MTU:  int(nativeEndian.Uint32(m.raw[m.extOff+8 : m.extOff+12])),
		},
	}
}

var compatFreeBSD32 bool // 386 emulation on amd64

func probeRoutingStack() (int, map[int]*wireFormat) {
	var p uintptr
	wordSize := int(unsafe.Sizeof(p))
	align := wordSize
	// In the case of kern.supported_archs="amd64 i386", we need
	// to know the underlying kernel's architecture because the

        this.systemInfo = systemInfo;
    }

    @Override
    public WindowsSdk forPlatform(final NativePlatformInternal platform) {
        String host;
        switch (systemInfo.getArchitecture()) {
            case i386:
                host = "x86";
                break;
            case amd64:
                host = "x64";
                break;
            case aarch64:
                host = "arm64";
                break;

		p.To.Type = obj.TYPE_REG
		p.To.Reg = regEntryTmp0
		if ctxt.Arch.Family == sys.I386 {
			p.As = AMOVL
		}

		// TESTQ regEntryTmp0, regEntryTmp0
		p = obj.Appendp(p, newprog)
		p.As = ATESTQ
		p.From.Type = obj.TYPE_REG
		p.From.Reg = regEntryTmp0
		p.To.Type = obj.TYPE_REG
		p.To.Reg = regEntryTmp0
		if ctxt.Arch.Family == sys.I386 {
			p.As = ATESTL
		}

        project.targets[0].buildConfigurationList.buildConfigurations[0].name == "${DefaultXcodeProject.BUILD_DEBUG}X86"
        project.targets[0].buildConfigurationList.buildConfigurations[0].buildSettings.ARCHS == "i386"
        project.targets[0].buildConfigurationList.buildConfigurations[0].buildSettings.CONFIGURATION_BUILD_DIR == file("build/install/main/debug/x86/lib").absolutePath

        UnitTestPreconditions.NotWindows
    ])
    def "reassembles binary with target platform change"() {
        when:
        buildFile.text = buildFile.text.replace("i386", "x86-64")

        run "installMainExecutable"

        then:
        executedAndNotSkipped ":assembleHelloSharedLibraryHelloAsm"

		Gentext:          gentext,
		Machoreloc1:      machoreloc1,
		PEreloc1:         pereloc1,

		ELF: ld.ELFArch{
			Linuxdynld:     "/lib/ld-linux.so.2",
			LinuxdynldMusl: "/lib/ld-musl-i386.so.1",
			Freebsddynld:   "/usr/libexec/ld-elf.so.1",
			Openbsddynld:   "/usr/libexec/ld.so",
			Netbsddynld:    "/usr/libexec/ld.elf_so",
			Solarisdynld:   "/lib/ld.so.1",

			Reloc1:    elfreloc1,
			RelocSize: 8,

			} else if ctxt.Arch.Family == sys.I386 {
				// On 386 PC-relative addressing (for non-call/jmp instructions)
				// assumes that the previous instruction loaded the PC of the end
				// of that instruction into CX, so the adjustment is relative to
				// that.
				r.Add += int64(r.Off) - p.Pc + int64(r.Siz)
			}
		}
		if r.Type == objabi.R_GOTPCREL && ctxt.Arch.Family == sys.I386 {

// the one in glibc. The glibc source code is:
// https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/i386/libc_sigaction.c;h=0665b41bbcd0986f0b33bf19a7ecbcedf9961d0a#l59
// The code that cares about the precise instructions used is:
// https://gcc.gnu.org/git/?p=gcc.git;a=blob;f=libgcc/config/i386/linux-unwind.h;h=5486223d60272c73d5103b29ae592d2ee998e1cf#l136
//

    def component = BaseComponentFixtures.createNode(NativeLibrarySpec, TestNativeComponentSpec, id)

    def platform1 = Stub(NativePlatform) {
        getArchitecture() >> Architectures.forInput("i386")
    }
    def buildType1 = Stub(BuildType) {
        getName() >> "BuildType1"
    }
    def resolver = Mock(NativeDependencyResolver)

    def "uses resolver to resolve lib to dependency"() {

            argsFor(platformToolChain.assembler) == compilerArg
            argsFor(platformToolChain.staticLibArchiver) == []
        })

        where:
        arch     | linkerArg | compilerArg
        "i386"   | ["-m32"]  | ["-m32"]
        "x86_64" | ["-m64"]  | ["-m64"]
    }

    @Requires(UnitTestPreconditions.MacOs)
    def "supplies args for supported architecture for macOS platforms"() {