// Copyright 2016 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.

// The standard Linux sigset type on big-endian 64-bit machines.

//go:build linux && (ppc64 || s390x)

package runtime

const (
	_SS_DISABLE  = 2
	_NSIG        = 65
	_SIG_BLOCK   = 0
	_SIG_UNBLOCK = 1
	_SIG_SETMASK = 2
)

type sigset uint64

                    publicHeaders.from('src/main/headers')
                    targetMachines = [machines.host().x86]
                }
            }
            project(':app') {
                apply plugin: 'cpp-application'
                application {
                    targetMachines = [machines.host().x86]
                }
                dependencies {
                    implementation project(':library')

	PushThrottle = func() int {
		v := env.Register(
			"PILOT_PUSH_THROTTLE",
			0,
			"Limits the number of concurrent pushes allowed. On larger machines this can be increased for faster pushes. "+
				"If set to 0 or unset, the max will be automatically determined based on the machine size",
		).Get()
		if v > 0 {
			return v
		}
		procs := runtime.GOMAXPROCS(0)
		// Heuristic to scale with cores. We end up with...
		// 1: 20

Target machines - defaults to the tested component (if present) or build host (otherwise)::
The target machine expresses which machines the application expects to run.
A target machine is identified by its operating system and architecture.
Gradle uses the target machine to decide which tool chain to choose based on availability on the host machine.

The target machine can be configured as follows:

        """

        buildFile << """
            project(':app') {
                apply plugin: 'cpp-application'

                application {
                    targetMachines = [machines.os('os-family')]
                    dependencies {
                        implementation project(':greeter')
                    }
                }
            }
            project(':greeter') {

====

Target machines - defaults to the build host::
The target machine expresses which machines the application expects to run.
A target machine is identified by its operating system and architecture.
Gradle uses the target machine to decide which tool chain to choose based on availability on the host machine.

The target machine can be configured as follows:

.Configure library target machines

	// mapping of linux feature strings to S390X fields
	mapping := make(map[string]*bool)
	for _, option := range Options {
		mapping[option.Name] = option.Feature
	}

	// these must be true on the machines Go supports
	mandatory := make(map[string]bool)
	mandatory["zarch"] = false
	mandatory["eimm"] = false
	mandatory["ldisp"] = false
	mandatory["stfle"] = false

	features, err := getFeatureList()
	if err != nil {

                }

                components.withType(CppComponent) {
                    targetMachines = [machines.windows.architecture('${currentArchitecture}'), machines.linux.architecture('${currentArchitecture}'), machines.macOS.architecture('${currentArchitecture}')]
                }
            }
            project(':deck') {
                dependencies {

            buildScriptBuilder.methodInvocation(null, "targetMachines.add", buildScriptBuilder.propertyExpression("machines.linux.x86_64"));
        } else {

====

Target machines - defaults to the build host::
The target machine expresses which machines the application expects to run.
A target machine is identified by its operating system and architecture.
Gradle uses the target machine to decide which tool chain to choose based on availability on the host machine.

The target machine can be configured as follows:

.Configure library target machines