[llvm] [BOLT][Linux] Add support for relocation mode (PR #130931)
via llvm-commits
llvm-commits at lists.llvm.org
Wed Mar 12 02:17:46 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-bolt
Author: Franklin (FLZ101)
<details>
<summary>Changes</summary>
---
Patch is 89.24 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/130931.diff
35 Files Affected:
- (modified) bolt/docs/CommandLineArgumentReference.md (-12)
- (modified) bolt/include/bolt/Core/BinaryBasicBlock.h (+11)
- (modified) bolt/include/bolt/Core/BinaryContext.h (+27-1)
- (modified) bolt/include/bolt/Core/BinaryFunction.h (+40)
- (modified) bolt/include/bolt/Core/BinarySection.h (+4)
- (modified) bolt/include/bolt/Core/FunctionLayout.h (+4)
- (modified) bolt/include/bolt/Core/Linker.h (+7)
- (modified) bolt/include/bolt/Core/MCPlusBuilder.h (+8-1)
- (modified) bolt/include/bolt/Core/Relocation.h (+7)
- (modified) bolt/include/bolt/Passes/PatchEntries.h (+11)
- (modified) bolt/include/bolt/Rewrite/MetadataRewriter.h (+7-1)
- (modified) bolt/include/bolt/Rewrite/MetadataRewriters.h (+4-4)
- (modified) bolt/include/bolt/Rewrite/RewriteInstance.h (+5)
- (modified) bolt/lib/Core/BinaryBasicBlock.cpp (+5)
- (modified) bolt/lib/Core/BinaryContext.cpp (+18-1)
- (modified) bolt/lib/Core/BinaryEmitter.cpp (+6-2)
- (modified) bolt/lib/Core/BinaryFunction.cpp (+2-8)
- (modified) bolt/lib/Core/BinarySection.cpp (+12)
- (modified) bolt/lib/Core/FunctionLayout.cpp (+4)
- (modified) bolt/lib/Core/JumpTable.cpp (+1-1)
- (modified) bolt/lib/Core/MCPlusBuilder.cpp (+7-2)
- (modified) bolt/lib/Core/Relocation.cpp (+13)
- (modified) bolt/lib/Passes/PatchEntries.cpp (+14-24)
- (modified) bolt/lib/Rewrite/BuildIDRewriter.cpp (+4-4)
- (modified) bolt/lib/Rewrite/CMakeLists.txt (+1)
- (modified) bolt/lib/Rewrite/LinuxKernelRewriter.cpp (+298-221)
- (added) bolt/lib/Rewrite/MetadataRewriter.cpp (+20)
- (modified) bolt/lib/Rewrite/PseudoProbeRewriter.cpp (+4-4)
- (modified) bolt/lib/Rewrite/RewriteInstance.cpp (+161-48)
- (modified) bolt/lib/Rewrite/SDTRewriter.cpp (+4-3)
- (modified) bolt/lib/Target/AArch64/AArch64MCPlusBuilder.cpp (+14)
- (modified) bolt/lib/Target/RISCV/RISCVMCPlusBuilder.cpp (+4)
- (modified) bolt/lib/Target/X86/X86MCPlusBuilder.cpp (+4)
- (modified) bolt/test/X86/linux-alt-instruction.s (+2-36)
- (modified) llvm/lib/CodeGen/CodeGenPrepare.cpp (+45)
``````````diff
diff --git a/bolt/docs/CommandLineArgumentReference.md b/bolt/docs/CommandLineArgumentReference.md
index f3881c9a640a9..2c880388e3faa 100644
--- a/bolt/docs/CommandLineArgumentReference.md
+++ b/bolt/docs/CommandLineArgumentReference.md
@@ -56,14 +56,6 @@
Allow processing of stripped binaries
-- `--alt-inst-feature-size=<uint>`
-
- Size of feature field in .altinstructions
-
-- `--alt-inst-has-padlen`
-
- Specify that .altinstructions has padlen field
-
- `--asm-dump[=<dump folder>]`
Dump function into assembly
@@ -254,10 +246,6 @@
Redirect journaling to a file instead of stdout/stderr
-- `--long-jump-labels`
-
- Always use long jumps/nops for Linux kernel static keys
-
- `--match-profile-with-function-hash`
Match profile with function hash
diff --git a/bolt/include/bolt/Core/BinaryBasicBlock.h b/bolt/include/bolt/Core/BinaryBasicBlock.h
index 25cccc4edecf6..5334f7e02fcb7 100644
--- a/bolt/include/bolt/Core/BinaryBasicBlock.h
+++ b/bolt/include/bolt/Core/BinaryBasicBlock.h
@@ -690,10 +690,16 @@ class BinaryBasicBlock {
void setCanOutline(const bool Flag) { CanOutline = Flag; }
+ void undefineLabels() const {
+ for (const MCInst &Inst : Instructions)
+ undefineInstLabel(Inst);
+ }
+
/// Erase pseudo instruction at a given iterator.
/// Return iterator following the removed instruction.
iterator erasePseudoInstruction(iterator II) {
--NumPseudos;
+ undefineInstLabel(*II);
return Instructions.erase(II);
}
@@ -701,6 +707,7 @@ class BinaryBasicBlock {
/// Return iterator following the removed instruction.
iterator eraseInstruction(iterator II) {
adjustNumPseudos(*II, -1);
+ undefineInstLabel(*II);
return Instructions.erase(II);
}
@@ -718,6 +725,7 @@ class BinaryBasicBlock {
/// Erase all instructions.
void clear() {
+ undefineLabels();
Instructions.clear();
NumPseudos = 0;
}
@@ -742,6 +750,7 @@ class BinaryBasicBlock {
adjustNumPseudos(Begin, End, 1);
auto I = II - Instructions.begin();
+ undefineInstLabel(*II);
Instructions.insert(Instructions.erase(II), Begin, End);
return I + Instructions.begin();
}
@@ -917,6 +926,8 @@ class BinaryBasicBlock {
uint64_t getHash() const { return Hash; }
private:
+ void undefineInstLabel(const llvm::MCInst &Inst) const;
+
void adjustNumPseudos(const MCInst &Inst, int Sign);
template <typename Itr> void adjustNumPseudos(Itr Begin, Itr End, int Sign) {
diff --git a/bolt/include/bolt/Core/BinaryContext.h b/bolt/include/bolt/Core/BinaryContext.h
index 8bec1db70e25a..bbfda368fb605 100644
--- a/bolt/include/bolt/Core/BinaryContext.h
+++ b/bolt/include/bolt/Core/BinaryContext.h
@@ -433,6 +433,13 @@ class BinaryContext {
Address);
}
+ bool isInRange(StringRef NameStart, StringRef NameEnd,
+ uint64_t Address) const {
+ ErrorOr<uint64_t> Start = getSymbolValue(NameStart);
+ ErrorOr<uint64_t> End = getSymbolValue(NameEnd);
+ return Start && End && *Start <= Address && Address < *End;
+ }
+
/// Return size of an entry for the given jump table \p Type.
uint64_t getJumpTableEntrySize(JumpTable::JumpTableType Type) const {
return Type == JumpTable::JTT_PIC ? 4 : AsmInfo->getCodePointerSize();
@@ -545,6 +552,11 @@ class BinaryContext {
/// binary and functions created by BOLT.
std::vector<BinaryFunction *> getAllBinaryFunctions();
+ void undefineInstLabel(const MCInst &Inst) const {
+ if (MCSymbol *const Label = MIB->getInstLabel(Inst))
+ UndefinedSymbols.insert(Label);
+ }
+
/// Construct a jump table for \p Function at \p Address or return an existing
/// one at that location.
///
@@ -613,6 +625,9 @@ class BinaryContext {
/// Addresses reserved for kernel on x86_64 start at this location.
static constexpr uint64_t KernelStartX86_64 = 0xFFFF'FFFF'8000'0000;
+ /// Addresses reserved for kernel on aarch64 start at this location.
+ static constexpr uint64_t KernelStartAArch64 = 0xFFFF'0000'0000'0000;
+
/// Map address to a constant island owner (constant data in code section)
std::map<uint64_t, BinaryFunction *> AddressToConstantIslandMap;
@@ -911,7 +926,11 @@ class BinaryContext {
/// Return a value of the global \p Symbol or an error if the value
/// was not set.
ErrorOr<uint64_t> getSymbolValue(const MCSymbol &Symbol) const {
- const BinaryData *BD = getBinaryDataByName(Symbol.getName());
+ return getSymbolValue(Symbol.getName());
+ }
+
+ ErrorOr<uint64_t> getSymbolValue(StringRef Name) const {
+ const BinaryData *BD = getBinaryDataByName(Name);
if (!BD)
return std::make_error_code(std::errc::bad_address);
return BD->getAddress();
@@ -1237,6 +1256,13 @@ class BinaryContext {
return const_cast<BinaryContext *>(this)->getSectionForAddress(Address);
}
+ ErrorOr<BinarySection &> getSectionForOutputAddress(uint64_t Address);
+ ErrorOr<const BinarySection &>
+ getSectionForOutputAddress(uint64_t Address) const {
+ return const_cast<BinaryContext *>(this)->getSectionForOutputAddress(
+ Address);
+ }
+
/// Return internal section representation for a section in a file.
BinarySection *getSectionForSectionRef(SectionRef Section) const {
return SectionRefToBinarySection.lookup(Section);
diff --git a/bolt/include/bolt/Core/BinaryFunction.h b/bolt/include/bolt/Core/BinaryFunction.h
index 942840a7621fd..766aac652cdde 100644
--- a/bolt/include/bolt/Core/BinaryFunction.h
+++ b/bolt/include/bolt/Core/BinaryFunction.h
@@ -294,6 +294,12 @@ class BinaryFunction {
/// Pseudo functions should not be disassembled or emitted.
bool IsPseudo{false};
+ // True if address of this function can not be changed
+ bool KeepAddress{false};
+
+ // True if code of this function might be changed at run time
+ bool MayChange{false};
+
/// True if the original function code has all necessary relocations to track
/// addresses of functions emitted to new locations. Typically set for
/// functions that we are not going to emit.
@@ -1198,6 +1204,21 @@ class BinaryFunction {
/// Return true if all callbacks returned true, false otherwise.
bool forEachEntryPoint(EntryPointCallbackTy Callback) const;
+ void undefineLabels() {
+ for (std::pair<const uint32_t, MCSymbol *> &LI : Labels)
+ BC.UndefinedSymbols.insert(LI.second);
+
+ for (MCSymbol *const EndLabel : FunctionEndLabels)
+ if (EndLabel)
+ BC.UndefinedSymbols.insert(EndLabel);
+
+ for (const std::pair<const uint32_t, MCInst> &II : Instructions)
+ BC.undefineInstLabel(II.second);
+
+ for (const BinaryBasicBlock *BB : BasicBlocks)
+ BB->undefineLabels();
+ }
+
/// Return MC symbol associated with the end of the function.
MCSymbol *
getFunctionEndLabel(const FragmentNum Fragment = FragmentNum::main()) const {
@@ -1243,6 +1264,17 @@ class BinaryFunction {
return Islands->FunctionColdConstantIslandLabel;
}
+ const FunctionFragment *
+ getFunctionFragmentForOutputAddress(uint64_t OutputAddress) const {
+ for (const FunctionFragment &FF : Layout.fragments()) {
+ uint64_t Address = FF.getAddress();
+ uint64_t Size = FF.getImageSize();
+ if (Address <= OutputAddress && OutputAddress < Address + Size)
+ return &FF;
+ }
+ return nullptr;
+ }
+
/// Return true if this is a function representing a PLT entry.
bool isPLTFunction() const { return PLTSymbol != nullptr; }
@@ -1318,6 +1350,12 @@ class BinaryFunction {
/// otherwise processed.
bool isPseudo() const { return IsPseudo; }
+ /// Return true if address of this function can not be changed
+ bool mustKeepAddress() const { return KeepAddress; }
+
+ /// Return true if code of this function might be changed at run time
+ bool mayChange() const { return MayChange; }
+
/// Return true if the function contains explicit or implicit indirect branch
/// to its split fragments, e.g., split jump table, landing pad in split
/// fragment.
@@ -1729,6 +1767,8 @@ class BinaryFunction {
/// Mark function that should not be emitted.
void setIgnored();
+ void setMayChange() { MayChange = true; }
+
void setIsPatched(bool V) { IsPatched = V; }
void setHasIndirectTargetToSplitFragment(bool V) {
diff --git a/bolt/include/bolt/Core/BinarySection.h b/bolt/include/bolt/Core/BinarySection.h
index 9c252c3675951..31f0b9de39af8 100644
--- a/bolt/include/bolt/Core/BinarySection.h
+++ b/bolt/include/bolt/Core/BinarySection.h
@@ -385,6 +385,10 @@ class BinarySection {
Patches.emplace_back(BinaryPatch(Offset, Bytes));
}
+ void addPatch(uint64_t Offset, StringRef Bytes) {
+ addPatch(Offset, SmallVector<char>(Bytes.begin(), Bytes.end()));
+ }
+
/// Register patcher for this section.
void registerPatcher(std::unique_ptr<BinaryPatcher> BPatcher) {
Patcher = std::move(BPatcher);
diff --git a/bolt/include/bolt/Core/FunctionLayout.h b/bolt/include/bolt/Core/FunctionLayout.h
index ee4dd689b8dd6..65b80051862c4 100644
--- a/bolt/include/bolt/Core/FunctionLayout.h
+++ b/bolt/include/bolt/Core/FunctionLayout.h
@@ -117,6 +117,10 @@ class FunctionFragment {
uint64_t getFileOffset() const { return FileOffset; }
void setFileOffset(uint64_t Offset) { FileOffset = Offset; }
+ uint8_t *getOutputData() const {
+ return reinterpret_cast<uint8_t *>(getImageAddress());
+ }
+
unsigned size() const { return Size; };
bool empty() const { return size() == 0; };
iterator begin();
diff --git a/bolt/include/bolt/Core/Linker.h b/bolt/include/bolt/Core/Linker.h
index 66b3ad18e3c7b..1e0876a0e13d9 100644
--- a/bolt/include/bolt/Core/Linker.h
+++ b/bolt/include/bolt/Core/Linker.h
@@ -46,6 +46,13 @@ class BOLTLinker {
/// Return the address and size of a symbol or std::nullopt if it cannot be
/// found.
virtual std::optional<SymbolInfo> lookupSymbolInfo(StringRef Name) const = 0;
+
+ /// Return the address of a symbol or std::nullopt if it cannot be found.
+ std::optional<uint64_t> lookupSymbol(StringRef Name) const {
+ if (const auto Info = lookupSymbolInfo(Name))
+ return Info->Address;
+ return std::nullopt;
+ }
};
} // namespace bolt
diff --git a/bolt/include/bolt/Core/MCPlusBuilder.h b/bolt/include/bolt/Core/MCPlusBuilder.h
index fbb853656fb91..dadc627c6c6bb 100644
--- a/bolt/include/bolt/Core/MCPlusBuilder.h
+++ b/bolt/include/bolt/Core/MCPlusBuilder.h
@@ -689,6 +689,12 @@ class MCPlusBuilder {
return StringRef();
}
+ /// Used to fill the executable space with undefined instructions.
+ virtual StringRef getUndefFillValue() const {
+ llvm_unreachable("not implemented");
+ return StringRef();
+ }
+
/// Interface and basic functionality of a MCInstMatcher. The idea is to make
/// it easy to match one or more MCInsts against a tree-like pattern and
/// extract the fragment operands. Example:
@@ -1211,8 +1217,9 @@ class MCPlusBuilder {
/// Set the label of \p Inst or return the existing label for the instruction.
/// This label will be emitted right before \p Inst is emitted to MCStreamer.
+ /// If \p Temp is true, then this label does not survive in the symbol table.
MCSymbol *getOrCreateInstLabel(MCInst &Inst, const Twine &Name,
- MCContext *Ctx) const;
+ MCContext *Ctx, bool Temp = true) const;
/// Set the label of \p Inst. This label will be emitted right before \p Inst
/// is emitted to MCStreamer.
diff --git a/bolt/include/bolt/Core/Relocation.h b/bolt/include/bolt/Core/Relocation.h
index 933f62a31f8fd..5bb8e2c569c99 100644
--- a/bolt/include/bolt/Core/Relocation.h
+++ b/bolt/include/bolt/Core/Relocation.h
@@ -92,6 +92,9 @@ struct Relocation {
/// Return true if relocation type is RELATIVE
static bool isRelative(uint64_t Type);
+ /// Return true if relocation type is GLOB_DAT
+ static bool isGlobDat(uint64_t Type);
+
/// Return true if relocation type is IRELATIVE
static bool isIRelative(uint64_t Type);
@@ -124,6 +127,10 @@ struct Relocation {
/// otherwise.
bool isRelative() const { return isRelative(Type); }
+ /// Return true if this relocation is R_*_GLOB_DAT type. Return false
+ /// otherwise.
+ bool isGlobDat() const { return isGlobDat(Type); }
+
/// Return true if this relocation is R_*_IRELATIVE type. Return false
/// otherwise.
bool isIRelative() const { return isIRelative(Type); }
diff --git a/bolt/include/bolt/Passes/PatchEntries.h b/bolt/include/bolt/Passes/PatchEntries.h
index fa6b5811a4c3b..e4982b5c6529c 100644
--- a/bolt/include/bolt/Passes/PatchEntries.h
+++ b/bolt/include/bolt/Passes/PatchEntries.h
@@ -33,6 +33,17 @@ class PatchEntries : public BinaryFunctionPass {
public:
explicit PatchEntries() : BinaryFunctionPass(false) {}
+ // Calculate the size of the patch.
+ static size_t getPatchSize(const BinaryContext &BC) {
+ static size_t PatchSize = 0;
+ if (!PatchSize) {
+ InstructionListType Seq;
+ BC.MIB->createLongTailCall(Seq, BC.Ctx->createTempSymbol(), BC.Ctx.get());
+ PatchSize = BC.computeCodeSize(Seq.begin(), Seq.end());
+ }
+ return PatchSize;
+ }
+
const char *getName() const override { return "patch-entries"; }
Error runOnFunctions(BinaryContext &BC) override;
};
diff --git a/bolt/include/bolt/Rewrite/MetadataRewriter.h b/bolt/include/bolt/Rewrite/MetadataRewriter.h
index 6ff8f0af7a8e6..6988e5de4e6bd 100644
--- a/bolt/include/bolt/Rewrite/MetadataRewriter.h
+++ b/bolt/include/bolt/Rewrite/MetadataRewriter.h
@@ -19,6 +19,8 @@
namespace llvm {
namespace bolt {
+class RewriteInstance;
+
/// Base class for handling file sections with metadata. In this context,
/// metadata encompasses a wide range of data that references code and other
/// data. Such metadata may or may not have an impact on program execution.
@@ -34,10 +36,14 @@ class MetadataRewriter {
StringRef Name;
protected:
+ RewriteInstance &RI;
+
/// Provides access to the binary context.
BinaryContext &BC;
- MetadataRewriter(StringRef Name, BinaryContext &BC) : Name(Name), BC(BC) {}
+ MetadataRewriter(StringRef Name, RewriteInstance &RI);
+
+ std::optional<uint64_t> lookupSymbol(const StringRef Name);
public:
virtual ~MetadataRewriter() = default;
diff --git a/bolt/include/bolt/Rewrite/MetadataRewriters.h b/bolt/include/bolt/Rewrite/MetadataRewriters.h
index b71bd6cad2505..76face9888235 100644
--- a/bolt/include/bolt/Rewrite/MetadataRewriters.h
+++ b/bolt/include/bolt/Rewrite/MetadataRewriters.h
@@ -19,13 +19,13 @@ class BinaryContext;
// The list of rewriter build functions.
-std::unique_ptr<MetadataRewriter> createLinuxKernelRewriter(BinaryContext &);
+std::unique_ptr<MetadataRewriter> createLinuxKernelRewriter(RewriteInstance &);
-std::unique_ptr<MetadataRewriter> createBuildIDRewriter(BinaryContext &);
+std::unique_ptr<MetadataRewriter> createBuildIDRewriter(RewriteInstance &);
-std::unique_ptr<MetadataRewriter> createPseudoProbeRewriter(BinaryContext &);
+std::unique_ptr<MetadataRewriter> createPseudoProbeRewriter(RewriteInstance &);
-std::unique_ptr<MetadataRewriter> createSDTRewriter(BinaryContext &);
+std::unique_ptr<MetadataRewriter> createSDTRewriter(RewriteInstance &);
} // namespace bolt
} // namespace llvm
diff --git a/bolt/include/bolt/Rewrite/RewriteInstance.h b/bolt/include/bolt/Rewrite/RewriteInstance.h
index 42094cb732107..3934c8b6ed79e 100644
--- a/bolt/include/bolt/Rewrite/RewriteInstance.h
+++ b/bolt/include/bolt/Rewrite/RewriteInstance.h
@@ -42,6 +42,8 @@ class ProfileReaderBase;
/// optimizations) and rewriting. It also has the logic to coordinate such
/// events.
class RewriteInstance {
+ friend class MetadataRewriter;
+
public:
// This constructor has complex initialization that can fail during
// construction. Constructors can’t return errors, so clients must test \p Err
@@ -471,6 +473,9 @@ class RewriteInstance {
/// Track next available address for new allocatable sections.
uint64_t NextAvailableAddress{0};
+ uint64_t BOLTReservedStartAddress{0};
+ uint64_t BOLTReservedEndAddress{0};
+
/// Location and size of dynamic relocations.
std::optional<uint64_t> DynamicRelocationsAddress;
uint64_t DynamicRelocationsSize{0};
diff --git a/bolt/lib/Core/BinaryBasicBlock.cpp b/bolt/lib/Core/BinaryBasicBlock.cpp
index 2a2192b79bb4b..83b477be02d27 100644
--- a/bolt/lib/Core/BinaryBasicBlock.cpp
+++ b/bolt/lib/Core/BinaryBasicBlock.cpp
@@ -44,6 +44,11 @@ const JumpTable *BinaryBasicBlock::getJumpTable() const {
return JT;
}
+void BinaryBasicBlock::undefineInstLabel(const llvm::MCInst &Inst) const {
+ BinaryContext &BC = Function->getBinaryContext();
+ BC.undefineInstLabel(Inst);
+}
+
void BinaryBasicBlock::adjustNumPseudos(const MCInst &Inst, int Sign) {
BinaryContext &BC = Function->getBinaryContext();
if (BC.MIB->isPseudo(Inst))
diff --git a/bolt/lib/Core/BinaryContext.cpp b/bolt/lib/Core/BinaryContext.cpp
index f9fc536f3569a..5b382d318dffb 100644
--- a/bolt/lib/Core/BinaryContext.cpp
+++ b/bolt/lib/Core/BinaryContext.cpp
@@ -319,7 +319,7 @@ bool BinaryContext::forceSymbolRelocations(StringRef SymbolName) const {
(SymbolName == "__hot_data_start" || SymbolName == "__hot_data_end"))
return true;
- if (SymbolName == "_end")
+ if (SymbolName == "_end" && !IsLinuxKernel)
return true;
return false;
@@ -2110,6 +2110,23 @@ ErrorOr<BinarySection &> BinaryContext::getSectionForAddress(uint64_t Address) {
return std::make_error_code(std::errc::bad_address);
}
+ErrorOr<BinarySection &>
+BinaryContext::getSectionForOutputAddress(uint64_t Address) {
+ for (auto &Sec : allocatableSections()) {
+ // Skip pseudo sections that serve a purpose of creating a corresponding
+ // entry in section header table
+ if (Sec.getOutputContents().empty())
+ continue;
+
+ uint64_t OutputAddress = Sec.getOutputAddress();
+ uint64_t OutputSize = Sec.getOutputSize();
+ if (OutputAddress && OutputAddress <= Address &&
+ Address < OutputAddress + OutputSize)
+ return Sec;
+ }
+ return std::make_error_code(std::errc::bad_address);
+}
+
ErrorOr<StringRef>
BinaryContext::getSectionNameForAddress(uint64_t Address) const {
if (ErrorOr<const BinarySection &> Section = getSectionForAddress(Address))
diff --git a/bolt/lib/Core/BinaryEmitter.cpp b/bolt/lib/Core/BinaryEmitter.cpp
index 1aad25242712f..02a69ae296001 100644
--- a/bolt/lib/Core/BinaryEmitter.cpp
+++ b/bolt/lib/Core/BinaryEmitter.cpp
@@ -287,6 +287,10 @@ void BinaryEmitter::emitFunctions() {
// Emit functions added by BOLT.
emit(BC.getInjectedBinaryFunctions());
+ for (BinaryFunction *BF : SortedFunctions)
+ if (!BF->isEmitted())
+ BF->undefineLabels();
+
// Mark the end of hot text.
if (opts::HotText) {
if (BC.HasWarmSection)
@@ -397,11 +401,11 @@ bool BinaryEmitter::emitFunction(BinaryFunction &Function,
assert((Function.empty() || !(*Function.begin()).isCold()) &&
"first basic block should never be cold");
- // Emit UD2 at the beginning if requested by user.
+ // Emit undefined instruction at the beginning if requested by user.
if (!opts::BreakFunctionNames.empty()) {
for (std::string &Name : opts::BreakFunctionNames) {
if (Function.hasNameRegex(Name)) {
- Streamer.emitIntValue(0x0B0F, 2); // UD2: 0F 0B
+ Streamer.emitBytes(BC.MIB->getUndefFillValue());
break;
}
}
diff --git a/bolt/lib/Core/BinaryFunction.cpp b/bolt/lib/Core/BinaryFunction.cpp
index ff5eb5cf6e1eb..3e7e8f6f861ed 100644
--- a/bolt/lib/Core/BinaryFunction.cpp
+++ b/bolt/lib/Core/BinaryFunction.cpp
@@ -3047,17 +3047,11 @@ uint64_t BinaryFunction::getInstructionCount() const {
}
void BinaryFunction::clearDisasmState() {
+ undefineLabels();
+
clearList(Instructions);
clearList(IgnoredBranches);
clearList(TakenBranches);
-
- if (BC.HasRelocations) {
- for (std::pair<const uint32_t, MCSymbol *> &LI : Labels)
- BC.UndefinedSymbols.insert(LI.second);
- for (MCSymbol *const EndLabel : FunctionEndLabels)
- if (EndLabel)
- BC.UndefinedSymbols.insert(EndLabel);
- }
}
void BinaryFunction::setTrapOnEntry() {
diff --git a/bolt/lib/Core/BinarySection.cpp b/bolt/lib/Core/BinarySection.cpp
index b16e0a4333aa2..c4f5e171657f0 100644
--- a/bolt/lib/Core/BinarySection.cpp
+++ b/bolt/lib/Core/BinarySection.cpp
@@ -130,6 +130,18 @@ void BinarySection::emitAsData(MCStrea...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/130931
More information about the llvm-commits
mailing list