// the opaque handle as a Go uintptr rather than a Go pointer to avoid
// garbage collector confusion.  See issue 23663.

uintptr_t dlopen4029(char* name, int flags) {
	return (uintptr_t)(dlopen(name, flags));
}

uintptr_t dlsym4029(uintptr_t handle, char* name) {
	return (uintptr_t)(dlsym((void*)(handle), name));
}

int dlclose4029(uintptr_t handle) {
	return dlclose((void*)(handle));
}

static ucontext_t uctx_save, uctx_switch;

extern void stackSwitchCallback(void);

char *stack2;

static void *stackSwitchThread(void *arg) {
	// Simple test: callback works from the normal system stack.
	stackSwitchCallback();

	// Next, verify that switching stacks doesn't break callbacks.

	char *stack1 = malloc(STACK_SIZE);
	if (stack1 == NULL) {
		perror("malloc");
		exit(1);
	}

	// "the type chan E if T contains only bidirectional channels, or the type chan<- E or
	// <-chan E depending on the direction of the directional channels present."
	for chans := identical; chans < len(terms); chans++ {
		curr, ok := terms[chans].Type().Underlying().(*types.Chan)
		if !ok {
			return nil
		}
		if !types.Identical(ch.Elem(), curr.Elem()) {
			return nil // channel elements are not identical.
		}

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

// This file is like map.go, but instead of importing chans, it contains
// the necessary functionality at the end of the file.

// Package orderedmap provides an ordered map, implemented as a binary tree.
package orderedmap

// Map is an ordered map.
type Map[K, V any] struct {

//go:build aix || (!android && linux) || dragonfly || freebsd || netbsd || openbsd || solaris

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include "libcgo.h"

void
fatalf(const char* format, ...)
{
	va_list ap;

	fprintf(stderr, "runtime/cgo: ");
	va_start(ap, format);
	vfprintf(stderr, format, ap);
	va_end(ap);
	fprintf(stderr, "\n");
	abort();

#include <string.h>
#include <time.h>
#include <sched.h>
#include <dlfcn.h>

static void die(const char* msg) {
	perror(msg);
	exit(EXIT_FAILURE);
}

static volatile sig_atomic_t sigioSeen;

static void ioHandler(int signo, siginfo_t* info, void* ctxt) {
	sigioSeen = 1;
}

int main(int argc, char** argv) {
	int verbose;
	struct sigaction sa;
	void* handle;
	void (*catchSIGIO)(void);

  width: 100%;
  flex-grow: 1;
  overflow-y: auto;
  background: #eee; /* Light grey gives better contrast with boxes */
  position: relative; /* Allows absolute positioning of child boxes */
}
/* Flame graph */
#stack-chart {
  width: 100%;
  position: relative; /* Allows absolute positioning of child boxes */
}
/* Shows details of frame that is under the mouse */
#current-details {
  position: absolute;
  top: 5px;
  right: 5px;

//   - Names cannot contain whitespace or newlines.
//
//   - Names must be valid unicode, with no unprintable characters.
//
//   - Names may contain at most one ':'. In the counter "foo:bar", we refer to
//     "foo" as the "chart name" and "bar" as the "bucket name".
//
//   - The '/' character should partition counter names into a hierarchy. The
//     root of this hierarchy should identify the logical entity that "owns"

	// badCharSkip[b] is len(pattern).
	//
	// Whenever a mismatch is found with byte b in the text, we can safely
	// shift the matching frame at least badCharSkip[b] until the next time
	// the matching char could be in alignment.
	badCharSkip [256]int

	// goodSuffixSkip[i] defines how far we can shift the matching frame given
	// that the suffix pattern[i+1:] matches, but the byte pattern[i] does

	if len(name) >= IFNAMSIZ {
		return nil, EINVAL
	}

	var ifr ifreq
	copy(ifr.Ifrn[:], name)

	return &Ifreq{raw: ifr}, nil
}

// TODO(mdlayher): get/set methods for hardware address sockaddr, char array, etc.

// Name returns the interface name associated with the Ifreq.
func (ifr *Ifreq) Name() string {
	return ByteSliceToString(ifr.raw.Ifrn[:])
}