package abi

const (
	// See abi_generic.go.

	// RAX, RBX, RCX, RDI, RSI, R8, R9, R10, R11.
	IntArgRegs = 9

	// X0 -> X14.
	FloatArgRegs = 15

	// We use SSE2 registers which support 64-bit float operations.
	EffectiveFloatRegSize = 8

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

// Issue 18994: SSA didn't handle DOT STRUCTLIT for zero-valued
// STRUCTLIT.

package main

// large struct - not SSA-able
type T struct {
	a, b, c, d, e, f, g, h int
}

func main() {
	x := T{}.a
	if x != 0 {
		panic("FAIL")
	}

// buildrun -t 10  -gcflags=-d=ssa/insert_resched_checks/on,ssa/check/on

//go:build !nacl && !js && disabled_see_issue_18589

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

// Test is disabled because it flakes when run in all.bash
// on some platforms, but is useful standalone to verify
// that rescheduling checks are working (and we may wish

package loong64

import (
	"cmd/compile/internal/ssa"
	"cmd/compile/internal/ssagen"
	"cmd/internal/obj/loong64"
)

func Init(arch *ssagen.ArchInfo) {
	arch.LinkArch = &loong64.Linkloong64
	arch.REGSP = loong64.REGSP
	arch.MAXWIDTH = 1 << 50
	arch.ZeroRange = zerorange
	arch.Ginsnop = ginsnop

	arch.SSAMarkMoves = func(s *ssagen.State, b *ssa.Block) {}
	arch.SSAGenValue = ssaGenValue

	if y != &ptrData()[1<<20+2] {
		panic("testLargeOffset: address mismatch")
	}
}

func main() {
	testLoop()

	// SSA rules commonly merge offsets into addresses. These
	// tests access global data in different ways to try
	// and exercise different SSA rules.
	testMediumOffset()
	testLargeOffset()

.ast {
    white-space: nowrap;
}

td.ssa-prog {
    width: 600px;
    word-wrap: break-word;
}

li {
    list-style-type: none;
}

li.ssa-long-value {
    text-indent: -2em;  /* indent wrapped lines */
}

li.ssa-value-list {
    display: inline;
}

li.ssa-start-block {
    padding: 0;
    margin: 0;
}

li.ssa-end-block {
    padding: 0;
    margin: 0;

// compile -d=ssa/check/on

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

// Issue 36723: fail to compile on PPC64 when SSA check is on.

package p

import "unsafe"

type T struct {
	a, b, c, d uint8
	x          [10]int32
}

func F(p *T, i uintptr) int32 {

		return false
	}
}

func (s *ssafn) AllocFrame(f *ssa.Func) {
	s.stksize = 0
	s.stkptrsize = 0
	s.stkalign = int64(types.RegSize)
	fn := s.curfn

	// Mark the PAUTO's unused.
	for _, ln := range fn.Dcl {
		if ln.OpenDeferSlot() {
			// Open-coded defer slots have indices that were assigned
			// upfront during SSA construction, but the defer statement can

func validStorageVersion() *apiserverinternal.StorageVersion {
	ssv1 := apiserverinternal.ServerStorageVersion{
		APIServerID:       "1",
		EncodingVersion:   "v1",
		DecodableVersions: []string{"v1", "v2"},
	}
	ssv2 := apiserverinternal.ServerStorageVersion{
		APIServerID:       "2",
		EncodingVersion:   "v1",
		DecodableVersions: []string{"v1", "v2"},
	}
	// ssv3 has a different encoding version

// Copyright 2015 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 ssa

import (
	"cmd/compile/internal/ir"
	"cmd/compile/internal/types"
	"fmt"
)

// A place that an ssa variable can reside.
type Location interface {
	String() string // name to use in assembly templates: AX, 16(SP), ...
}