"cmd/asm/internal/asm"
	"cmd/asm/internal/flags"
	"cmd/asm/internal/lex"

	"cmd/internal/bio"
	"cmd/internal/obj"
	"cmd/internal/objabi"
	"cmd/internal/telemetry"
)

func main() {
	log.SetFlags(0)
	log.SetPrefix("asm: ")
	telemetry.Start()

	buildcfg.Check()
	GOARCH := buildcfg.GOARCH

	flags.Parse()
	telemetry.Inc("asm/invocations")
	telemetry.CountFlags("asm/flag:", *flag.CommandLine)

				sigaddset(&act.sa_mask, (int)(i+1));
			}
		}
		act.sa_flags = (int)(goact->flags & ~(uint64_t)SA_RESTORER);
	}

	ret = sigaction((int)signum, goact ? &act : NULL, oldgoact ? &oldact : NULL);
	if (ret == -1) {
		// runtime.rt_sigaction expects _cgo_sigaction to return errno on error.
		_cgo_tsan_release();
		return errno;
	}

	if (oldgoact) {
		if (oldact.sa_flags & SA_SIGINFO) {

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct sigaction prev_sa;

void forwardSignal(int signo, siginfo_t *info, void *context) {
	// One of sa_sigaction and/or sa_handler
	if ((prev_sa.sa_flags&SA_SIGINFO) != 0) {
		prev_sa.sa_sigaction(signo, info, context);
		return;
	}
	if (prev_sa.sa_handler != SIG_IGN && prev_sa.sa_handler != SIG_DFL) {
		prev_sa.sa_handler(signo);
		return;
	}

	if (oldHandler) {
		oldHandler(signo, info, ctxt);
	}
}

int install_handler() {
	// Install our own signal handler.
	memset(&sa, 0, sizeof sa);
	sa.sa_sigaction = handler;
	sigemptyset(&sa.sa_mask);
	sa.sa_flags = SA_ONSTACK | SA_SIGINFO;
	memset(&osa, 0, sizeof osa);
	sigemptyset(&osa.sa_mask);
	if (sigaction(SIGSEGV, &sa, &osa) < 0) {
		perror("sigaction");
		return 2;
	}
	if (osa.sa_handler == SIG_DFL) {

				sigaddset(&act.sa_mask, i+1);
			}
		}
		act.sa_flags = goact->flags;
	}

	ret = sigaction(signum, goact ? &act : NULL, oldgoact ? &oldact : NULL);
	if (ret == -1) {
		// runtime.sigaction expects _cgo_sigaction to return errno on error.
		_cgo_tsan_release();
		return errno;
	}

	if (oldgoact) {
		if (oldact.sa_flags & SA_SIGINFO) {
			oldgoact->handler = (uintptr_t)(oldact.sa_sigaction);

// license that can be found in the LICENSE file.

package runtime

import "internal/abi"

func cgoSigtramp()

//go:nosplit
//go:nowritebarrierrec
func setsig(i uint32, fn uintptr) {
	var sa sigactiont
	sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK | _SA_RESTART
	sa.sa_mask = sigset_all
	if fn == abi.FuncPCABIInternal(sighandler) { // abi.FuncPCABIInternal(sighandler) matches the callers in signal_unix.go
		if iscgo {

  ops_flags = new XlaOpsCommonFlags;
  ops_flags->tf_xla_always_defer_compilation = false;
  ops_flags->tf_xla_async_compilation = false;
  ops_flags->tf_xla_use_device_api.enabled_for_xla_launch_ = true;
  ops_flags->tf_xla_use_device_api.enabled_for_compile_on_demand_ = true;
  ops_flags->tf_xla_use_device_api.enabled_for_compile_and_run_ = true;
  ops_flags->tf_xla_use_device_api.enabled_for_all_ = false;

stdout '^\tbuild\tGOOS='
stdout '^\tbuild\tGOARCH='
[GOARCH:amd64] stdout '^\tbuild\tGOAMD64='
! stdout asmflags|gcflags|ldflags|gccgoflags

# Toolchain flags are added if present.
# The raw flags are included, with package patterns if specified.
go build -asmflags=example.com/m=-D=FOO=bar
go version -m m$GOEXE
stdout '^\tbuild\t-asmflags=example\.com/m=-D=FOO=bar$'

go build -gcflags=example.com/m=-N
go version -m m$GOEXE

#include <linux/time.h>

struct xsiginfo {
	int si_signo;
	int si_errno;
	int si_code;
	char _sifields[4];
};

#undef sa_handler
#undef sa_flags
#undef sa_restorer
#undef sa_mask

struct xsigaction {
	void (*sa_handler)(void);
	unsigned long sa_flags;
	void (*sa_restorer)(void);
	unsigned int sa_mask;		// mask last for extensibility
};
*/
import "C"

const (
	PROT_NONE  = C.PROT_NONE

	l := clog.NewConsoleLogger(cmd.OutOrStdout(), cmd.OutOrStderr(), nil)
	setFlags := make([]string, 0)
	if pfArgs.manifestsPath != "" {
		setFlags = append(setFlags, fmt.Sprintf("installPackagePath=%s", pfArgs.manifestsPath))
	}
	return profileDiffInternal(args[0], args[1], setFlags, cmd.OutOrStdout(), l)
}

func profileDiffInternal(profileA, profileB string, setFlags []string, writer io.Writer, l clog.Logger) (bool, error) {