for _, line := range strings.Split(in, "\n") {
		if !strings.HasPrefix(line, "func ") || !strings.HasSuffix(line, "_trampoline()") {
			continue
		}
		fn := line[5 : len(line)-13]
		if !trampolines[fn] {
			trampolines[fn] = true
			fmt.Fprintf(&out, "TEXT ·%s_trampoline(SB),NOSPLIT,$0-0\n", fn)
			if goos == "openbsd" && arch == "ppc64" {
				fmt.Fprintf(&out, "\tCALL\t%s(SB)\n", fn)
				fmt.Fprintf(&out, "\tRET\n")

		$text .= "\t}\n";
	}
	$text .= "\treturn\n";
	$text .= "}\n\n";
	if($libc) {
		if (not exists $trampolines{$funcname}) {
			$trampolines{$funcname} = 1;
			# The assembly trampoline that jumps to the libc routine.
			$text .= "func ${funcname}_trampoline()\n\n";
			# Tell the linker that funcname can be found in libSystem using varname without the libc_ prefix.
			my $basename = substr $funcname, 5;

package cgotest

// extern int notoc_func(void);
// int TestPPC64Stubs(void) {
//	return notoc_func();
// }
import "C"
import "testing"

func testPPC64CallStubs(t *testing.T) {
	// Verify the trampolines run on the testing machine. If they
	// do not, or are missing, a crash is expected.
	if C.TestPPC64Stubs() != 0 {
		t.Skipf("This test requires binutils 2.35 or newer.")
	}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
 * On AIX, call to _cgo_topofstack and Go main are forced to be a longcall.
 * Without it, ld might add trampolines in the middle of .text section
 * to reach these functions which are normally declared in runtime package.
 */
extern int __attribute__((longcall)) __cgo_topofstack(void);

		Archrelocvariant: archrelocvariant,
		Extreloc:         extreloc,

		// TrampLimit is set such that we always run the trampoline
		// generation code. This is necessary since calls to external
		// symbols require the use of trampolines, regardless of the
		// text size.
		TrampLimit: 1,
		Trampoline: trampoline,

		Gentext:     gentext,
		GenSymsLate: genSymsLate,
		Machoreloc1: machoreloc1,

		ELF: ld.ELFArch{

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build darwin

#include "textflag.h"

// The trampolines are ABIInternal as they are address-taken in
// Go code.

TEXT ·x509_SecTrustSettingsCopyCertificates_trampoline(SB),NOSPLIT,$0-0
	JMP	x509_SecTrustSettingsCopyCertificates(SB)

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build darwin

#include "textflag.h"

// The trampolines are ABIInternal as they are address-taken in
// Go code.

TEXT ·x509_CFArrayGetCount_trampoline(SB),NOSPLIT,$0-0
	JMP	x509_CFArrayGetCount(SB)
TEXT ·x509_CFArrayGetValueAtIndex_trampoline(SB),NOSPLIT,$0-0

		t.Fatalf("nm failure: %s\n%s\n", err, string(out))
	}
	if !bytes.Contains(out, []byte(" T a-tramp0")) {
		t.Errorf("Trampoline a-tramp0 is missing")
	}
	if bytes.Contains(out, []byte(" T b-tramp0")) {
		t.Errorf("Trampoline b-tramp0 exists unnecessarily")
	}

	if thearch.Trampoline == nil || isTramp {
		return 0
	}

	n := uint64(0)
	relocs := ldr.Relocs(s)
	for ri := 0; ri < relocs.Count(); ri++ {
		r := relocs.At(ri)
		if r.Type().IsDirectCallOrJump() {
			n++
		}
	}

	switch {
	case ctxt.IsARM():
		return n * 20 // Trampolines in ARM range from 3 to 5 instructions.
	case ctxt.IsARM64():

	}

	// Generate the scenario where the total amount of text exceeds the
	// limit for the jmp/call instruction, on RISC architectures like ppc64le,
	// which is 2^26.  When that happens the call requires special trampolines or
	// long branches inserted by the linker where supported.
	// Multiple .s files are generated instead of one.
	instOnArch := map[string]string{
		"ppc64":   "\tMOVD\tR0,R3\n",
		"ppc64le": "\tMOVD\tR0,R3\n",