!173 [BOLT] Add support for kernel instrumentation of aarch64

From: @polaris_jiang 
Reviewed-by: @chenzheng1030, @liyunfei33 
Signed-off-by: @liyunfei33

Author: openeuler-ci-bot

bolt/CMakeLists.txt

@@ -89,7 +89,7 @@ if (LLVM_INCLUDE_TESTS)
 endif()
 
 if (BOLT_ENABLE_RUNTIME)
-  message(STATUS "Building BOLT runtime libraries for X86")
+  message(STATUS "Building BOLT runtime libraries")
   set(extra_args "")
   if(CMAKE_SYSROOT)
     list(APPEND extra_args -DCMAKE_SYSROOT=${CMAKE_SYSROOT})

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
@@ -250,10 +242,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

bolt/include/bolt/Core/BinaryBasicBlock.h

@@ -689,17 +689,24 @@ class BinaryBasicBlock {
 
   void setCanOutline(const bool Flag) { CanOutline = Flag; }
 
+  void undefineLabels() {
+    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);
   }
 
   /// Erase non-pseudo instruction at a given iterator \p II.
   /// Return iterator following the removed instruction.
   iterator eraseInstruction(iterator II) {
     adjustNumPseudos(*II, -1);
+    undefineInstLabel(*II);
     return Instructions.erase(II);
   }
 
@@ -717,6 +724,7 @@ class BinaryBasicBlock {
 
   /// Erase all instructions.
   void clear() {
+    undefineLabels();
     Instructions.clear();
     NumPseudos = 0;
   }
@@ -741,6 +749,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();
   }
@@ -913,6 +922,8 @@ class BinaryBasicBlock {
   uint64_t getHash() const { return Hash; }
 
 private:
+  void undefineInstLabel(const llvm::MCInst &Inst);
+
   void adjustNumPseudos(const MCInst &Inst, int Sign);
 
   template <typename Itr> void adjustNumPseudos(Itr Begin, Itr End, int Sign) {

bolt/include/bolt/Core/BinaryContext.h

@@ -426,6 +426,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();
@@ -538,6 +545,11 @@ class BinaryContext {
   /// binary and functions created by BOLT.
   std::vector<BinaryFunction *> getAllBinaryFunctions();
 
+  void undefineInstLabel(const MCInst &Inst) {
+    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.
   ///
@@ -606,6 +618,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;
 
@@ -749,6 +764,8 @@ class BinaryContext {
   /// Area in the input binary reserved for BOLT.
   AddressRange BOLTReserved;
 
+  AddressRange BOLTReservedRW;
+
   /// Address of the code/function that is executed before any other code in
   /// the binary.
   std::optional<uint64_t> StartFunctionAddress;
@@ -884,7 +901,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();
@@ -1202,6 +1223,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);

bolt/include/bolt/Core/BinaryData.h

@@ -169,6 +169,11 @@ class BinaryData {
     return Parent && (Parent == BD || Parent->isAncestorOf(BD));
   }
 
+  void updateSize(uint64_t N) {
+    if (N > Size)
+      Size = N;
+  }
+
   void setIsMoveable(bool Flag) { IsMoveable = Flag; }
   void setSection(BinarySection &NewSection);
   void setOutputSection(BinarySection &NewSection) {

bolt/include/bolt/Core/BinaryFunction.h

@@ -295,6 +295,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.
@@ -1176,6 +1182,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 (BinaryBasicBlock *BB : BasicBlocks)
+      BB->undefineLabels();
+  }
+
   /// Return MC symbol associated with the end of the function.
   MCSymbol *
   getFunctionEndLabel(const FragmentNum Fragment = FragmentNum::main()) const {
@@ -1221,6 +1242,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; }
 
@@ -1296,6 +1328,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.
@@ -1723,6 +1761,8 @@ class BinaryFunction {
   /// Mark the function as using ORC format for stack unwinding.
   void setHasORC(bool V) { HasORC = V; }
 
+  void setMayChange() { MayChange = true; }
+
   BinaryFunction &setPersonalityFunction(uint64_t Addr) {
     assert(!PersonalityFunction && "can't set personality function twice");
     PersonalityFunction = BC.getOrCreateGlobalSymbol(Addr, "FUNCat");

bolt/include/bolt/Core/BinarySection.h

@@ -390,6 +390,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);

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();

bolt/include/bolt/Core/MCPlusBuilder.h

@@ -672,6 +672,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:

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); }