"ppc64":   disasm_ppc64,
	"ppc64le": disasm_ppc64,
}

var byteOrders = map[string]binary.ByteOrder{
	"386":     binary.LittleEndian,
	"amd64":   binary.LittleEndian,
	"arm":     binary.LittleEndian,
	"arm64":   binary.LittleEndian,
	"ppc64":   binary.BigEndian,
	"ppc64le": binary.LittleEndian,
	"s390x":   binary.BigEndian,
}

type Liner interface {

		return fmt.Errorf("error seeking in patchSegmentHeader: %v", err)
	}
	if cfw.debug {
		fmt.Fprintf(os.Stderr, "=-= writing counter segment header: %+v", cfw.csh)
	}
	if err := binary.Write(ws, binary.LittleEndian, cfw.csh); err != nil {
		return err
	}
	// ... and finally return to the original offset.
	if _, err := ws.Seek(off, io.SeekStart); err != nil {

    }
    tasks { t ->
        $.components.main.binaries.each { binary ->
            def preLinkTask = binary.tasks.taskName("preLink")
            t.create(preLinkTask) {
                dependsOn binary.tasks.withType(CppCompile)
                doLast {
                    println "Pre Link"
                }
            }
            binary.tasks.link.dependsOn preLinkTask

    def "renders additional binaries"() {
        def binary1 = Stub(BinarySpec)
        def binary2 = Stub(BinarySpec)
        def component = Stub(ComponentSpec) {
            getBinaries() >> Stub(ModelMap) {
                values() >> [binary1]
            }
        }
        binaryRenderer.render(binary2, _) >> { BinarySpec binary, TextReportBuilder builder -> builder.output.println("<binary>") }

        when:

            Set<File> allSourcesFromBinaries = new LinkedHashSet<>();
            for (VisualStudioTargetBinary binary : configurations.keySet()) {
                allSourcesFromBinaries.addAll(binary.getSourceFiles().getFiles());
            }
            return allSourcesFromBinaries;
        }), providerFactory.provider(() -> additionalFiles));

    @Override
    protected void configureCompileTask(AbstractNativeCompileTask abstractTask, final NativeBinarySpecInternal binary, final LanguageSourceSetInternal sourceSet) {
        AbstractNativeSourceCompileTask task = (AbstractNativeSourceCompileTask) abstractTask;

        task.setDescription("Compiles the " + sourceSet + " of " + binary);

        task.source(sourceSet.getSource());

        final Project project = task.getProject();

import org.gradle.api.Incubating;
import org.gradle.platform.base.BinarySpec;

/**
 * A binary which runs a suite of tests.
 */
@Incubating
public interface TestSuiteBinarySpec extends BinarySpec {

    /**
     * Returns the test suite that this binary belongs to.
     */
    TestSuiteSpec getTestSuite();

    /**
     * Returns the binary tested by this test suite.
     */
    BinarySpec getTestedBinary();

    }

    @Override
    protected void renderTasks(NativeExecutableBinarySpec binary, TextReportBuilder builder) {
        builder.item("install using task", binary.getTasks().getInstall().getPath());
    }

    @Override
    protected void renderOutputs(NativeExecutableBinarySpec binary, TextReportBuilder builder) {
        builder.item("executable file", binary.getExecutable().getFile());
    }

        """
    }

    @ToBeFixedForConfigurationCache
    def "strips symbols from binary"() {
        when:
        succeeds ":stripSymbolsDebug"

        then:
        executedAndNotSkipped":stripSymbolsDebug"
        executable("build/exe/main/debug/app").assertHasDebugSymbolsFor(withoutHeaders(app.original))
        binary("build/stripped").assertDoesNotHaveDebugSymbolsFor(withoutHeaders(app.original))
    }

	spec := w.specs[e.Ev]
	for _, arg := range e.Args[:len(spec.Args)] {
		w.buf = binary.AppendUvarint(w.buf, arg)
	}
	if spec.IsStack {
		frameArgs := e.Args[len(spec.Args):]
		for i := 0; i < len(frameArgs); i++ {
			w.buf = binary.AppendUvarint(w.buf, frameArgs[i])
		}
	}

	// Write out the length of the data.
	if spec.HasData {
		w.buf = binary.AppendUvarint(w.buf, uint64(len(e.Data)))
	}

	// Write out varint events.