Merge branch 'main' into dwarf-pauth-llvm-dinodes

Author: kovdan01

.github/CODEOWNERS

@@ -27,6 +27,7 @@
 /llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp @nikic
 /llvm/lib/Transforms/InstCombine/ @nikic
 
+/clang/include/clang/Sema/Sema.h @Endilll
 /clang/test/CXX/drs/ @Endilll
 /clang/www/cxx_dr_status.html @Endilll
 /clang/www/make_cxx_dr_status @Endilll

bolt/lib/Core/ParallelUtilities.cpp

@@ -49,7 +49,7 @@ namespace ParallelUtilities {
 
 namespace {
 /// A single thread pool that is used to run parallel tasks
-std::unique_ptr<ThreadPool> ThreadPoolPtr;
+std::unique_ptr<DefaultThreadPool> ThreadPoolPtr;
 
 unsigned computeCostFor(const BinaryFunction &BF,
                         const PredicateTy &SkipPredicate,
@@ -106,7 +106,7 @@ ThreadPoolInterface &getThreadPool() {
   if (ThreadPoolPtr.get())
     return *ThreadPoolPtr;
 
-  ThreadPoolPtr = std::make_unique<ThreadPool>(
+  ThreadPoolPtr = std::make_unique<DefaultThreadPool>(
       llvm::hardware_concurrency(opts::ThreadCount));
   return *ThreadPoolPtr;
 }

bolt/lib/Rewrite/LinuxKernelRewriter.cpp

@@ -36,6 +36,10 @@ static cl::opt<bool>
     DumpORC("dump-orc", cl::desc("dump raw ORC unwind information (sorted)"),
             cl::init(false), cl::Hidden, cl::cat(BoltCategory));
 
+static cl::opt<bool> DumpParavirtualPatchSites(
+    "dump-para-sites", cl::desc("dump Linux kernel paravitual patch sites"),
+    cl::init(false), cl::Hidden, cl::cat(BoltCategory));
+
 static cl::opt<bool> DumpStaticCalls("dump-static-calls",
                                      cl::desc("dump Linux kernel static calls"),
                                      cl::init(false), cl::Hidden,
@@ -147,6 +151,18 @@ class LinuxKernelRewriter final : public MetadataRewriter {
   /// Functions with exception handling code.
   DenseSet<BinaryFunction *> FunctionsWithExceptions;
 
+  /// Section with paravirtual patch sites.
+  ErrorOr<BinarySection &> ParavirtualPatchSection = std::errc::bad_address;
+
+  /// Alignment of paravirtual patch structures.
+  static constexpr size_t PARA_PATCH_ALIGN = 8;
+
+  /// Section containing Linux bug table.
+  ErrorOr<BinarySection &> BugTableSection = std::errc::bad_address;
+
+  /// Size of bug_entry struct.
+  static constexpr size_t BUG_TABLE_ENTRY_SIZE = 12;
+
   /// Insert an LKMarker for a given code pointer \p PC from a non-code section
   /// \p SectionName.
   void insertLKMarker(uint64_t PC, uint64_t SectionOffset,
@@ -162,9 +178,6 @@ class LinuxKernelRewriter final : public MetadataRewriter {
   /// Process __ksymtab and __ksymtab_gpl.
   void processLKKSymtab(bool IsGPL = false);
 
-  /// Process special linux kernel section, __bug_table.
-  void processLKBugTable();
-
   /// Process special linux kernel section, .smp_locks.
   void processLKSMPLocks();
 
@@ -187,6 +200,11 @@ class LinuxKernelRewriter final : public MetadataRewriter {
   Error readExceptionTable();
   Error rewriteExceptionTable();
 
+  /// Paravirtual instruction patch sites.
+  Error readParaInstructions();
+
+  Error readBugTable();
+
   /// Mark instructions referenced by kernel metadata.
   Error markInstructions();
 
@@ -208,6 +226,12 @@ class LinuxKernelRewriter final : public MetadataRewriter {
     if (Error E = readExceptionTable())
       return E;
 
+    if (Error E = readParaInstructions())
+      return E;
+
+    if (Error E = readBugTable())
+      return E;
+
     return Error::success();
   }
 
@@ -273,7 +297,6 @@ void LinuxKernelRewriter::processLKSections() {
   processLKPCIFixup();
   processLKKSymtab();
   processLKKSymtab(true);
-  processLKBugTable();
   processLKSMPLocks();
 }
 
@@ -340,37 +363,6 @@ void LinuxKernelRewriter::processLKKSymtab(bool IsGPL) {
   }
 }
 
-/// Process __bug_table section.
-/// This section contains information useful for kernel debugging.
-/// Each entry in the section is a struct bug_entry that contains a pointer to
-/// the ud2 instruction corresponding to the bug, corresponding file name (both
-/// pointers use PC relative offset addressing), line number, and flags.
-/// The definition of the struct bug_entry can be found in
-/// `include/asm-generic/bug.h`
-void LinuxKernelRewriter::processLKBugTable() {
-  ErrorOr<BinarySection &> SectionOrError =
-      BC.getUniqueSectionByName("__bug_table");
-  if (!SectionOrError)
-    return;
-
-  const uint64_t SectionSize = SectionOrError->getSize();
-  const uint64_t SectionAddress = SectionOrError->getAddress();
-  assert((SectionSize % 12) == 0 &&
-         "The size of the __bug_table section should be a multiple of 12");
-  for (uint64_t I = 0; I < SectionSize; I += 12) {
-    const uint64_t EntryAddress = SectionAddress + I;
-    ErrorOr<uint64_t> Offset = BC.getSignedValueAtAddress(EntryAddress, 4);
-    assert(Offset &&
-           "Reading valid PC-relative offset for a __bug_table entry");
-    const int32_t SignedOffset = *Offset;
-    const uint64_t RefAddress = EntryAddress + SignedOffset;
-    assert(BC.getBinaryFunctionContainingAddress(RefAddress) &&
-           "__bug_table entries should point to a function");
-
-    insertLKMarker(RefAddress, I, SignedOffset, true, "__bug_table");
-  }
-}
-
 /// .smp_locks section contains PC-relative references to instructions with LOCK
 /// prefix. The prefix can be converted to NOP at boot time on non-SMP systems.
 void LinuxKernelRewriter::processLKSMPLocks() {
@@ -1013,6 +1005,133 @@ Error LinuxKernelRewriter::rewriteExceptionTable() {
   return Error::success();
 }
 
+/// .parainsrtuctions section contains information for patching parvirtual call
+/// instructions during runtime. The entries in the section are in the form:
+///
+///    struct paravirt_patch_site {
+///      u8 *instr;    /* original instructions */
+///      u8 type;      /* type of this instruction */
+///      u8 len;       /* length of original instruction */
+///    };
+///
+/// Note that the structures are aligned at 8-byte boundary.
+Error LinuxKernelRewriter::readParaInstructions() {
+  ParavirtualPatchSection = BC.getUniqueSectionByName(".parainstructions");
+  if (!ParavirtualPatchSection)
+    return Error::success();
+
+  DataExtractor DE = DataExtractor(ParavirtualPatchSection->getContents(),
+                                   BC.AsmInfo->isLittleEndian(),
+                                   BC.AsmInfo->getCodePointerSize());
+  uint32_t EntryID = 0;
+  DataExtractor::Cursor Cursor(0);
+  while (Cursor && !DE.eof(Cursor)) {
+    const uint64_t NextOffset = alignTo(Cursor.tell(), Align(PARA_PATCH_ALIGN));
+    if (!DE.isValidOffset(NextOffset))
+      break;
+
+    Cursor.seek(NextOffset);
+
+    const uint64_t InstrLocation = DE.getU64(Cursor);
+    const uint8_t Type = DE.getU8(Cursor);
+    const uint8_t Len = DE.getU8(Cursor);
+
+    if (!Cursor)
+      return createStringError(errc::executable_format_error,
+                               "out of bounds while reading .parainstructions");
+
+    ++EntryID;
+
+    if (opts::DumpParavirtualPatchSites) {
+      BC.outs() << "Paravirtual patch site: " << EntryID << '\n';
+      BC.outs() << "\tInstr: 0x" << Twine::utohexstr(InstrLocation)
+                << "\n\tType:  0x" << Twine::utohexstr(Type) << "\n\tLen:   0x"
+                << Twine::utohexstr(Len) << '\n';
+    }
+
+    BinaryFunction *BF = BC.getBinaryFunctionContainingAddress(InstrLocation);
+    if (!BF && opts::Verbosity) {
+      BC.outs() << "BOLT-INFO: no function matches address 0x"
+                << Twine::utohexstr(InstrLocation)
+                << " referenced by paravirutal patch site\n";
+    }
+
+    if (BF && BC.shouldEmit(*BF)) {
+      MCInst *Inst =
+          BF->getInstructionAtOffset(InstrLocation - BF->getAddress());
+      if (!Inst)
+        return createStringError(errc::executable_format_error,
+                                 "no instruction at address 0x%" PRIx64
+                                 " in paravirtual call site %d",
+                                 InstrLocation, EntryID);
+      BC.MIB->addAnnotation(*Inst, "ParaSite", EntryID);
+    }
+  }
+
+  BC.outs() << "BOLT-INFO: parsed " << EntryID << " paravirtual patch sites\n";
+
+  return Error::success();
+}
+
+/// Process __bug_table section.
+/// This section contains information useful for kernel debugging.
+/// Each entry in the section is a struct bug_entry that contains a pointer to
+/// the ud2 instruction corresponding to the bug, corresponding file name (both
+/// pointers use PC relative offset addressing), line number, and flags.
+/// The definition of the struct bug_entry can be found in
+/// `include/asm-generic/bug.h`
+///
+/// NB: find_bug() uses linear search to match an address to an entry in the bug
+///     table. Hence there is no need to sort entries when rewriting the table.
+Error LinuxKernelRewriter::readBugTable() {
+  BugTableSection = BC.getUniqueSectionByName("__bug_table");
+  if (!BugTableSection)
+    return Error::success();
+
+  if (BugTableSection->getSize() % BUG_TABLE_ENTRY_SIZE)
+    return createStringError(errc::executable_format_error,
+                             "bug table size error");
+
+  const uint64_t SectionAddress = BugTableSection->getAddress();
+  DataExtractor DE(BugTableSection->getContents(), BC.AsmInfo->isLittleEndian(),
+                   BC.AsmInfo->getCodePointerSize());
+  DataExtractor::Cursor Cursor(0);
+  uint32_t EntryID = 0;
+  while (Cursor && Cursor.tell() < BugTableSection->getSize()) {
+    const uint64_t Pos = Cursor.tell();
+    const uint64_t InstAddress =
+        SectionAddress + Pos + (int32_t)DE.getU32(Cursor);
+    Cursor.seek(Pos + BUG_TABLE_ENTRY_SIZE);
+
+    if (!Cursor)
+      return createStringError(errc::executable_format_error,
+                               "out of bounds while reading __bug_table");
+
+    ++EntryID;
+
+    BinaryFunction *BF = BC.getBinaryFunctionContainingAddress(InstAddress);
+    if (!BF && opts::Verbosity) {
+      BC.outs() << "BOLT-INFO: no function matches address 0x"
+                << Twine::utohexstr(InstAddress)
+                << " referenced by bug table\n";
+    }
+
+    if (BF && BC.shouldEmit(*BF)) {
+      MCInst *Inst = BF->getInstructionAtOffset(InstAddress - BF->getAddress());
+      if (!Inst)
+        return createStringError(errc::executable_format_error,
+                                 "no instruction at address 0x%" PRIx64
+                                 " referenced by bug table entry %d",
+                                 InstAddress, EntryID);
+      BC.MIB->addAnnotation(*Inst, "BugEntry", EntryID);
+    }
+  }
+
+  BC.outs() << "BOLT-INFO: parsed " << EntryID << " bug table entries\n";
+
+  return Error::success();
+}
+
 } // namespace
 
 std::unique_ptr<MetadataRewriter>

bolt/test/X86/gotpcrelx.s

@@ -5,8 +5,7 @@
 ## kinds of handling of the relocation by the linker (no relaxation, pic, and
 ## non-pic).
 
-# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux \
-# RUN:   -relax-relocations %s -o %t.o
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t.exe -q
 # RUN: ld.lld %t.o -o %t.pie.exe -q -pie
 # RUN: ld.lld %t.o -o %t.no-relax.exe -q --no-relax

bolt/test/X86/linux-bug-table.s

@@ -0,0 +1,46 @@
+# REQUIRES: system-linux
+
+## Check that BOLT correctly parses the Linux kernel __bug_table section.
+
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
+# RUN: %clang %cflags -nostdlib %t.o -o %t.exe \
+# RUN:   -Wl,--image-base=0xffffffff80000000,--no-dynamic-linker,--no-eh-frame-hdr,--no-pie
+
+## Verify bug entry bindings to instructions.
+
+# RUN: llvm-bolt %t.exe --print-normalized -o %t.out | FileCheck %s
+
+# CHECK:      BOLT-INFO: Linux kernel binary detected
+# CHECK:      BOLT-INFO: parsed 2 bug table entries
+
+  .text
+  .globl _start
+  .type _start, %function
+_start:
+# CHECK: Binary Function "_start"
+  nop
+.L0:
+  ud2
+# CHECK:      ud2
+# CHECK-SAME: BugEntry: 1
+  nop
+.L1:
+  ud2
+# CHECK:      ud2
+# CHECK-SAME: BugEntry: 2
+  ret
+  .size _start, .-_start
+
+
+## Bug table.
+  .section __bug_table,"a",@progbits
+1:
+  .long .L0 - .  # instruction
+  .org 1b + 12
+2:
+  .long .L1 - .  # instruction
+  .org 2b + 12
+
+## Fake Linux Kernel sections.
+  .section __ksymtab,"a",@progbits
+  .section __ksymtab_gpl,"a",@progbits

bolt/test/X86/linux-parainstructions.s

@@ -0,0 +1,54 @@
+# REQUIRES: system-linux
+
+## Check that BOLT correctly parses the Linux kernel .parainstructions section.
+
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
+# RUN: %clang %cflags -nostdlib %t.o -o %t.exe \
+# RUN:   -Wl,--image-base=0xffffffff80000000,--no-dynamic-linker,--no-eh-frame-hdr,--no-pie
+
+## Verify paravirtual bindings to instructions.
+
+# RUN: llvm-bolt %t.exe --print-normalized -o %t.out | FileCheck %s
+
+# CHECK:      BOLT-INFO: Linux kernel binary detected
+# CHECK:      BOLT-INFO: parsed 2 paravirtual patch sites
+
+  .rodata
+fptr:
+  .quad 0
+
+  .text
+  .globl _start
+  .type _start, %function
+_start:
+# CHECK: Binary Function "_start"
+  nop
+.L1:
+  call *fptr(%rip)
+# CHECK:      call
+# CHECK-SAME: ParaSite: 1
+  nop
+.L2:
+  call *fptr(%rip)
+# CHECK:      call
+# CHECK-SAME: ParaSite: 2
+  ret
+  .size _start, .-_start
+
+
+## Paravirtual patch sites.
+  .section .parainstructions,"a",@progbits
+
+  .balign 8
+  .quad .L1      # instruction
+  .byte 1        # type
+  .byte 7        # length
+
+  .balign 8
+  .quad .L2      # instruction
+  .byte 1        # type
+  .byte 7        # length
+
+## Fake Linux Kernel sections.
+  .section __ksymtab,"a",@progbits
+  .section __ksymtab_gpl,"a",@progbits

bolt/test/X86/pt_gnu_relro.s

@@ -3,7 +3,7 @@
 # Check that BOLT recognizes PT_GNU_RELRO segment and marks respective sections
 # accordingly.
 
-# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux %s -o %t.o -relax-relocations
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t.exe -q --no-relax
 # RUN: llvm-readelf -We %t.exe | FileCheck --check-prefix=READELF %s
 # Unfortunately there's no direct way to extract a segment to section mapping