OBJECTIVECPP_COMPILER("Objective-C++ compiler"),
    OBJECTIVEC_COMPILER("Objective-C compiler"),
    WINDOW_RESOURCES_COMPILER("Windows resources compiler"),
    ASSEMBLER("Assembler"),
    LINKER("Linker"),
    STATIC_LIB_ARCHIVER("Static library archiver"),
    SWIFT_COMPILER("Swift compiler"),
    SYMBOL_EXTRACTOR("Symbol extractor"),
    STRIPPER("Stripper");

    private final String toolName;

#!/bin/bash

if [[ "${2}" == "-V=full" ]]; then
  "$@"
  exit 0
fi
case "$(basename ${1})" in
  link)
    # Output a dummy file
    touch "${3}"
    ;;
  *)
    "$@"

                            linker.args '/MANIFESTUAC:level=\\'asInvoker\\' uiAccess=\\'false\\''
                        } else if (toolChain in Clang) {
                            cCompiler.args '-frandom-seed="here is the \\'random\\' seed"'
                            // TODO:DAZ Find something that works here (for all our CI machines)
                            // linker.args '-Wl,-client_name,"a \\'client\\' name"'

	}
	return *p
}

// modulesinit creates the active modules slice out of all loaded modules.
//
// When a module is first loaded by the dynamic linker, an .init_array
// function (written by cmd/link) is invoked to call addmoduledata,
// appending to the module to the linked list that starts with
// firstmoduledata.
//
// There are two times this can happen in the lifecycle of a Go

                    if (targetPlatform.operatingSystem.macOsX) {
                        linker.args "-framework", "Foundation"
                    } else {
                        objcCompiler.args "-I/usr/include/GNUstep", "-I/usr/local/include/objc", "-fconstant-string-class=NSConstantString", "-D_NATIVE_OBJC_EXCEPTIONS"
                        linker.args "-lgnustep-base", "-lobjc"
                    }
                }
            }

                def librarySearchPath = 'build/libs/hello/static'
                def libraryName = 'hello'
                if (toolChain in VisualCpp) {
                    linker.args "/LIBPATH:\${librarySearchPath}", "\${libraryName}.lib"
                } else {
                    linker.args "-L\${librarySearchPath}", "-l\${libraryName}"
                }
            }
        }
        hello(NativeLibrarySpec)
    }
}
"""

                }
                linker.withArguments { args ->
                    args.remove "CUSTOM"
                }
            }
        }
    }
    components {
        main(NativeExecutableSpec) {
            binaries.all {
                cppCompiler.args "CUSTOM"
                linker.args "CUSTOM"
            }
        }
    }
}
        """
        and:

type cacheTable[K, V any] [cacheSize]atomic.Pointer[cacheEntry[K, V]]

// A cacheEntry is a single entry in the linked list for a given hash table entry.
type cacheEntry[K, V any] struct {
	k    *K                // immutable once created
	v    atomic.Pointer[V] // read and written atomically to allow updates
	next *cacheEntry[K, V] // immutable once linked into table
}

func registerCache(unsafe.Pointer) // provided by runtime

GLOBL _rt0_ppc64le_linux_lib_argv<>(SB),NOPTR, $8

TEXT _main<>(SB),NOSPLIT,$-8
	// In a statically linked binary, the stack contains argc,
	// argv as argc string pointers followed by a NULL, envv as a
	// sequence of string pointers followed by a NULL, and auxv.
	// The TLS pointer should be initialized to 0.
	//
	// In an ELFv2 compliant dynamically linked binary, R3 contains argc,
	// R4 contains argv, R5 contains envp, R6 contains auxv, and R13

    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def argsTransformer = new LinkExeLinker.LinkerArgsTransformer()

    def "generates linker args for shared library"() {
        def dllFile = tmpDir.file("dll/out.dll")
        def libFile = tmpDir.file("import/out.lib")
        def objFile = tmpDir.file("obj/in.obj")
        def libInFile = tmpDir.file("libs/in.lib")