testApp.plugins.each { plugin ->
            buildFile << "apply plugin: '$plugin'\n"
        }

        buildFile << """
model {
    platforms {
        x86 {
            architecture "i386"
        }
    }
    components {
        main(NativeExecutableSpec) {
            targetPlatform "x86"
            binaries.all {
                linker.args "-v"
            }
        }
    }
}

                'net/',
                'net/rubygrapefruit/',
                'net/rubygrapefruit/platform/',
                'net/rubygrapefruit/platform/osx-i386/',
                'net/rubygrapefruit/platform/osx-i386/libnative-platform.dylib',
                'org/gradle/reporting/',
                'org/gradle/reporting/report.js',
                'org/joda/',
                'org/joda/time/',

 * }
 *
 * model {
 *     components {
 *         main(NativeLibrarySpec) {
 *             sources {
 *                 asm {
 *                     source {
 *                         srcDirs "src/main/i386", "src/shared/asm"
 *                         include "**{@literal /}*.s"
 *                     }
 *                 }
 *             }
 *         }
 *     }
 * }
 * </pre>
 */
@Incubating @Managed

 * Constants for various processor architectures Gradle runs on.
 *
 * @since 7.6
 */
@Incubating
public enum Architecture {
    /**
     * 32-bit complex instruction set computer (CISC) architectures, including "x32", "i386", "x86"..
     */
    X86,

    /**
     * 64-bit variant of the X86 instruction set, including "x64", "x86_64", "amd64", "ia64".
     */
    X86_64,

    /**

		switch arch.Family {
		case sys.AMD64:
			return elf.R_X86_64(nr).String()
		case sys.ARM:
			return elf.R_ARM(nr).String()
		case sys.ARM64:
			return elf.R_AARCH64(nr).String()
		case sys.I386:
			return elf.R_386(nr).String()
		case sys.Loong64:
			return elf.R_LARCH(nr).String()
		case sys.MIPS, sys.MIPS64:
			return elf.R_MIPS(nr).String()
		case sys.PPC64:
			return elf.R_PPC64(nr).String()

		AMD64 | uint32(elf.R_X86_64_GOTPCRELX)<<16,
		AMD64 | uint32(elf.R_X86_64_REX_GOTPCRELX)<<16,
		I386 | uint32(elf.R_386_32)<<16,
		I386 | uint32(elf.R_386_PC32)<<16,
		I386 | uint32(elf.R_386_GOT32)<<16,
		I386 | uint32(elf.R_386_PLT32)<<16,
		I386 | uint32(elf.R_386_GOTOFF)<<16,
		I386 | uint32(elf.R_386_GOTPC)<<16,
		I386 | uint32(elf.R_386_GOT32X)<<16,
		PPC64 | uint32(elf.R_PPC64_REL24)<<16,

 * a specific {@link Architecture} and/or {@link OperatingSystem} to target.
 *
 * <pre>
 *     model {
 *         platforms {
 *             windows_x86 {
 *                 architecture "i386"
 *                 operatingSystem "windows"
 *             }
 *         }
 *     }
 * </pre>
 */
@HasInternalProtocol
public interface NativePlatform extends Platform, Describable {
    /**

		// native (widest) instruction set on the running kernel:
		out := run("", CheckExit, "isainfo", "-n")
		if strings.Contains(out, "amd64") {
			gohostarch = "amd64"
		}
		if strings.Contains(out, "i386") {
			gohostarch = "386"
		}
	case "windows":
		exe = ".exe"
	}

	sysinit()

	if gohostarch == "" {
		// Default Unix system.
		out := run("", CheckExit, "uname", "-m")

}
        """)
    ]

    def outputPlatform() {
        return """
    #if defined(__x86_64__) || defined(_M_X64)
    cout << "amd64";
    #elif defined(__i386) || defined(_M_IX86)
    cout << "i386";
    #elif defined(_M_IA64)
    cout << "itanium";
    #else
    cout << "unknown";
    #endif
    cout << " ";

    #if defined(__linux__)
    cout << "linux";

    }

    private ArchitectureInternal determineArchitecture(Map<String, String> defines) {
        boolean i386 = defines.containsKey("__i386__");
        boolean amd64 = defines.containsKey("__amd64__");
        final ArchitectureInternal architecture;
        if (i386) {
            architecture = Architectures.forInput("i386");
        } else if (amd64) {
            architecture = Architectures.forInput("amd64");
        } else {