delocate: use address helpers for known symbols on aarch64

Replace adr with address helper functions for known global symbols
on aarch64 to remove the ±1MiB PC-relative reach limitation. The
FIPS module .text section now exceeds 1MiB (~1.62MB), causing adr
instructions to fail when referencing symbols far away in the module.

The fix introduces lightweight helper functions that are emitted
outside the FIPS module boundary (after BORINGSSL_bcm_text_end).
These helpers use adrp+add which the linker resolves and which
support ±4GiB range. Inside the module, call sites use bl (±128MiB
range) to reach the helpers, with save/restore of x0 and x30.

This keeps the .text bytes within the hashed FIPS region free of
relocations, preserving the integrity check mechanism. Local .L*
symbols continue to use adr since they are always close to their
reference site.

Benchmarks show no measurable performance impact (all within ±0.36%
noise) since the change only affects address loads of global symbols
during setup/initialization, not hot inner loops.

Author: dkostic

util/fipstools/delocate/delocate.go

@@ -104,7 +104,12 @@ type delocation struct {
 	// tocLoaders is a set of symbol names for which TOC helper functions
 	// are required. (ppc64le only.)
 	tocLoaders map[string]struct{}
-	// gotExternalsNeeded is a set of symbol names for which we need
+	// localAddrHelpers is a set of known symbol names (already converted
+	// to local target names) for which address helper functions are needed
+	// on aarch64. These helpers use adrp+add (which the linker resolves)
+	// and live outside the FIPS module boundary, avoiding the ±1MiB reach
+	// limitation of adr within the module.
+	localAddrHelpers map[string]struct{}	// gotExternalsNeeded is a set of symbol names for which we need
 	// “delta” symbols: symbols that contain the offset from their location
 	// to the memory in question.
 	gotExternalsNeeded map[string]struct{}
@@ -440,6 +445,12 @@ func instructionArgs(node *node32) (argNodes []*node32) {
 
 // Aarch64 support
 
+// localAddrHelperName returns the name of a synthesised function that loads
+// the address of a known symbol using adrp+add (outside the FIPS module).
+func localAddrHelperName(symbol string) string {
+	return ".Lboringssl_loadaddr_" + symbol
+}
+
 // gotHelperName returns the name of a synthesised function that returns an
 // address from the GOT.
 func gotHelperName(symbol string) string {
@@ -449,33 +460,69 @@ func gotHelperName(symbol string) string {
 // loadAarch64Address emits instructions to put the address of |symbol|
 // (optionally adjusted by |offsetStr|) into |targetReg|.
 func (d *delocation) loadAarch64Address(statement *node32, targetReg string, symbol string, offsetStr string) (*node32, error) {
-	// There are two paths here: either the symbol is known to be local in which
-	// case adr is used to get the address (within 1MiB), or a GOT reference is
-	// really needed in which case the code needs to jump to a helper function.
+	// There are three paths here:
+	//
+	// 1. Local (.L*) symbols use adr directly since they are always close
+	//    to their reference site (within ±1MiB).
 	//
-	// A helper function is needed because using code appears to be the only way
-	// to load a GOT value. On other platforms we have ".quad foo@GOT" outside of
-	// the module, but on Aarch64 that results in a "COPY" relocation and linker
-	// comments suggest it's a weird hack. So, for each GOT symbol needed, we emit
-	// a function outside of the module that returns the address from the GOT in
-	// x0.
+	// 2. Known global symbols (defined within the FIPS module) use a helper
+	//    function that lives outside the module boundary. The helper uses
+	//    adrp+add (which the linker resolves) to load the full address.
+	//    This avoids the ±1MiB reach limitation of adr for large modules.
+	//
+	// 3. External/GOT symbols use a helper function that loads and
+	//    dereferences the GOT entry.
 
 	d.writeCommentedNode(statement)
 
 	_, isKnown := d.symbols[symbol]
 	isLocal := strings.HasPrefix(symbol, ".L")
-	if isKnown || isLocal || isSynthesized(symbol, aarch64) {
+	if isLocal || isSynthesized(symbol, aarch64) {
 		if isLocal {
 			symbol = d.mapLocalSymbol(symbol)
-		} else if isKnown {
-			symbol = localTargetName(symbol)
 		}
 
 		d.output.WriteString("\tadr " + targetReg + ", " + symbol + offsetStr + "\n")
 
 		return statement, nil
 	}
 
+	if isKnown {
+		// Known symbols within the module use address helper functions
+		// that live outside the hashed FIPS region. This avoids the ±1MiB
+		// adr reach limit while keeping the module's .text free of
+		// relocations (required for the FIPS integrity check).
+		localSymbol := localTargetName(symbol)
+
+		d.localAddrHelpers[localSymbol] = struct{}{}
+		helperFunc := localAddrHelperName(localSymbol)
+
+		// Use the same save/restore pattern as GOT helpers.
+		d.output.WriteString("\tsub sp, sp, 128\n")
+		d.output.WriteString("\tstp x0, x30, [sp, #-16]!\n")
+		d.output.WriteString("\tbl " + helperFunc + "\n")
+
+		if targetReg == "x0" {
+			d.output.WriteString("\tldp xzr, x30, [sp], #16\n")
+		} else if targetReg == "x30" {
+			d.output.WriteString("\tmov " + targetReg + ", x0\n")
+			d.output.WriteString("\tldp x0, xzr, [sp], #16\n")
+		} else {
+			d.output.WriteString("\tmov " + targetReg + ", x0\n")
+			d.output.WriteString("\tldp x0, x30, [sp], #16\n")
+		}
+
+		d.output.WriteString("\tadd sp, sp, 128\n")
+
+		// If there's an offset (e.g., symbol+4096), add it after loading
+		// the base address.
+		if len(offsetStr) != 0 {
+			d.output.WriteString("\tadd " + targetReg + ", " + targetReg + ", " + offsetStr + "\n")
+		}
+
+		return statement, nil
+	}
+
 	if len(offsetStr) != 0 {
 		panic("non-zero offset for helper-based reference")
 	}
@@ -2291,6 +2338,7 @@ func transform(w stringWriter, includes []string, inputs []inputFile, startEndDe
 		redirectors:              make(map[string]string),
 		bssAccessorsNeeded:       make(map[string]string),
 		tocLoaders:               make(map[string]struct{}),
+		localAddrHelpers:         make(map[string]struct{}),
 		gotExternalsNeeded:       make(map[string]struct{}),
 		gotOffsetsNeeded:         make(map[string]struct{}),
 		gotOffOffsetsNeeded:      make(map[string]struct{}),
@@ -2448,6 +2496,19 @@ func transform(w stringWriter, includes []string, inputs []inputFile, startEndDe
 			})
 		}
 
+		// Emit address helpers for known symbols within the module.
+		// These use adrp+add which the linker resolves, avoiding the
+		// ±1MiB adr reach limit for large FIPS modules.
+		localAddrNames := sortedSet(d.localAddrHelpers)
+		for _, symbol := range localAddrNames {
+			sym := symbol // capture for closure
+			writeAarch64Function(w, localAddrHelperName(sym), func(w stringWriter) {
+				w.WriteString("\tadrp x0, " + sym + "\n")
+				w.WriteString("\tadd x0, x0, :lo12:" + sym + "\n")
+				w.WriteString("\tret\n")
+			})
+		}
+
 		writeAarch64Function(w, ".LOPENSSL_armcap_P_addr", func(w stringWriter) {
 			w.WriteString("\tadrp x0, OPENSSL_armcap_P\n")
 			w.WriteString("\tadd x0, x0, :lo12:OPENSSL_armcap_P\n")

util/fipstools/delocate/testdata/aarch64-Basic/in.s

@@ -51,6 +51,22 @@ foo:
 
 	bl bss_symbol_bss_get
 
+	// Known symbol address load (global function defined in module)
+	adrp x0, foo
+	add x1, x0, :lo12:foo
+
+	// Known symbol address load with no-op add
+	adrp x0, foo
+	add x0, x0, :lo12:foo
+
+	// Known symbol load
+	adrp x10, foo
+	ldr x0, [x10, :lo12:foo]
+
+	// Known symbol address load with offset
+	adrp x6, foo+4096
+	add x6, x6, :lo12:foo+4096
+
 	// Regression test for a two-digit index.
 	ld1 { v1.b }[10], [x9]
 

util/fipstools/delocate/testdata/aarch64-Basic/out.s

@@ -142,6 +142,47 @@ foo:
 
 	bl bss_symbol_bss_get
 
+	// Known symbol address load (global function defined in module)
+// WAS adrp x0, foo
+	sub sp, sp, 128
+	stp x0, x30, [sp, #-16]!
+	bl .Lboringssl_loadaddr_.Lfoo_local_target
+	ldp xzr, x30, [sp], #16
+	add sp, sp, 128
+// WAS add x1, x0, :lo12:foo
+	add	x1, x0, #0
+
+	// Known symbol address load with no-op add
+// WAS adrp x0, foo
+	sub sp, sp, 128
+	stp x0, x30, [sp, #-16]!
+	bl .Lboringssl_loadaddr_.Lfoo_local_target
+	ldp xzr, x30, [sp], #16
+	add sp, sp, 128
+// WAS add x0, x0, :lo12:foo
+
+	// Known symbol load
+// WAS adrp x10, foo
+	sub sp, sp, 128
+	stp x0, x30, [sp, #-16]!
+	bl .Lboringssl_loadaddr_.Lfoo_local_target
+	mov x10, x0
+	ldp x0, x30, [sp], #16
+	add sp, sp, 128
+// WAS ldr x0, [x10, :lo12:foo]
+	ldr	x0, [x10]
+
+	// Known symbol address load with offset
+// WAS adrp x6, foo+4096
+	sub sp, sp, 128
+	stp x0, x30, [sp, #-16]!
+	bl .Lboringssl_loadaddr_.Lfoo_local_target
+	mov x6, x0
+	ldp x0, x30, [sp], #16
+	add sp, sp, 128
+	add x6, x6, +4096
+// WAS add x6, x6, :lo12:foo+4096
+
 	// Regression test for a two-digit index.
 	ld1 { v1.b }[10], [x9]
 
@@ -314,6 +355,17 @@ bss_symbol_bss_get:
 .cfi_endproc
 .size .Lboringssl_loadgot_stderr, .-.Lboringssl_loadgot_stderr
 .p2align 2
+.hidden .Lboringssl_loadaddr_.Lfoo_local_target
+.type .Lboringssl_loadaddr_.Lfoo_local_target, @function
+.Lboringssl_loadaddr_.Lfoo_local_target:
+.cfi_startproc
+	hint #34 // bti c
+	adrp x0, .Lfoo_local_target
+	add x0, x0, :lo12:.Lfoo_local_target
+	ret
+.cfi_endproc
+.size .Lboringssl_loadaddr_.Lfoo_local_target, .-.Lboringssl_loadaddr_.Lfoo_local_target
+.p2align 2
 .hidden .LOPENSSL_armcap_P_addr
 .type .LOPENSSL_armcap_P_addr, @function
 .LOPENSSL_armcap_P_addr: