//go:linkname addVW
//go:noescape
func addVW(z, x []Word, y Word) (c Word)

// subVW should be an internal detail,
// but widely used packages access it using linkname.
// Notable members of the hall of shame include:
//   - github.com/remyoudompheng/bigfft
//
// Do not remove or change the type signature.
// See go.dev/issue/67401.
//
//go:linkname subVW
//go:noescape
func subVW(z, x []Word, y Word) (c Word)

TEXT ·getisar0(SB),NOSPLIT,$0-8
	// get Instruction Set Attributes 0 into x0
	// mrs x0, ID_AA64ISAR0_EL1 = d5380600
	WORD	$0xd5380600
	MOVD	R0, ret+0(FP)
	RET

// func getisar1() uint64
TEXT ·getisar1(SB),NOSPLIT,$0-8
	// get Instruction Set Attributes 1 into x0
	// mrs x0, ID_AA64ISAR1_EL1 = d5380620
	WORD	$0xd5380620
	MOVD	R0, ret+0(FP)
	RET

// func getpfr0() uint64
TEXT ·getpfr0(SB),NOSPLIT,$0-8

         word_index++) {
      uint64 word = storage_[word_index];
      while (word != 0) {
        uint64 only_lowest_bit_set = word & -word;
        // The number of trailing zeros in a non-zero word is the index of the
        // least significant 1.
        int bit_index = absl::countr_zero(word);
        if (!func(DeviceId(word_index * kWordSize + bit_index))) {
          return;

	word := uint32(v) << ((uaddr & 3) * 8) // little endian
	for {
		old := *addr32
		if Cas(addr32, old, old|word) {
			return
		}
	}
}

//go:nosplit
func And8(addr *uint8, v uint8) {
	// Align down to 4 bytes and use 32-bit CAS.
	uaddr := uintptr(unsafe.Pointer(addr))
	addr32 := (*uint32)(unsafe.Pointer(uaddr &^ 3))
	word := uint32(v) << ((uaddr & 3) * 8)    // little endian

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

package abi

import "unsafe"

// The first word of every non-empty interface type contains an *ITab.
// It records the underlying concrete type (Type), the interface type it
// is implementing (Inter), and some ancillary information.
//
// allocated in non-garbage-collected memory

all-container-registry: $(addprefix sub-container-registry-,$(ALL_OS_ARCH))

# split words on hyphen, access by 1-index
word-hyphen = $(word $2,$(subst -, ,$1))
sub-container-%:
	$(MAKE) OUTPUT_TYPE=$(call word-hyphen,$*,1) OS=$(call word-hyphen,$*,2) ARCH=$(call word-hyphen,$*,3) OSVERSION=$(call word-hyphen,$*,4) container

build: $(foreach binary, ${BIN}, bin/${binary}-${OS}-${ARCH})

bin/${BIN.linux}-$(OS)-$(ARCH): $(SRCS)

  const bool toSnake = (to == LOWER_SNAKE || to == UPPER_SNAKE);

  string result;

  bool inputStart = true;
  bool wordStart = true;
  for (const char c : str) {
    // Find a word start.
    if (c == delimiter) {
      // Repeated cases of wordStart means explicit delimiter usage.
      if (wordStart) {
        result.push_back(delimiter);
      }
      wordStart = true;
      continue;

// 64-bit PowerPC (PPC64) instruction set, to minimize its interaction
// with the core of the assembler.

package arch

import (
	"cmd/internal/obj"
	"cmd/internal/obj/ppc64"
)

func jumpPPC64(word string) bool {
	switch word {
	case "BC", "BCL", "BEQ", "BGE", "BGT", "BL", "BLE", "BLT", "BNE", "BR", "BVC", "BVS", "BDNZ", "BDZ", "CALL", "JMP":
		return true
	}
	return false
}

// Loong64 (LoongArch64) instruction set, to minimize its interaction
// with the core of the assembler.

package arch

import (
	"cmd/internal/obj"
	"cmd/internal/obj/loong64"
)

func jumpLoong64(word string) bool {
	switch word {
	case "BEQ", "BFPF", "BFPT", "BLTZ", "BGEZ", "BLEZ", "BGTZ", "BLT", "BLTU", "JIRL", "BNE", "BGE", "BGEU", "JMP", "JAL", "CALL":
		return true
	}
	return false
}

#define	REGCTXT	R29

// The frames of each of the two functions below contain two locals, at offsets
// that are known to the runtime.
//
// The first local is a bool called retValid with a whole pointer-word reserved
// for it on the stack. The purpose of this word is so that the runtime knows
// whether the stack-allocated return space contains valid values for stack
// scanning.
//
// The second local is an abi.RegArgs value whose offset is also known to the