[llvm] [BOLT] Skip out-of-range pending relocations (PR #116964)
Paschalis Mpeis via llvm-commits
llvm-commits at lists.llvm.org
Thu Feb 20 08:45:55 PST 2025
https://github.com/paschalis-mpeis updated https://github.com/llvm/llvm-project/pull/116964
>From 721b75b96841536bf3068a909784f14fe5aa7f73 Mon Sep 17 00:00:00 2001
From: Paschalis Mpeis <Paschalis.Mpeis at arm.com>
Date: Wed, 19 Feb 2025 13:05:20 +0000
Subject: [PATCH 1/4] [NFC][BOLT] Refactor PatchEntries
Move force-patch flag to CommandLineOpts and add details on PatchEntries.
---
bolt/include/bolt/Utils/CommandLineOpts.h | 1 +
bolt/lib/Passes/PatchEntries.cpp | 21 +++++++++++----------
bolt/lib/Rewrite/MachORewriteInstance.cpp | 6 +++---
bolt/lib/Utils/CommandLineOpts.cpp | 6 ++++++
4 files changed, 21 insertions(+), 13 deletions(-)
diff --git a/bolt/include/bolt/Utils/CommandLineOpts.h b/bolt/include/bolt/Utils/CommandLineOpts.h
index 111eb650c3746..ee110eb8707f7 100644
--- a/bolt/include/bolt/Utils/CommandLineOpts.h
+++ b/bolt/include/bolt/Utils/CommandLineOpts.h
@@ -37,6 +37,7 @@ extern llvm::cl::opt<unsigned> BucketsPerLine;
extern llvm::cl::opt<bool> DiffOnly;
extern llvm::cl::opt<bool> EnableBAT;
extern llvm::cl::opt<bool> EqualizeBBCounts;
+extern llvm::cl::opt<bool> ForcePatch;
extern llvm::cl::opt<bool> RemoveSymtab;
extern llvm::cl::opt<unsigned> ExecutionCountThreshold;
extern llvm::cl::opt<unsigned> HeatmapBlock;
diff --git a/bolt/lib/Passes/PatchEntries.cpp b/bolt/lib/Passes/PatchEntries.cpp
index 981d1b70af907..afe489b4667c3 100644
--- a/bolt/lib/Passes/PatchEntries.cpp
+++ b/bolt/lib/Passes/PatchEntries.cpp
@@ -6,27 +6,28 @@
//
//===----------------------------------------------------------------------===//
//
-// This file implements the PatchEntries class that is used for patching
-// the original function entry points.
+// This file implements the PatchEntries class that is used for patching the
+// original function entry points. This ensures that only the new/optimized code
+// executes and that the old code is never used. This is necessary due to
+// current BOLT limitations of not being able to duplicate all function's
+// associated metadata (e.g., .eh_frame, exception ranges, debug info,
+// jump-tables).
+//
+// NOTE: A successful run of 'scanExternalRefs' can relax this requirement as
+// it also ensures that old code is never executed.
//
//===----------------------------------------------------------------------===//
#include "bolt/Passes/PatchEntries.h"
+#include "bolt/Utils/CommandLineOpts.h"
#include "bolt/Utils/NameResolver.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/CommandLine.h"
namespace opts {
-
extern llvm::cl::OptionCategory BoltCategory;
-
extern llvm::cl::opt<unsigned> Verbosity;
-
-llvm::cl::opt<bool>
- ForcePatch("force-patch",
- llvm::cl::desc("force patching of original entry points"),
- llvm::cl::Hidden, llvm::cl::cat(BoltCategory));
-}
+} // namespace opts
namespace llvm {
namespace bolt {
diff --git a/bolt/lib/Rewrite/MachORewriteInstance.cpp b/bolt/lib/Rewrite/MachORewriteInstance.cpp
index 2f05b03290ba3..335b7b42ddde5 100644
--- a/bolt/lib/Rewrite/MachORewriteInstance.cpp
+++ b/bolt/lib/Rewrite/MachORewriteInstance.cpp
@@ -20,6 +20,7 @@
#include "bolt/Rewrite/JITLinkLinker.h"
#include "bolt/Rewrite/RewriteInstance.h"
#include "bolt/RuntimeLibs/InstrumentationRuntimeLibrary.h"
+#include "bolt/Utils/CommandLineOpts.h"
#include "bolt/Utils/Utils.h"
#include "llvm/MC/MCObjectStreamer.h"
#include "llvm/Support/Errc.h"
@@ -32,9 +33,8 @@ namespace opts {
using namespace llvm;
extern cl::opt<unsigned> AlignText;
-//FIXME! Upstream change
-//extern cl::opt<bool> CheckOverlappingElements;
-extern cl::opt<bool> ForcePatch;
+// FIXME! Upstream change
+// extern cl::opt<bool> CheckOverlappingElements;
extern cl::opt<bool> Instrument;
extern cl::opt<bool> InstrumentCalls;
extern cl::opt<bolt::JumpTableSupportLevel> JumpTables;
diff --git a/bolt/lib/Utils/CommandLineOpts.cpp b/bolt/lib/Utils/CommandLineOpts.cpp
index 17f090aa61ee9..ad714371436e0 100644
--- a/bolt/lib/Utils/CommandLineOpts.cpp
+++ b/bolt/lib/Utils/CommandLineOpts.cpp
@@ -80,6 +80,12 @@ cl::opt<bool> EqualizeBBCounts(
"in non-LBR and shrink wrapping)"),
cl::ZeroOrMore, cl::init(false), cl::Hidden, cl::cat(BoltOptCategory));
+llvm::cl::opt<bool> ForcePatch(
+ "force-patch",
+ llvm::cl::desc("force patching of original entry points to ensure "
+ "execution follows only the new/optimized code."),
+ llvm::cl::Hidden, llvm::cl::cat(BoltCategory));
+
cl::opt<bool> RemoveSymtab("remove-symtab", cl::desc("Remove .symtab section"),
cl::cat(BoltCategory));
>From 4f805f02392e1f0258bb8dc810587d31e3fd4e19 Mon Sep 17 00:00:00 2001
From: Paschalis Mpeis <Paschalis.Mpeis at arm.com>
Date: Mon, 20 Jan 2025 16:08:02 +0000
Subject: [PATCH 2/4] BOLT asserts on out-of-range pending relocs
---
bolt/unittests/Core/BinaryContext.cpp | 27 +++++++++++++++++++++++++++
1 file changed, 27 insertions(+)
diff --git a/bolt/unittests/Core/BinaryContext.cpp b/bolt/unittests/Core/BinaryContext.cpp
index 09d16966334da..a2f073e9b2e26 100644
--- a/bolt/unittests/Core/BinaryContext.cpp
+++ b/bolt/unittests/Core/BinaryContext.cpp
@@ -161,6 +161,33 @@ TEST_P(BinaryContextTester, FlushPendingRelocJUMP26) {
<< "Wrong forward branch value\n";
}
+// TODO: BOLT currently asserts when a relocation is out of range.
+TEST_P(BinaryContextTester, FlushOptionalOutOfRangePendingRelocCALL26) {
+ if (GetParam() != Triple::aarch64)
+ GTEST_SKIP();
+
+ // This test checks that flushPendingRelocations skips flushing any optional
+ // pending relocations that cannot be encoded.
+
+ BinarySection &BS = BC->registerOrUpdateSection(
+ ".text", ELF::SHT_PROGBITS, ELF::SHF_EXECINSTR | ELF::SHF_ALLOC);
+ MCSymbol *RelSymbol = BC->getOrCreateGlobalSymbol(4, "Func");
+ ASSERT_TRUE(RelSymbol);
+ BS.addPendingRelocation(
+ Relocation{8, RelSymbol, ELF::R_AARCH64_CALL26, 0, 0});
+
+ SmallVector<char> Vect;
+ raw_svector_ostream OS(Vect);
+
+ // FIXME: bolt must be able to skip pending relocs that are out of range.
+ EXPECT_DEBUG_DEATH(
+ // Resolve relocation symbol to a high value so encoding will be out of
+ // range.
+ BS.flushPendingRelocations(OS,
+ [&](const MCSymbol *S) { return 0x800000F; }),
+ ".*only PC \\+/- 128MB is allowed for direct call");
+}
+
#endif
TEST_P(BinaryContextTester, BaseAddress) {
>From bd3d4ff48f030adfee9aa51127a3b8f3b36547bb Mon Sep 17 00:00:00 2001
From: Paschalis Mpeis <Paschalis.Mpeis at arm.com>
Date: Mon, 20 Jan 2025 16:16:58 +0000
Subject: [PATCH 3/4] [BOLT] Skip flushing optional out-of-range pending relocs
When a pending relocation is created it is also marked whether it is
optional or not. It can be optional when such relocation is added as
part of an optimization (i.e., `scanExternalRefs`).
When bolt tries to `flushPendingRelocations`, it safely skips any
optional relocations that cannot be encoded.
Background:
BOLT, as part of scanExternalRefs, identifies external references from
calls and creates some pending relocations for them. Those when flushed
will update references to point to the optimized functions. This
optimization can be disabled using `--no-scan`.
BOLT can assert if any of these pending relocations cannot be encoded.
This patch does not disable this optimization but instead selectively
applies it given that a pending relocation is optional.
---
bolt/include/bolt/Core/BinarySection.h | 13 ++++++----
bolt/include/bolt/Core/Relocation.h | 5 +++-
bolt/lib/Core/BinaryFunction.cpp | 2 +-
bolt/lib/Core/BinarySection.cpp | 14 ++++++++++-
bolt/lib/Core/Relocation.cpp | 33 ++++++++++++++++++++++++++
bolt/unittests/Core/BinaryContext.cpp | 25 +++++++++++--------
6 files changed, 74 insertions(+), 18 deletions(-)
diff --git a/bolt/include/bolt/Core/BinarySection.h b/bolt/include/bolt/Core/BinarySection.h
index 9c252c3675951..11cd6768e3b5e 100644
--- a/bolt/include/bolt/Core/BinarySection.h
+++ b/bolt/include/bolt/Core/BinarySection.h
@@ -66,8 +66,10 @@ class BinarySection {
// from the original section address.
RelocationSetType DynamicRelocations;
- // Pending relocations for this section.
- std::vector<Relocation> PendingRelocations;
+ /// Pending relocations for this section and whether they are optional, i.e.,
+ /// added as part of an optimization. In that case they can be safely omitted
+ /// if flushPendingRelocations discovers they cannot be encoded.
+ std::vector<std::pair<Relocation, bool>> PendingRelocations;
struct BinaryPatch {
uint64_t Offset;
@@ -375,9 +377,10 @@ class BinarySection {
DynamicRelocations.emplace(Reloc);
}
- /// Add relocation against the original contents of this section.
- void addPendingRelocation(const Relocation &Rel) {
- PendingRelocations.push_back(Rel);
+ /// Add relocation against the original contents of this section. When added
+ /// as part of an optimization it is marked as \p Optional.
+ void addPendingRelocation(const Relocation &Rel, bool Optional = false) {
+ PendingRelocations.push_back({Rel, Optional});
}
/// Add patch to the input contents of this section.
diff --git a/bolt/include/bolt/Core/Relocation.h b/bolt/include/bolt/Core/Relocation.h
index 933f62a31f8fd..177cc0c70431f 100644
--- a/bolt/include/bolt/Core/Relocation.h
+++ b/bolt/include/bolt/Core/Relocation.h
@@ -64,9 +64,12 @@ struct Relocation {
/// and \P Type mismatch occurred.
static bool skipRelocationProcess(uint64_t &Type, uint64_t Contents);
- // Adjust value depending on relocation type (make it PC relative or not)
+ /// Adjust value depending on relocation type (make it PC relative or not).
static uint64_t encodeValue(uint64_t Type, uint64_t Value, uint64_t PC);
+ /// Return true if there are enough bits to encode the relocation value.
+ static bool canEncodeValue(uint64_t Type, uint64_t Value, uint64_t PC);
+
/// Extract current relocated value from binary contents. This is used for
/// RISC architectures where values are encoded in specific bits depending
/// on the relocation value. For X86, we limit to sign extending the value
diff --git a/bolt/lib/Core/BinaryFunction.cpp b/bolt/lib/Core/BinaryFunction.cpp
index bc45caf3ec8b7..9545e0346ce6f 100644
--- a/bolt/lib/Core/BinaryFunction.cpp
+++ b/bolt/lib/Core/BinaryFunction.cpp
@@ -1712,7 +1712,7 @@ bool BinaryFunction::scanExternalRefs() {
// Add relocations unless disassembly failed for this function.
if (!DisassemblyFailed)
for (Relocation &Rel : FunctionRelocations)
- getOriginSection()->addPendingRelocation(Rel);
+ getOriginSection()->addPendingRelocation(Rel, /*Optional*/ true);
// Inform BinaryContext that this function symbols will not be defined and
// relocations should not be created against them.
diff --git a/bolt/lib/Core/BinarySection.cpp b/bolt/lib/Core/BinarySection.cpp
index b16e0a4333aa2..2e970ddf68f08 100644
--- a/bolt/lib/Core/BinarySection.cpp
+++ b/bolt/lib/Core/BinarySection.cpp
@@ -174,11 +174,19 @@ void BinarySection::flushPendingRelocations(raw_pwrite_stream &OS,
OS.pwrite(Patch.Bytes.data(), Patch.Bytes.size(),
SectionFileOffset + Patch.Offset);
- for (Relocation &Reloc : PendingRelocations) {
+ uint64_t SkippedPendingRelocations = 0;
+ for (auto &[Reloc, Optional] : PendingRelocations) {
uint64_t Value = Reloc.Addend;
if (Reloc.Symbol)
Value += Resolver(Reloc.Symbol);
+ // Safely skip any pending relocation that cannot be encoded and was added
+ // as part of an optimization.
+ if (Optional && !Relocation::canEncodeValue(
+ Reloc.Type, Value, SectionAddress + Reloc.Offset)) {
+ ++SkippedPendingRelocations;
+ continue;
+ }
Value = Relocation::encodeValue(Reloc.Type, Value,
SectionAddress + Reloc.Offset);
@@ -197,6 +205,10 @@ void BinarySection::flushPendingRelocations(raw_pwrite_stream &OS,
}
clearList(PendingRelocations);
+
+ if (SkippedPendingRelocations > 0)
+ LLVM_DEBUG(dbgs() << "BOLT-INFO: Skipped " << SkippedPendingRelocations
+ << " pending relocations as they were out of range\n");
}
BinarySection::~BinarySection() { updateContents(nullptr, 0); }
diff --git a/bolt/lib/Core/Relocation.cpp b/bolt/lib/Core/Relocation.cpp
index e9a9741bc3716..4dc582097e1da 100644
--- a/bolt/lib/Core/Relocation.cpp
+++ b/bolt/lib/Core/Relocation.cpp
@@ -365,6 +365,16 @@ static uint64_t encodeValueX86(uint64_t Type, uint64_t Value, uint64_t PC) {
return Value;
}
+static bool canEncodeValueAArch64(uint64_t Type, uint64_t Value, uint64_t PC) {
+ switch (Type) {
+ default:
+ llvm_unreachable("unsupported relocation");
+ case ELF::R_AARCH64_CALL26:
+ case ELF::R_AARCH64_JUMP26:
+ return isInt<28>(Value - PC);
+ }
+}
+
static uint64_t encodeValueAArch64(uint64_t Type, uint64_t Value, uint64_t PC) {
switch (Type) {
default:
@@ -397,6 +407,16 @@ static uint64_t encodeValueAArch64(uint64_t Type, uint64_t Value, uint64_t PC) {
return Value;
}
+static uint64_t canEncodeValueRISCV(uint64_t Type, uint64_t Value,
+ uint64_t PC) {
+ switch (Type) {
+ default:
+ llvm_unreachable("unsupported relocation");
+ case ELF::R_RISCV_64:
+ return true;
+ }
+}
+
static uint64_t encodeValueRISCV(uint64_t Type, uint64_t Value, uint64_t PC) {
switch (Type) {
default:
@@ -846,6 +866,19 @@ uint64_t Relocation::encodeValue(uint64_t Type, uint64_t Value, uint64_t PC) {
}
}
+bool Relocation::canEncodeValue(uint64_t Type, uint64_t Value, uint64_t PC) {
+ switch (Arch) {
+ default:
+ llvm_unreachable("Unsupported architecture");
+ case Triple::aarch64:
+ return canEncodeValueAArch64(Type, Value, PC);
+ case Triple::riscv64:
+ return canEncodeValueRISCV(Type, Value, PC);
+ case Triple::x86_64:
+ return true;
+ }
+}
+
uint64_t Relocation::extractValue(uint64_t Type, uint64_t Contents,
uint64_t PC) {
switch (Arch) {
diff --git a/bolt/unittests/Core/BinaryContext.cpp b/bolt/unittests/Core/BinaryContext.cpp
index a2f073e9b2e26..423d9ac37fd16 100644
--- a/bolt/unittests/Core/BinaryContext.cpp
+++ b/bolt/unittests/Core/BinaryContext.cpp
@@ -161,7 +161,6 @@ TEST_P(BinaryContextTester, FlushPendingRelocJUMP26) {
<< "Wrong forward branch value\n";
}
-// TODO: BOLT currently asserts when a relocation is out of range.
TEST_P(BinaryContextTester, FlushOptionalOutOfRangePendingRelocCALL26) {
if (GetParam() != Triple::aarch64)
GTEST_SKIP();
@@ -169,23 +168,29 @@ TEST_P(BinaryContextTester, FlushOptionalOutOfRangePendingRelocCALL26) {
// This test checks that flushPendingRelocations skips flushing any optional
// pending relocations that cannot be encoded.
+ bool DebugFlagPrev = ::llvm::DebugFlag;
+ ::llvm::DebugFlag = true;
+ testing::internal::CaptureStderr();
+
BinarySection &BS = BC->registerOrUpdateSection(
".text", ELF::SHT_PROGBITS, ELF::SHF_EXECINSTR | ELF::SHF_ALLOC);
MCSymbol *RelSymbol = BC->getOrCreateGlobalSymbol(4, "Func");
ASSERT_TRUE(RelSymbol);
- BS.addPendingRelocation(
- Relocation{8, RelSymbol, ELF::R_AARCH64_CALL26, 0, 0});
+ BS.addPendingRelocation(Relocation{8, RelSymbol, ELF::R_AARCH64_CALL26, 0, 0},
+ /*Optional*/ true);
SmallVector<char> Vect;
raw_svector_ostream OS(Vect);
- // FIXME: bolt must be able to skip pending relocs that are out of range.
- EXPECT_DEBUG_DEATH(
- // Resolve relocation symbol to a high value so encoding will be out of
- // range.
- BS.flushPendingRelocations(OS,
- [&](const MCSymbol *S) { return 0x800000F; }),
- ".*only PC \\+/- 128MB is allowed for direct call");
+ // Resolve relocation symbol to a high value so encoding will be out of range.
+ BS.flushPendingRelocations(OS, [&](const MCSymbol *S) { return 0x800000F; });
+
+ std::string CapturedStdErr = testing::internal::GetCapturedStderr();
+ EXPECT_TRUE(CapturedStdErr.find("BOLT-INFO: Skipped 1 pending relocations as "
+ "they were out of range") !=
+ std::string::npos);
+
+ ::llvm::DebugFlag = DebugFlagPrev;
}
#endif
>From d46158c9b560ba2f4c8543372eb5820bb1cc6bbb Mon Sep 17 00:00:00 2001
From: Paschalis Mpeis <Paschalis.Mpeis at arm.com>
Date: Thu, 20 Feb 2025 16:34:54 +0000
Subject: [PATCH 4/4] Ensure PatchEntries runs
Allow skipping pending relocations only when `-force-patch` is set.
Otherwise, exit with a relevant message.
---
bolt/lib/Core/BinarySection.cpp | 15 ++++++++++-
bolt/unittests/Core/BinaryContext.cpp | 39 ++++++++++++++++++++++++---
bolt/unittests/Core/CMakeLists.txt | 1 +
3 files changed, 51 insertions(+), 4 deletions(-)
diff --git a/bolt/lib/Core/BinarySection.cpp b/bolt/lib/Core/BinarySection.cpp
index 2e970ddf68f08..126fe888da5bc 100644
--- a/bolt/lib/Core/BinarySection.cpp
+++ b/bolt/lib/Core/BinarySection.cpp
@@ -12,6 +12,7 @@
#include "bolt/Core/BinarySection.h"
#include "bolt/Core/BinaryContext.h"
+#include "bolt/Utils/CommandLineOpts.h"
#include "bolt/Utils/Utils.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/Support/CommandLine.h"
@@ -22,8 +23,8 @@ using namespace llvm;
using namespace bolt;
namespace opts {
-extern cl::opt<bool> PrintRelocations;
extern cl::opt<bool> HotData;
+extern cl::opt<bool> PrintRelocations;
} // namespace opts
uint64_t BinarySection::Count = 0;
@@ -184,6 +185,18 @@ void BinarySection::flushPendingRelocations(raw_pwrite_stream &OS,
// as part of an optimization.
if (Optional && !Relocation::canEncodeValue(
Reloc.Type, Value, SectionAddress + Reloc.Offset)) {
+
+ // A successful run of 'scanExternalRefs' means that all pending
+ // relocations are flushed. Otherwise, PatchEntries should run.
+ if (!opts::ForcePatch) {
+ BC.errs()
+ << "BOLT-ERROR: Cannot fully run scanExternalRefs as pending "
+ "relocation for symbol "
+ << Reloc.Symbol->getName()
+ << " is out-of-range. Cannot proceed without using -force-patch\n";
+ exit(1);
+ }
+
++SkippedPendingRelocations;
continue;
}
diff --git a/bolt/unittests/Core/BinaryContext.cpp b/bolt/unittests/Core/BinaryContext.cpp
index 423d9ac37fd16..e9e2db2154651 100644
--- a/bolt/unittests/Core/BinaryContext.cpp
+++ b/bolt/unittests/Core/BinaryContext.cpp
@@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "bolt/Core/BinaryContext.h"
+#include "bolt/Utils/CommandLineOpts.h"
#include "llvm/BinaryFormat/ELF.h"
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
#include "llvm/Support/TargetSelect.h"
@@ -161,12 +162,44 @@ TEST_P(BinaryContextTester, FlushPendingRelocJUMP26) {
<< "Wrong forward branch value\n";
}
-TEST_P(BinaryContextTester, FlushOptionalOutOfRangePendingRelocCALL26) {
+TEST_P(BinaryContextTester,
+ FlushOptionalOutOfRangePendingRelocCALL26_ForcePatchOff) {
if (GetParam() != Triple::aarch64)
GTEST_SKIP();
- // This test checks that flushPendingRelocations skips flushing any optional
- // pending relocations that cannot be encoded.
+ // Tests that flushPendingRelocations exits if any pending relocation is out
+ // of range and PatchEntries hasn't run. Pending relocations are added by
+ // scanExternalRefs, so this ensures that either all scanExternalRefs
+ // relocations were flushed or PatchEntries ran.
+
+ BinarySection &BS = BC->registerOrUpdateSection(
+ ".text", ELF::SHT_PROGBITS, ELF::SHF_EXECINSTR | ELF::SHF_ALLOC);
+ // Create symbol 'Func0x4'
+ MCSymbol *RelSymbol = BC->getOrCreateGlobalSymbol(4, "Func");
+ ASSERT_TRUE(RelSymbol);
+ BS.addPendingRelocation(Relocation{8, RelSymbol, ELF::R_AARCH64_CALL26, 0, 0},
+ /*Optional*/ true);
+
+ SmallVector<char> Vect;
+ raw_svector_ostream OS(Vect);
+
+ // Resolve relocation symbol to a high value so encoding will be out of range.
+ EXPECT_EXIT(BS.flushPendingRelocations(
+ OS, [&](const MCSymbol *S) { return 0x800000F; }),
+ ::testing::ExitedWithCode(1),
+ "BOLT-ERROR: Cannot fully run scanExternalRefs as pending "
+ "relocation for symbol Func0x4 is out-of-range. Cannot proceed "
+ "without using -force-patch");
+}
+
+TEST_P(BinaryContextTester,
+ FlushOptionalOutOfRangePendingRelocCALL26_ForcePatchOn) {
+ if (GetParam() != Triple::aarch64)
+ GTEST_SKIP();
+
+ // Tests that flushPendingRelocations can skip flushing any optional pending
+ // relocations that cannot be encoded, given that PatchEntries runs.
+ opts::ForcePatch = true;
bool DebugFlagPrev = ::llvm::DebugFlag;
::llvm::DebugFlag = true;
diff --git a/bolt/unittests/Core/CMakeLists.txt b/bolt/unittests/Core/CMakeLists.txt
index 8ac88b701ea05..54e8ea10cda12 100644
--- a/bolt/unittests/Core/CMakeLists.txt
+++ b/bolt/unittests/Core/CMakeLists.txt
@@ -19,6 +19,7 @@ target_link_libraries(CoreTests
LLVMBOLTCore
LLVMBOLTRewrite
LLVMBOLTProfile
+ LLVMBOLTUtils
LLVMTestingSupport
)
More information about the llvm-commits
mailing list