LLVM and SPIRV-LLVM-Translator pulldown (WW15)

LLVM: llvm/llvm-project@a113a582b1a2c
SPIRV-LLVM-Translator: KhronosGroup/SPIRV-LLVM-Translator@4611812

Author: bb-sycl

bolt/include/bolt/Core/BinaryFunction.h

@@ -172,6 +172,9 @@ class BinaryFunction {
 
     mutable MCSymbol *FunctionConstantIslandLabel{nullptr};
     mutable MCSymbol *FunctionColdConstantIslandLabel{nullptr};
+
+    // Returns constant island alignment
+    uint16_t getAlignment() const { return sizeof(uint64_t); }
   };
 
   static constexpr uint64_t COUNT_NO_PROFILE =
@@ -2047,6 +2050,10 @@ class BinaryFunction {
     return *std::prev(CodeIter) <= *DataIter;
   }
 
+  uint16_t getConstantIslandAlignment() const {
+    return Islands ? Islands->getAlignment() : 1;
+  }
+
   uint64_t
   estimateConstantIslandSize(const BinaryFunction *OnBehalfOf = nullptr) const {
     if (!Islands)
@@ -2074,9 +2081,13 @@ class BinaryFunction {
       Size += NextMarker - *DataIter;
     }
 
-    if (!OnBehalfOf)
-      for (BinaryFunction *ExternalFunc : Islands->Dependency)
+    if (!OnBehalfOf) {
+      for (BinaryFunction *ExternalFunc : Islands->Dependency) {
+        Size = alignTo(Size, ExternalFunc->getConstantIslandAlignment());
         Size += ExternalFunc->estimateConstantIslandSize(this);
+      }
+    }
+
     return Size;
   }
 

bolt/lib/Core/BinaryContext.cpp

@@ -155,12 +155,17 @@ BinaryContext::createBinaryContext(const ObjectFile *File, bool IsPIC,
         Twine("BOLT-ERROR: no register info for target ", TripleName));
 
   // Set up disassembler.
-  std::unique_ptr<const MCAsmInfo> AsmInfo(
+  std::unique_ptr<MCAsmInfo> AsmInfo(
       TheTarget->createMCAsmInfo(*MRI, TripleName, MCTargetOptions()));
   if (!AsmInfo)
     return createStringError(
         make_error_code(std::errc::not_supported),
         Twine("BOLT-ERROR: no assembly info for target ", TripleName));
+  // BOLT creates "func@PLT" symbols for PLT entries. In function assembly dump
+  // we want to emit such names as using @PLT without double quotes to convey
+  // variant kind to the assembler. BOLT doesn't rely on the linker so we can
+  // override the default AsmInfo behavior to emit names the way we want.
+  AsmInfo->setAllowAtInName(true);
 
   std::unique_ptr<const MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(TripleName, "", FeaturesStr));
@@ -1529,6 +1534,9 @@ void BinaryContext::preprocessDebugInfo() {
 }
 
 bool BinaryContext::shouldEmit(const BinaryFunction &Function) const {
+  if (Function.isPseudo())
+    return false;
+
   if (opts::processAllFunctions())
     return true;
 

bolt/lib/Core/BinaryEmitter.cpp

@@ -277,7 +277,7 @@ void BinaryEmitter::emitFunctions() {
 }
 
 bool BinaryEmitter::emitFunction(BinaryFunction &Function, bool EmitColdPart) {
-  if (Function.size() == 0)
+  if (Function.size() == 0 && !Function.hasIslandsInfo())
     return false;
 
   if (Function.getState() == BinaryFunction::State::Empty)
@@ -500,6 +500,13 @@ void BinaryEmitter::emitConstantIslands(BinaryFunction &BF, bool EmitColdPart,
   if (Islands.DataOffsets.empty() && Islands.Dependency.empty())
     return;
 
+  // AArch64 requires CI to be aligned to 8 bytes due to access instructions
+  // restrictions. E.g. the ldr with imm, where imm must be aligned to 8 bytes.
+  const uint16_t Alignment = OnBehalfOf
+                                 ? OnBehalfOf->getConstantIslandAlignment()
+                                 : BF.getConstantIslandAlignment();
+  Streamer.emitCodeAlignment(Alignment, &*BC.STI);
+
   if (!OnBehalfOf) {
     if (!EmitColdPart)
       Streamer.emitLabel(BF.getFunctionConstantIslandLabel());

bolt/lib/Passes/Aligner.cpp

@@ -172,6 +172,20 @@ void AlignerPass::runOnFunctions(BinaryContext &BC) {
     else
       alignMaxBytes(BF);
 
+    // Align objects that contains constant islands and no code
+    // to at least 8 bytes.
+    if (!BF.size() && BF.hasIslandsInfo()) {
+      const uint16_t Alignment = BF.getConstantIslandAlignment();
+      if (BF.getAlignment() < Alignment)
+        BF.setAlignment(Alignment);
+
+      if (BF.getMaxAlignmentBytes() < Alignment)
+        BF.setMaxAlignmentBytes(Alignment);
+
+      if (BF.getMaxColdAlignmentBytes() < Alignment)
+        BF.setMaxColdAlignmentBytes(Alignment);
+    }
+
     if (opts::AlignBlocks && !opts::PreserveBlocksAlignment)
       alignBlocks(BF, Emitter.MCE.get());
   };

bolt/lib/Passes/LongJmp.cpp

@@ -308,6 +308,7 @@ uint64_t LongJmpPass::tentativeLayoutRelocColdPart(
     LLVM_DEBUG(dbgs() << Func->getPrintName() << " cold tentative: "
                       << Twine::utohexstr(DotAddress) << "\n");
     DotAddress += Func->estimateColdSize();
+    DotAddress = alignTo(DotAddress, Func->getConstantIslandAlignment());
     DotAddress += Func->estimateConstantIslandSize();
   }
   return DotAddress;
@@ -344,6 +345,11 @@ uint64_t LongJmpPass::tentativeLayoutRelocMode(
   CurrentIndex = 0;
   bool ColdLayoutDone = false;
   for (BinaryFunction *Func : SortedFunctions) {
+    if (!BC.shouldEmit(*Func)) {
+      HotAddresses[Func] = Func->getAddress();
+      continue;
+    }
+
     if (!ColdLayoutDone && CurrentIndex >= LastHotIndex) {
       DotAddress =
           tentativeLayoutRelocColdPart(BC, SortedFunctions, DotAddress);
@@ -364,6 +370,8 @@ uint64_t LongJmpPass::tentativeLayoutRelocMode(
       DotAddress += Func->estimateSize();
     else
       DotAddress += Func->estimateHotSize();
+
+    DotAddress = alignTo(DotAddress, Func->getConstantIslandAlignment());
     DotAddress += Func->estimateConstantIslandSize();
     ++CurrentIndex;
   }

bolt/lib/Rewrite/RewriteInstance.cpp

@@ -2350,7 +2350,7 @@ void RewriteInstance::readRelocations(const SectionRef &Section) {
         continue;
     }
 
-    if (BC->getDynamicRelocationAt(Rel.getOffset())) {
+    if (!IsAArch64 && BC->getDynamicRelocationAt(Rel.getOffset())) {
       LLVM_DEBUG(
           dbgs() << "BOLT-DEBUG: address 0x"
                  << Twine::utohexstr(Rel.getOffset())

bolt/test/AArch64/constant-island-alignment.s

@@ -0,0 +1,38 @@
+// This test checks that the constant island is aligned after BOLT tool.
+// In case the nop before .Lci will be removed the pointer to exit function
+// won't be alinged and the test will fail.
+
+# RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \
+# RUN:   %s -o %t.o
+# RUN: %clang %cflags -fPIC -pie %t.o -o %t.exe -Wl,-q \
+# RUN:    -nostartfiles -nodefaultlibs -Wl,-z,notext
+# RUN: llvm-bolt %t.exe -o %t.bolt -use-old-text=0 -lite=0 -trap-old-code
+# RUN: llvm-objdump -d --disassemble-symbols='$d' %t.bolt | FileCheck %s
+
+.text
+.align 4
+.global
+.type dummy, %function
+dummy:
+  add x0, x0, #1
+  ret
+
+.global
+.type exitOk, %function
+exitOk:
+  mov x0, #0
+  ret
+
+.global _start
+.type _start, %function
+_start:
+  adrp x0, .Lci
+  ldr x0, [x0, #:lo12:.Lci]
+  blr x0
+  mov x0, #1
+  ret
+  nop
+# CHECK: {{0|8}} <$d>:
+.Lci:
+  .xword exitOk
+  .xword 0

bolt/test/AArch64/constant_island_pie_update.s

@@ -0,0 +1,38 @@
+// This test checks that the constant island value is updated if it
+// has dynamic relocation.
+
+# RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \
+# RUN:   %s -o %t.o
+# RUN: %clang %cflags -fPIC -pie %t.o -o %t.exe -Wl,-q -nostdlib -Wl,-z,notext
+# RUN: llvm-bolt %t.exe -o %t.bolt -use-old-text=0 -lite=0
+# RUN: llvm-objdump -j .text -dR %t.bolt | FileCheck %s
+
+# CHECK: R_AARCH64_RELATIVE *ABS*+0x[[#%x,ADDR:]]
+# CHECK: [[#ADDR]] <exitLocal>:
+# CHECK: {{.*}} <$d>:
+# CHECK-NEXT: {{.*}} .word 0x{{[0]+}}[[#ADDR]]
+# CHECK-NEXT: {{.*}} .word 0x00000000
+
+  .text
+  .align 4
+  .local exitLocal
+  .type exitLocal, %function
+exitLocal:
+  add x1, x1, #1
+  add x1, x1, #1
+  ret
+  .size exitLocal, .-exitLocal
+
+  .global _start
+  .type _start, %function
+_start:
+  mov x0, #0
+  adr x1, .Lci
+  ldr x1, [x1]
+  blr x1
+  mov x0, #1
+  bl exitLocal
+  nop
+.Lci:
+  .xword exitLocal
+  .size _start, .-_start

bolt/test/AArch64/double_jump.cpp

@@ -52,4 +52,4 @@ unsigned long foo(unsigned long count) {
   return count;
 }
 
-int main(int argc, const char *argv[]) { return foo(38); }
+extern "C" int _start() { return foo(38); }

bolt/test/AArch64/lit.local.cfg

@@ -1,2 +1,7 @@
 if config.host_arch not in ['aarch64']:
     config.unsupported = True
+
+config.substitutions.insert(
+    0, ('%cflags',
+        '%cflags --target=aarch64-pc-linux -nostartfiles -nostdlib -fuse-ld=lld'
+        ' -Wl,--unresolved-symbols=ignore-all'))