toolchain-bootstrap: apply patches related to computed gotos

The vendored patches were produced from the latest versions of the
following PRs:

* llvm/llvm-project#114990
* llvm/llvm-project#120267

The first improves codegen for computed gotos. There was a
regression in LLVM 19 causing a ~10% performance drop in CPython.

The second enables BOLT to work with computed gotos. This enables
BOLT to accomplish more on CPython.

Author: indygreg

toolchain-bootstrap/Earthfile

@@ -367,6 +367,7 @@ llvm-gnu-x86-64-linux-build:
   FOR toolchain IN cpython-x86-64-linux clang-bootstrap-x86-64-linux zstd-x86-64-linux
     COPY +$toolchain/install /toolchain/
   END
+  COPY patches/*.patch /build/
   COPY scripts/clang-gnu-stage2.sh /build/
   RUN --secret SCCACHE_REGION --secret SCCACHE_BUCKET --secret AWS_ACCESS_KEY_ID --secret AWS_SECRET_ACCESS_KEY \
     PARALLEL_NINJA=${PARALLEL_NINJA} NINJA_MAX_LOAD=${NINJA_MAX_LOAD} \

toolchain-bootstrap/patches/bolt-computed-gotos.patch

@@ -0,0 +1,271 @@
+commit 430cceda43be7e9306823fcacbd3c91c1f1a29d2
+Author: Gregory Szorc <[email protected]>
+Date:   Sat Mar 8 13:30:46 2025 -0800
+
+    Squashed commit of the following:
+    
+    commit bb4bf9f4c3ce9eae007b623e9be07f7338db7905
+    Author: Ash Dobrescu <[email protected]>
+    Date:   Wed Feb 26 12:48:20 2025 +0000
+    
+        Fix error message.
+    
+    commit 8b51075b1b88f1265cfc117387a306c243c1e9bd
+    Author: Ash Dobrescu <[email protected]>
+    Date:   Tue Feb 25 16:42:08 2025 +0000
+    
+        Add extra check and formatting.
+    
+    commit fea7541c63daa16d533bbe54e395837610d6927c
+    Author: Ash Dobrescu <[email protected]>
+    Date:   Fri Feb 7 14:42:22 2025 +0000
+    
+        Remove unnecessary brackets
+    
+    commit fb865642f7d3cefaa52477dc8ae3bc03770cfef1
+    Author: Ash Dobrescu <[email protected]>
+    Date:   Fri Feb 7 14:23:57 2025 +0000
+    
+        Add BOLT-ERRORs
+    
+    commit db722a9b5d02d90cdd647f3429c0636653093844
+    Author: Ash Dobrescu <[email protected]>
+    Date:   Wed Feb 5 15:45:32 2025 +0000
+    
+        Add checks
+    
+    commit 39d46f3762fbc7efcf4bd8a9adce5616cbacbcd3
+    Author: Ash Dobrescu <[email protected]>
+    Date:   Fri Jan 31 12:23:01 2025 +0000
+    
+        Address comments regarding tests
+    
+    commit b44c28a7ff27b48e8ce3db6842599c725d0b57e9
+    Author: Rin Dobrescu <[email protected]>
+    Date:   Thu Jan 23 10:45:38 2025 +0000
+    
+        Fix formatting issue.
+    
+    commit b1d80333d48237f39efbdabe82fe2514bc77e753
+    Author: Rin Dobrescu <[email protected]>
+    Date:   Mon Jan 20 14:50:11 2025 +0000
+    
+        Add target independent test.
+    
+    commit 1dd6d5a0d6b572036a004bb87a1a204fa0c5dd84
+    Author: Rin Dobrescu <[email protected]>
+    Date:   Tue Dec 31 12:45:05 2024 +0000
+    
+        Remove redundant test and expand different test.
+    
+    commit dd67da54eba30b68350cc95f6e3eeb31d9dbb9ce
+    Author: Rin Dobrescu <[email protected]>
+    Date:   Wed Dec 18 12:11:10 2024 +0000
+    
+        Fix clang-format and address PR comments.
+    
+    commit f6435e5499dd0384820381bf85995b823789c279
+    Author: Rin Dobrescu <[email protected]>
+    Date:   Tue Dec 17 16:43:33 2024 +0000
+    
+        [BOLT][AArch64] Create entry points for addresses referenced by dynamic relocations and allow getNewFunctionOrDataAddress to map addrs inside functions.
+    
+        By adding addresses referenced by dynamic relocations as entry points,
+        this patch fixes an issue where bolt fails on code using computing
+        goto's. This also fixes a mapping issue with the bugfix from this
+        PR: https://github.com/llvm/llvm-project/pull/117766.
+
+diff --git a/bolt/lib/Rewrite/RewriteInstance.cpp b/bolt/lib/Rewrite/RewriteInstance.cpp
+index 4329235d4704..1439b88c253d 100644
+--- a/bolt/lib/Rewrite/RewriteInstance.cpp
++++ b/bolt/lib/Rewrite/RewriteInstance.cpp
+@@ -2439,6 +2439,33 @@ void RewriteInstance::readDynamicRelocations(const SectionRef &Section,
+     if (Symbol)
+       SymbolIndex[Symbol] = getRelocationSymbol(InputFile, Rel);
+ 
++    const uint64_t ReferencedAddress = SymbolAddress + Addend;
++    BinaryFunction *Func =
++        BC->getBinaryFunctionContainingAddress(ReferencedAddress);
++
++    if (Relocation::isRelative(RType) && SymbolAddress == 0) {
++      if (Func) {
++        if (!Func->isInConstantIsland(ReferencedAddress)) {
++          if (const uint64_t ReferenceOffset =
++                  ReferencedAddress - Func->getAddress()) {
++            Func->addEntryPointAtOffset(ReferenceOffset);
++          } else if (ReferencedAddress < Func->getAddress()) {
++            BC->errs() << "BOLT-ERROR: Unable to compute symbol offset.\n";
++            exit(1);
++          }
++        } else {
++          BC->errs() << "BOLT-ERROR: referenced address: " << ReferencedAddress
++                     << " is in constant island of function : " << *Func
++                     << "\n";
++          exit(1);
++        }
++      }
++    } else if (Relocation::isRelative(RType) && SymbolAddress != 0) {
++      BC->errs() << "BOLT-ERROR: symbol address non zero for RELATIVE "
++                    "relocation type.\n";
++      exit(1);
++    }
++
+     BC->addDynamicRelocation(Rel.getOffset(), Symbol, RType, Addend);
+   }
+ }
+@@ -5599,7 +5626,7 @@ uint64_t RewriteInstance::getNewFunctionOrDataAddress(uint64_t OldAddress) {
+         for (const BinaryBasicBlock &BB : *BF)
+           if (BB.isEntryPoint() &&
+               (BF->getAddress() + BB.getOffset()) == OldAddress)
+-            return BF->getOutputAddress() + BB.getOffset();
++            return BB.getOutputStartAddress();
+       }
+       BC->errs() << "BOLT-ERROR: unable to get new address corresponding to "
+                     "input address 0x"
+diff --git a/bolt/test/AArch64/computed-goto.s b/bolt/test/AArch64/computed-goto.s
+new file mode 100644
+index 000000000000..5d775b9a6aea
+--- /dev/null
++++ b/bolt/test/AArch64/computed-goto.s
+@@ -0,0 +1,67 @@
++// This test checks that BOLT creates entry points for addresses
++// referenced by dynamic relocations.
++// The test also checks that BOLT can map addresses inside functions.
++
++// Checks for error and entry points.
++# RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown %s -o %t.o
++# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
++# RUN: llvm-bolt %t.exe -o %t.bolt 2>&1 | FileCheck %s
++# RUN: llvm-bolt %t.exe -o %t.bolt --print-cfg | FileCheck --check-prefix=CHECK-ENTRIES %s
++
++// Checks for dynamic relocations.
++# RUN: llvm-readelf -dr %t.bolt > %t.out.txt
++# RUN: llvm-objdump -j .rela.dyn -d %t.bolt >> %t.out.txt
++# RUN: FileCheck --check-prefix=CHECK-RELOCS %s --input-file=%t.out.txt
++
++// Before bolt could handle mapping addresses within moved functions, it
++// would bail out with an error of the form:
++// BOLT-ERROR: unable to get new address corresponding to input address 0x10390 in function main. Consider adding this function to --skip-funcs=...
++// These addresses arise if computed GOTO is in use.
++// Check that bolt does not emit any error.
++# CHECK-NOT: BOLT-ERROR
++
++// Check that there are dynamic relocations.
++# CHECK-RELOCS:     Dynamic section at offset {{.*}} contains {{.*}} entries:
++# CHECK-RELOCS:     Relocation section '.rela.dyn' at offset {{.*}} contains {{.*}} entries
++
++// Check that dynamic relocations were updated
++# CHECK-RELOCS: [[#%x,OFF:]] [[#%x,INFO_DYN:]] R_AARCH64_RELATIVE [[#%x,ADDR:]]
++# CHECK-RELOCS-NEXT: [[#OFF + 8]] {{0*}}[[#INFO_DYN]] R_AARCH64_RELATIVE [[#ADDR + 8]]
++# CHECK-RELOCS: [[#ADDR]] <unknown>
++# CHECK-RELOCS: [[#ADDR + 8]] <unknown>
++
++// Check that BOLT registers extra entry points for dynamic relocations.
++# CHECK-ENTRIES: Binary Function "main" after building cfg {
++# CHECK-ENTRIES:  IsMultiEntry: 1
++# CHECK-ENTRIES: .Ltmp0 {{.*}}
++# CHECK-ENTRIES-NEXT: Secondary Entry Point: {{.*}}
++# CHECK-ENTRIES: .Ltmp1 {{.*}}
++# CHECK-ENTRIES-NEXT: Secondary Entry Point: {{.*}}
++
++.globl  main
++.p2align        2
++.type   main,@function
++main:
++.cfi_startproc
++        adrp    x8, .L__const.main.ptrs+8
++        add     x8, x8, :lo12:.L__const.main.ptrs+8
++        ldr     x9, [x8], #8
++        br      x9
++
++.Label0: // Block address taken
++        ldr     x9, [x8], #8
++        br      x9
++
++.Label1: // Block address taken
++        mov     w0, #42
++        ret
++
++.Lfunc_end0:
++.size   main, .Lfunc_end0-main
++.cfi_endproc
++        .type   .L__const.main.ptrs,@object
++        .section        .data.rel.ro,"aw",@progbits
++        .p2align        3, 0x0
++.L__const.main.ptrs:
++        .xword  .Label0
++        .xword  .Label1
+diff --git a/bolt/test/X86/Inputs/indirect_goto.c b/bolt/test/Inputs/indirect_goto.c
+similarity index 64%
+rename from bolt/test/X86/Inputs/indirect_goto.c
+rename to bolt/test/Inputs/indirect_goto.c
+index b781e9e03b6d..5b8d91526441 100644
+--- a/bolt/test/X86/Inputs/indirect_goto.c
++++ b/bolt/test/Inputs/indirect_goto.c
+@@ -1,6 +1,6 @@
+ int main(int argc, char *argv[]) {
+-  static const void *T1[] = { &&L1, &&L2 };
+-  static const void *T2[] = { &&L2, &&L3 };
++  static const void *T1[] = {&&L1, &&L2};
++  static const void *T2[] = {&&L2, &&L3};
+ 
+   const void **T = (argc > 1) ? T1 : T2;
+ 
+diff --git a/bolt/test/X86/indirect-goto-pie.test b/bolt/test/X86/indirect-goto-pie.test
+deleted file mode 100644
+index 3311c1aec061..000000000000
+--- a/bolt/test/X86/indirect-goto-pie.test
++++ /dev/null
+@@ -1,16 +0,0 @@
+-## Check that llvm-bolt fails to process PIC binaries with computed goto, as the
+-## support is not there yet for correctly updating dynamic relocations
+-## referencing code inside functions.
+-
+-REQUIRES: x86_64-linux
+-
+-RUN: %clang %S/Inputs/indirect_goto.c -o %t -fpic -pie -Wl,-q
+-RUN: not llvm-bolt %t -o %t.bolt --relocs=1 --print-cfg --print-only=main \
+-RUN:   2>&1 | FileCheck %s
+-
+-## Check that processing works if main() is skipped.
+-RUN: llvm-bolt %t -o %t.bolt --relocs=1 --skip-funcs=main
+-
+-CHECK:  jmpq    *%rax # UNKNOWN CONTROL FLOW
+-
+-CHECK: BOLT-ERROR: unable to get new address
+diff --git a/bolt/test/X86/indirect-goto.test b/bolt/test/X86/indirect-goto.test
+index 8d2cb5e62a97..aeb89de3f2fc 100644
+--- a/bolt/test/X86/indirect-goto.test
++++ b/bolt/test/X86/indirect-goto.test
+@@ -1,5 +1,5 @@
+ ## Check llvm-bolt processes binaries compiled from sources that use indirect goto.
+-RUN: %clang %cflags -no-pie %S/Inputs/indirect_goto.c -Wl,-q -o %t
++RUN: %clang %cflags -no-pie %S/../Inputs/indirect_goto.c -Wl,-q -o %t
+ RUN: llvm-bolt %t -o %t.null --relocs=1 --print-cfg --print-only=main \
+ RUN:   --strict \
+ RUN:   2>&1 | FileCheck %s
+diff --git a/bolt/test/indirect-goto-relocs.test b/bolt/test/indirect-goto-relocs.test
+new file mode 100644
+index 000000000000..30175dcb0b9c
+--- /dev/null
++++ b/bolt/test/indirect-goto-relocs.test
+@@ -0,0 +1,19 @@
++// This test checks that BOLT creates entry points from sources
++// that use indirect goto.
++
++RUN: %clang %cflags -pie %S/Inputs/indirect_goto.c -o %t.exe -Wl,-q
++RUN: llvm-bolt %t.exe -o %t.bolt --print-cfg | FileCheck --check-prefix=CHECK-PIE %s
++
++RUN: %clang %cflags -no-pie %S/Inputs/indirect_goto.c -o %t.exe -Wl,-q
++RUN: llvm-bolt %t.exe -o %t.bolt --print-cfg | FileCheck --check-prefix=CHECK-NO-PIE %s
++
++// Check that BOLT registers extra entry points for dynamic relocations with PIE.
++CHECK-PIE: Binary Function "main" after building cfg {
++CHECK-PIE: IsMultiEntry: 1
++CHECK-PIE: Secondary Entry Points : {{.*}}
++
++// Check that BOLT does not register extra entry points for dynamic relocations
++// without PIE
++CHECK-NO-PIE: Binary Function "main" after building cfg {
++CHECK-NO-PIE-NOT: IsMultiEntry: 1
++CHECK-NO-PIE-NOT: Secondary Entry Points : {{.*}}