ctxt *obj.Link

newprog obj.ProgAlloc

cursym *obj.LSym

autosize int32

instoffset int64

pc int64

as obj.As // opcode

i uint8 // handler index

a1 uint8 // From

a2 uint8 // Reg

a3 uint8 // RestArgs[0]

a4 uint8 // RestArgs[1]

a5 uint8 // RestArgs[2]

a6 uint8 // To

if ctxt.Retpoline {

ctxt.Diag("-spectre=ret not supported on s390x")

ctxt.Retpoline = false // don't keep printing

}

p := cursym.Func().Text

if p == nil || p.Link == nil { // handle external functions and ELF section symbols

return

}

if oprange[AORW&obj.AMask] == nil {

ctxt.Diag("s390x ops not initialized, call s390x.buildop first")

}

c := ctxtz{ctxt: ctxt, newprog: newprog, cursym: cursym, autosize: int32(p.To.Offset)}

buffer := make([]byte, 0)

changed := true

loop := 0

nrelocs0 := len(c.cursym.R)

for changed {

if loop > 100 {

c.ctxt.Diag("stuck in spanz loop")

break

}

changed = false

buffer = buffer[:0]

for i := range c.cursym.R[nrelocs0:] {

c.cursym.R[nrelocs0+i] = obj.Reloc{}

}

c.cursym.R = c.cursym.R[:nrelocs0] // preserve marker relocations generated by the compiler

for p := c.cursym.Func().Text; p != nil; p = p.Link {

pc := int64(len(buffer))

if pc != p.Pc {

changed = true

}

p.Pc = pc

c.pc = p.Pc

c.asmout(p, &buffer)

if pc == int64(len(buffer)) {

switch p.As {

case obj.ANOP, obj.AFUNCDATA, obj.APCDATA, obj.ATEXT:

// ok

default:

c.ctxt.Diag("zero-width instruction\n%v", p)

}

}

}

loop++

}

c.cursym.Size = int64(len(buffer))

if c.cursym.Size%funcAlign != 0 {

c.cursym.Size += funcAlign - (c.cursym.Size % funcAlign)

}

c.cursym.Grow(c.cursym.Size)

copy(c.cursym.P, buffer)

// Mark nonpreemptible instruction sequences.

// We use REGTMP as a scratch register during call injection,

// so instruction sequences that use REGTMP are unsafe to

// preempt asynchronously.

obj.MarkUnsafePoints(c.ctxt, c.cursym.Func().Text, c.newprog, c.isUnsafePoint, nil)

if p.From.Reg == REGTMP || p.To.Reg == REGTMP || p.Reg == REGTMP {

return true

}

for _, a := range p.RestArgs {

if a.Reg == REGTMP {

return true

}

}

return p.Mark&USETMP != 0

switch a.Type {

case obj.TYPE_NONE:

return C_NONE

case obj.TYPE_REG:

if REG_R0 <= a.Reg && a.Reg <= REG_R15 {

return C_REG

}

if REG_F0 <= a.Reg && a.Reg <= REG_F15 {

return C_FREG

}

if REG_AR0 <= a.Reg && a.Reg <= REG_AR15 {

return C_AREG

}

if REG_V0 <= a.Reg && a.Reg <= REG_V31 {

return C_VREG

}

return C_GOK

case obj.TYPE_MEM:

switch a.Name {

case obj.NAME_EXTERN,

obj.NAME_STATIC:

if a.Sym == nil {

// must have a symbol

break

}

c.instoffset = a.Offset

if a.Sym.Type == objabi.STLSBSS {

if c.ctxt.Flag_shared {

return C_TLS_IE // initial exec model

}

return C_TLS_LE // local exec model

}

return C_ADDR

case obj.NAME_GOTREF:

return C_GOTADDR

case obj.NAME_AUTO:

if a.Reg == REGSP {

// unset base register for better printing, since

// a.Offset is still relative to pseudo-SP.

a.Reg = obj.REG_NONE

}

c.instoffset = int64(c.autosize) + a.Offset

if c.instoffset >= -BIG && c.instoffset < BIG {

return C_SAUTO

}

return C_LAUTO

case obj.NAME_PARAM:

if a.Reg == REGSP {

// unset base register for better printing, since

// a.Offset is still relative to pseudo-FP.

a.Reg = obj.REG_NONE

}

c.instoffset = int64(c.autosize) + a.Offset + c.ctxt.Arch.FixedFrameSize

if c.instoffset >= -BIG && c.instoffset < BIG {

return C_SAUTO

}

return C_LAUTO

case obj.NAME_NONE:

c.instoffset = a.Offset

if c.instoffset == 0 {

return C_ZOREG

}

if c.instoffset >= -BIG && c.instoffset < BIG {

return C_SOREG

}

return C_LOREG

}

return C_GOK

case obj.TYPE_TEXTSIZE:

return C_TEXTSIZE

case obj.TYPE_FCONST:

if f64, ok := a.Val.(float64); ok && math.Float64bits(f64) == 0 {

return C_ZCON

}

c.ctxt.Diag("cannot handle the floating point constant %v", a.Val)

case obj.TYPE_CONST,

obj.TYPE_ADDR:

switch a.Name {

case obj.NAME_NONE:

c.instoffset = a.Offset

if a.Reg != 0 {

if -BIG <= c.instoffset && c.instoffset <= BIG {

return C_SACON

}

if isint32(c.instoffset) {

return C_LACON

}

return C_DACON

}

case obj.NAME_EXTERN,

obj.NAME_STATIC:

s := a.Sym

if s == nil {

return C_GOK

}

c.instoffset = a.Offset

return C_SYMADDR

case obj.NAME_AUTO:

if a.Reg == REGSP {

// unset base register for better printing, since

// a.Offset is still relative to pseudo-SP.

a.Reg = obj.REG_NONE

}

c.instoffset = int64(c.autosize) + a.Offset

if c.instoffset >= -BIG && c.instoffset < BIG {

return C_SACON

}

return C_LACON

case obj.NAME_PARAM:

if a.Reg == REGSP {

// unset base register for better printing, since

// a.Offset is still relative to pseudo-FP.

a.Reg = obj.REG_NONE

}

c.instoffset = int64(c.autosize) + a.Offset + c.ctxt.Arch.FixedFrameSize

if c.instoffset >= -BIG && c.instoffset < BIG {

return C_SACON

}

return C_LACON

default:

return C_GOK

}

if c.instoffset == 0 {

return C_ZCON

}

if c.instoffset >= 0 {

if c.instoffset <= 0x7fff {

return C_SCON

}

if c.instoffset <= 0xffff {

return C_ANDCON

}

if c.instoffset&0xffff == 0 && isuint32(uint64(c.instoffset)) { /* && ((instoffset & (1<<31)) == 0) */

return C_UCON

}

if isint32(c.instoffset) || isuint32(uint64(c.instoffset)) {

return C_LCON

}

return C_DCON

}

if c.instoffset >= -0x8000 {

return C_ADDCON

}

if c.instoffset&0xffff == 0 && isint32(c.instoffset) {

return C_UCON

}

if isint32(c.instoffset) {

return C_LCON

}

return C_DCON

case obj.TYPE_BRANCH:

return C_SBRA

}

return C_GOK

// Return cached optab entry if available.

if p.Optab != 0 {

return &optab[p.Optab-1]

}

if len(p.RestArgs) > 3 {

c.ctxt.Diag("too many RestArgs: got %v, maximum is 3\n", len(p.RestArgs))

return nil

}

// Initialize classes for all arguments.

p.From.Class = int8(c.aclass(&p.From) + 1)

p.To.Class = int8(c.aclass(&p.To) + 1)

for i := range p.RestArgs {

p.RestArgs[i].Addr.Class = int8(c.aclass(&p.RestArgs[i].Addr) + 1)

}

// Mirrors the argument list in Optab.

args := [...]int8{

p.From.Class - 1,

C_NONE, // p.Reg

C_NONE, // p.RestArgs[0]

C_NONE, // p.RestArgs[1]

C_NONE, // p.RestArgs[2]

p.To.Class - 1,

}

// Fill in argument class for p.Reg.

switch {

case REG_R0 <= p.Reg && p.Reg <= REG_R15:

args[1] = C_REG

case REG_V0 <= p.Reg && p.Reg <= REG_V31:

args[1] = C_VREG

case REG_F0 <= p.Reg && p.Reg <= REG_F15:

args[1] = C_FREG

case REG_AR0 <= p.Reg && p.Reg <= REG_AR15:

args[1] = C_AREG

}

// Fill in argument classes for p.RestArgs.

for i, a := range p.RestArgs {

args[2+i] = a.Class - 1

}

// Lookup op in optab.

ops := oprange[p.As&obj.AMask]

cmp := [len(args)]*[C_NCLASS]bool{}

for i := range cmp {

cmp[i] = &xcmp[args[i]]

}

for i := range ops {

op := &ops[i]

if cmp[0][op.a1] && cmp[1][op.a2] &&

cmp[2][op.a3] && cmp[3][op.a4] &&

cmp[4][op.a5] && cmp[5][op.a6] {

p.Optab = uint16(cap(optab) - cap(ops) + i + 1)

return op

}

}

// Cannot find a case; abort.

s := ""

for _, a := range args {

s += fmt.Sprintf(" %v", DRconv(int(a)))

}

c.ctxt.Diag("illegal combination %v%v\n", p.As, s)

c.ctxt.Diag("prog: %v\n", p)

return nil

if a == b {

return true

}

switch a {

case C_DCON:

if b == C_LCON {

return true

}

fallthrough

case C_LCON:

if b == C_ZCON || b == C_SCON || b == C_UCON || b == C_ADDCON || b == C_ANDCON {

return true

}

case C_ADDCON:

if b == C_ZCON || b == C_SCON {

return true

}

case C_ANDCON:

if b == C_ZCON || b == C_SCON {

return true

}

case C_UCON:

if b == C_ZCON || b == C_SCON {

return true

}

case C_SCON:

if b == C_ZCON {

return true

}

case C_LACON:

if b == C_SACON {

return true

}

case C_LBRA:

if b == C_SBRA {

return true

}

case C_LAUTO:

if b == C_SAUTO {

return true

}

case C_LOREG:

if b == C_ZOREG || b == C_SOREG {

return true

}

case C_SOREG:

if b == C_ZOREG {

return true

}

case C_ANY:

return true

}

return false

if p1.as != p2.as {

return int(p1.as) - int(p2.as)

}

if p1.a1 != p2.a1 {

return int(p1.a1) - int(p2.a1)

}

if p1.a2 != p2.a2 {

return int(p1.a2) - int(p2.a2)

}

if p1.a3 != p2.a3 {

return int(p1.a3) - int(p2.a3)

}

if p1.a4 != p2.a4 {

return int(p1.a4) - int(p2.a4)

}

return 0

if oprange[AORW&obj.AMask] != nil {

// Already initialized; stop now.

// This happens in the cmd/asm tests,

// each of which re-initializes the arch.

return

}

for i := 0; i < C_NCLASS; i++ {

for n := 0; n < C_NCLASS; n++ {

if cmp(n, i) {

xcmp[i][n] = true

}

}

}

slices.SortFunc(optab, ocmp)

for i := 0; i < len(optab); i++ {

r := optab[i].as

start := i

for ; i+1 < len(optab); i++ {

if optab[i+1].as != r {

break

}

}

oprange[r&obj.AMask] = optab[start : i+1]

// opset() aliases optab ranges for similar instructions, to reduce the number of optabs in the array.

// oprange[] is used by oplook() to find the Optab entry that applies to a given Prog.

switch r {

case AADD:

opset(AADDC, r)

opset(AADDW, r)

opset(AADDE, r)

opset(AMULLD, r)

opset(AMULLW, r)

case ADIVW:

opset(ADIVD, r)

opset(ADIVDU, r)

opset(ADIVWU, r)

opset(AMODD, r)

opset(AMODDU, r)

opset(AMODW, r)

opset(AMODWU, r)

case AMULHD:

opset(AMULHDU, r)

case AMOVBZ:

opset(AMOVH, r)

opset(AMOVHZ, r)

case ALA:

opset(ALAY, r)

case AMVC:

opset(AMVCIN, r)

opset(ACLC, r)

opset(AXC, r)

opset(AOC, r)

opset(ANC, r)

case ASTCK:

opset(ASTCKC, r)

opset(ASTCKE, r)

opset(ASTCKF, r)

case ALAAG:

opset(ALAA, r)

opset(ALAAL, r)

opset(ALAALG, r)

opset(ALAN, r)

opset(ALANG, r)

opset(ALAX, r)

opset(ALAXG, r)

opset(ALAO, r)

opset(ALAOG, r)

case ASTMG:

opset(ASTMY, r)

case ALMG:

opset(ALMY, r)

case ABEQ:

opset(ABGE, r)

opset(ABGT, r)

opset(ABLE, r)

opset(ABLT, r)

opset(ABNE, r)

opset(ABVC, r)

opset(ABVS, r)

opset(ABLEU, r)

opset(ABLTU, r)

case ABR:

opset(ABL, r)

case ABC:

opset(ABCL, r)

case AFABS:

opset(AFNABS, r)

opset(ALPDFR, r)

opset(ALNDFR, r)

opset(AFNEG, r)

opset(AFNEGS, r)

opset(ALCDBR, r)

opset(ALEDBR, r)

opset(ALDEBR, r)

opset(AFSQRT, r)

opset(AFSQRTS, r)

case AFADD:

opset(AFADDS, r)

opset(AFDIV, r)

opset(AFDIVS, r)

opset(AFSUB, r)

opset(AFSUBS, r)

case AFMADD:

opset(AFMADDS, r)

opset(AFMSUB, r)

opset(AFMSUBS, r)

case AFMUL:

opset(AFMULS, r)

case AFCMPO:

opset(AFCMPU, r)

opset(ACEBR, r)

case AAND:

opset(AOR, r)

opset(AXOR, r)

case AANDW:

opset(AORW, r)

opset(AXORW, r)

case ASLD:

opset(ASRD, r)

opset(ASLW, r)