package arm
-var anames5 = []string{
+var Anames = []string{
"XXX",
"AND",
"EOR",
Scond: C_SCOND_NONE,
Reg: NREG,
From: obj.Addr{
- Name: D_NONE,
- Type_: D_NONE,
- Reg: NREG,
+ Name: D_NONE,
+ Type: D_NONE,
+ Reg: NREG,
},
To: obj.Addr{
- Name: D_NONE,
- Type_: D_NONE,
- Reg: NREG,
+ Name: D_NONE,
+ Type: D_NONE,
+ Reg: NREG,
},
}
case AB,
ABL:
- if p.To.Type_ != D_OREG {
+ if p.To.Type != D_OREG {
if out != nil {
asmout(ctxt, p, o, out)
}
AMOVW,
ASTREX,
ASTREXD:
- if p.To.Type_ == D_REG && p.To.Reg == 15 && p.From.Reg == 13 { // MOVW.W x(R13), PC
+ if p.To.Type == D_REG && p.To.Reg == 15 && p.From.Reg == 13 { // MOVW.W x(R13), PC
if out != nil {
asmout(ctxt, p, o, out)
}
}
}
- if p.To.Type_ == D_REG && p.To.Reg == 15 {
+ if p.To.Type == D_REG && p.To.Reg == 15 {
ctxt.Diag("unsupported instruction (move to another register and use indirect jump instead): %v", p)
}
- if p.To.Type_ == D_OREG && p.To.Reg == 13 && (p.Scond&C_WBIT != 0) && size > 4 {
+ if p.To.Type == D_OREG && p.To.Reg == 13 && (p.Scond&C_WBIT != 0) && size > 4 {
// function prolog with very large frame size: MOVW.W R14,-100004(R13)
// split it into two instructions:
// ADD $-100004, R13
p.Scond &^= C_WBIT
*q = *p
a = &p.To
- if p.To.Type_ == D_OREG {
+ if p.To.Type == D_OREG {
a2 = &q.To
} else {
p.From = *a
p.From.Reg = NREG
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.To = zprg.To
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 13
// make q into p but load/store from 0(R13)
q.Spadj = 0
*a2 = zprg.From
- a2.Type_ = D_OREG
+ a2.Type = D_OREG
a2.Reg = 13
a2.Sym = nil
a2.Offset = 0
break
}
- if (p.To.Type_ == D_OREG && p.To.Reg != 13 && p.To.Reg != 9) || (p.From.Type_ == D_OREG && p.From.Reg != 13 && p.From.Reg != 9) { // MOVW Rx, X(Ry), y != 13 && y != 9 // MOVW X(Rx), Ry, x != 13 && x != 9
- if p.To.Type_ == D_OREG {
+ if (p.To.Type == D_OREG && p.To.Reg != 13 && p.To.Reg != 9) || (p.From.Type == D_OREG && p.From.Reg != 13 && p.From.Reg != 9) { // MOVW Rx, X(Ry), y != 13 && y != 9 // MOVW X(Rx), Ry, x != 13 && x != 9
+ if p.To.Type == D_OREG {
a = &p.To
} else {
}
q = ctxt.Arch.Prg()
*q = *p
- if p.To.Type_ == D_OREG {
+ if p.To.Type == D_OREG {
a2 = &q.To
} else {
p.As = AMOVW
p.From = *a
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.To = zprg.To
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 11
// make q into p but load/store from 0(R11)
*a2 = zprg.From
- a2.Type_ = D_OREG
+ a2.Type = D_OREG
a2.Reg = 11
a2.Sym = nil
a2.Offset = 0
}
// destination register specific
- if p.To.Type_ == D_REG {
+ if p.To.Type == D_REG {
switch p.To.Reg {
case 9:
break
}
- if p.As == AMOVW && p.To.Type_ == D_REG && p.To.Reg == REGPC && p.Scond&C_SCOND == C_SCOND_NONE {
+ if p.As == AMOVW && p.To.Type == D_REG && p.To.Reg == REGPC && p.Scond&C_SCOND == C_SCOND_NONE {
flushpool(ctxt, p, 0, 0)
}
c += int32(m)
}
q = ctxt.Arch.Prg()
q.As = AB
- q.To.Type_ = D_BRANCH
+ q.To.Type = D_BRANCH
q.Pcond = p.Link
q.Link = ctxt.Blitrl
q.Lineno = p.Lineno
default:
t.To.Offset = a.Offset
t.To.Sym = a.Sym
- t.To.Type_ = a.Type_
+ t.To.Type = a.Type
t.To.Name = a.Name
if ctxt.Flag_shared != 0 && t.To.Sym != nil {
C_SAUTO,
C_LAUTO,
C_LACON:
- t.To.Type_ = D_CONST
+ t.To.Type = D_CONST
t.To.Offset = ctxt.Instoffset
break
}
var s *obj.LSym
var t int
- switch a.Type_ {
+ switch a.Type {
case D_NONE:
return C_NONE
if false { /*debug['O']*/
fmt.Printf("oplook %v %v %v %v\n", Aconv(int(p.As)), DRconv(a1), DRconv(a2), DRconv(a3))
- fmt.Printf("\t\t%d %d\n", p.From.Type_, p.To.Type_)
+ fmt.Printf("\t\t%d %d\n", p.From.Type, p.To.Type)
}
e = oprange[r].stop
}
}
- ctxt.Diag("illegal combination %v; %v %v %v, %d %d", p, DRconv(a1), DRconv(a2), DRconv(a3), p.From.Type_, p.To.Type_)
- ctxt.Diag("from %d %d to %d %d\n", p.From.Type_, p.From.Name, p.To.Type_, p.To.Name)
+ ctxt.Diag("illegal combination %v; %v %v %v, %d %d", p, DRconv(a1), DRconv(a2), DRconv(a3), p.From.Type, p.To.Type)
+ ctxt.Diag("from %d %d to %d %d\n", p.From.Type, p.From.Name, p.To.Type, p.To.Name)
prasm(p)
if o == nil {
o = optab
rf = int(p.From.Reg)
rt = int(p.To.Reg)
r = int(p.Reg)
- if p.To.Type_ == D_NONE {
+ if p.To.Type == D_NONE {
rt = 0
}
if p.As == AMOVB || p.As == AMOVH || p.As == AMOVW || p.As == AMVN {
o1 |= uint32(immrot(uint32(ctxt.Instoffset)))
rt = int(p.To.Reg)
r = int(p.Reg)
- if p.To.Type_ == D_NONE {
+ if p.To.Type == D_NONE {
rt = 0
}
if p.As == AMOVW || p.As == AMVN {
rel.Sym = p.To.Sym
v += int32(p.To.Offset)
rel.Add = int64(o1) | (int64(v)>>2)&0xffffff
- rel.Type_ = obj.R_CALLARM
+ rel.Type = obj.R_CALLARM
break
}
rel = obj.Addrel(ctxt.Cursym)
rel.Off = int32(ctxt.Pc)
rel.Siz = 0
- rel.Type_ = obj.R_CALLIND
+ rel.Type = obj.R_CALLIND
case 8: /* sll $c,[R],R -> mov (R<<$c),R */
aclass(ctxt, &p.From)
case 10: /* swi [$con] */
o1 = oprrr(ctxt, int(p.As), int(p.Scond))
- if p.To.Type_ != D_NONE {
+ if p.To.Type != D_NONE {
aclass(ctxt, &p.To)
o1 |= uint32(ctxt.Instoffset & 0xffffff)
}
// Emit a TLS relocation instead of a standard one.
if rel.Sym == ctxt.Tlsg {
- rel.Type_ = obj.R_TLS
+ rel.Type = obj.R_TLS
if ctxt.Flag_shared != 0 {
rel.Add += ctxt.Pc - p.Pcrel.Pc - 8 - int64(rel.Siz)
}
rel.Xadd = rel.Add
rel.Xsym = rel.Sym
} else if ctxt.Flag_shared != 0 {
- rel.Type_ = obj.R_PCREL
+ rel.Type = obj.R_PCREL
rel.Add += ctxt.Pc - p.Pcrel.Pc - 8
} else {
- rel.Type_ = obj.R_ADDR
+ rel.Type = obj.R_ADDR
}
o1 = 0
}
r = int(p.To.Reg)
}
o2 |= uint32(r) << 16
- if p.To.Type_ != D_NONE {
+ if p.To.Type != D_NONE {
o2 |= uint32(p.To.Reg) << 12
}
r = int(o.param)
}
o2 |= uint32(r) << 16
- if p.To.Type_ != D_NONE {
+ if p.To.Type != D_NONE {
o2 |= uint32(p.To.Reg) << 12
}
o1 |= uint32(immrot(0xff))
rt = int(p.To.Reg)
r = int(p.From.Reg)
- if p.To.Type_ == D_NONE {
+ if p.To.Type == D_NONE {
rt = 0
}
if r == NREG {
rel = obj.Addrel(ctxt.Cursym)
rel.Off = int32(ctxt.Pc)
rel.Siz = 4
- if p.To.Sym != nil && p.To.Sym.Type_ != 0 {
+ if p.To.Sym != nil && p.To.Sym.Type != 0 {
rel.Sym = p.To.Sym
rel.Add = p.To.Offset
} else {
}
if o.flag&LPCREL != 0 {
- rel.Type_ = obj.R_PCREL
+ rel.Type = obj.R_PCREL
rel.Add += ctxt.Pc - p.Pcrel.Pc - 16 + int64(rel.Siz)
} else {
- rel.Type_ = obj.R_ADDR
+ rel.Type = obj.R_ADDR
}
o1 = 0
}
o1 |= uint32(p.From.Offset)
rt = int(p.To.Reg)
r = int(p.Reg)
- if p.To.Type_ == D_NONE {
+ if p.To.Type == D_NONE {
rt = 0
}
if p.As == AMOVW || p.As == AMVN {
sc += ".U"
}
if a == AMOVM {
- if p.From.Type_ == D_CONST {
+ if p.From.Type == D_CONST {
str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v", p.Pc, p.Line(), Aconv(a), sc, RAconv(&p.From), Dconv(p, 0, &p.To))
- } else if p.To.Type_ == D_CONST {
+ } else if p.To.Type == D_CONST {
str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v", p.Pc, p.Line(), Aconv(a), sc, Dconv(p, 0, &p.From), RAconv(&p.To))
} else {
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v", p.Pc, p.Line(), Aconv(a), Dconv(p, 0, &p.From), p.Reg, Dconv(p, 0, &p.To))
} else if p.Reg == NREG {
str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v", p.Pc, p.Line(), Aconv(a), sc, Dconv(p, 0, &p.From), Dconv(p, 0, &p.To))
- } else if p.From.Type_ != D_FREG {
+ } else if p.From.Type != D_FREG {
str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,R%d,%v", p.Pc, p.Line(), Aconv(a), sc, Dconv(p, 0, &p.From), p.Reg, Dconv(p, 0, &p.To))
} else {
s = "???"
if a >= AXXX && a < ALAST {
- s = anames5[a]
+ s = Anames[a]
}
fp += s
return fp
var op string
var v int
- switch a.Type_ {
+ switch a.Type {
default:
- str = fmt.Sprintf("GOK-type(%d)", a.Type_)
+ str = fmt.Sprintf("GOK-type(%d)", a.Type)
case D_NONE:
str = ""
var v int
str = fmt.Sprintf("GOK-reglist")
- switch a.Type_ {
+ switch a.Type {
case D_CONST,
D_CONST2:
if a.Reg != NREG {
Scond: C_SCOND_NONE,
Reg: NREG,
From: obj.Addr{
- Name: D_NONE,
- Type_: D_NONE,
- Reg: NREG,
+ Name: D_NONE,
+ Type: D_NONE,
+ Reg: NREG,
},
To: obj.Addr{
- Name: D_NONE,
- Type_: D_NONE,
- Reg: NREG,
+ Name: D_NONE,
+ Type: D_NONE,
+ Reg: NREG,
},
}
ABL,
ADUFFZERO,
ADUFFCOPY:
- if p.To.Type_ == D_OREG && (p.To.Name == D_EXTERN || p.To.Name == D_STATIC) && p.To.Sym != nil {
- p.To.Type_ = D_BRANCH
+ if p.To.Type == D_OREG && (p.To.Name == D_EXTERN || p.To.Name == D_STATIC) && p.To.Sym != nil {
+ p.To.Type = D_BRANCH
}
break
}
// MOVW LR, R11
p.As = AMOVW
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = REGLINK
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = REGTMP
// BL runtime.read_tls_fallback(SB)
p = obj.Appendp(ctxt, p)
p.As = ABL
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p.To.Sym = tlsfallback
p.To.Offset = 0
p = obj.Appendp(ctxt, p)
p.As = AMOVW
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = REGTMP
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = REGLINK
break
}
switch p.As {
case AMOVF:
- if p.From.Type_ == D_FCONST && chipfloat5(ctxt, p.From.U.Dval) < 0 && (chipzero5(ctxt, p.From.U.Dval) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
+ if p.From.Type == D_FCONST && chipfloat5(ctxt, p.From.U.Dval) < 0 && (chipzero5(ctxt, p.From.U.Dval) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
var i32 uint32
var f32 float32
f32 = float32(p.From.U.Dval)
i32 = math.Float32bits(f32)
literal = fmt.Sprintf("$f32.%08x", i32)
s = obj.Linklookup(ctxt, literal, 0)
- if s.Type_ == 0 {
- s.Type_ = obj.SRODATA
+ if s.Type == 0 {
+ s.Type = obj.SRODATA
obj.Adduint32(ctxt, s, i32)
s.Reachable = 0
}
- p.From.Type_ = D_OREG
+ p.From.Type = D_OREG
p.From.Sym = s
p.From.Name = D_EXTERN
p.From.Offset = 0
}
case AMOVD:
- if p.From.Type_ == D_FCONST && chipfloat5(ctxt, p.From.U.Dval) < 0 && (chipzero5(ctxt, p.From.U.Dval) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
+ if p.From.Type == D_FCONST && chipfloat5(ctxt, p.From.U.Dval) < 0 && (chipzero5(ctxt, p.From.U.Dval) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
var i64 uint64
i64 = math.Float64bits(p.From.U.Dval)
literal = fmt.Sprintf("$f64.%016x", i64)
s = obj.Linklookup(ctxt, literal, 0)
- if s.Type_ == 0 {
- s.Type_ = obj.SRODATA
+ if s.Type == 0 {
+ s.Type = obj.SRODATA
obj.Adduint64(ctxt, s, i64)
s.Reachable = 0
}
- p.From.Type_ = D_OREG
+ p.From.Type = D_OREG
p.From.Sym = s
p.From.Name = D_EXTERN
p.From.Offset = 0
ctxt.Tlsg = obj.Linklookup(ctxt, "runtime.tlsg", 0)
}
- if p.From.Type_ == D_CONST && p.From.Name == D_EXTERN && p.From.Sym == ctxt.Tlsg {
- p.From.Type_ = D_OREG
+ if p.From.Type == D_CONST && p.From.Name == D_EXTERN && p.From.Sym == ctxt.Tlsg {
+ p.From.Type = D_OREG
}
- if p.To.Type_ == D_CONST && p.To.Name == D_EXTERN && p.To.Sym == ctxt.Tlsg {
- p.To.Type_ = D_OREG
+ if p.To.Type == D_CONST && p.To.Name == D_EXTERN && p.To.Sym == ctxt.Tlsg {
+ p.To.Type = D_OREG
}
}
}
p = obj.Appendp(ctxt, p)
p.As = AMOVW
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Reg = 13
p.From.Offset = 4
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 1
// MOVW $n(R13), R2
p = obj.Appendp(ctxt, p)
p.As = AMOVW
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Reg = 13
p.From.Offset = 4 + int64(autoffset)
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 2
// MOVW $0, R3
p = obj.Appendp(ctxt, p)
p.As = AMOVW
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = 0
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 3
// L:
p = pl
p.As = AMOVW
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = 3
- p.To.Type_ = D_OREG
+ p.To.Type = D_OREG
p.To.Reg = 1
p.To.Offset = 4
p.Scond |= C_PBIT
p = obj.Appendp(ctxt, p)
p.As = ACMP
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = 1
p.Reg = 2
p = obj.Appendp(ctxt, p)
p.As = ABNE
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p.Pcond = pl
}
}
p.As = AMOVW
p.Scond |= C_WBIT
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = REGLINK
- p.To.Type_ = D_OREG
+ p.To.Type = D_OREG
p.To.Offset = int64(-autosize)
p.To.Reg = REGSP
p.Spadj = autosize
p = obj.Appendp(ctxt, p)
p.As = AMOVW
- p.From.Type_ = D_OREG
+ p.From.Type = D_OREG
p.From.Reg = REGG
p.From.Offset = 4 * int64(ctxt.Arch.Ptrsize) // G.panic
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 1
p = obj.Appendp(ctxt, p)
p.As = ACMP
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = 0
p.Reg = 1
p = obj.Appendp(ctxt, p)
p.As = ABEQ
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p1 = p
p = obj.Appendp(ctxt, p)
p.As = AMOVW
- p.From.Type_ = D_OREG
+ p.From.Type = D_OREG
p.From.Reg = 1
p.From.Offset = 0 // Panic.argp
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 2
p = obj.Appendp(ctxt, p)
p.As = AADD
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = int64(autosize) + 4
p.Reg = 13
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 3
p = obj.Appendp(ctxt, p)
p.As = ACMP
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = 2
p.Reg = 3
p = obj.Appendp(ctxt, p)
p.As = ABNE
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p2 = p
p = obj.Appendp(ctxt, p)
p.As = AADD
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = 4
p.Reg = 13
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 4
p = obj.Appendp(ctxt, p)
p.As = AMOVW
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = 4
- p.To.Type_ = D_OREG
+ p.To.Type = D_OREG
p.To.Reg = 1
p.To.Offset = 0 // Panic.argp
p.As = AB
p.From = zprg5.From
if p.To.Sym != nil { // retjmp
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
} else {
- p.To.Type_ = D_OREG
+ p.To.Type = D_OREG
p.To.Offset = 0
p.To.Reg = REGLINK
}
p.As = AMOVW
p.Scond |= C_PBIT
- p.From.Type_ = D_OREG
+ p.From.Type = D_OREG
p.From.Offset = int64(autosize)
p.From.Reg = REGSP
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = REGPC
// If there are instructions following
p.To.Reg = REGLINK
q2 = obj.Appendp(ctxt, p)
q2.As = AB
- q2.To.Type_ = D_BRANCH
+ q2.To.Type = D_BRANCH
q2.To.Sym = p.To.Sym
p.To.Sym = nil
p = q2
}
case AADD:
- if p.From.Type_ == D_CONST && p.From.Reg == NREG && p.To.Type_ == D_REG && p.To.Reg == REGSP {
+ if p.From.Type == D_CONST && p.From.Reg == NREG && p.To.Type == D_REG && p.To.Reg == REGSP {
p.Spadj = int32(-p.From.Offset)
}
case ASUB:
- if p.From.Type_ == D_CONST && p.From.Reg == NREG && p.To.Type_ == D_REG && p.To.Reg == REGSP {
+ if p.From.Type == D_CONST && p.From.Reg == NREG && p.To.Type == D_REG && p.To.Reg == REGSP {
p.Spadj = int32(p.From.Offset)
}
if ctxt.Debugdivmod != 0 {
break
}
- if p.From.Type_ != D_REG {
+ if p.From.Type != D_REG {
break
}
- if p.To.Type_ != D_REG {
+ if p.To.Type != D_REG {
break
}
q1 = p
p.As = AMOVW
p.Lineno = q1.Lineno
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = q1.From.Reg
- p.To.Type_ = D_OREG
+ p.To.Type = D_OREG
p.To.Reg = REGSP
p.To.Offset = 4
p.As = AMOVW
p.Lineno = q1.Lineno
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = int8(q1.Reg)
if q1.Reg == NREG {
p.From.Reg = q1.To.Reg
}
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = REGTMP
p.To.Offset = 0
p.As = ABL
p.Lineno = q1.Lineno
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
switch o {
case ADIV:
p.To.Sym = ctxt.Sym_div
p.As = AMOVW
p.Lineno = q1.Lineno
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = REGTMP
p.From.Offset = 0
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = q1.To.Reg
/* ADD $8,SP */
p.As = AADD
p.Lineno = q1.Lineno
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Reg = NREG
p.From.Offset = 8
p.Reg = NREG
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = REGSP
p.Spadj = -8
/* TODO: Remove SP adjustments; see issue 6699. */
q1.As = AMOVW
- q1.From.Type_ = D_OREG
+ q1.From.Type = D_OREG
q1.From.Reg = REGSP
q1.From.Offset = 0
q1.Reg = NREG
- q1.To.Type_ = D_REG
+ q1.To.Type = D_REG
q1.To.Reg = REGTMP
/* SUB $8,SP */
q1 = obj.Appendp(ctxt, q1)
q1.As = AMOVW
- q1.From.Type_ = D_REG
+ q1.From.Type = D_REG
q1.From.Reg = REGTMP
q1.Reg = NREG
- q1.To.Type_ = D_OREG
+ q1.To.Type = D_OREG
q1.To.Reg = REGSP
q1.To.Offset = -8
q1.Scond |= C_WBIT
q1.Spadj = 8
case AMOVW:
- if (p.Scond&C_WBIT != 0) && p.To.Type_ == D_OREG && p.To.Reg == REGSP {
+ if (p.Scond&C_WBIT != 0) && p.To.Type == D_OREG && p.To.Reg == REGSP {
p.Spadj = int32(-p.To.Offset)
}
- if (p.Scond&C_PBIT != 0) && p.From.Type_ == D_OREG && p.From.Reg == REGSP && p.To.Reg != REGPC {
+ if (p.Scond&C_PBIT != 0) && p.From.Type == D_OREG && p.From.Reg == REGSP && p.To.Reg != REGPC {
p.Spadj = int32(-p.From.Offset)
}
- if p.From.Type_ == D_CONST && p.From.Reg == REGSP && p.To.Type_ == D_REG && p.To.Reg == REGSP {
+ if p.From.Type == D_CONST && p.From.Reg == REGSP && p.To.Type == D_REG && p.To.Reg == REGSP {
p.Spadj = int32(-p.From.Offset)
}
break
for p = cursym.Text; p != nil; p = p.Link {
switch p.As {
case AMOVW:
- if p.To.Type_ == D_FREG || p.From.Type_ == D_FREG {
+ if p.To.Type == D_FREG || p.From.Type == D_FREG {
goto soft
}
goto notsoft
p.Link = next
p.As = ABL
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p.To.Sym = symsfloat
p.Lineno = next.Lineno
p = obj.Appendp(ctxt, p)
p.As = AMOVW
- p.From.Type_ = D_OREG
+ p.From.Type = D_OREG
p.From.Reg = REGG
p.From.Offset = 2 * int64(ctxt.Arch.Ptrsize) // G.stackguard0
if ctxt.Cursym.Cfunc != 0 {
p.From.Offset = 3 * int64(ctxt.Arch.Ptrsize) // G.stackguard1
}
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 1
if framesize <= obj.StackSmall {
p = obj.Appendp(ctxt, p)
p.As = ACMP
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = 1
p.Reg = REGSP
} else if framesize <= obj.StackBig {
p = obj.Appendp(ctxt, p)
p.As = AMOVW
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Reg = REGSP
p.From.Offset = int64(-framesize)
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 2
p = obj.Appendp(ctxt, p)
p.As = ACMP
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = 1
p.Reg = 2
} else {
p = obj.Appendp(ctxt, p)
p.As = ACMP
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = int64(uint32(obj.StackPreempt & (1<<32 - 1)))
p.Reg = 1
p = obj.Appendp(ctxt, p)
p.As = AMOVW
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Reg = REGSP
p.From.Offset = obj.StackGuard
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 2
p.Scond = C_SCOND_NE
p = obj.Appendp(ctxt, p)
p.As = ASUB
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = 1
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 2
p.Scond = C_SCOND_NE
p = obj.Appendp(ctxt, p)
p.As = AMOVW
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = int64(framesize) + (obj.StackGuard - obj.StackSmall)
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 3
p.Scond = C_SCOND_NE
p = obj.Appendp(ctxt, p)
p.As = ACMP
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = 3
p.Reg = 2
p.Scond = C_SCOND_NE
p.As = AMOVW
p.Scond = C_SCOND_LS
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = REGLINK
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 3
// BL.LS runtime.morestack(SB) // modifies LR, returns with LO still asserted
p.As = ABL
p.Scond = C_SCOND_LS
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
if ctxt.Cursym.Cfunc != 0 {
p.To.Sym = obj.Linklookup(ctxt, "runtime.morestackc", 0)
} else {
p = obj.Appendp(ctxt, p)
p.As = ABLS
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p.Pcond = ctxt.Cursym.Text.Link
return p
return ABGT
}
- log.Fatalf("unknown relation: %s", anames5[a])
+ log.Fatalf("unknown relation: %s", Anames[a])
return 0
}
q = ctxt.Arch.Prg()
q.As = int16(a)
q.Lineno = p.Lineno
- q.To.Type_ = D_BRANCH
+ q.To.Type = D_BRANCH
q.To.Offset = p.Pc
q.Pcond = p
p = q
}
Symgrow(ctxt, s, int64(off+siz))
- switch int(p.To.Type_) {
+ switch int(p.To.Type) {
default:
ctxt.Diag("bad data: %P", p)
copy(s.P[off:off+siz], p.To.U.Sval)
case ctxt.Arch.D_CONST, ctxt.Arch.D_ADDR:
- if p.To.Sym != nil || int(p.To.Type_) == ctxt.Arch.D_ADDR {
+ if p.To.Sym != nil || int(p.To.Type) == ctxt.Arch.D_ADDR {
r := Addrel(s)
r.Off = off
r.Siz = uint8(siz)
r.Sym = p.To.Sym
- r.Type_ = R_ADDR
+ r.Type = R_ADDR
r.Add = p.To.Offset
break
}
}
func setuintxx(ctxt *Link, s *LSym, off int64, v uint64, wid int64) int64 {
- if s.Type_ == 0 {
- s.Type_ = SDATA
+ if s.Type == 0 {
+ s.Type = SDATA
}
s.Reachable = 1
if s.Size < off+wid {
var i int64
var r *Reloc
- if s.Type_ == 0 {
- s.Type_ = SDATA
+ if s.Type == 0 {
+ s.Type = SDATA
}
s.Reachable = 1
i = s.Size
r.Sym = t
r.Off = int32(i)
r.Siz = uint8(ctxt.Arch.Ptrsize)
- r.Type_ = R_ADDR
+ r.Type = R_ADDR
r.Add = add
return i + int64(r.Siz)
}
var i int64
var r *Reloc
- if s.Type_ == 0 {
- s.Type_ = SDATA
+ if s.Type == 0 {
+ s.Type = SDATA
}
s.Reachable = 1
i = s.Size
r.Sym = t
r.Off = int32(i)
r.Add = add
- r.Type_ = R_PCREL
+ r.Type = R_PCREL
r.Siz = 4
return i + int64(r.Siz)
}
func setaddrplus(ctxt *Link, s *LSym, off int64, t *LSym, add int64) int64 {
var r *Reloc
- if s.Type_ == 0 {
- s.Type_ = SDATA
+ if s.Type == 0 {
+ s.Type = SDATA
}
s.Reachable = 1
if off+int64(ctxt.Arch.Ptrsize) > s.Size {
r.Sym = t
r.Off = int32(off)
r.Siz = uint8(ctxt.Arch.Ptrsize)
- r.Type_ = R_ADDR
+ r.Type = R_ADDR
r.Add = add
return off + int64(r.Siz)
}
var i int64
var r *Reloc
- if s.Type_ == 0 {
- s.Type_ = SDATA
+ if s.Type == 0 {
+ s.Type = SDATA
}
s.Reachable = 1
i = s.Size
r.Sym = t
r.Off = int32(i)
r.Siz = uint8(ctxt.Arch.Ptrsize)
- r.Type_ = R_SIZE
+ r.Type = R_SIZE
return i + int64(r.Siz)
}
var i int64
var r *Reloc
- if s.Type_ == 0 {
- s.Type_ = SDATA
+ if s.Type == 0 {
+ s.Type = SDATA
}
s.Reachable = 1
i = s.Size
r.Sym = t
r.Off = int32(i)
r.Siz = 4
- r.Type_ = R_ADDR
+ r.Type = R_ADDR
r.Add = add
return i + int64(r.Siz)
}
/*
* this is the ranlib header
*/
-var anames8 = []string{
+var Anames = []string{
"XXX",
"AAA",
"AAD",
for p = s.Text; p != nil; p = p.Link {
n = 0
- if p.To.Type_ == D_BRANCH {
+ if p.To.Type == D_BRANCH {
if p.Pcond == nil {
p.Pcond = p
}
}
p.Back = uint8(n)
if p.As == AADJSP {
- p.To.Type_ = D_SP
+ p.To.Type = D_SP
v = int32(-p.From.Offset)
p.From.Offset = int64(v)
p.As = AADDL
if p.As == AADJSP {
- p.To.Type_ = D_SP
+ p.To.Type = D_SP
v = int32(-p.From.Offset)
p.From.Offset = int64(v)
p.As = AADDL
}
func prefixof(ctxt *obj.Link, a *obj.Addr) int {
- switch a.Type_ {
+ switch a.Type {
case D_INDIR + D_CS:
return 0x2e
func oclass(a *obj.Addr) int {
var v int32
- if (a.Type_ >= D_INDIR && a.Type_ < 2*D_INDIR) || a.Index != D_NONE {
+ if (a.Type >= D_INDIR && a.Type < 2*D_INDIR) || a.Index != D_NONE {
if a.Index != D_NONE && a.Scale == 0 {
- if a.Type_ == D_ADDR {
+ if a.Type == D_ADDR {
switch a.Index {
case D_EXTERN,
D_STATIC:
return Ym
}
- switch a.Type_ {
+ switch a.Type {
case D_AL:
return Yal
*r = obj.Reloc{}
}
- t = int(a.Type_)
+ t = int(a.Type)
v = int32(a.Offset)
if t == D_ADDR {
t = int(a.Index)
log.Fatalf("bad code")
}
- r.Type_ = obj.R_ADDR
+ r.Type = obj.R_ADDR
r.Siz = 4
r.Off = -1
r.Sym = s
log.Fatalf("bad code")
}
- r.Type_ = obj.R_TLS_LE
+ r.Type = obj.R_TLS_LE
r.Siz = 4
r.Off = -1 // caller must fill in
r.Add = int64(v)
var rel obj.Reloc
v = int32(a.Offset)
- t = int(a.Type_)
+ t = int(a.Type)
rel.Siz = 0
if a.Index != D_NONE && a.Index != D_TLS {
if t < D_INDIR || t >= 2*D_INDIR {
scale = int(a.Scale)
if t < D_INDIR || t >= 2*D_INDIR {
- switch a.Type_ {
+ switch a.Type {
default:
goto bad
if t >= D_AX && t <= D_DI {
if a.Index == D_TLS {
rel = obj.Reloc{}
- rel.Type_ = obj.R_TLS_IE
+ rel.Type = obj.R_TLS_IE
rel.Siz = 4
rel.Sym = nil
rel.Add = int64(v)
canb = canc
cana = canb
- switch a.Type_ {
+ switch a.Type {
case D_NONE:
cand = 0
cana = cand
fmt.Printf("\n%v\ts/%v/%v/\n", p, Rconv(from), Rconv(to))
}
- if int(p.From.Type_) == from {
- p.From.Type_ = int16(to)
+ if int(p.From.Type) == from {
+ p.From.Type = int16(to)
p.Ft = 0
}
- if int(p.To.Type_) == from {
- p.To.Type_ = int16(to)
+ if int(p.To.Type) == from {
+ p.To.Type = int16(to)
p.Tt = 0
}
}
from += D_INDIR
- if int(p.From.Type_) == from {
- p.From.Type_ = int16(to + D_INDIR)
+ if int(p.From.Type) == from {
+ p.From.Type = int16(to + D_INDIR)
p.Ft = 0
}
- if int(p.To.Type_) == from {
- p.To.Type_ = int16(to + D_INDIR)
+ if int(p.To.Type) == from {
+ p.To.Type = int16(to + D_INDIR)
p.Tt = 0
}
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
}
- asmand(ctxt, p, &p.From, reg[p.To.Type_])
+ asmand(ctxt, p, &p.From, reg[p.To.Type])
case Zm_r:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
- asmand(ctxt, p, &p.From, reg[p.To.Type_])
+ asmand(ctxt, p, &p.From, reg[p.To.Type])
case Zm2_r:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(o.op[z+1])
ctxt.Andptr = ctxt.Andptr[1:]
- asmand(ctxt, p, &p.From, reg[p.To.Type_])
+ asmand(ctxt, p, &p.From, reg[p.To.Type])
case Zm_r_xm:
mediaop(ctxt, o, op, int(t[3]), z)
- asmand(ctxt, p, &p.From, reg[p.To.Type_])
+ asmand(ctxt, p, &p.From, reg[p.To.Type])
case Zm_r_i_xm:
mediaop(ctxt, o, op, int(t[3]), z)
- asmand(ctxt, p, &p.From, reg[p.To.Type_])
+ asmand(ctxt, p, &p.From, reg[p.To.Type])
ctxt.Andptr[0] = byte(p.To.Offset)
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
}
- asmand(ctxt, p, &p.From, reg[p.To.Type_])
+ asmand(ctxt, p, &p.From, reg[p.To.Type])
ctxt.Andptr[0] = byte(p.To.Offset)
ctxt.Andptr = ctxt.Andptr[1:]
case Zaut_r:
ctxt.Andptr[0] = 0x8d
ctxt.Andptr = ctxt.Andptr[1:] /* leal */
- if p.From.Type_ != D_ADDR {
+ if p.From.Type != D_ADDR {
ctxt.Diag("asmins: Zaut sb type ADDR")
}
- p.From.Type_ = int16(p.From.Index)
+ p.From.Type = int16(p.From.Index)
p.From.Index = D_NONE
p.Ft = 0
- asmand(ctxt, p, &p.From, reg[p.To.Type_])
- p.From.Index = uint8(p.From.Type_)
- p.From.Type_ = D_ADDR
+ asmand(ctxt, p, &p.From, reg[p.To.Type])
+ p.From.Index = uint8(p.From.Type)
+ p.From.Type = D_ADDR
p.Ft = 0
case Zm_o:
case Zr_m:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
- asmand(ctxt, p, &p.To, reg[p.From.Type_])
+ asmand(ctxt, p, &p.To, reg[p.From.Type])
case Zr_m_xm:
mediaop(ctxt, o, op, int(t[3]), z)
- asmand(ctxt, p, &p.To, reg[p.From.Type_])
+ asmand(ctxt, p, &p.To, reg[p.From.Type])
case Zr_m_i_xm:
mediaop(ctxt, o, op, int(t[3]), z)
- asmand(ctxt, p, &p.To, reg[p.From.Type_])
+ asmand(ctxt, p, &p.To, reg[p.From.Type])
ctxt.Andptr[0] = byte(p.From.Offset)
ctxt.Andptr = ctxt.Andptr[1:]
case Zcallindreg:
r = obj.Addrel(ctxt.Cursym)
r.Off = int32(p.Pc)
- r.Type_ = obj.R_CALLIND
+ r.Type = obj.R_CALLIND
r.Siz = 0
fallthrough
ctxt.Andptr = ctxt.Andptr[1:]
case Zib_rp:
- ctxt.Andptr[0] = byte(op + reg[p.To.Type_])
+ ctxt.Andptr[0] = byte(op + reg[p.To.Type])
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
ctxt.Andptr = ctxt.Andptr[1:]
case Zil_rp:
- ctxt.Andptr[0] = byte(op + reg[p.To.Type_])
+ ctxt.Andptr[0] = byte(op + reg[p.To.Type])
ctxt.Andptr = ctxt.Andptr[1:]
if o.prefix == Pe {
v = vaddr(ctxt, p, &p.From, nil)
case Zib_rr:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
- asmand(ctxt, p, &p.To, reg[p.To.Type_])
+ asmand(ctxt, p, &p.To, reg[p.To.Type])
ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
ctxt.Andptr = ctxt.Andptr[1:]
case Zil_rr:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
- asmand(ctxt, p, &p.To, reg[p.To.Type_])
+ asmand(ctxt, p, &p.To, reg[p.To.Type])
if o.prefix == Pe {
v = vaddr(ctxt, p, &p.From, nil)
ctxt.Andptr[0] = byte(v)
}
case Z_rp:
- ctxt.Andptr[0] = byte(op + reg[p.To.Type_])
+ ctxt.Andptr[0] = byte(op + reg[p.To.Type])
ctxt.Andptr = ctxt.Andptr[1:]
case Zrp_:
- ctxt.Andptr[0] = byte(op + reg[p.From.Type_])
+ ctxt.Andptr[0] = byte(op + reg[p.From.Type])
ctxt.Andptr = ctxt.Andptr[1:]
case Zclr:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
- asmand(ctxt, p, &p.To, reg[p.To.Type_])
+ asmand(ctxt, p, &p.To, reg[p.To.Type])
case Zcall:
if p.To.Sym == nil {
ctxt.Andptr = ctxt.Andptr[1:]
r = obj.Addrel(ctxt.Cursym)
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
- r.Type_ = obj.R_CALL
+ r.Type = obj.R_CALL
r.Siz = 4
r.Sym = p.To.Sym
r.Add = p.To.Offset
r = obj.Addrel(ctxt.Cursym)
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
r.Sym = p.To.Sym
- r.Type_ = obj.R_PCREL
+ r.Type = obj.R_PCREL
r.Siz = 4
put4(ctxt, 0)
break
}
r = obj.Addrel(ctxt.Cursym)
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
- r.Type_ = obj.R_PCREL
+ r.Type = obj.R_PCREL
r.Siz = 4
r.Add = p.To.Offset
put4(ctxt, 0)
ctxt.Andptr = ctxt.Andptr[1:]
r = obj.Addrel(ctxt.Cursym)
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
- r.Type_ = obj.R_ADDR
+ r.Type = obj.R_ADDR
r.Siz = 4
r.Add = p.To.Offset
r.Sym = p.To.Sym
bad:
pp = *p
- z = int(p.From.Type_)
+ z = int(p.From.Type)
if z >= D_BP && z <= D_DI {
breg = byteswapreg(ctxt, &p.To)
if breg != D_AX {
return
}
- z = int(p.To.Type_)
+ z = int(p.To.Type)
if z >= D_BP && z <= D_DI {
breg = byteswapreg(ctxt, &p.From)
if breg != D_AX {
return
}
- ctxt.Diag("doasm: notfound t2=%x from=%x to=%x %v", t[2], uint16(p.From.Type_), uint16(p.To.Type_), p)
+ ctxt.Diag("doasm: notfound t2=%x from=%x to=%x %v", t[2], uint16(p.From.Type), uint16(p.To.Type), p)
return
mfound:
break
}
- asmand(ctxt, p, &p.From, reg[p.To.Type_])
+ asmand(ctxt, p, &p.From, reg[p.To.Type])
case 6: /* double shift */
- z = int(p.From.Type_)
+ z = int(p.From.Type)
switch z {
default:
}
ctxt.Andptr[0] = t[5]
ctxt.Andptr = ctxt.Andptr[1:]
- asmand(ctxt, p, &p.From, reg[p.To.Type_])
+ asmand(ctxt, p, &p.From, reg[p.To.Type])
// NOTE: The systems listed here are the ones that use the "TLS initial exec" model,
// where you load the TLS base register into a register and then index off that
obj.Hnacl:
pp.From = p.From
- pp.From.Type_ = D_INDIR + D_GS
+ pp.From.Type = D_INDIR + D_GS
pp.From.Offset = 0
pp.From.Index = D_NONE
pp.From.Scale = 0
ctxt.Andptr = ctxt.Andptr[1:] // GS
ctxt.Andptr[0] = 0x8B
ctxt.Andptr = ctxt.Andptr[1:]
- asmand(ctxt, p, &pp.From, reg[p.To.Type_])
+ asmand(ctxt, p, &pp.From, reg[p.To.Type])
case obj.Hplan9:
if ctxt.Plan9privates == nil {
ctxt.Plan9privates = obj.Linklookup(ctxt, "_privates", 0)
}
pp.From = obj.Addr{}
- pp.From.Type_ = D_EXTERN
+ pp.From.Type = D_EXTERN
pp.From.Sym = ctxt.Plan9privates
pp.From.Offset = 0
pp.From.Index = D_NONE
ctxt.Andptr[0] = 0x8B
ctxt.Andptr = ctxt.Andptr[1:]
- asmand(ctxt, p, &pp.From, reg[p.To.Type_])
+ asmand(ctxt, p, &pp.From, reg[p.To.Type])
// Windows TLS base is always 0x14(FS).
case obj.Hwindows:
pp.From = p.From
- pp.From.Type_ = D_INDIR + D_FS
+ pp.From.Type = D_INDIR + D_FS
pp.From.Offset = 0x14
pp.From.Index = D_NONE
pp.From.Scale = 0
ctxt.Andptr = ctxt.Andptr[1:] // FS
ctxt.Andptr[0] = 0x8B
ctxt.Andptr = ctxt.Andptr[1:]
- asmand(ctxt, p, &pp.From, reg[p.To.Type_])
+ asmand(ctxt, p, &pp.From, reg[p.To.Type])
break
}
r = obj.Addrel(ctxt.Cursym)
r.Off = 0
r.Sym = p.From.Sym
- r.Type_ = obj.R_USEFIELD
+ r.Type = obj.R_USEFIELD
r.Siz = 0
return
}
case ACALL,
AJMP:
- if D_AX <= p.To.Type_ && p.To.Type_ <= D_DI {
+ if D_AX <= p.To.Type && p.To.Type <= D_DI {
ctxt.Andptr[0] = 0x83
ctxt.Andptr = ctxt.Andptr[1:]
- ctxt.Andptr[0] = byte(0xe0 | (p.To.Type_ - D_AX))
+ ctxt.Andptr[0] = byte(0xe0 | (p.To.Type - D_AX))
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0xe0
ctxt.Andptr = ctxt.Andptr[1:]
func Aconv(i int) string {
var fp string
- fp += anames8[i]
+ fp += Anames[i]
return fp
}
var i int
- i = int(a.Type_)
+ i = int(a.Type)
if flag&fmtLong != 0 /*untyped*/ {
if i == D_CONST2 {
str = fmt.Sprintf("$\"%q\"", a.U.Sval)
case D_ADDR:
- a.Type_ = int16(a.Index)
+ a.Type = int16(a.Index)
a.Index = D_NONE
str = fmt.Sprintf("$%v", Dconv(p, 0, a))
- a.Index = uint8(a.Type_)
- a.Type_ = D_ADDR
+ a.Index = uint8(a.Type)
+ a.Type = D_ADDR
goto conv
}
return fp
}
-var regstr = []string{
+var Register = []string{
"AL", /* [D_AL] */
"CL",
"DL",
var fp string
if r >= D_AL && r <= D_NONE {
- str = fmt.Sprintf("%s", regstr[r-D_AL])
+ str = fmt.Sprintf("%s", Register[r-D_AL])
} else {
str = fmt.Sprintf("gok(%d)", r)
Back: 2,
As: AGOK,
From: obj.Addr{
- Type_: D_NONE,
+ Type: D_NONE,
Index: D_NONE,
Scale: 1,
},
To: obj.Addr{
- Type_: D_NONE,
+ Type: D_NONE,
Index: D_NONE,
Scale: 1,
},
func symtype(a *obj.Addr) int {
var t int
- t = int(a.Type_)
+ t = int(a.Type)
if t == D_ADDR {
t = int(a.Index)
}
// become
// NOP
// ... off(TLS) ...
- if p.As == AMOVL && p.From.Type_ == D_TLS && D_AX <= p.To.Type_ && p.To.Type_ <= D_DI {
+ if p.As == AMOVL && p.From.Type == D_TLS && D_AX <= p.To.Type && p.To.Type <= D_DI {
p.As = ANOP
- p.From.Type_ = D_NONE
- p.To.Type_ = D_NONE
+ p.From.Type = D_NONE
+ p.To.Type = D_NONE
}
- if p.From.Index == D_TLS && D_INDIR+D_AX <= p.From.Type_ && p.From.Type_ <= D_INDIR+D_DI {
- p.From.Type_ = D_INDIR + D_TLS
+ if p.From.Index == D_TLS && D_INDIR+D_AX <= p.From.Type && p.From.Type <= D_INDIR+D_DI {
+ p.From.Type = D_INDIR + D_TLS
p.From.Scale = 0
p.From.Index = D_NONE
}
- if p.To.Index == D_TLS && D_INDIR+D_AX <= p.To.Type_ && p.To.Type_ <= D_INDIR+D_DI {
- p.To.Type_ = D_INDIR + D_TLS
+ if p.To.Index == D_TLS && D_INDIR+D_AX <= p.To.Type && p.To.Type <= D_INDIR+D_DI {
+ p.To.Type = D_INDIR + D_TLS
p.To.Scale = 0
p.To.Index = D_NONE
}
// MOVL TLS, BX
// MOVL off(BX)(TLS*1), BX
// This allows the C compilers to emit references to m and g using the direct off(TLS) form.
- if p.As == AMOVL && p.From.Type_ == D_INDIR+D_TLS && D_AX <= p.To.Type_ && p.To.Type_ <= D_DI {
+ if p.As == AMOVL && p.From.Type == D_INDIR+D_TLS && D_AX <= p.To.Type && p.To.Type <= D_DI {
q = obj.Appendp(ctxt, p)
q.As = p.As
q.From = p.From
- q.From.Type_ = D_INDIR + p.To.Type_
+ q.From.Type = D_INDIR + p.To.Type
q.From.Index = D_TLS
q.From.Scale = 2 // TODO: use 1
q.To = p.To
- p.From.Type_ = D_TLS
+ p.From.Type = D_TLS
p.From.Index = D_NONE
p.From.Offset = 0
}
case ACALL,
AJMP,
ARET:
- if (p.To.Type_ == D_EXTERN || p.To.Type_ == D_STATIC) && p.To.Sym != nil {
- p.To.Type_ = D_BRANCH
+ if (p.To.Type == D_EXTERN || p.To.Type == D_STATIC) && p.To.Sym != nil {
+ p.To.Type = D_BRANCH
}
break
}
// Convert AMOVSS $(0), Xx to AXORPS Xx, Xx
case AMOVSS:
- if p.From.Type_ == D_FCONST {
+ if p.From.Type == D_FCONST {
if p.From.U.Dval == 0 {
- if p.To.Type_ >= D_X0 {
- if p.To.Type_ <= D_X7 {
+ if p.To.Type >= D_X0 {
+ if p.To.Type <= D_X7 {
p.As = AXORPS
- p.From.Type_ = p.To.Type_
+ p.From.Type = p.To.Type
p.From.Index = p.To.Index
break
}
ADIVSS,
ACOMISS,
AUCOMISS:
- if p.From.Type_ == D_FCONST {
+ if p.From.Type == D_FCONST {
var i32 uint32
var f32 float32
i32 = math.Float32bits(f32)
literal = fmt.Sprintf("$f32.%08x", i32)
s = obj.Linklookup(ctxt, literal, 0)
- if s.Type_ == 0 {
- s.Type_ = obj.SRODATA
+ if s.Type == 0 {
+ s.Type = obj.SRODATA
obj.Adduint32(ctxt, s, i32)
s.Reachable = 0
}
- p.From.Type_ = D_EXTERN
+ p.From.Type = D_EXTERN
p.From.Sym = s
p.From.Offset = 0
}
// Convert AMOVSD $(0), Xx to AXORPS Xx, Xx
case AMOVSD:
- if p.From.Type_ == D_FCONST {
+ if p.From.Type == D_FCONST {
if p.From.U.Dval == 0 {
- if p.To.Type_ >= D_X0 {
- if p.To.Type_ <= D_X7 {
+ if p.To.Type >= D_X0 {
+ if p.To.Type <= D_X7 {
p.As = AXORPS
- p.From.Type_ = p.To.Type_
+ p.From.Type = p.To.Type
p.From.Index = p.To.Index
break
}
ADIVSD,
ACOMISD,
AUCOMISD:
- if p.From.Type_ == D_FCONST {
+ if p.From.Type == D_FCONST {
var i64 uint64
i64 = math.Float64bits(p.From.U.Dval)
literal = fmt.Sprintf("$f64.%016x", i64)
s = obj.Linklookup(ctxt, literal, 0)
- if s.Type_ == 0 {
- s.Type_ = obj.SRODATA
+ if s.Type == 0 {
+ s.Type = obj.SRODATA
obj.Adduint64(ctxt, s, i64)
s.Reachable = 0
}
- p.From.Type_ = D_EXTERN
+ p.From.Type = D_EXTERN
p.From.Sym = s
p.From.Offset = 0
}
p = obj.Appendp(ctxt, p)
p.As = AADJSP
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = int64(autoffset)
p.Spadj = autoffset
} else {
p = obj.Appendp(ctxt, p)
p.As = AMOVL
- p.From.Type_ = D_INDIR + D_CX
+ p.From.Type = D_INDIR + D_CX
p.From.Offset = 4 * int64(ctxt.Arch.Ptrsize) // G.panic
- p.To.Type_ = D_BX
+ p.To.Type = D_BX
p = obj.Appendp(ctxt, p)
p.As = ATESTL
- p.From.Type_ = D_BX
- p.To.Type_ = D_BX
+ p.From.Type = D_BX
+ p.To.Type = D_BX
p = obj.Appendp(ctxt, p)
p.As = AJEQ
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p1 = p
p = obj.Appendp(ctxt, p)
p.As = ALEAL
- p.From.Type_ = D_INDIR + D_SP
+ p.From.Type = D_INDIR + D_SP
p.From.Offset = int64(autoffset) + 4
- p.To.Type_ = D_DI
+ p.To.Type = D_DI
p = obj.Appendp(ctxt, p)
p.As = ACMPL
- p.From.Type_ = D_INDIR + D_BX
+ p.From.Type = D_INDIR + D_BX
p.From.Offset = 0 // Panic.argp
- p.To.Type_ = D_DI
+ p.To.Type = D_DI
p = obj.Appendp(ctxt, p)
p.As = AJNE
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p2 = p
p = obj.Appendp(ctxt, p)
p.As = AMOVL
- p.From.Type_ = D_SP
- p.To.Type_ = D_INDIR + D_BX
+ p.From.Type = D_SP
+ p.To.Type = D_INDIR + D_BX
p.To.Offset = 0 // Panic.argp
p = obj.Appendp(ctxt, p)
p = obj.Appendp(ctxt, p)
p.As = AMOVL
- p.From.Type_ = D_SP
- p.To.Type_ = D_DI
+ p.From.Type = D_SP
+ p.To.Type = D_DI
p = obj.Appendp(ctxt, p)
p.As = AMOVL
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = int64(autoffset) / 4
- p.To.Type_ = D_CX
+ p.To.Type = D_CX
p = obj.Appendp(ctxt, p)
p.As = AMOVL
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = 0
- p.To.Type_ = D_AX
+ p.To.Type = D_AX
p = obj.Appendp(ctxt, p)
p.As = AREP
}
for ; p != nil; p = p.Link {
- a = int(p.From.Type_)
+ a = int(p.From.Type)
if a == D_AUTO {
p.From.Offset += int64(deltasp)
}
if a == D_PARAM {
p.From.Offset += int64(deltasp) + 4
}
- a = int(p.To.Type_)
+ a = int(p.To.Type)
if a == D_AUTO {
p.To.Offset += int64(deltasp)
}
if autoffset != 0 {
p.As = AADJSP
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = int64(-autoffset)
p.Spadj = -autoffset
p = obj.Appendp(ctxt, p)
var next *obj.Prog
p.As = AMOVL
- p.From.Type_ = D_INDIR + D_TLS
+ p.From.Type = D_INDIR + D_TLS
p.From.Offset = 0
- p.To.Type_ = D_CX
+ p.To.Type = D_CX
next = p.Link
progedit(ctxt, p)
p = obj.Appendp(ctxt, p)
p.As = ACMPL
- p.From.Type_ = D_INDIR + D_CX
+ p.From.Type = D_INDIR + D_CX
p.From.Offset = 4
- p.To.Type_ = D_SP
+ p.To.Type = D_SP
p = obj.Appendp(ctxt, p)
p.As = AJCC
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p.To.Offset = 4
q1 = p
p = obj.Appendp(ctxt, p)
p.As = AINT
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = 3
p = obj.Appendp(ctxt, p)
p = obj.Appendp(ctxt, p)
p.As = ACMPL
- p.From.Type_ = D_SP
- p.To.Type_ = D_INDIR + D_CX
+ p.From.Type = D_SP
+ p.To.Type = D_INDIR + D_CX
p.To.Offset = 2 * int64(ctxt.Arch.Ptrsize) // G.stackguard0
if ctxt.Cursym.Cfunc != 0 {
p.To.Offset = 3 * int64(ctxt.Arch.Ptrsize) // G.stackguard1
p = obj.Appendp(ctxt, p)
p.As = ALEAL
- p.From.Type_ = D_INDIR + D_SP
+ p.From.Type = D_INDIR + D_SP
p.From.Offset = -(int64(framesize) - obj.StackSmall)
- p.To.Type_ = D_AX
+ p.To.Type = D_AX
p = obj.Appendp(ctxt, p)
p.As = ACMPL
- p.From.Type_ = D_AX
- p.To.Type_ = D_INDIR + D_CX
+ p.From.Type = D_AX
+ p.To.Type = D_INDIR + D_CX
p.To.Offset = 2 * int64(ctxt.Arch.Ptrsize) // G.stackguard0
if ctxt.Cursym.Cfunc != 0 {
p.To.Offset = 3 * int64(ctxt.Arch.Ptrsize) // G.stackguard1
p = obj.Appendp(ctxt, p)
p.As = AMOVL
- p.From.Type_ = D_INDIR + D_CX
+ p.From.Type = D_INDIR + D_CX
p.From.Offset = 0
p.From.Offset = 2 * int64(ctxt.Arch.Ptrsize) // G.stackguard0
if ctxt.Cursym.Cfunc != 0 {
p.From.Offset = 3 * int64(ctxt.Arch.Ptrsize) // G.stackguard1
}
- p.To.Type_ = D_SI
+ p.To.Type = D_SI
p = obj.Appendp(ctxt, p)
p.As = ACMPL
- p.From.Type_ = D_SI
- p.To.Type_ = D_CONST
+ p.From.Type = D_SI
+ p.To.Type = D_CONST
p.To.Offset = int64(uint32(obj.StackPreempt & (1<<32 - 1)))
p = obj.Appendp(ctxt, p)
p.As = AJEQ
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
q1 = p
p = obj.Appendp(ctxt, p)
p.As = ALEAL
- p.From.Type_ = D_INDIR + D_SP
+ p.From.Type = D_INDIR + D_SP
p.From.Offset = obj.StackGuard
- p.To.Type_ = D_AX
+ p.To.Type = D_AX
p = obj.Appendp(ctxt, p)
p.As = ASUBL
- p.From.Type_ = D_SI
+ p.From.Type = D_SI
p.From.Offset = 0
- p.To.Type_ = D_AX
+ p.To.Type = D_AX
p = obj.Appendp(ctxt, p)
p.As = ACMPL
- p.From.Type_ = D_AX
- p.To.Type_ = D_CONST
+ p.From.Type = D_AX
+ p.To.Type = D_CONST
p.To.Offset = int64(framesize) + (obj.StackGuard - obj.StackSmall)
}
p = obj.Appendp(ctxt, p)
p.As = AJHI
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p.To.Offset = 4
q = p
p = obj.Appendp(ctxt, p)
p.As = ACALL
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
if ctxt.Cursym.Cfunc != 0 {
p.To.Sym = obj.Linklookup(ctxt, "runtime.morestackc", 0)
} else {
p = obj.Appendp(ctxt, p)
p.As = AJMP
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p.Pcond = ctxt.Cursym.Text.Link
if q != nil {
return AJOS
}
- log.Fatalf("unknown relation: %s", anames8[a])
+ log.Fatalf("unknown relation: %s", Anames[a])
return 0
}
q = ctxt.Arch.Prg()
q.As = AJMP
q.Lineno = p.Lineno
- q.To.Type_ = D_BRANCH
+ q.To.Type = D_BRANCH
q.To.Offset = p.Pc
q.Pcond = p
p = q
if q != nil {
p.Link = q
}
- if p.From.Type_ == D_CONST {
+ if p.From.Type == D_CONST {
if p.From.Offset == 1 {
/*
* expect conditional jump to be taken.
}
Sym *LSym
Gotype *LSym
- Type_ int16
+ Type int16
Index uint8
Scale int8
Reg int8
type LSym struct {
Name string
Extname string
- Type_ int16
+ Type int16
Version int16
Dupok uint8
Cfunc uint8
Off int32
Siz uint8
Done uint8
- Type_ int32
+ Type int32
Variant int32
Add int64
Xadd int64
Asym *LSym
Link *Auto
Aoffset int32
- Type_ int16
+ Type int16
Gotype *LSym
}
a = new(Auto)
a.Asym = p.From.Sym
a.Aoffset = int32(p.From.Offset)
- a.Type_ = int16(ctxt.Arch.Symtype(&p.From))
+ a.Type = int16(ctxt.Arch.Symtype(&p.From))
a.Gotype = p.From.Gotype
a.Link = curtext.Autom
curtext.Autom = a
}
s.Next = nil
s.Size = p.To.Offset
- if s.Type_ == 0 || s.Type_ == SXREF {
- s.Type_ = SBSS
+ if s.Type == 0 || s.Type == SXREF {
+ s.Type = SBSS
}
flag = ctxt.Arch.Textflag(p)
if flag&DUPOK != 0 {
s.Dupok = 1
}
if flag&RODATA != 0 {
- s.Type_ = SRODATA
+ s.Type = SRODATA
} else if flag&NOPTR != 0 {
- s.Type_ = SNOPTRBSS
+ s.Type = SNOPTRBSS
}
edata = s
continue
s.Nosplit = 1
}
s.Next = nil
- s.Type_ = STEXT
+ s.Type = STEXT
s.Text = p
s.Etext = p
curtext = s
continue
}
if p.To.Sym.Name == "go_args_stackmap" {
- if int(p.From.Type_) != ctxt.Arch.D_CONST || p.From.Offset != FUNCDATA_ArgsPointerMaps {
+ if int(p.From.Type) != ctxt.Arch.D_CONST || p.From.Offset != FUNCDATA_ArgsPointerMaps {
ctxt.Diag("FUNCDATA use of go_args_stackmap(SB) without FUNCDATA_ArgsPointerMaps")
}
p.To.Sym = Linklookup(ctxt, string(fmt.Sprintf("%s.args_stackmap", curtext.Name)), int(curtext.Version))
}
found = 0
for p = s.Text; p != nil; p = p.Link {
- if int(p.As) == ctxt.Arch.AFUNCDATA && int(p.From.Type_) == ctxt.Arch.D_CONST && p.From.Offset == FUNCDATA_ArgsPointerMaps {
+ if int(p.As) == ctxt.Arch.AFUNCDATA && int(p.From.Type) == ctxt.Arch.D_CONST && p.From.Offset == FUNCDATA_ArgsPointerMaps {
found = 1
break
}
if !(found != 0) {
p = Appendp(ctxt, s.Text)
p.As = int16(ctxt.Arch.AFUNCDATA)
- p.From.Type_ = int16(ctxt.Arch.D_CONST)
+ p.From.Type = int16(ctxt.Arch.D_CONST)
p.From.Offset = FUNCDATA_ArgsPointerMaps
if ctxt.Arch.Thechar == '6' || ctxt.Arch.Thechar == '8' {
- p.To.Type_ = int16(ctxt.Arch.D_EXTERN)
+ p.To.Type = int16(ctxt.Arch.D_EXTERN)
} else {
- p.To.Type_ = int16(ctxt.Arch.D_OREG)
+ p.To.Type = int16(ctxt.Arch.D_OREG)
p.To.Name = int8(ctxt.Arch.D_EXTERN)
}
if s.Version != 0 {
fmt.Fprintf(ctxt.Bso, "v=%d ", s.Version)
}
- if s.Type_ != 0 {
- fmt.Fprintf(ctxt.Bso, "t=%d ", s.Type_)
+ if s.Type != 0 {
+ fmt.Fprintf(ctxt.Bso, "t=%d ", s.Type)
}
if s.Dupok != 0 {
fmt.Fprintf(ctxt.Bso, "dupok ")
fmt.Fprintf(ctxt.Bso, "nosplit ")
}
fmt.Fprintf(ctxt.Bso, "size=%d value=%d", int64(s.Size), int64(s.Value))
- if s.Type_ == STEXT {
+ if s.Type == STEXT {
fmt.Fprintf(ctxt.Bso, " args=%#x locals=%#x", uint64(s.Args), uint64(s.Locals))
if s.Leaf != 0 {
fmt.Fprintf(ctxt.Bso, " leaf")
name = r.Sym.Name
}
if ctxt.Arch.Thechar == '5' || ctxt.Arch.Thechar == '9' {
- fmt.Fprintf(ctxt.Bso, "\trel %d+%d t=%d %s+%x\n", int(r.Off), r.Siz, r.Type_, name, uint64(int64(r.Add)))
+ fmt.Fprintf(ctxt.Bso, "\trel %d+%d t=%d %s+%x\n", int(r.Off), r.Siz, r.Type, name, uint64(int64(r.Add)))
} else {
- fmt.Fprintf(ctxt.Bso, "\trel %d+%d t=%d %s+%d\n", int(r.Off), r.Siz, r.Type_, name, int64(r.Add))
+ fmt.Fprintf(ctxt.Bso, "\trel %d+%d t=%d %s+%d\n", int(r.Off), r.Siz, r.Type, name, int64(r.Add))
}
}
}
Bputc(b, 0xfe)
- wrint(b, int64(s.Type_))
+ wrint(b, int64(s.Type))
wrstring(b, s.Name)
wrint(b, int64(s.Version))
wrint(b, int64(s.Dupok))
r = &s.R[i]
wrint(b, int64(r.Off))
wrint(b, int64(r.Siz))
- wrint(b, int64(r.Type_))
+ wrint(b, int64(r.Type))
wrint(b, r.Add)
wrint(b, r.Xadd)
wrsym(b, r.Sym)
wrsym(b, r.Xsym)
}
- if s.Type_ == STEXT {
+ if s.Type == STEXT {
wrint(b, int64(s.Args))
wrint(b, int64(s.Locals))
wrint(b, int64(s.Nosplit))
for a = s.Autom; a != nil; a = a.Link {
wrsym(b, a.Asym)
wrint(b, int64(a.Aoffset))
- if int(a.Type_) == ctxt.Arch.D_AUTO {
+ if int(a.Type) == ctxt.Arch.D_AUTO {
wrint(b, A_AUTO)
- } else if int(a.Type_) == ctxt.Arch.D_PARAM {
+ } else if int(a.Type) == ctxt.Arch.D_PARAM {
wrint(b, A_PARAM)
} else {
- log.Fatalf("%s: invalid local variable type %d", s.Name, a.Type_)
+ log.Fatalf("%s: invalid local variable type %d", s.Name, a.Type)
}
wrsym(b, a.Gotype)
}
if ctxt.Arch.Progedit != nil {
ctxt.Arch.Progedit(ctxt, p)
}
- if int(p.To.Type_) != ctxt.Arch.D_BRANCH {
+ if int(p.To.Type) != ctxt.Arch.D_BRANCH {
continue
}
if p.To.U.Branch != nil {
name = p.To.Sym.Name
}
ctxt.Diag("branch out of range (%#x)\n%v [%s]", uint32(c), p, name)
- p.To.Type_ = int16(ctxt.Arch.D_NONE)
+ p.To.Type = int16(ctxt.Arch.D_NONE)
}
p.To.U.Branch = q
if p.Pcond != nil {
p.Pcond = brloop(ctxt, p.Pcond)
if p.Pcond != nil {
- if int(p.To.Type_) == ctxt.Arch.D_BRANCH {
+ if int(p.To.Type) == ctxt.Arch.D_BRANCH {
p.To.Offset = p.Pcond.Pc
}
}
if int(p.As) == ctxt.Arch.AFUNCDATA {
i = int(p.From.Offset)
pcln.Funcdataoff[i] = p.To.Offset
- if int(p.To.Type_) != ctxt.Arch.D_CONST {
+ if int(p.To.Type) != ctxt.Arch.D_CONST {
// TODO: Dedup.
//funcdata_bytes += p->to.sym->size;
pcln.Funcdata[i] = p.To.Sym
/*
* this is the ranlib header
*/
-var anames9 = []string{
+var Anames = []string{
"XXX",
"ADD",
"ADDCC",
q.Link = p.Link
p.Link = q
q.As = ABR
- q.To.Type_ = D_BRANCH
+ q.To.Type = D_BRANCH
q.Pcond = p.Pcond
p.Pcond = q
q = ctxt.Arch.Prg()
q.Link = p.Link
p.Link = q
q.As = ABR
- q.To.Type_ = D_BRANCH
+ q.To.Type = D_BRANCH
q.Pcond = q.Link.Link
//addnop(p->link);
func aclass(ctxt *obj.Link, a *obj.Addr) int {
var s *obj.LSym
- switch a.Type_ {
+ switch a.Type {
case D_NONE:
return C_NONE
if s == nil {
break
}
- if s.Type_ == obj.SCONST {
+ if s.Type == obj.SCONST {
ctxt.Instoffset = s.Value + a.Offset
goto consize
}
rel.Siz = 8
rel.Sym = s
rel.Add = int64(uint64(*o1)<<32 | uint64(uint32(*o2)))
- rel.Type_ = obj.R_ADDRPOWER
+ rel.Type = obj.R_ADDRPOWER
}
/*
break
case 1: /* mov r1,r2 ==> OR Rs,Rs,Ra */
- if p.To.Reg == REGZERO && p.From.Type_ == D_CONST {
+ if p.To.Reg == REGZERO && p.From.Type == D_CONST {
v = regoff(ctxt, &p.From)
if r0iszero != 0 /*TypeKind(100016)*/ && v != 0 {
r = int(o.param)
}
v = regoff(ctxt, &p.To)
- if p.To.Type_ == D_OREG && p.Reg != NREG {
+ if p.To.Type == D_OREG && p.Reg != NREG {
if v != 0 {
ctxt.Diag("illegal indexed instruction\n%v", p)
}
r = int(o.param)
}
v = regoff(ctxt, &p.From)
- if p.From.Type_ == D_OREG && p.Reg != NREG {
+ if p.From.Type == D_OREG && p.Reg != NREG {
if v != 0 {
ctxt.Diag("illegal indexed instruction\n%v", p)
}
r = int(o.param)
}
v = regoff(ctxt, &p.From)
- if p.From.Type_ == D_OREG && p.Reg != NREG {
+ if p.From.Type == D_OREG && p.Reg != NREG {
if v != 0 {
ctxt.Diag("illegal indexed instruction\n%v", p)
}
}
rel.Add = int64(v)
- rel.Type_ = obj.R_CALLPOWER
+ rel.Type = obj.R_CALLPOWER
}
case 12: /* movb r,r (extsb); movw r,r (extsw) */
- if p.To.Reg == REGZERO && p.From.Type_ == D_CONST {
+ if p.To.Reg == REGZERO && p.From.Type == D_CONST {
v = regoff(ctxt, &p.From)
if r0iszero != 0 /*TypeKind(100016)*/ && v != 0 {
16: /* bc bo,bi,sbra */
a = 0
- if p.From.Type_ == D_CONST {
+ if p.From.Type == D_CONST {
a = int(regoff(ctxt, &p.From))
}
r = int(p.Reg)
rel.Siz = 8
rel.Sym = p.From.Sym
rel.Add = p.From.Offset
- rel.Type_ = obj.R_ADDR
+ rel.Type = obj.R_ADDR
o2 = 0
o1 = o2
}
o1 = LOP_RRR(uint32(oprrr(ctxt, int(p.As))), uint32(p.To.Reg), uint32(r), 0)
case 49: /* op Rb; op $n, Rb */
- if p.From.Type_ != D_REG { /* tlbie $L, rB */
+ if p.From.Type != D_REG { /* tlbie $L, rB */
v = regoff(ctxt, &p.From) & 1
o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), 0, 0, uint32(p.To.Reg)) | uint32(v)<<21
} else {
o1 |= (uint32(mask[0])&31)<<6 | (uint32(mask[1])&31)<<1
case 64: /* mtfsf fr[, $m] {,fpcsr} */
- if p.From3.Type_ != D_NONE {
+ if p.From3.Type != D_NONE {
v = regoff(ctxt, &p.From3) & 255
} else {
o1 = OP_MTFSFI | (uint32(p.To.Reg)&15)<<23 | (uint32(regoff(ctxt, &p.From))&31)<<12
case 66: /* mov spr,r1; mov r1,spr, also dcr */
- if p.From.Type_ == D_REG {
+ if p.From.Type == D_REG {
r = int(p.From.Reg)
v = int32(p.To.Offset)
- if p.To.Type_ == D_DCR {
+ if p.To.Type == D_DCR {
o1 = OPVCC(31, 451, 0, 0) /* mtdcr */
} else {
r = int(p.To.Reg)
v = int32(p.From.Offset)
- if p.From.Type_ == D_DCR {
+ if p.From.Type == D_DCR {
o1 = OPVCC(31, 323, 0, 0) /* mfdcr */
} else {
o1 = AOP_RRR(o1, uint32(r), 0, 0) | (uint32(v)&0x1f)<<16 | ((uint32(v)>>5)&0x1f)<<11
case 67: /* mcrf crfD,crfS */
- if p.From.Type_ != D_CREG || p.From.Reg == NREG || p.To.Type_ != D_CREG || p.To.Reg == NREG {
+ if p.From.Type != D_CREG || p.From.Reg == NREG || p.To.Type != D_CREG || p.To.Reg == NREG {
ctxt.Diag("illegal CR field number\n%v", p)
}
o1 = AOP_RRR(OP_MCRF, ((uint32(p.To.Reg) & 7) << 2), ((uint32(p.From.Reg) & 7) << 2), 0)
case 68: /* mfcr rD; mfocrf CRM,rD */
- if p.From.Type_ == D_CREG && p.From.Reg != NREG {
+ if p.From.Type == D_CREG && p.From.Reg != NREG {
v = 1 << uint(7-(p.To.Reg&7)) /* CR(n) */
o1 = AOP_RRR(OP_MFCR, uint32(p.To.Reg), 0, 0) | 1<<20 | uint32(v)<<12 /* new form, mfocrf */
}
case 69: /* mtcrf CRM,rS */
- if p.From3.Type_ != D_NONE {
+ if p.From3.Type != D_NONE {
if p.To.Reg != NREG {
ctxt.Diag("can't use both mask and CR(n)\n%v", p)
o1 = AOP_RRR(uint32(oprrr(ctxt, int(p.As))), uint32(p.From.Reg), 0, uint32(p.To.Reg))
case 73: /* mcrfs crfD,crfS */
- if p.From.Type_ != D_FPSCR || p.From.Reg == NREG || p.To.Type_ != D_CREG || p.To.Reg == NREG {
+ if p.From.Type != D_FPSCR || p.From.Reg == NREG || p.To.Type != D_CREG || p.To.Reg == NREG {
ctxt.Diag("illegal FPSCR/CR field number\n%v", p)
}
o1 = AOP_RRR(OP_MCRFS, ((uint32(p.To.Reg) & 7) << 2), ((uint32(p.From.Reg) & 7) << 2), 0)
case 77: /* syscall $scon, syscall Rx */
- if p.From.Type_ == D_CONST {
+ if p.From.Type == D_CONST {
if p.From.Offset > BIG || p.From.Offset < -BIG {
ctxt.Diag("illegal syscall, sysnum too large: %v", p)
}
o1 = AOP_IRR(OP_ADDI, REGZERO, REGZERO, uint32(p.From.Offset))
- } else if p.From.Type_ == D_REG {
+ } else if p.From.Type == D_REG {
o1 = LOP_RRR(OP_OR, REGZERO, uint32(p.From.Reg), uint32(p.From.Reg))
} else {
if p.Mark&NOSCHED != 0 {
str += fmt.Sprintf("*")
}
- if p.Reg == NREG && p.From3.Type_ == D_NONE {
+ if p.Reg == NREG && p.From3.Type == D_NONE {
str += fmt.Sprintf("%.5d (%v)\t%v\t%v,%v", p.Pc, p.Line(), Aconv(a), Dconv(p, 0, &p.From), Dconv(p, 0, &p.To))
- } else if a != ATEXT && p.From.Type_ == D_OREG {
+ } else if a != ATEXT && p.From.Type == D_OREG {
str += fmt.Sprintf("%.5d (%v)\t%v\t%d(R%d+R%d),%v", p.Pc, p.Line(), Aconv(a), p.From.Offset, p.From.Reg, p.Reg, Dconv(p, 0, &p.To))
- } else if p.To.Type_ == D_OREG {
+ } else if p.To.Type == D_OREG {
str += fmt.Sprintf("%.5d (%v)\t%v\t%v,%d(R%d+R%d)", p.Pc, p.Line(), Aconv(a), Dconv(p, 0, &p.From), p.To.Offset, p.To.Reg, p.Reg)
} else {
str += fmt.Sprintf("%.5d (%v)\t%v\t%v", p.Pc, p.Line(), Aconv(a), Dconv(p, 0, &p.From))
if p.Reg != NREG {
ch = 'R'
- if p.From.Type_ == D_FREG {
+ if p.From.Type == D_FREG {
ch = 'F'
}
str += fmt.Sprintf(",%c%d", ch, p.Reg)
}
- if p.From3.Type_ != D_NONE {
+ if p.From3.Type != D_NONE {
str += fmt.Sprintf(",%v", Dconv(p, 0, &p.From3))
}
str += fmt.Sprintf(",%v", Dconv(p, 0, &p.To))
s = "???"
if a >= AXXX && a < ALAST {
- s = anames9[a]
+ s = Anames[a]
}
fp += s
return fp
var v int32
if flag&fmtLong != 0 /*untyped*/ {
- if a.Type_ == D_CONST {
+ if a.Type == D_CONST {
str = fmt.Sprintf("$%d-%d", int32(a.Offset), int32(a.Offset>>32))
} else {
goto ret
}
- switch a.Type_ {
+ switch a.Type {
default:
- str = fmt.Sprintf("GOK-type(%d)", a.Type_)
+ str = fmt.Sprintf("GOK-type(%d)", a.Type)
case D_NONE:
str = ""
As: AGOK,
Reg: NREG,
From: obj.Addr{
- Name: D_NONE,
- Type_: D_NONE,
- Reg: NREG,
+ Name: D_NONE,
+ Type: D_NONE,
+ Reg: NREG,
},
From3: obj.Addr{
- Name: D_NONE,
- Type_: D_NONE,
- Reg: NREG,
+ Name: D_NONE,
+ Type: D_NONE,
+ Reg: NREG,
},
To: obj.Addr{
- Name: D_NONE,
- Type_: D_NONE,
- Reg: NREG,
+ Name: D_NONE,
+ Type: D_NONE,
+ Reg: NREG,
},
}
ADUFFZERO,
ADUFFCOPY:
if p.To.Sym != nil {
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
}
break
}
switch p.As {
case AFMOVS:
- if p.From.Type_ == D_FCONST {
+ if p.From.Type == D_FCONST {
var i32 uint32
var f32 float32
f32 = float32(p.From.U.Dval)
literal = fmt.Sprintf("$f32.%08x", i32)
s = obj.Linklookup(ctxt, literal, 0)
s.Size = 4
- p.From.Type_ = D_OREG
+ p.From.Type = D_OREG
p.From.Sym = s
p.From.Name = D_EXTERN
p.From.Offset = 0
}
case AFMOVD:
- if p.From.Type_ == D_FCONST {
+ if p.From.Type == D_FCONST {
var i64 uint64
i64 = math.Float64bits(p.From.U.Dval)
literal = fmt.Sprintf("$f64.%016x", i64)
s = obj.Linklookup(ctxt, literal, 0)
s.Size = 8
- p.From.Type_ = D_OREG
+ p.From.Type = D_OREG
p.From.Sym = s
p.From.Name = D_EXTERN
p.From.Offset = 0
// Put >32-bit constants in memory and load them
case AMOVD:
- if p.From.Type_ == D_CONST && p.From.Name == D_NONE && p.From.Reg == NREG && int64(int32(p.From.Offset)) != p.From.Offset {
+ if p.From.Type == D_CONST && p.From.Name == D_NONE && p.From.Reg == NREG && int64(int32(p.From.Offset)) != p.From.Offset {
literal = fmt.Sprintf("$i64.%016x", uint64(p.From.Offset))
s = obj.Linklookup(ctxt, literal, 0)
s.Size = 8
- p.From.Type_ = D_OREG
+ p.From.Type = D_OREG
p.From.Sym = s
p.From.Name = D_EXTERN
p.From.Offset = 0
switch p.As {
case ASUBC:
- if p.From.Type_ == D_CONST {
+ if p.From.Type == D_CONST {
p.From.Offset = -p.From.Offset
p.As = AADDC
}
case ASUBCCC:
- if p.From.Type_ == D_CONST {
+ if p.From.Type == D_CONST {
p.From.Offset = -p.From.Offset
p.As = AADDCCC
}
case ASUB:
- if p.From.Type_ == D_CONST {
+ if p.From.Type == D_CONST {
p.From.Offset = -p.From.Offset
p.As = AADD
}
case ANOR:
q = p
- if p.To.Type_ == D_REG {
+ if p.To.Type == D_REG {
if p.To.Reg == REGZERO {
p.Mark |= LABEL | SYNC
}
AMOVWZ,
AMOVD:
q = p
- switch p.From.Type_ {
+ switch p.From.Type {
case D_MSR,
D_SPR,
D_FPSCR,
p.Mark |= LABEL | SYNC
}
- switch p.To.Type_ {
+ switch p.To.Type {
case D_MSR,
D_SPR,
D_FPSCR,
q = obj.Appendp(ctxt, p)
q.As = AADD
q.Lineno = p.Lineno
- q.From.Type_ = D_CONST
+ q.From.Type = D_CONST
q.From.Offset = int64(-autosize)
- q.To.Type_ = D_REG
+ q.To.Type = D_REG
q.To.Reg = REGSP
q.Spadj = +autosize
}
q = obj.Appendp(ctxt, q)
q.As = AMOVD
q.Lineno = p.Lineno
- q.From.Type_ = D_SPR
+ q.From.Type = D_SPR
q.From.Offset = D_LR
- q.To.Type_ = D_REG
+ q.To.Type = D_REG
q.To.Reg = REGTMP
q = obj.Appendp(ctxt, q)
q.As = int16(mov)
q.Lineno = p.Lineno
- q.From.Type_ = D_REG
+ q.From.Type = D_REG
q.From.Reg = REGTMP
- q.To.Type_ = D_OREG
+ q.To.Type = D_OREG
q.To.Offset = int64(aoffset)
q.To.Reg = REGSP
if q.As == AMOVDU {
q = obj.Appendp(ctxt, q)
q.As = AMOVD
- q.From.Type_ = D_OREG
+ q.From.Type = D_OREG
q.From.Reg = REGG
q.From.Offset = 4 * int64(ctxt.Arch.Ptrsize) // G.panic
- q.To.Type_ = D_REG
+ q.To.Type = D_REG
q.To.Reg = 3
q = obj.Appendp(ctxt, q)
q.As = ACMP
- q.From.Type_ = D_REG
+ q.From.Type = D_REG
q.From.Reg = 0
- q.To.Type_ = D_REG
+ q.To.Type = D_REG
q.To.Reg = 3
q = obj.Appendp(ctxt, q)
q.As = ABEQ
- q.To.Type_ = D_BRANCH
+ q.To.Type = D_BRANCH
p1 = q
q = obj.Appendp(ctxt, q)
q.As = AMOVD
- q.From.Type_ = D_OREG
+ q.From.Type = D_OREG
q.From.Reg = 3
q.From.Offset = 0 // Panic.argp
- q.To.Type_ = D_REG
+ q.To.Type = D_REG
q.To.Reg = 4
q = obj.Appendp(ctxt, q)
q.As = AADD
- q.From.Type_ = D_CONST
+ q.From.Type = D_CONST
q.From.Offset = int64(autosize) + 8
q.Reg = REGSP
- q.To.Type_ = D_REG
+ q.To.Type = D_REG
q.To.Reg = 5
q = obj.Appendp(ctxt, q)
q.As = ACMP
- q.From.Type_ = D_REG
+ q.From.Type = D_REG
q.From.Reg = 4
- q.To.Type_ = D_REG
+ q.To.Type = D_REG
q.To.Reg = 5
q = obj.Appendp(ctxt, q)
q.As = ABNE
- q.To.Type_ = D_BRANCH
+ q.To.Type = D_BRANCH
p2 = q
q = obj.Appendp(ctxt, q)
q.As = AADD
- q.From.Type_ = D_CONST
+ q.From.Type = D_CONST
q.From.Offset = 8
q.Reg = REGSP
- q.To.Type_ = D_REG
+ q.To.Type = D_REG
q.To.Reg = 6
q = obj.Appendp(ctxt, q)
q.As = AMOVD
- q.From.Type_ = D_REG
+ q.From.Type = D_REG
q.From.Reg = 6
- q.To.Type_ = D_OREG
+ q.To.Type = D_OREG
q.To.Reg = 3
q.To.Offset = 0 // Panic.argp
}
case ARETURN:
- if p.From.Type_ == D_CONST {
+ if p.From.Type == D_CONST {
ctxt.Diag("using BECOME (%v) is not supported!", p)
break
}
if p.To.Sym != nil { // retjmp
p.As = ABR
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
break
}
if !(autosize != 0) {
p.As = ABR
p.From = zprg.From
- p.To.Type_ = D_SPR
+ p.To.Type = D_SPR
p.To.Offset = D_LR
p.Mark |= BRANCH
break
}
p.As = AADD
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = int64(autosize)
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = REGSP
p.Spadj = -autosize
q = ctxt.Arch.Prg()
q.As = ABR
q.Lineno = p.Lineno
- q.To.Type_ = D_SPR
+ q.To.Type = D_SPR
q.To.Offset = D_LR
q.Mark |= BRANCH
q.Spadj = +autosize
}
p.As = AMOVD
- p.From.Type_ = D_OREG
+ p.From.Type = D_OREG
p.From.Offset = 0
p.From.Reg = REGSP
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = REGTMP
q = ctxt.Arch.Prg()
q.As = AMOVD
q.Lineno = p.Lineno
- q.From.Type_ = D_REG
+ q.From.Type = D_REG
q.From.Reg = REGTMP
- q.To.Type_ = D_SPR
+ q.To.Type = D_SPR
q.To.Offset = D_LR
q.Link = p.Link
q.As = AMOVD
q.Lineno = p.Lineno
- q.From.Type_ = D_OREG
+ q.From.Type = D_OREG
q.From.Offset = 0
q.From.Reg = REGTMP
- q.To.Type_ = D_REG
+ q.To.Type = D_REG
q.To.Reg = REGTMP
q.Link = p.Link
q = ctxt.Arch.Prg()
q.As = AADD
q.Lineno = p.Lineno
- q.From.Type_ = D_CONST
+ q.From.Type = D_CONST
q.From.Offset = int64(autosize)
- q.To.Type_ = D_REG
+ q.To.Type = D_REG
q.To.Reg = REGSP
q.Spadj = -autosize
q1 = ctxt.Arch.Prg()
q1.As = ABR
q1.Lineno = p.Lineno
- q1.To.Type_ = D_SPR
+ q1.To.Type = D_SPR
q1.To.Offset = D_LR
q1.Mark |= BRANCH
q1.Spadj = +autosize
q.Link = q1
case AADD:
- if p.To.Type_ == D_REG && p.To.Reg == REGSP && p.From.Type_ == D_CONST {
+ if p.To.Type == D_REG && p.To.Reg == REGSP && p.From.Type == D_CONST {
p.Spadj = int32(-p.From.Offset)
}
break
p = obj.Appendp(ctxt, p)
p.As = AMOVD
- p.From.Type_ = D_OREG
+ p.From.Type = D_OREG
p.From.Reg = REGG
p.From.Offset = 2 * int64(ctxt.Arch.Ptrsize) // G.stackguard0
if ctxt.Cursym.Cfunc != 0 {
p.From.Offset = 3 * int64(ctxt.Arch.Ptrsize) // G.stackguard1
}
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 3
q = nil
p = obj.Appendp(ctxt, p)
p.As = ACMPU
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = 3
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = REGSP
} else if framesize <= obj.StackBig {
// large stack: SP-framesize < stackguard-StackSmall
p = obj.Appendp(ctxt, p)
p.As = AADD
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = int64(-framesize)
p.Reg = REGSP
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 4
p = obj.Appendp(ctxt, p)
p.As = ACMPU
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = 3
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 4
} else {
p = obj.Appendp(ctxt, p)
p.As = ACMP
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = 3
- p.To.Type_ = D_CONST
+ p.To.Type = D_CONST
p.To.Offset = obj.StackPreempt
p = obj.Appendp(ctxt, p)
q = p
p.As = ABEQ
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p = obj.Appendp(ctxt, p)
p.As = AADD
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = obj.StackGuard
p.Reg = REGSP
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 4
p = obj.Appendp(ctxt, p)
p.As = ASUB
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = 3
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 4
p = obj.Appendp(ctxt, p)
p.As = AMOVD
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = int64(framesize) + obj.StackGuard - obj.StackSmall
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = REGTMP
p = obj.Appendp(ctxt, p)
p.As = ACMPU
- p.From.Type_ = D_REG
+ p.From.Type = D_REG
p.From.Reg = REGTMP
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 4
}
q1 = p
p.As = ABLT
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
// MOVD LR, R5
p = obj.Appendp(ctxt, p)
p.As = AMOVD
- p.From.Type_ = D_SPR
+ p.From.Type = D_SPR
p.From.Offset = D_LR
- p.To.Type_ = D_REG
+ p.To.Type = D_REG
p.To.Reg = 5
if q != nil {
q.Pcond = p
p = obj.Appendp(ctxt, p)
p.As = ABL
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
if ctxt.Cursym.Cfunc != 0 {
p.To.Sym = obj.Linklookup(ctxt, "runtime.morestackc", 0)
} else {
p = obj.Appendp(ctxt, p)
p.As = ABR
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p.Pcond = ctxt.Cursym.Text.Link
// placeholder for q1's jump target
q = ctxt.Arch.Prg()
q.As = int16(a)
q.Lineno = p.Lineno
- q.To.Type_ = D_BRANCH
+ q.To.Type = D_BRANCH
q.To.Offset = p.Pc
q.Pcond = p
p = q
s.Plt = -1
s.Got = -1
s.Name = symb
- s.Type_ = 0
+ s.Type = 0
s.Version = int16(v)
s.Value = 0
s.Sig = 0
/*
* this is the ranlib header
*/
-var anames6 = []string{
+var Anames = []string{
"XXX",
"AAA",
"AAD",
for p = ctxt.Cursym.Text; p != nil; p = p.Link {
n = 0
- if p.To.Type_ == D_BRANCH {
+ if p.To.Type == D_BRANCH {
if p.Pcond == nil {
p.Pcond = p
}
}
p.Back = uint8(n)
if p.As == AADJSP {
- p.To.Type_ = D_SP
+ p.To.Type = D_SP
v = int32(-p.From.Offset)
p.From.Offset = int64(v)
p.As = int16(spadjop(ctxt, p, AADDL, AADDQ))
}
if p.As == AADJSP {
- p.To.Type_ = D_SP
+ p.To.Type = D_SP
v = int32(-p.From.Offset)
p.From.Offset = int64(v)
p.As = int16(spadjop(ctxt, p, AADDL, AADDQ))
}
func prefixof(ctxt *obj.Link, a *obj.Addr) int {
- switch a.Type_ {
+ switch a.Type {
case D_INDIR + D_CS:
return 0x2e
var v int64
var l int32
- if a.Type_ >= D_INDIR || a.Index != D_NONE {
+ if a.Type >= D_INDIR || a.Index != D_NONE {
if a.Index != D_NONE && a.Scale == 0 {
- if a.Type_ == D_ADDR {
+ if a.Type == D_ADDR {
switch a.Index {
case D_EXTERN,
D_STATIC:
return Ym
}
- switch a.Type_ {
+ switch a.Type {
case D_AL:
return Yal
*r = obj.Reloc{}
}
- t = int(a.Type_)
+ t = int(a.Type)
v = a.Offset
if t == D_ADDR {
t = int(a.Index)
if isextern(s) != 0 {
r.Siz = 4
- r.Type_ = obj.R_ADDR
+ r.Type = obj.R_ADDR
} else {
r.Siz = 4
- r.Type_ = obj.R_PCREL
+ r.Type = obj.R_PCREL
}
r.Off = -1 // caller must fill in
r.Sym = s
r.Add = v
v = 0
- if s.Type_ == obj.STLSBSS {
+ if s.Type == obj.STLSBSS {
r.Xadd = r.Add - int64(r.Siz)
- r.Type_ = obj.R_TLS
+ r.Type = obj.R_TLS
r.Xsym = s
}
log.Fatalf("reloc")
}
- r.Type_ = obj.R_TLS_LE
+ r.Type = obj.R_TLS_LE
r.Siz = 4
r.Off = -1 // caller must fill in
r.Add = v
rex &= 0x40 | Rxr
v = int32(a.Offset)
- t = int(a.Type_)
+ t = int(a.Type)
rel.Siz = 0
if a.Index != D_NONE && a.Index != D_TLS {
if t < D_INDIR {
scale = int(a.Scale)
if t < D_INDIR {
- switch a.Type_ {
+ switch a.Type {
default:
goto bad
ctxt.Rexflag |= regrex[t]&Rxb | rex
if t == D_NONE || (D_CS <= t && t <= D_GS) || t == D_TLS {
- if (a.Sym == nil || !(isextern(a.Sym) != 0)) && t == D_NONE && (a.Type_ == D_STATIC || a.Type_ == D_EXTERN) || ctxt.Asmode != 64 {
+ if (a.Sym == nil || !(isextern(a.Sym) != 0)) && t == D_NONE && (a.Type == D_STATIC || a.Type == D_EXTERN) || ctxt.Asmode != 64 {
ctxt.Andptr[0] = byte(0<<6 | 5<<0 | r<<3)
ctxt.Andptr = ctxt.Andptr[1:]
goto putrelv
if t >= D_AX && t <= D_R15 {
if a.Index == D_TLS {
rel = obj.Reloc{}
- rel.Type_ = obj.R_TLS_IE
+ rel.Type = obj.R_TLS_IE
rel.Siz = 4
rel.Sym = nil
rel.Add = int64(v)
}
func asmand(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, ra *obj.Addr) {
- asmandsz(ctxt, p, a, reg[ra.Type_], regrex[ra.Type_], 0)
+ asmandsz(ctxt, p, a, reg[ra.Type], regrex[ra.Type], 0)
}
func asmando(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, o int) {
}
func bytereg(a *obj.Addr, t *uint8) {
- if a.Index == D_NONE && (a.Type_ >= D_AX && a.Type_ <= D_R15) {
- a.Type_ = D_AL + (a.Type_ - D_AX)
+ if a.Index == D_NONE && (a.Type >= D_AX && a.Type <= D_R15) {
+ a.Type = D_AL + (a.Type - D_AX)
*t = 0
}
}
}
func isax(a *obj.Addr) int {
- switch a.Type_ {
+ switch a.Type {
case D_AX,
D_AL,
D_AH,
fmt.Printf("\n%v\ts/%v/%v/\n", p, Rconv(from), Rconv(to))
}
- if int(p.From.Type_) == from {
- p.From.Type_ = int16(to)
+ if int(p.From.Type) == from {
+ p.From.Type = int16(to)
}
- if int(p.To.Type_) == from {
- p.To.Type_ = int16(to)
+ if int(p.To.Type) == from {
+ p.To.Type = int16(to)
}
if int(p.From.Index) == from {
}
from += D_INDIR
- if int(p.From.Type_) == from {
- p.From.Type_ = int16(to + D_INDIR)
+ if int(p.From.Type) == from {
+ p.From.Type = int16(to + D_INDIR)
}
- if int(p.To.Type_) == from {
- p.To.Type_ = int16(to + D_INDIR)
+ if int(p.To.Type) == from {
+ p.To.Type = int16(to + D_INDIR)
}
if false { /*debug['Q']*/
case Zaut_r:
ctxt.Andptr[0] = 0x8d
ctxt.Andptr = ctxt.Andptr[1:] /* leal */
- if p.From.Type_ != D_ADDR {
+ if p.From.Type != D_ADDR {
ctxt.Diag("asmins: Zaut sb type ADDR")
}
- p.From.Type_ = int16(p.From.Index)
+ p.From.Type = int16(p.From.Index)
p.From.Index = D_NONE
asmand(ctxt, p, &p.From, &p.To)
- p.From.Index = uint8(p.From.Type_)
- p.From.Type_ = D_ADDR
+ p.From.Index = uint8(p.From.Type)
+ p.From.Type = D_ADDR
case Zm_o:
ctxt.Andptr[0] = byte(op)
case Zcallindreg:
r = obj.Addrel(ctxt.Cursym)
r.Off = int32(p.Pc)
- r.Type_ = obj.R_CALLIND
+ r.Type = obj.R_CALLIND
r.Siz = 0
fallthrough
ctxt.Andptr = ctxt.Andptr[1:]
case Zib_rp:
- ctxt.Rexflag |= regrex[p.To.Type_] & (Rxb | 0x40)
- ctxt.Andptr[0] = byte(op + reg[p.To.Type_])
+ ctxt.Rexflag |= regrex[p.To.Type] & (Rxb | 0x40)
+ ctxt.Andptr[0] = byte(op + reg[p.To.Type])
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = byte(vaddr(ctxt, p, &p.From, nil))
ctxt.Andptr = ctxt.Andptr[1:]
case Zil_rp:
- ctxt.Rexflag |= regrex[p.To.Type_] & Rxb
- ctxt.Andptr[0] = byte(op + reg[p.To.Type_])
+ ctxt.Rexflag |= regrex[p.To.Type] & Rxb
+ ctxt.Andptr[0] = byte(op + reg[p.To.Type])
ctxt.Andptr = ctxt.Andptr[1:]
if o.prefix == Pe {
v = vaddr(ctxt, p, &p.From, nil)
case Zo_iw:
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
- if p.From.Type_ != D_NONE {
+ if p.From.Type != D_NONE {
v = vaddr(ctxt, p, &p.From, nil)
ctxt.Andptr[0] = byte(v)
ctxt.Andptr = ctxt.Andptr[1:]
//print("zero: %llux %P\n", v, p);
ctxt.Rexflag &^= (0x40 | Rxw)
- ctxt.Rexflag |= regrex[p.To.Type_] & Rxb
- ctxt.Andptr[0] = byte(0xb8 + reg[p.To.Type_])
+ ctxt.Rexflag |= regrex[p.To.Type] & Rxb
+ ctxt.Andptr[0] = byte(0xb8 + reg[p.To.Type])
ctxt.Andptr = ctxt.Andptr[1:]
- if rel.Type_ != 0 {
+ if rel.Type != 0 {
r = obj.Addrel(ctxt.Cursym)
*r = rel
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
} else {
//print("all: %llux %P\n", v, p);
- ctxt.Rexflag |= regrex[p.To.Type_] & Rxb
+ ctxt.Rexflag |= regrex[p.To.Type] & Rxb
- ctxt.Andptr[0] = byte(op + reg[p.To.Type_])
+ ctxt.Andptr[0] = byte(op + reg[p.To.Type])
ctxt.Andptr = ctxt.Andptr[1:]
- if rel.Type_ != 0 {
+ if rel.Type != 0 {
r = obj.Addrel(ctxt.Cursym)
*r = rel
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
}
case Z_rp:
- ctxt.Rexflag |= regrex[p.To.Type_] & (Rxb | 0x40)
- ctxt.Andptr[0] = byte(op + reg[p.To.Type_])
+ ctxt.Rexflag |= regrex[p.To.Type] & (Rxb | 0x40)
+ ctxt.Andptr[0] = byte(op + reg[p.To.Type])
ctxt.Andptr = ctxt.Andptr[1:]
case Zrp_:
- ctxt.Rexflag |= regrex[p.From.Type_] & (Rxb | 0x40)
- ctxt.Andptr[0] = byte(op + reg[p.From.Type_])
+ ctxt.Rexflag |= regrex[p.From.Type] & (Rxb | 0x40)
+ ctxt.Andptr[0] = byte(op + reg[p.From.Type])
ctxt.Andptr = ctxt.Andptr[1:]
case Zclr:
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
r.Sym = p.To.Sym
r.Add = p.To.Offset
- r.Type_ = obj.R_CALL
+ r.Type = obj.R_CALL
r.Siz = 4
put4(ctxt, 0)
r = obj.Addrel(ctxt.Cursym)
r.Off = int32(p.Pc + int64(-cap(ctxt.Andptr)+cap(ctxt.And[:])))
r.Sym = p.To.Sym
- r.Type_ = obj.R_PCREL
+ r.Type = obj.R_PCREL
r.Siz = 4
put4(ctxt, 0)
break
*/
pp = *p
- z = int(p.From.Type_)
+ z = int(p.From.Type)
if z >= D_BP && z <= D_DI {
- if isax(&p.To) != 0 || p.To.Type_ == D_NONE {
+ if isax(&p.To) != 0 || p.To.Type == D_NONE {
// We certainly don't want to exchange
// with AX if the op is MUL or DIV.
ctxt.Andptr[0] = 0x87
return
}
- z = int(p.To.Type_)
+ z = int(p.To.Type)
if z >= D_BP && z <= D_DI {
if isax(&p.From) != 0 {
ctxt.Andptr[0] = 0x87
}
}
- ctxt.Diag("doasm: notfound from=%x to=%x %v", uint16(p.From.Type_), uint16(p.To.Type_), p)
+ ctxt.Diag("doasm: notfound from=%x to=%x %v", uint16(p.From.Type), uint16(p.To.Type), p)
return
mfound:
ctxt.Andptr[0] = t[1]
ctxt.Andptr = ctxt.Andptr[1:]
asmando(ctxt, p, &p.To, int(t[2]))
- ctxt.Rexflag |= regrex[p.From.Type_] & (Rxr | 0x40)
+ ctxt.Rexflag |= regrex[p.From.Type] & (Rxr | 0x40)
case 4: /* m,r - 2op */
ctxt.Andptr[0] = t[0]
ctxt.Andptr[0] = t[1]
ctxt.Andptr = ctxt.Andptr[1:]
asmando(ctxt, p, &p.From, int(t[2]))
- ctxt.Rexflag |= regrex[p.To.Type_] & (Rxr | 0x40)
+ ctxt.Rexflag |= regrex[p.To.Type] & (Rxr | 0x40)
case 5: /* load full pointer, trash heap */
if t[0] != 0 {
t = t[1:]
}
- z = int(p.From.Type_)
+ z = int(p.From.Type)
switch z {
default:
goto bad
ctxt.Plan9privates = obj.Linklookup(ctxt, "_privates", 0)
}
pp.From = obj.Addr{}
- pp.From.Type_ = D_EXTERN
+ pp.From.Type = D_EXTERN
pp.From.Sym = ctxt.Plan9privates
pp.From.Offset = 0
pp.From.Index = D_NONE
case obj.Hsolaris: // TODO(rsc): Delete Hsolaris from list. Should not use this code. See progedit in obj6.c.
pp.From = p.From
- pp.From.Type_ = D_INDIR + D_NONE
+ pp.From.Type = D_INDIR + D_NONE
pp.From.Offset = 0
pp.From.Index = D_NONE
pp.From.Scale = 0
case obj.Hwindows:
pp.From = p.From
- pp.From.Type_ = D_INDIR + D_GS
+ pp.From.Type = D_INDIR + D_GS
pp.From.Offset = 0x28
pp.From.Index = D_NONE
pp.From.Scale = 0
r.Off = 0
r.Siz = 0
r.Sym = p.From.Sym
- r.Type_ = obj.R_USEFIELD
+ r.Type = obj.R_USEFIELD
return
}
case ACALL,
AJMP:
- if D_AX <= p.To.Type_ && p.To.Type_ <= D_DI {
+ if D_AX <= p.To.Type && p.To.Type <= D_DI {
// ANDL $~31, reg
ctxt.Andptr[0] = 0x83
ctxt.Andptr = ctxt.Andptr[1:]
- ctxt.Andptr[0] = byte(0xe0 | (p.To.Type_ - D_AX))
+ ctxt.Andptr[0] = byte(0xe0 | (p.To.Type - D_AX))
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0xe0
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0x01
ctxt.Andptr = ctxt.Andptr[1:]
- ctxt.Andptr[0] = byte(0xf8 | (p.To.Type_ - D_AX))
+ ctxt.Andptr[0] = byte(0xf8 | (p.To.Type - D_AX))
ctxt.Andptr = ctxt.Andptr[1:]
}
- if D_R8 <= p.To.Type_ && p.To.Type_ <= D_R15 {
+ if D_R8 <= p.To.Type && p.To.Type <= D_R15 {
// ANDL $~31, reg
ctxt.Andptr[0] = 0x41
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0x83
ctxt.Andptr = ctxt.Andptr[1:]
- ctxt.Andptr[0] = byte(0xe0 | (p.To.Type_ - D_R8))
+ ctxt.Andptr[0] = byte(0xe0 | (p.To.Type - D_R8))
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0xe0
ctxt.Andptr = ctxt.Andptr[1:]
ctxt.Andptr[0] = 0x01
ctxt.Andptr = ctxt.Andptr[1:]
- ctxt.Andptr[0] = byte(0xf8 | (p.To.Type_ - D_R8))
+ ctxt.Andptr[0] = byte(0xf8 | (p.To.Type - D_R8))
ctxt.Andptr = ctxt.Andptr[1:]
}
if ctxt.Rexflag != 0 {
r.Off++
}
- if r.Type_ == obj.R_PCREL || r.Type_ == obj.R_CALL {
+ if r.Type == obj.R_PCREL || r.Type == obj.R_CALL {
r.Add -= p.Pc + int64(n) - (int64(r.Off) + int64(r.Siz))
}
}
if ctxt.Headtype == obj.Hnacl && p.As != ACMPL && p.As != ACMPQ {
- switch p.To.Type_ {
+ switch p.To.Type {
case D_SP:
copy(ctxt.Andptr, naclspfix)
ctxt.Andptr = ctxt.Andptr[len(naclspfix):]
func Aconv(i int) string {
var fp string
- fp += anames6[i]
+ fp += Anames[i]
return fp
}
var i int
- i = int(a.Type_)
+ i = int(a.Type)
if flag&fmtLong != 0 /*untyped*/ {
if i == D_CONST {
str = fmt.Sprintf("$\"%q\"", a.U.Sval)
case D_ADDR:
- a.Type_ = int16(a.Index)
+ a.Type = int16(a.Index)
a.Index = D_NONE
str = fmt.Sprintf("$%v", Dconv(p, 0, a))
- a.Index = uint8(a.Type_)
- a.Type_ = D_ADDR
+ a.Index = uint8(a.Type)
+ a.Type = D_ADDR
goto conv
}
return fp
}
-var regstr = []string{
+var Register = []string{
"AL", /* [D_AL] */
"CL",
"DL",
var fp string
if r >= D_AL && r <= D_NONE {
- str = fmt.Sprintf("%s", regstr[r-D_AL])
+ str = fmt.Sprintf("%s", Register[r-D_AL])
} else {
str = fmt.Sprintf("gok(%d)", r)
Back: 2,
As: AGOK,
From: obj.Addr{
- Type_: D_NONE,
+ Type: D_NONE,
Index: D_NONE,
},
To: obj.Addr{
- Type_: D_NONE,
+ Type: D_NONE,
Index: D_NONE,
},
}
func nopout(p *obj.Prog) {
p.As = ANOP
- p.From.Type_ = D_NONE
- p.To.Type_ = D_NONE
+ p.From.Type = D_NONE
+ p.To.Type = D_NONE
}
func symtype(a *obj.Addr) int {
var t int
- t = int(a.Type_)
+ t = int(a.Type)
if t == D_ADDR {
t = int(a.Index)
}
// TODO(rsc): Remove the Hsolaris special case. It exists only to
// guarantee we are producing byte-identical binaries as before this code.
// But it should be unnecessary.
- if (p.As == AMOVQ || p.As == AMOVL) && p.From.Type_ == D_TLS && D_AX <= p.To.Type_ && p.To.Type_ <= D_R15 && ctxt.Headtype != obj.Hsolaris {
+ if (p.As == AMOVQ || p.As == AMOVL) && p.From.Type == D_TLS && D_AX <= p.To.Type && p.To.Type <= D_R15 && ctxt.Headtype != obj.Hsolaris {
nopout(p)
}
- if p.From.Index == D_TLS && D_INDIR+D_AX <= p.From.Type_ && p.From.Type_ <= D_INDIR+D_R15 {
- p.From.Type_ = D_INDIR + D_TLS
+ if p.From.Index == D_TLS && D_INDIR+D_AX <= p.From.Type && p.From.Type <= D_INDIR+D_R15 {
+ p.From.Type = D_INDIR + D_TLS
p.From.Scale = 0
p.From.Index = D_NONE
}
- if p.To.Index == D_TLS && D_INDIR+D_AX <= p.To.Type_ && p.To.Type_ <= D_INDIR+D_R15 {
- p.To.Type_ = D_INDIR + D_TLS
+ if p.To.Index == D_TLS && D_INDIR+D_AX <= p.To.Type && p.To.Type <= D_INDIR+D_R15 {
+ p.To.Type = D_INDIR + D_TLS
p.To.Scale = 0
p.To.Index = D_NONE
}
// MOVQ TLS, BX
// MOVQ off(BX)(TLS*1), BX
// This allows the C compilers to emit references to m and g using the direct off(TLS) form.
- if (p.As == AMOVQ || p.As == AMOVL) && p.From.Type_ == D_INDIR+D_TLS && D_AX <= p.To.Type_ && p.To.Type_ <= D_R15 {
+ if (p.As == AMOVQ || p.As == AMOVL) && p.From.Type == D_INDIR+D_TLS && D_AX <= p.To.Type && p.To.Type <= D_R15 {
q = obj.Appendp(ctxt, p)
q.As = p.As
q.From = p.From
- q.From.Type_ = D_INDIR + p.To.Type_
+ q.From.Type = D_INDIR + p.To.Type
q.From.Index = D_TLS
q.From.Scale = 2 // TODO: use 1
q.To = p.To
- p.From.Type_ = D_TLS
+ p.From.Type = D_TLS
p.From.Index = D_NONE
p.From.Offset = 0
}
switch p.As {
case AMODE:
- if p.From.Type_ == D_CONST || p.From.Type_ == D_INDIR+D_NONE {
+ if p.From.Type == D_CONST || p.From.Type == D_INDIR+D_NONE {
switch int(p.From.Offset) {
case 16,
32,
case ACALL,
AJMP,
ARET:
- if (p.To.Type_ == D_EXTERN || p.To.Type_ == D_STATIC) && p.To.Sym != nil {
- p.To.Type_ = D_BRANCH
+ if (p.To.Type == D_EXTERN || p.To.Type == D_STATIC) && p.To.Sym != nil {
+ p.To.Type = D_BRANCH
}
break
}
// Convert AMOVSS $(0), Xx to AXORPS Xx, Xx
case AMOVSS:
- if p.From.Type_ == D_FCONST {
+ if p.From.Type == D_FCONST {
if p.From.U.Dval == 0 {
- if p.To.Type_ >= D_X0 {
- if p.To.Type_ <= D_X15 {
+ if p.To.Type >= D_X0 {
+ if p.To.Type <= D_X15 {
p.As = AXORPS
- p.From.Type_ = p.To.Type_
+ p.From.Type = p.To.Type
p.From.Index = p.To.Index
break
}
ADIVSS,
ACOMISS,
AUCOMISS:
- if p.From.Type_ == D_FCONST {
+ if p.From.Type == D_FCONST {
var i32 uint32
var f32 float32
i32 = math.Float32bits(f32)
literal = fmt.Sprintf("$f32.%08x", i32)
s = obj.Linklookup(ctxt, literal, 0)
- if s.Type_ == 0 {
- s.Type_ = obj.SRODATA
+ if s.Type == 0 {
+ s.Type = obj.SRODATA
obj.Adduint32(ctxt, s, i32)
s.Reachable = 0
}
- p.From.Type_ = D_EXTERN
+ p.From.Type = D_EXTERN
p.From.Sym = s
p.From.Offset = 0
}
// Convert AMOVSD $(0), Xx to AXORPS Xx, Xx
case AMOVSD:
- if p.From.Type_ == D_FCONST {
+ if p.From.Type == D_FCONST {
if p.From.U.Dval == 0 {
- if p.To.Type_ >= D_X0 {
- if p.To.Type_ <= D_X15 {
+ if p.To.Type >= D_X0 {
+ if p.To.Type <= D_X15 {
p.As = AXORPS
- p.From.Type_ = p.To.Type_
+ p.From.Type = p.To.Type
p.From.Index = p.To.Index
break
}
ADIVSD,
ACOMISD,
AUCOMISD:
- if p.From.Type_ == D_FCONST {
+ if p.From.Type == D_FCONST {
var i64 uint64
i64 = math.Float64bits(p.From.U.Dval)
literal = fmt.Sprintf("$f64.%016x", i64)
s = obj.Linklookup(ctxt, literal, 0)
- if s.Type_ == 0 {
- s.Type_ = obj.SRODATA
+ if s.Type == 0 {
+ s.Type = obj.SRODATA
obj.Adduint64(ctxt, s, i64)
s.Reachable = 0
}
- p.From.Type_ = D_EXTERN
+ p.From.Type = D_EXTERN
p.From.Sym = s
p.From.Offset = 0
}
return
}
- if a.Type_ == D_BP || a.Type_ == D_INDIR+D_BP {
+ if a.Type == D_BP || a.Type == D_INDIR+D_BP {
ctxt.Diag("invalid address: %v", p)
return
}
- if a.Type_ == D_INDIR+D_TLS {
- a.Type_ = D_INDIR + D_BP
- } else if a.Type_ == D_TLS {
- a.Type_ = D_BP
+ if a.Type == D_INDIR+D_TLS {
+ a.Type = D_INDIR + D_BP
+ } else if a.Type == D_TLS {
+ a.Type = D_BP
}
- if D_INDIR <= a.Type_ && a.Type_ <= D_INDIR+D_INDIR {
- switch a.Type_ {
+ if D_INDIR <= a.Type && a.Type <= D_INDIR+D_INDIR {
+ switch a.Type {
// all ok
case D_INDIR + D_BP,
D_INDIR + D_SP,
if a.Index != D_NONE {
ctxt.Diag("invalid address %v", p)
}
- a.Index = uint8(a.Type_ - D_INDIR)
+ a.Index = uint8(a.Type - D_INDIR)
if a.Index != D_NONE {
a.Scale = 1
}
- a.Type_ = D_INDIR + D_R15
+ a.Type = D_INDIR + D_R15
break
}
}
}
p = obj.Appendp(ctxt, p)
p.As = AADJSP
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = int64(autoffset)
p.Spadj = autoffset
} else {
p = obj.Appendp(ctxt, p)
p.As = AMOVQ
- p.From.Type_ = D_INDIR + D_CX
+ p.From.Type = D_INDIR + D_CX
p.From.Offset = 4 * int64(ctxt.Arch.Ptrsize) // G.panic
- p.To.Type_ = D_BX
+ p.To.Type = D_BX
if ctxt.Headtype == obj.Hnacl {
p.As = AMOVL
- p.From.Type_ = D_INDIR + D_R15
+ p.From.Type = D_INDIR + D_R15
p.From.Scale = 1
p.From.Index = D_CX
}
p = obj.Appendp(ctxt, p)
p.As = ATESTQ
- p.From.Type_ = D_BX
- p.To.Type_ = D_BX
+ p.From.Type = D_BX
+ p.To.Type = D_BX
if ctxt.Headtype == obj.Hnacl {
p.As = ATESTL
}
p = obj.Appendp(ctxt, p)
p.As = AJEQ
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p1 = p
p = obj.Appendp(ctxt, p)
p.As = ALEAQ
- p.From.Type_ = D_INDIR + D_SP
+ p.From.Type = D_INDIR + D_SP
p.From.Offset = int64(autoffset) + 8
- p.To.Type_ = D_DI
+ p.To.Type = D_DI
if ctxt.Headtype == obj.Hnacl {
p.As = ALEAL
}
p = obj.Appendp(ctxt, p)
p.As = ACMPQ
- p.From.Type_ = D_INDIR + D_BX
+ p.From.Type = D_INDIR + D_BX
p.From.Offset = 0 // Panic.argp
- p.To.Type_ = D_DI
+ p.To.Type = D_DI
if ctxt.Headtype == obj.Hnacl {
p.As = ACMPL
- p.From.Type_ = D_INDIR + D_R15
+ p.From.Type = D_INDIR + D_R15
p.From.Scale = 1
p.From.Index = D_BX
}
p = obj.Appendp(ctxt, p)
p.As = AJNE
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p2 = p
p = obj.Appendp(ctxt, p)
p.As = AMOVQ
- p.From.Type_ = D_SP
- p.To.Type_ = D_INDIR + D_BX
+ p.From.Type = D_SP
+ p.To.Type = D_INDIR + D_BX
p.To.Offset = 0 // Panic.argp
if ctxt.Headtype == obj.Hnacl {
p.As = AMOVL
- p.To.Type_ = D_INDIR + D_R15
+ p.To.Type = D_INDIR + D_R15
p.To.Scale = 1
p.To.Index = D_BX
}
p = obj.Appendp(ctxt, p)
p.As = AMOVQ
- p.From.Type_ = D_SP
- p.To.Type_ = D_DI
+ p.From.Type = D_SP
+ p.To.Type = D_DI
p = obj.Appendp(ctxt, p)
p.As = AMOVQ
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = int64(autoffset) / 8
- p.To.Type_ = D_CX
+ p.To.Type = D_CX
p = obj.Appendp(ctxt, p)
p.As = AMOVQ
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = 0
- p.To.Type_ = D_AX
+ p.To.Type = D_AX
p = obj.Appendp(ctxt, p)
p.As = AREP
for ; p != nil; p = p.Link {
pcsize = int(p.Mode) / 8
- a = int(p.From.Type_)
+ a = int(p.From.Type)
if a == D_AUTO {
p.From.Offset += int64(deltasp)
}
if a == D_PARAM {
p.From.Offset += int64(deltasp) + int64(pcsize)
}
- a = int(p.To.Type_)
+ a = int(p.To.Type)
if a == D_AUTO {
p.To.Offset += int64(deltasp)
}
if autoffset != 0 {
p.As = AADJSP
- p.From.Type_ = D_CONST
+ p.From.Type = D_CONST
p.From.Offset = int64(-autoffset)
p.Spadj = -autoffset
p = obj.Appendp(ctxt, p)
func indir_cx(ctxt *obj.Link, a *obj.Addr) {
if ctxt.Headtype == obj.Hnacl {
- a.Type_ = D_INDIR + D_R15
+ a.Type = D_INDIR + D_R15
a.Index = D_CX
a.Scale = 1
return
}
- a.Type_ = D_INDIR + D_CX
+ a.Type = D_INDIR + D_CX
}
// Append code to p to load g into cx.
if ctxt.Arch.Ptrsize == 4 {
p.As = AMOVL
}
- p.From.Type_ = D_INDIR + D_TLS
+ p.From.Type = D_INDIR + D_TLS
p.From.Offset = 0
- p.To.Type_ = D_CX
+ p.To.Type = D_CX
next = p.Link
progedit(ctxt, p)
p = obj.Appendp(ctxt, p)
p.As = int16(cmp)
- p.From.Type_ = D_SP
+ p.From.Type = D_SP
indir_cx(ctxt, &p.To)
p.To.Offset = 2 * int64(ctxt.Arch.Ptrsize) // G.stackguard0
if ctxt.Cursym.Cfunc != 0 {
p = obj.Appendp(ctxt, p)
p.As = int16(lea)
- p.From.Type_ = D_INDIR + D_SP
+ p.From.Type = D_INDIR + D_SP
p.From.Offset = -(int64(framesize) - obj.StackSmall)
- p.To.Type_ = D_AX
+ p.To.Type = D_AX
p = obj.Appendp(ctxt, p)
p.As = int16(cmp)
- p.From.Type_ = D_AX
+ p.From.Type = D_AX
indir_cx(ctxt, &p.To)
p.To.Offset = 2 * int64(ctxt.Arch.Ptrsize) // G.stackguard0
if ctxt.Cursym.Cfunc != 0 {
if ctxt.Cursym.Cfunc != 0 {
p.From.Offset = 3 * int64(ctxt.Arch.Ptrsize) // G.stackguard1
}
- p.To.Type_ = D_SI
+ p.To.Type = D_SI
p = obj.Appendp(ctxt, p)
p.As = int16(cmp)
- p.From.Type_ = D_SI
- p.To.Type_ = D_CONST
+ p.From.Type = D_SI
+ p.To.Type = D_CONST
p.To.Offset = obj.StackPreempt
p = obj.Appendp(ctxt, p)
p.As = AJEQ
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
q1 = p
p = obj.Appendp(ctxt, p)
p.As = int16(lea)
- p.From.Type_ = D_INDIR + D_SP
+ p.From.Type = D_INDIR + D_SP
p.From.Offset = obj.StackGuard
- p.To.Type_ = D_AX
+ p.To.Type = D_AX
p = obj.Appendp(ctxt, p)
p.As = int16(sub)
- p.From.Type_ = D_SI
- p.To.Type_ = D_AX
+ p.From.Type = D_SI
+ p.To.Type = D_AX
p = obj.Appendp(ctxt, p)
p.As = int16(cmp)
- p.From.Type_ = D_AX
- p.To.Type_ = D_CONST
+ p.From.Type = D_AX
+ p.To.Type = D_CONST
p.To.Offset = int64(framesize) + (obj.StackGuard - obj.StackSmall)
}
p = obj.Appendp(ctxt, p)
p.As = AJHI
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
q = p
p = obj.Appendp(ctxt, p)
p.As = ACALL
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
if ctxt.Cursym.Cfunc != 0 {
p.To.Sym = obj.Linklookup(ctxt, "runtime.morestackc", 0)
} else {
p = obj.Appendp(ctxt, p)
p.As = AJMP
- p.To.Type_ = D_BRANCH
+ p.To.Type = D_BRANCH
p.Pcond = ctxt.Cursym.Text.Link
if q != nil {
return AJOS
}
- log.Fatalf("unknown relation: %s", anames6[a])
+ log.Fatalf("unknown relation: %s", Anames[a])
return 0
}
q = ctxt.Arch.Prg()
q.As = AJMP
q.Lineno = p.Lineno
- q.To.Type_ = D_BRANCH
+ q.To.Type = D_BRANCH
q.To.Offset = p.Pc
q.Pcond = p
p = q
if q != nil {
p.Link = q
}
- if p.From.Type_ == D_CONST {
+ if p.From.Type == D_CONST {
if p.From.Offset == 1 {
/*
* expect conditional jump to be taken.
var g obj.Addr
g = nullgen;
- g.Type_ = D_CONST;
+ g.Type = D_CONST;
g.Offset = int64($6);
outcode($1, $2, &$3, NREG, &g);
}
var g obj.Addr
g = nullgen;
- g.Type_ = D_CONST;
+ g.Type = D_CONST;
g.Offset = int64($4);
outcode($1, $2, &g, NREG, &$7);
}
| LTYPEB name ',' imm
{
asm.Settext($2.Sym);
- $4.Type_ = D_CONST2;
+ $4.Type = D_CONST2;
$4.Offset2 = -obj.ArgsSizeUnknown;
outcode($1, Always, &$2, 0, &$4);
}
| LTYPEB name ',' con ',' imm
{
asm.Settext($2.Sym);
- $6.Type_ = D_CONST2;
+ $6.Type = D_CONST2;
$6.Offset2 = -obj.ArgsSizeUnknown;
outcode($1, Always, &$2, $4, &$6);
}
| LTYPEB name ',' con ',' imm '-' con
{
asm.Settext($2.Sym);
- $6.Type_ = D_CONST2;
+ $6.Type = D_CONST2;
$6.Offset2 = $8;
outcode($1, Always, &$2, $4, &$6);
}
var g obj.Addr
g = nullgen;
- g.Type_ = D_CONST;
+ g.Type = D_CONST;
g.Offset = int64(
(0xe << 24) | /* opcode */
($1 << 20) | /* MCR/MRC */
*/
| LTYPEN cond reg ',' reg ',' reg ',' spreg
{
- $7.Type_ = D_REGREG2;
+ $7.Type = D_REGREG2;
$7.Offset = int64($9);
outcode($1, $2, &$3, int32($5.Reg), &$7);
}
*/
| LTYPEPC gen ',' gen
{
- if $2.Type_ != D_CONST || $4.Type_ != D_CONST {
+ if $2.Type != D_CONST || $4.Type != D_CONST {
yyerror("arguments to PCDATA must be integer constants")
}
outcode($1, Always, &$2, NREG, &$4);
*/
| LTYPEF gen ',' gen
{
- if $2.Type_ != D_CONST {
+ if $2.Type != D_CONST {
yyerror("index for FUNCDATA must be integer constant")
}
- if $4.Type_ != D_EXTERN && $4.Type_ != D_STATIC && $4.Type_ != D_OREG {
+ if $4.Type != D_EXTERN && $4.Type != D_STATIC && $4.Type != D_OREG {
yyerror("value for FUNCDATA must be symbol reference")
}
outcode($1, Always, &$2, NREG, &$4);
con '(' LPC ')'
{
$$ = nullgen;
- $$.Type_ = D_BRANCH;
+ $$.Type = D_BRANCH;
$$.Offset = int64($1) + int64(asm.PC);
}
| LNAME offset
if asm.Pass == 2 && $1.Type != LLAB {
yyerror("undefined label: %s", $1.Labelname)
}
- $$.Type_ = D_BRANCH;
+ $$.Type = D_BRANCH;
$$.Offset = $1.Value + int64($2);
}
ximm: '$' con
{
$$ = nullgen;
- $$.Type_ = D_CONST;
+ $$.Type = D_CONST;
$$.Offset = int64($2);
}
| '$' oreg
{
$$ = $2;
- $$.Type_ = D_CONST;
+ $$.Type = D_CONST;
}
| '$' '*' '$' oreg
{
$$ = $4;
- $$.Type_ = D_OCONST;
+ $$.Type = D_OCONST;
}
| '$' LSCONST
{
$$ = nullgen;
- $$.Type_ = D_SCONST;
+ $$.Type = D_SCONST;
$$.U.Sval = $2
}
| fcon
'$' LFCONST
{
$$ = nullgen;
- $$.Type_ = D_FCONST;
+ $$.Type = D_FCONST;
$$.U.Dval = $2;
}
| '$' '-' LFCONST
{
$$ = nullgen;
- $$.Type_ = D_FCONST;
+ $$.Type = D_FCONST;
$$.U.Dval = -$3;
}
| LPSR
{
$$ = nullgen;
- $$.Type_ = D_PSR;
+ $$.Type = D_PSR;
$$.Reg = int8($1);
}
| LFCR
{
$$ = nullgen;
- $$.Type_ = D_FPCR;
+ $$.Type = D_FPCR;
$$.Reg = int8($1);
}
| con
{
$$ = nullgen;
- $$.Type_ = D_OREG;
+ $$.Type = D_OREG;
$$.Offset = int64($1);
}
| oreg
'(' spreg ')'
{
$$ = nullgen;
- $$.Type_ = D_OREG;
+ $$.Type = D_OREG;
$$.Reg = int8($2);
$$.Offset = 0;
}
| con '(' sreg ')'
{
$$ = nullgen;
- $$.Type_ = D_OREG;
+ $$.Type = D_OREG;
$$.Reg = int8($3);
$$.Offset = int64($1);
}
| name '(' sreg ')'
{
$$ = $1;
- $$.Type_ = D_OREG;
+ $$.Type = D_OREG;
$$.Reg = int8($3);
}
| ioreg
imm: '$' con
{
$$ = nullgen;
- $$.Type_ = D_CONST;
+ $$.Type = D_CONST;
$$.Offset = int64($2);
}
spreg
{
$$ = nullgen;
- $$.Type_ = D_REG;
+ $$.Type = D_REG;
$$.Reg = int8($1);
}
'(' spreg ',' spreg ')'
{
$$ = nullgen;
- $$.Type_ = D_REGREG;
+ $$.Type = D_REGREG;
$$.Reg = int8($2);
$$.Offset = int64($4);
}
spreg '<' '<' rcon
{
$$ = nullgen;
- $$.Type_ = D_SHIFT;
+ $$.Type = D_SHIFT;
$$.Offset = int64($1) | int64($4) | (0 << 5);
}
| spreg '>' '>' rcon
{
$$ = nullgen;
- $$.Type_ = D_SHIFT;
+ $$.Type = D_SHIFT;
$$.Offset = int64($1) | int64($4) | (1 << 5);
}
| spreg '-' '>' rcon
{
$$ = nullgen;
- $$.Type_ = D_SHIFT;
+ $$.Type = D_SHIFT;
$$.Offset = int64($1) | int64($4) | (2 << 5);
}
| spreg LAT '>' rcon
{
$$ = nullgen;
- $$.Type_ = D_SHIFT;
+ $$.Type = D_SHIFT;
$$.Offset = int64($1) | int64($4) | (3 << 5);
}
LFREG
{
$$ = nullgen;
- $$.Type_ = D_FREG;
+ $$.Type = D_FREG;
$$.Reg = int8($1);
}
| LF '(' con ')'
{
$$ = nullgen;
- $$.Type_ = D_FREG;
+ $$.Type = D_FREG;
$$.Reg = int8($3);
}
con '(' pointer ')'
{
$$ = nullgen;
- $$.Type_ = D_OREG;
+ $$.Type = D_OREG;
$$.Name = int8($3);
$$.Sym = nil;
$$.Offset = int64($1);
| LNAME offset '(' pointer ')'
{
$$ = nullgen;
- $$.Type_ = D_OREG;
+ $$.Type = D_OREG;
$$.Name = int8($4);
$$.Sym = obj.Linklookup(asm.Ctxt, $1.Name, 0);
$$.Offset = int64($2);
| LNAME '<' '>' offset '(' LSB ')'
{
$$ = nullgen;
- $$.Type_ = D_OREG;
+ $$.Type = D_OREG;
$$.Name = D_STATIC;
$$.Sym = obj.Linklookup(asm.Ctxt, $1.Name, 1);
$$.Offset = int64($4);
}
func cinit() {
- nullgen.Type_ = arm.D_NONE
+ nullgen.Type = arm.D_NONE
nullgen.Name = arm.D_NONE
nullgen.Reg = arm.NREG
}
var g obj.Addr
g = nullgen
- g.Type_ = D_CONST
+ g.Type = D_CONST
g.Offset = int64(yyS[yypt-1].lval)
outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &yyS[yypt-4].addr, NREG, &g)
}
var g obj.Addr
g = nullgen
- g.Type_ = D_CONST
+ g.Type = D_CONST
g.Offset = int64(yyS[yypt-3].lval)
outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &g, NREG, &yyS[yypt-0].addr)
}
//line a.y:221
{
asm.Settext(yyS[yypt-2].addr.Sym)
- yyS[yypt-0].addr.Type_ = D_CONST2
+ yyS[yypt-0].addr.Type = D_CONST2
yyS[yypt-0].addr.Offset2 = -obj.ArgsSizeUnknown
outcode(yyS[yypt-3].lval, Always, &yyS[yypt-2].addr, 0, &yyS[yypt-0].addr)
}
//line a.y:228
{
asm.Settext(yyS[yypt-4].addr.Sym)
- yyS[yypt-0].addr.Type_ = D_CONST2
+ yyS[yypt-0].addr.Type = D_CONST2
yyS[yypt-0].addr.Offset2 = -obj.ArgsSizeUnknown
outcode(yyS[yypt-5].lval, Always, &yyS[yypt-4].addr, yyS[yypt-2].lval, &yyS[yypt-0].addr)
}
//line a.y:235
{
asm.Settext(yyS[yypt-6].addr.Sym)
- yyS[yypt-2].addr.Type_ = D_CONST2
+ yyS[yypt-2].addr.Type = D_CONST2
yyS[yypt-2].addr.Offset2 = yyS[yypt-0].lval
outcode(yyS[yypt-7].lval, Always, &yyS[yypt-6].addr, yyS[yypt-4].lval, &yyS[yypt-2].addr)
}
var g obj.Addr
g = nullgen
- g.Type_ = D_CONST
+ g.Type = D_CONST
g.Offset = int64(
(0xe << 24) | /* opcode */
(yyS[yypt-11].lval << 20) | /* MCR/MRC */
case 40:
//line a.y:305
{
- yyS[yypt-2].addr.Type_ = D_REGREG2
+ yyS[yypt-2].addr.Type = D_REGREG2
yyS[yypt-2].addr.Offset = int64(yyS[yypt-0].lval)
outcode(yyS[yypt-8].lval, yyS[yypt-7].lval, &yyS[yypt-6].addr, int32(yyS[yypt-4].addr.Reg), &yyS[yypt-2].addr)
}
case 42:
//line a.y:321
{
- if yyS[yypt-2].addr.Type_ != D_CONST || yyS[yypt-0].addr.Type_ != D_CONST {
+ if yyS[yypt-2].addr.Type != D_CONST || yyS[yypt-0].addr.Type != D_CONST {
yyerror("arguments to PCDATA must be integer constants")
}
outcode(yyS[yypt-3].lval, Always, &yyS[yypt-2].addr, NREG, &yyS[yypt-0].addr)
case 43:
//line a.y:331
{
- if yyS[yypt-2].addr.Type_ != D_CONST {
+ if yyS[yypt-2].addr.Type != D_CONST {
yyerror("index for FUNCDATA must be integer constant")
}
- if yyS[yypt-0].addr.Type_ != D_EXTERN && yyS[yypt-0].addr.Type_ != D_STATIC && yyS[yypt-0].addr.Type_ != D_OREG {
+ if yyS[yypt-0].addr.Type != D_EXTERN && yyS[yypt-0].addr.Type != D_STATIC && yyS[yypt-0].addr.Type != D_OREG {
yyerror("value for FUNCDATA must be symbol reference")
}
outcode(yyS[yypt-3].lval, Always, &yyS[yypt-2].addr, NREG, &yyS[yypt-0].addr)
//line a.y:366
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_BRANCH
+ yyVAL.addr.Type = D_BRANCH
yyVAL.addr.Offset = int64(yyS[yypt-3].lval) + int64(asm.PC)
}
case 51:
if asm.Pass == 2 && yyS[yypt-1].sym.Type != LLAB {
yyerror("undefined label: %s", yyS[yypt-1].sym.Labelname)
}
- yyVAL.addr.Type_ = D_BRANCH
+ yyVAL.addr.Type = D_BRANCH
yyVAL.addr.Offset = yyS[yypt-1].sym.Value + int64(yyS[yypt-0].lval)
}
case 52:
//line a.y:383
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_CONST
+ yyVAL.addr.Type = D_CONST
yyVAL.addr.Offset = int64(yyS[yypt-0].lval)
}
case 53:
//line a.y:389
{
yyVAL.addr = yyS[yypt-0].addr
- yyVAL.addr.Type_ = D_CONST
+ yyVAL.addr.Type = D_CONST
}
case 54:
//line a.y:394
{
yyVAL.addr = yyS[yypt-0].addr
- yyVAL.addr.Type_ = D_OCONST
+ yyVAL.addr.Type = D_OCONST
}
case 55:
//line a.y:399
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_SCONST
+ yyVAL.addr.Type = D_SCONST
yyVAL.addr.U.Sval = yyS[yypt-0].sval
}
case 56:
//line a.y:408
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FCONST
+ yyVAL.addr.Type = D_FCONST
yyVAL.addr.U.Dval = yyS[yypt-0].dval
}
case 58:
//line a.y:414
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FCONST
+ yyVAL.addr.Type = D_FCONST
yyVAL.addr.U.Dval = -yyS[yypt-0].dval
}
case 59:
//line a.y:450
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_PSR
+ yyVAL.addr.Type = D_PSR
yyVAL.addr.Reg = int8(yyS[yypt-0].lval)
}
case 67:
//line a.y:456
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FPCR
+ yyVAL.addr.Type = D_FPCR
yyVAL.addr.Reg = int8(yyS[yypt-0].lval)
}
case 68:
//line a.y:462
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_OREG
+ yyVAL.addr.Type = D_OREG
yyVAL.addr.Offset = int64(yyS[yypt-0].lval)
}
case 69:
//line a.y:481
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_OREG
+ yyVAL.addr.Type = D_OREG
yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
yyVAL.addr.Offset = 0
}
//line a.y:491
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_OREG
+ yyVAL.addr.Type = D_OREG
yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
yyVAL.addr.Offset = int64(yyS[yypt-3].lval)
}
//line a.y:501
{
yyVAL.addr = yyS[yypt-3].addr
- yyVAL.addr.Type_ = D_OREG
+ yyVAL.addr.Type = D_OREG
yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
}
case 78:
//line a.y:514
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_CONST
+ yyVAL.addr.Type = D_CONST
yyVAL.addr.Offset = int64(yyS[yypt-0].lval)
}
case 83:
//line a.y:522
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_REG
+ yyVAL.addr.Type = D_REG
yyVAL.addr.Reg = int8(yyS[yypt-0].lval)
}
case 84:
//line a.y:530
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_REGREG
+ yyVAL.addr.Type = D_REGREG
yyVAL.addr.Reg = int8(yyS[yypt-3].lval)
yyVAL.addr.Offset = int64(yyS[yypt-1].lval)
}
//line a.y:539
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_SHIFT
+ yyVAL.addr.Type = D_SHIFT
yyVAL.addr.Offset = int64(yyS[yypt-3].lval) | int64(yyS[yypt-0].lval) | (0 << 5)
}
case 86:
//line a.y:545
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_SHIFT
+ yyVAL.addr.Type = D_SHIFT
yyVAL.addr.Offset = int64(yyS[yypt-3].lval) | int64(yyS[yypt-0].lval) | (1 << 5)
}
case 87:
//line a.y:551
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_SHIFT
+ yyVAL.addr.Type = D_SHIFT
yyVAL.addr.Offset = int64(yyS[yypt-3].lval) | int64(yyS[yypt-0].lval) | (2 << 5)
}
case 88:
//line a.y:557
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_SHIFT
+ yyVAL.addr.Type = D_SHIFT
yyVAL.addr.Offset = int64(yyS[yypt-3].lval) | int64(yyS[yypt-0].lval) | (3 << 5)
}
case 89:
//line a.y:616
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FREG
+ yyVAL.addr.Type = D_FREG
yyVAL.addr.Reg = int8(yyS[yypt-0].lval)
}
case 101:
//line a.y:622
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FREG
+ yyVAL.addr.Type = D_FREG
yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
}
case 102:
//line a.y:630
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_OREG
+ yyVAL.addr.Type = D_OREG
yyVAL.addr.Name = int8(yyS[yypt-1].lval)
yyVAL.addr.Sym = nil
yyVAL.addr.Offset = int64(yyS[yypt-3].lval)
//line a.y:638
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_OREG
+ yyVAL.addr.Type = D_OREG
yyVAL.addr.Name = int8(yyS[yypt-1].lval)
yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-4].sym.Name, 0)
yyVAL.addr.Offset = int64(yyS[yypt-3].lval)
//line a.y:646
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_OREG
+ yyVAL.addr.Type = D_OREG
yyVAL.addr.Name = D_STATIC
yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-6].sym.Name, 1)
yyVAL.addr.Offset = int64(yyS[yypt-3].lval)
{
$$.from = $3;
$$.to = $5;
- if $1.Type_ != x86.D_CONST {
+ if $1.Type != x86.D_CONST {
yyerror("illegal constant");
}
$$.to.Offset = $1.Offset;
spec12: /* asm.PCDATA */
rim ',' rim
{
- if $1.Type_ != x86.D_CONST || $3.Type_ != x86.D_CONST {
+ if $1.Type != x86.D_CONST || $3.Type != x86.D_CONST {
yyerror("arguments to asm.PCDATA must be integer constants");
}
$$.from = $1;
spec13: /* FUNCDATA */
rim ',' rim
{
- if $1.Type_ != x86.D_CONST {
+ if $1.Type != x86.D_CONST {
yyerror("index for FUNCDATA must be integer constant");
}
- if $3.Type_ != x86.D_EXTERN && $3.Type_ != x86.D_STATIC {
+ if $3.Type != x86.D_EXTERN && $3.Type != x86.D_STATIC {
yyerror("value for FUNCDATA must be symbol reference");
}
$$.from = $1;
con '(' LPC ')'
{
$$ = nullgen;
- $$.Type_ = x86.D_BRANCH;
+ $$.Type = x86.D_BRANCH;
$$.Offset = $1 + int64(asm.PC);
}
| LNAME offset
if asm.Pass == 2 && $1.Type != LLAB {
yyerror("undefined label: %s", $1.Labelname);
}
- $$.Type_ = x86.D_BRANCH;
+ $$.Type = x86.D_BRANCH;
$$.Offset = $1.Value + $2;
}
LBREG
{
$$ = nullgen;
- $$.Type_ = int16($1);
+ $$.Type = int16($1);
}
| LFREG
{
$$ = nullgen;
- $$.Type_ = int16($1);
+ $$.Type = int16($1);
}
| LLREG
{
$$ = nullgen;
- $$.Type_ = int16($1);
+ $$.Type = int16($1);
}
| LMREG
{
$$ = nullgen;
- $$.Type_ = int16($1);
+ $$.Type = int16($1);
}
| LSP
{
$$ = nullgen;
- $$.Type_ = x86.D_SP;
+ $$.Type = x86.D_SP;
}
| LSREG
{
$$ = nullgen;
- $$.Type_ = int16($1);
+ $$.Type = int16($1);
}
| LXREG
{
$$ = nullgen;
- $$.Type_ = int16($1);
+ $$.Type = int16($1);
}
imm2:
'$' con2
{
$$ = nullgen;
- $$.Type_ = x86.D_CONST;
+ $$.Type = x86.D_CONST;
$$.Offset = $2;
}
'$' con
{
$$ = nullgen;
- $$.Type_ = x86.D_CONST;
+ $$.Type = x86.D_CONST;
$$.Offset = $2;
}
| '$' nam
{
$$ = $2;
- $$.Index = uint8($2.Type_);
- $$.Type_ = x86.D_ADDR;
+ $$.Index = uint8($2.Type);
+ $$.Type = x86.D_ADDR;
/*
- if($2.Type_ == x86.D_AUTO || $2.Type_ == x86.D_PARAM)
+ if($2.Type == x86.D_AUTO || $2.Type == x86.D_PARAM)
yyerror("constant cannot be automatic: %s",
$2.sym.Name);
*/
| '$' LSCONST
{
$$ = nullgen;
- $$.Type_ = x86.D_SCONST;
+ $$.Type = x86.D_SCONST;
$$.U.Sval = ($2+"\x00\x00\x00\x00\x00\x00\x00\x00")[:8]
}
| '$' LFCONST
{
$$ = nullgen;
- $$.Type_ = x86.D_FCONST;
+ $$.Type = x86.D_FCONST;
$$.U.Dval = $2;
}
| '$' '(' LFCONST ')'
{
$$ = nullgen;
- $$.Type_ = x86.D_FCONST;
+ $$.Type = x86.D_FCONST;
$$.U.Dval = $3;
}
| '$' '(' '-' LFCONST ')'
{
$$ = nullgen;
- $$.Type_ = x86.D_FCONST;
+ $$.Type = x86.D_FCONST;
$$.U.Dval = -$4;
}
| '$' '-' LFCONST
{
$$ = nullgen;
- $$.Type_ = x86.D_FCONST;
+ $$.Type = x86.D_FCONST;
$$.U.Dval = -$3;
}
con
{
$$ = nullgen;
- $$.Type_ = x86.D_INDIR+x86.D_NONE;
+ $$.Type = x86.D_INDIR+x86.D_NONE;
$$.Offset = $1;
}
| con '(' LLREG ')'
{
$$ = nullgen;
- $$.Type_ = int16(x86.D_INDIR+$3);
+ $$.Type = int16(x86.D_INDIR+$3);
$$.Offset = $1;
}
| con '(' LSP ')'
{
$$ = nullgen;
- $$.Type_ = int16(x86.D_INDIR+x86.D_SP);
+ $$.Type = int16(x86.D_INDIR+x86.D_SP);
$$.Offset = $1;
}
| con '(' LSREG ')'
{
$$ = nullgen;
- $$.Type_ = int16(x86.D_INDIR+$3);
+ $$.Type = int16(x86.D_INDIR+$3);
$$.Offset = $1;
}
| con '(' LLREG '*' con ')'
{
$$ = nullgen;
- $$.Type_ = int16(x86.D_INDIR+x86.D_NONE);
+ $$.Type = int16(x86.D_INDIR+x86.D_NONE);
$$.Offset = $1;
$$.Index = uint8($3);
$$.Scale = int8($5);
| con '(' LLREG ')' '(' LLREG '*' con ')'
{
$$ = nullgen;
- $$.Type_ = int16(x86.D_INDIR+$3);
+ $$.Type = int16(x86.D_INDIR+$3);
$$.Offset = $1;
$$.Index = uint8($6);
$$.Scale = int8($8);
| con '(' LLREG ')' '(' LSREG '*' con ')'
{
$$ = nullgen;
- $$.Type_ = int16(x86.D_INDIR+$3);
+ $$.Type = int16(x86.D_INDIR+$3);
$$.Offset = $1;
$$.Index = uint8($6);
$$.Scale = int8($8);
| '(' LLREG ')'
{
$$ = nullgen;
- $$.Type_ = int16(x86.D_INDIR+$2);
+ $$.Type = int16(x86.D_INDIR+$2);
}
| '(' LSP ')'
{
$$ = nullgen;
- $$.Type_ = int16(x86.D_INDIR+x86.D_SP);
+ $$.Type = int16(x86.D_INDIR+x86.D_SP);
}
| '(' LLREG '*' con ')'
{
$$ = nullgen;
- $$.Type_ = int16(x86.D_INDIR+x86.D_NONE);
+ $$.Type = int16(x86.D_INDIR+x86.D_NONE);
$$.Index = uint8($2);
$$.Scale = int8($4);
checkscale($$.Scale);
| '(' LLREG ')' '(' LLREG '*' con ')'
{
$$ = nullgen;
- $$.Type_ = int16(x86.D_INDIR+$2);
+ $$.Type = int16(x86.D_INDIR+$2);
$$.Index = uint8($5);
$$.Scale = int8($7);
checkscale($$.Scale);
LNAME offset '(' pointer ')'
{
$$ = nullgen;
- $$.Type_ = int16($4);
+ $$.Type = int16($4);
$$.Sym = obj.Linklookup(asm.Ctxt, $1.Name, 0);
$$.Offset = $2;
}
| LNAME '<' '>' offset '(' LSB ')'
{
$$ = nullgen;
- $$.Type_ = x86.D_STATIC;
+ $$.Type = x86.D_STATIC;
$$.Sym = obj.Linklookup(asm.Ctxt, $1.Name, 1);
$$.Offset = $4;
}
}
func cinit() {
- nullgen.Type_ = x86.D_NONE
+ nullgen.Type = x86.D_NONE
nullgen.Index = x86.D_NONE
}
{
yyVAL.addr2.from = yyS[yypt-2].addr
yyVAL.addr2.to = yyS[yypt-0].addr
- if yyS[yypt-4].addr.Type_ != x86.D_CONST {
+ if yyS[yypt-4].addr.Type != x86.D_CONST {
yyerror("illegal constant")
}
yyVAL.addr2.to.Offset = yyS[yypt-4].addr.Offset
case 61:
//line a.y:324
{
- if yyS[yypt-2].addr.Type_ != x86.D_CONST || yyS[yypt-0].addr.Type_ != x86.D_CONST {
+ if yyS[yypt-2].addr.Type != x86.D_CONST || yyS[yypt-0].addr.Type != x86.D_CONST {
yyerror("arguments to asm.PCDATA must be integer constants")
}
yyVAL.addr2.from = yyS[yypt-2].addr
case 62:
//line a.y:334
{
- if yyS[yypt-2].addr.Type_ != x86.D_CONST {
+ if yyS[yypt-2].addr.Type != x86.D_CONST {
yyerror("index for FUNCDATA must be integer constant")
}
- if yyS[yypt-0].addr.Type_ != x86.D_EXTERN && yyS[yypt-0].addr.Type_ != x86.D_STATIC {
+ if yyS[yypt-0].addr.Type != x86.D_EXTERN && yyS[yypt-0].addr.Type != x86.D_STATIC {
yyerror("value for FUNCDATA must be symbol reference")
}
yyVAL.addr2.from = yyS[yypt-2].addr
//line a.y:369
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = x86.D_BRANCH
+ yyVAL.addr.Type = x86.D_BRANCH
yyVAL.addr.Offset = yyS[yypt-3].lval + int64(asm.PC)
}
case 74:
if asm.Pass == 2 && yyS[yypt-1].sym.Type != LLAB {
yyerror("undefined label: %s", yyS[yypt-1].sym.Labelname)
}
- yyVAL.addr.Type_ = x86.D_BRANCH
+ yyVAL.addr.Type = x86.D_BRANCH
yyVAL.addr.Offset = yyS[yypt-1].sym.Value + yyS[yypt-0].lval
}
case 75:
//line a.y:387
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-0].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-0].lval)
}
case 76:
//line a.y:392
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-0].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-0].lval)
}
case 77:
//line a.y:397
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-0].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-0].lval)
}
case 78:
//line a.y:402
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-0].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-0].lval)
}
case 79:
//line a.y:407
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = x86.D_SP
+ yyVAL.addr.Type = x86.D_SP
}
case 80:
//line a.y:412
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-0].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-0].lval)
}
case 81:
//line a.y:417
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-0].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-0].lval)
}
case 82:
//line a.y:423
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = x86.D_CONST
+ yyVAL.addr.Type = x86.D_CONST
yyVAL.addr.Offset = yyS[yypt-0].lval
}
case 83:
//line a.y:431
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = x86.D_CONST
+ yyVAL.addr.Type = x86.D_CONST
yyVAL.addr.Offset = yyS[yypt-0].lval
}
case 84:
//line a.y:437
{
yyVAL.addr = yyS[yypt-0].addr
- yyVAL.addr.Index = uint8(yyS[yypt-0].addr.Type_)
- yyVAL.addr.Type_ = x86.D_ADDR
+ yyVAL.addr.Index = uint8(yyS[yypt-0].addr.Type)
+ yyVAL.addr.Type = x86.D_ADDR
/*
- if($2.Type_ == x86.D_AUTO || $2.Type_ == x86.D_PARAM)
+ if($2.Type == x86.D_AUTO || $2.Type == x86.D_PARAM)
yyerror("constant cannot be automatic: %s",
$2.sym.Name);
*/
//line a.y:447
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = x86.D_SCONST
+ yyVAL.addr.Type = x86.D_SCONST
yyVAL.addr.U.Sval = (yyS[yypt-0].sval + "\x00\x00\x00\x00\x00\x00\x00\x00")[:8]
}
case 86:
//line a.y:453
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = x86.D_FCONST
+ yyVAL.addr.Type = x86.D_FCONST
yyVAL.addr.U.Dval = yyS[yypt-0].dval
}
case 87:
//line a.y:459
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = x86.D_FCONST
+ yyVAL.addr.Type = x86.D_FCONST
yyVAL.addr.U.Dval = yyS[yypt-1].dval
}
case 88:
//line a.y:465
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = x86.D_FCONST
+ yyVAL.addr.Type = x86.D_FCONST
yyVAL.addr.U.Dval = -yyS[yypt-1].dval
}
case 89:
//line a.y:471
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = x86.D_FCONST
+ yyVAL.addr.Type = x86.D_FCONST
yyVAL.addr.U.Dval = -yyS[yypt-0].dval
}
case 90:
//line a.y:483
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = x86.D_INDIR + x86.D_NONE
+ yyVAL.addr.Type = x86.D_INDIR + x86.D_NONE
yyVAL.addr.Offset = yyS[yypt-0].lval
}
case 93:
//line a.y:489
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(x86.D_INDIR + yyS[yypt-1].lval)
+ yyVAL.addr.Type = int16(x86.D_INDIR + yyS[yypt-1].lval)
yyVAL.addr.Offset = yyS[yypt-3].lval
}
case 94:
//line a.y:495
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(x86.D_INDIR + x86.D_SP)
+ yyVAL.addr.Type = int16(x86.D_INDIR + x86.D_SP)
yyVAL.addr.Offset = yyS[yypt-3].lval
}
case 95:
//line a.y:501
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(x86.D_INDIR + yyS[yypt-1].lval)
+ yyVAL.addr.Type = int16(x86.D_INDIR + yyS[yypt-1].lval)
yyVAL.addr.Offset = yyS[yypt-3].lval
}
case 96:
//line a.y:507
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(x86.D_INDIR + x86.D_NONE)
+ yyVAL.addr.Type = int16(x86.D_INDIR + x86.D_NONE)
yyVAL.addr.Offset = yyS[yypt-5].lval
yyVAL.addr.Index = uint8(yyS[yypt-3].lval)
yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
//line a.y:516
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(x86.D_INDIR + yyS[yypt-6].lval)
+ yyVAL.addr.Type = int16(x86.D_INDIR + yyS[yypt-6].lval)
yyVAL.addr.Offset = yyS[yypt-8].lval
yyVAL.addr.Index = uint8(yyS[yypt-3].lval)
yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
//line a.y:525
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(x86.D_INDIR + yyS[yypt-6].lval)
+ yyVAL.addr.Type = int16(x86.D_INDIR + yyS[yypt-6].lval)
yyVAL.addr.Offset = yyS[yypt-8].lval
yyVAL.addr.Index = uint8(yyS[yypt-3].lval)
yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
//line a.y:534
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(x86.D_INDIR + yyS[yypt-1].lval)
+ yyVAL.addr.Type = int16(x86.D_INDIR + yyS[yypt-1].lval)
}
case 100:
//line a.y:539
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(x86.D_INDIR + x86.D_SP)
+ yyVAL.addr.Type = int16(x86.D_INDIR + x86.D_SP)
}
case 101:
//line a.y:544
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(x86.D_INDIR + x86.D_NONE)
+ yyVAL.addr.Type = int16(x86.D_INDIR + x86.D_NONE)
yyVAL.addr.Index = uint8(yyS[yypt-3].lval)
yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
checkscale(yyVAL.addr.Scale)
//line a.y:552
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(x86.D_INDIR + yyS[yypt-6].lval)
+ yyVAL.addr.Type = int16(x86.D_INDIR + yyS[yypt-6].lval)
yyVAL.addr.Index = uint8(yyS[yypt-3].lval)
yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
checkscale(yyVAL.addr.Scale)
//line a.y:575
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-1].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-1].lval)
yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-4].sym.Name, 0)
yyVAL.addr.Offset = yyS[yypt-3].lval
}
//line a.y:582
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = x86.D_STATIC
+ yyVAL.addr.Type = x86.D_STATIC
yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-6].sym.Name, 1)
yyVAL.addr.Offset = yyS[yypt-3].lval
}
{
$$.from = nullgen;
$$.to = $2;
- $$.to.Index = uint8($2.Type_)
- $$.to.Type_ = D_INDIR+D_ADDR;
+ $$.to.Index = uint8($2.Type)
+ $$.to.Type = D_INDIR+D_ADDR;
}
spec4: /* NOP */
{
$$.from = $3;
$$.to = $5;
- if $1.Type_ != D_CONST {
+ if $1.Type != D_CONST {
yyerror("illegal constant")
}
$$.to.Offset = $1.Offset;
spec11: /* PCDATA */
rim ',' rim
{
- if $1.Type_ != D_CONST || $3.Type_ != D_CONST {
+ if $1.Type != D_CONST || $3.Type != D_CONST {
yyerror("arguments to PCDATA must be integer constants");
}
$$.from = $1;
spec12: /* FUNCDATA */
rim ',' rim
{
- if $1.Type_ != D_CONST {
+ if $1.Type != D_CONST {
yyerror("index for FUNCDATA must be integer constant");
}
- if $3.Type_ != D_EXTERN && $3.Type_ != D_STATIC {
+ if $3.Type != D_EXTERN && $3.Type != D_STATIC {
yyerror("value for FUNCDATA must be symbol reference");
}
$$.from = $1;
con '(' LPC ')'
{
$$ = nullgen;
- $$.Type_ = D_BRANCH;
+ $$.Type = D_BRANCH;
$$.Offset = $1 + int64(asm.PC);
}
| LNAME offset
if asm.Pass == 2 && $1.Type != LLAB {
yyerror("undefined label: %s", $1.Labelname);
}
- $$.Type_ = D_BRANCH;
+ $$.Type = D_BRANCH;
$$.Offset = $1.Value + $2;
}
LBREG
{
$$ = nullgen;
- $$.Type_ = int16($1);
+ $$.Type = int16($1);
}
| LFREG
{
$$ = nullgen;
- $$.Type_ = int16($1);
+ $$.Type = int16($1);
}
| LLREG
{
$$ = nullgen;
- $$.Type_ = int16($1);
+ $$.Type = int16($1);
}
| LXREG
{
$$ = nullgen;
- $$.Type_ = int16($1);
+ $$.Type = int16($1);
}
| LSP
{
$$ = nullgen;
- $$.Type_ = D_SP;
+ $$.Type = D_SP;
}
| LSREG
{
$$ = nullgen;
- $$.Type_ = int16($1);
+ $$.Type = int16($1);
}
imm:
'$' con
{
$$ = nullgen;
- $$.Type_ = D_CONST;
+ $$.Type = D_CONST;
$$.Offset = $2;
}
| '$' nam
{
$$ = $2;
- $$.Index = uint8($2.Type_);
- $$.Type_ = D_ADDR;
+ $$.Index = uint8($2.Type);
+ $$.Type = D_ADDR;
/*
- if($2.Type_ == D_AUTO || $2.Type_ == D_PARAM)
+ if($2.Type == D_AUTO || $2.Type == D_PARAM)
yyerror("constant cannot be automatic: %s",
$2.Sym.name);
*/
| '$' LSCONST
{
$$ = nullgen;
- $$.Type_ = D_SCONST;
+ $$.Type = D_SCONST;
$$.U.Sval = $2
}
| '$' LFCONST
{
$$ = nullgen;
- $$.Type_ = D_FCONST;
+ $$.Type = D_FCONST;
$$.U.Dval = $2;
}
| '$' '(' LFCONST ')'
{
$$ = nullgen;
- $$.Type_ = D_FCONST;
+ $$.Type = D_FCONST;
$$.U.Dval = $3;
}
| '$' '(' '-' LFCONST ')'
{
$$ = nullgen;
- $$.Type_ = D_FCONST;
+ $$.Type = D_FCONST;
$$.U.Dval = -$4;
}
| '$' '-' LFCONST
{
$$ = nullgen;
- $$.Type_ = D_FCONST;
+ $$.Type = D_FCONST;
$$.U.Dval = -$3;
}
'$' con2
{
$$ = nullgen;
- $$.Type_ = D_CONST2;
+ $$.Type = D_CONST2;
$$.Offset = int64($2.v1);
$$.Offset2 = int32($2.v2);
}
con
{
$$ = nullgen;
- $$.Type_ = D_INDIR+D_NONE;
+ $$.Type = D_INDIR+D_NONE;
$$.Offset = $1;
}
| con '(' LLREG ')'
{
$$ = nullgen;
- $$.Type_ = int16(D_INDIR+$3);
+ $$.Type = int16(D_INDIR+$3);
$$.Offset = $1;
}
| con '(' LSP ')'
{
$$ = nullgen;
- $$.Type_ = D_INDIR+D_SP;
+ $$.Type = D_INDIR+D_SP;
$$.Offset = $1;
}
| con '(' LLREG '*' con ')'
{
$$ = nullgen;
- $$.Type_ = D_INDIR+D_NONE;
+ $$.Type = D_INDIR+D_NONE;
$$.Offset = $1;
$$.Index = uint8($3);
$$.Scale = int8($5);
| con '(' LLREG ')' '(' LLREG '*' con ')'
{
$$ = nullgen;
- $$.Type_ = int16(D_INDIR+$3);
+ $$.Type = int16(D_INDIR+$3);
$$.Offset = $1;
$$.Index = uint8($6);
$$.Scale = int8($8);
| con '(' LLREG ')' '(' LSREG '*' con ')'
{
$$ = nullgen;
- $$.Type_ = int16(D_INDIR+$3);
+ $$.Type = int16(D_INDIR+$3);
$$.Offset = $1;
$$.Index = uint8($6);
$$.Scale = int8($8);
| '(' LLREG ')'
{
$$ = nullgen;
- $$.Type_ = int16(D_INDIR+$2);
+ $$.Type = int16(D_INDIR+$2);
}
| '(' LSP ')'
{
$$ = nullgen;
- $$.Type_ = D_INDIR+D_SP;
+ $$.Type = D_INDIR+D_SP;
}
| con '(' LSREG ')'
{
$$ = nullgen;
- $$.Type_ = int16(D_INDIR+$3);
+ $$.Type = int16(D_INDIR+$3);
$$.Offset = $1;
}
| '(' LLREG '*' con ')'
{
$$ = nullgen;
- $$.Type_ = D_INDIR+D_NONE;
+ $$.Type = D_INDIR+D_NONE;
$$.Index = uint8($2);
$$.Scale = int8($4);
checkscale($$.Scale);
| '(' LLREG ')' '(' LLREG '*' con ')'
{
$$ = nullgen;
- $$.Type_ = int16(D_INDIR+$2);
+ $$.Type = int16(D_INDIR+$2);
$$.Index = uint8($5);
$$.Scale = int8($7);
checkscale($$.Scale);
LNAME offset '(' pointer ')'
{
$$ = nullgen;
- $$.Type_ = int16($4);
+ $$.Type = int16($4);
$$.Sym = obj.Linklookup(asm.Ctxt, $1.Name, 0);
$$.Offset = $2;
}
| LNAME '<' '>' offset '(' LSB ')'
{
$$ = nullgen;
- $$.Type_ = D_STATIC;
+ $$.Type = D_STATIC;
$$.Sym = obj.Linklookup(asm.Ctxt, $1.Name, 1);
$$.Offset = $4;
}
}
func cinit() {
- nullgen.Type_ = i386.D_NONE
+ nullgen.Type = i386.D_NONE
nullgen.Index = i386.D_NONE
}
{
yyVAL.addr2.from = nullgen
yyVAL.addr2.to = yyS[yypt-0].addr
- yyVAL.addr2.to.Index = uint8(yyS[yypt-0].addr.Type_)
- yyVAL.addr2.to.Type_ = D_INDIR + D_ADDR
+ yyVAL.addr2.to.Index = uint8(yyS[yypt-0].addr.Type)
+ yyVAL.addr2.to.Type = D_INDIR + D_ADDR
}
case 46:
yyVAL.addr2 = yyS[yypt-0].addr2
{
yyVAL.addr2.from = yyS[yypt-2].addr
yyVAL.addr2.to = yyS[yypt-0].addr
- if yyS[yypt-4].addr.Type_ != D_CONST {
+ if yyS[yypt-4].addr.Type != D_CONST {
yyerror("illegal constant")
}
yyVAL.addr2.to.Offset = yyS[yypt-4].addr.Offset
case 59:
//line a.y:322
{
- if yyS[yypt-2].addr.Type_ != D_CONST || yyS[yypt-0].addr.Type_ != D_CONST {
+ if yyS[yypt-2].addr.Type != D_CONST || yyS[yypt-0].addr.Type != D_CONST {
yyerror("arguments to PCDATA must be integer constants")
}
yyVAL.addr2.from = yyS[yypt-2].addr
case 60:
//line a.y:332
{
- if yyS[yypt-2].addr.Type_ != D_CONST {
+ if yyS[yypt-2].addr.Type != D_CONST {
yyerror("index for FUNCDATA must be integer constant")
}
- if yyS[yypt-0].addr.Type_ != D_EXTERN && yyS[yypt-0].addr.Type_ != D_STATIC {
+ if yyS[yypt-0].addr.Type != D_EXTERN && yyS[yypt-0].addr.Type != D_STATIC {
yyerror("value for FUNCDATA must be symbol reference")
}
yyVAL.addr2.from = yyS[yypt-2].addr
//line a.y:368
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_BRANCH
+ yyVAL.addr.Type = D_BRANCH
yyVAL.addr.Offset = yyS[yypt-3].lval + int64(asm.PC)
}
case 73:
if asm.Pass == 2 && yyS[yypt-1].sym.Type != LLAB {
yyerror("undefined label: %s", yyS[yypt-1].sym.Labelname)
}
- yyVAL.addr.Type_ = D_BRANCH
+ yyVAL.addr.Type = D_BRANCH
yyVAL.addr.Offset = yyS[yypt-1].sym.Value + yyS[yypt-0].lval
}
case 74:
//line a.y:386
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-0].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-0].lval)
}
case 75:
//line a.y:391
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-0].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-0].lval)
}
case 76:
//line a.y:396
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-0].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-0].lval)
}
case 77:
//line a.y:401
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-0].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-0].lval)
}
case 78:
//line a.y:406
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_SP
+ yyVAL.addr.Type = D_SP
}
case 79:
//line a.y:411
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-0].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-0].lval)
}
case 80:
//line a.y:418
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_CONST
+ yyVAL.addr.Type = D_CONST
yyVAL.addr.Offset = yyS[yypt-0].lval
}
case 81:
//line a.y:424
{
yyVAL.addr = yyS[yypt-0].addr
- yyVAL.addr.Index = uint8(yyS[yypt-0].addr.Type_)
- yyVAL.addr.Type_ = D_ADDR
+ yyVAL.addr.Index = uint8(yyS[yypt-0].addr.Type)
+ yyVAL.addr.Type = D_ADDR
/*
- if($2.Type_ == D_AUTO || $2.Type_ == D_PARAM)
+ if($2.Type == D_AUTO || $2.Type == D_PARAM)
yyerror("constant cannot be automatic: %s",
$2.Sym.name);
*/
//line a.y:434
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_SCONST
+ yyVAL.addr.Type = D_SCONST
yyVAL.addr.U.Sval = yyS[yypt-0].sval
}
case 83:
//line a.y:440
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FCONST
+ yyVAL.addr.Type = D_FCONST
yyVAL.addr.U.Dval = yyS[yypt-0].dval
}
case 84:
//line a.y:446
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FCONST
+ yyVAL.addr.Type = D_FCONST
yyVAL.addr.U.Dval = yyS[yypt-1].dval
}
case 85:
//line a.y:452
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FCONST
+ yyVAL.addr.Type = D_FCONST
yyVAL.addr.U.Dval = -yyS[yypt-1].dval
}
case 86:
//line a.y:458
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FCONST
+ yyVAL.addr.Type = D_FCONST
yyVAL.addr.U.Dval = -yyS[yypt-0].dval
}
case 87:
//line a.y:466
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_CONST2
+ yyVAL.addr.Type = D_CONST2
yyVAL.addr.Offset = int64(yyS[yypt-0].con2.v1)
yyVAL.addr.Offset2 = int32(yyS[yypt-0].con2.v2)
}
//line a.y:501
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_INDIR + D_NONE
+ yyVAL.addr.Type = D_INDIR + D_NONE
yyVAL.addr.Offset = yyS[yypt-0].lval
}
case 95:
//line a.y:507
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(D_INDIR + yyS[yypt-1].lval)
+ yyVAL.addr.Type = int16(D_INDIR + yyS[yypt-1].lval)
yyVAL.addr.Offset = yyS[yypt-3].lval
}
case 96:
//line a.y:513
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_INDIR + D_SP
+ yyVAL.addr.Type = D_INDIR + D_SP
yyVAL.addr.Offset = yyS[yypt-3].lval
}
case 97:
//line a.y:519
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_INDIR + D_NONE
+ yyVAL.addr.Type = D_INDIR + D_NONE
yyVAL.addr.Offset = yyS[yypt-5].lval
yyVAL.addr.Index = uint8(yyS[yypt-3].lval)
yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
//line a.y:528
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(D_INDIR + yyS[yypt-6].lval)
+ yyVAL.addr.Type = int16(D_INDIR + yyS[yypt-6].lval)
yyVAL.addr.Offset = yyS[yypt-8].lval
yyVAL.addr.Index = uint8(yyS[yypt-3].lval)
yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
//line a.y:537
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(D_INDIR + yyS[yypt-6].lval)
+ yyVAL.addr.Type = int16(D_INDIR + yyS[yypt-6].lval)
yyVAL.addr.Offset = yyS[yypt-8].lval
yyVAL.addr.Index = uint8(yyS[yypt-3].lval)
yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
//line a.y:546
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(D_INDIR + yyS[yypt-1].lval)
+ yyVAL.addr.Type = int16(D_INDIR + yyS[yypt-1].lval)
}
case 101:
//line a.y:551
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_INDIR + D_SP
+ yyVAL.addr.Type = D_INDIR + D_SP
}
case 102:
//line a.y:556
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(D_INDIR + yyS[yypt-1].lval)
+ yyVAL.addr.Type = int16(D_INDIR + yyS[yypt-1].lval)
yyVAL.addr.Offset = yyS[yypt-3].lval
}
case 103:
//line a.y:562
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_INDIR + D_NONE
+ yyVAL.addr.Type = D_INDIR + D_NONE
yyVAL.addr.Index = uint8(yyS[yypt-3].lval)
yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
checkscale(yyVAL.addr.Scale)
//line a.y:570
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(D_INDIR + yyS[yypt-6].lval)
+ yyVAL.addr.Type = int16(D_INDIR + yyS[yypt-6].lval)
yyVAL.addr.Index = uint8(yyS[yypt-3].lval)
yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
checkscale(yyVAL.addr.Scale)
//line a.y:593
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-1].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-1].lval)
yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-4].sym.Name, 0)
yyVAL.addr.Offset = yyS[yypt-3].lval
}
//line a.y:600
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_STATIC
+ yyVAL.addr.Type = D_STATIC
yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-6].sym.Name, 1)
yyVAL.addr.Offset = yyS[yypt-3].lval
}
{
var g obj.Addr
g = nullgen;
- g.Type_ = D_CONST;
+ g.Type = D_CONST;
g.Offset = $2;
outcode(int($1), &g, int($4), &$6);
}
{
var g obj.Addr
g = nullgen;
- g.Type_ = D_CONST;
+ g.Type = D_CONST;
g.Offset = $2;
outcode(int($1), &g, int($4), &$6);
}
{
var g obj.Addr
g = nullgen;
- g.Type_ = D_CONST;
+ g.Type = D_CONST;
g.Offset = $2;
outcode(int($1), &g, int($4), &$7);
}
*/
| LPCDAT imm ',' imm
{
- if $2.Type_ != D_CONST || $4.Type_ != D_CONST {
+ if $2.Type != D_CONST || $4.Type != D_CONST {
yyerror("arguments to PCDATA must be integer constants")
}
outcode(int($1), &$2, NREG, &$4);
*/
| LFUNCDAT imm ',' addr
{
- if $2.Type_ != D_CONST {
+ if $2.Type != D_CONST {
yyerror("index for FUNCDATA must be integer constant")
}
- if $4.Type_ != D_EXTERN && $4.Type_ != D_STATIC && $4.Type_ != D_OREG {
+ if $4.Type != D_EXTERN && $4.Type != D_STATIC && $4.Type != D_OREG {
yyerror("value for FUNCDATA must be symbol reference")
}
outcode(int($1), &$2, NREG, &$4);
con '(' LPC ')'
{
$$ = nullgen;
- $$.Type_ = D_BRANCH;
+ $$.Type = D_BRANCH;
$$.Offset = $1 + int64(asm.PC);
}
| LNAME offset
if asm.Pass == 2 && $1.Type != LLAB {
yyerror("undefined label: %s", $1.Labelname)
}
- $$.Type_ = D_BRANCH;
+ $$.Type = D_BRANCH;
$$.Offset = $1.Value + $2;
}
sreg
{
$$ = nullgen;
- $$.Type_ = D_REG;
+ $$.Type = D_REG;
$$.Reg = int8($1);
}
LLR
{
$$ = nullgen;
- $$.Type_ = D_SPR;
+ $$.Type = D_SPR;
$$.Offset = $1;
}
LCR
{
$$ = nullgen;
- $$.Type_ = D_CREG;
+ $$.Type = D_CREG;
$$.Reg = NREG; /* whole register */
}
LCTR
{
$$ = nullgen;
- $$.Type_ = D_SPR;
+ $$.Type = D_SPR;
$$.Offset = $1;
}
LMSR
{
$$ = nullgen;
- $$.Type_ = D_MSR;
+ $$.Type = D_MSR;
}
psr:
LSPREG
{
$$ = nullgen;
- $$.Type_ = D_SPR;
+ $$.Type = D_SPR;
$$.Offset = $1;
}
| LSPR '(' con ')'
{
$$ = nullgen;
- $$.Type_ = int16($1);
+ $$.Type = int16($1);
$$.Offset = $3;
}
| msr
LFPSCR
{
$$ = nullgen;
- $$.Type_ = D_FPSCR;
+ $$.Type = D_FPSCR;
$$.Reg = NREG;
}
LFPSCR '(' con ')'
{
$$ = nullgen;
- $$.Type_ = D_FPSCR;
+ $$.Type = D_FPSCR;
$$.Reg = int8($3);
}
LFREG
{
$$ = nullgen;
- $$.Type_ = D_FREG;
+ $$.Type = D_FREG;
$$.Reg = int8($1);
}
| LF '(' con ')'
{
$$ = nullgen;
- $$.Type_ = D_FREG;
+ $$.Type = D_FREG;
$$.Reg = int8($3);
}
LCREG
{
$$ = nullgen;
- $$.Type_ = D_CREG;
+ $$.Type = D_CREG;
$$.Reg = int8($1);
}
| LCR '(' con ')'
{
$$ = nullgen;
- $$.Type_ = D_CREG;
+ $$.Type = D_CREG;
$$.Reg = int8($3);
}
cbit: con
{
$$ = nullgen;
- $$.Type_ = D_REG;
+ $$.Type = D_REG;
$$.Reg = int8($1);
}
var v uint32
$$ = nullgen;
- $$.Type_ = D_CONST;
+ $$.Type = D_CONST;
mb = int($1);
me = int($3);
if(mb < 0 || mb > 31 || me < 0 || me > 31){
'$' addr
{
$$ = $2;
- $$.Type_ = D_CONST;
+ $$.Type = D_CONST;
}
| '$' LSCONST
{
$$ = nullgen;
- $$.Type_ = D_SCONST;
+ $$.Type = D_SCONST;
$$.U.Sval = $2
}
'$' LFCONST
{
$$ = nullgen;
- $$.Type_ = D_FCONST;
+ $$.Type = D_FCONST;
$$.U.Dval = $2;
}
| '$' '-' LFCONST
{
$$ = nullgen;
- $$.Type_ = D_FCONST;
+ $$.Type = D_FCONST;
$$.U.Dval = -$3;
}
imm: '$' con
{
$$ = nullgen;
- $$.Type_ = D_CONST;
+ $$.Type = D_CONST;
$$.Offset = $2;
}
'(' sreg ')'
{
$$ = nullgen;
- $$.Type_ = D_OREG;
+ $$.Type = D_OREG;
$$.Reg = int8($2);
$$.Offset = 0;
}
| '(' sreg '+' sreg ')'
{
$$ = nullgen;
- $$.Type_ = D_OREG;
+ $$.Type = D_OREG;
$$.Reg = int8($2);
$$.Scale = int8($4);
$$.Offset = 0;
| con '(' sreg ')'
{
$$ = nullgen;
- $$.Type_ = D_OREG;
+ $$.Type = D_OREG;
$$.Reg = int8($3);
$$.Offset = $1;
}
con '(' pointer ')'
{
$$ = nullgen;
- $$.Type_ = D_OREG;
+ $$.Type = D_OREG;
$$.Name = int8($3);
$$.Sym = nil;
$$.Offset = $1;
| LNAME offset '(' pointer ')'
{
$$ = nullgen;
- $$.Type_ = D_OREG;
+ $$.Type = D_OREG;
$$.Name = int8($4);
$$.Sym = obj.Linklookup(asm.Ctxt, $1.Name, 0);
$$.Offset = $2;
| LNAME '<' '>' offset '(' LSB ')'
{
$$ = nullgen;
- $$.Type_ = D_OREG;
+ $$.Type = D_OREG;
$$.Name = D_STATIC;
$$.Sym = obj.Linklookup(asm.Ctxt, $1.Name, 0);
$$.Offset = $4;
}
func cinit() {
- nullgen.Type_ = ppc64.D_NONE
+ nullgen.Type = ppc64.D_NONE
nullgen.Name = ppc64.D_NONE
nullgen.Reg = ppc64.NREG
nullgen.Scale = ppc64.NREG // replaced Gen.xreg with Prog.scale
{
var g obj.Addr
g = nullgen
- g.Type_ = D_CONST
+ g.Type = D_CONST
g.Offset = yyS[yypt-4].lval
outcode(int(yyS[yypt-5].lval), &g, int(yyS[yypt-2].lval), &yyS[yypt-0].addr)
}
{
var g obj.Addr
g = nullgen
- g.Type_ = D_CONST
+ g.Type = D_CONST
g.Offset = yyS[yypt-4].lval
outcode(int(yyS[yypt-5].lval), &g, int(yyS[yypt-2].lval), &yyS[yypt-0].addr)
}
{
var g obj.Addr
g = nullgen
- g.Type_ = D_CONST
+ g.Type = D_CONST
g.Offset = yyS[yypt-6].lval
outcode(int(yyS[yypt-7].lval), &g, int(yyS[yypt-4].lval), &yyS[yypt-1].addr)
}
case 114:
//line a.y:600
{
- if yyS[yypt-2].addr.Type_ != D_CONST || yyS[yypt-0].addr.Type_ != D_CONST {
+ if yyS[yypt-2].addr.Type != D_CONST || yyS[yypt-0].addr.Type != D_CONST {
yyerror("arguments to PCDATA must be integer constants")
}
outcode(int(yyS[yypt-3].lval), &yyS[yypt-2].addr, NREG, &yyS[yypt-0].addr)
case 115:
//line a.y:610
{
- if yyS[yypt-2].addr.Type_ != D_CONST {
+ if yyS[yypt-2].addr.Type != D_CONST {
yyerror("index for FUNCDATA must be integer constant")
}
- if yyS[yypt-0].addr.Type_ != D_EXTERN && yyS[yypt-0].addr.Type_ != D_STATIC && yyS[yypt-0].addr.Type_ != D_OREG {
+ if yyS[yypt-0].addr.Type != D_EXTERN && yyS[yypt-0].addr.Type != D_STATIC && yyS[yypt-0].addr.Type != D_OREG {
yyerror("value for FUNCDATA must be symbol reference")
}
outcode(int(yyS[yypt-3].lval), &yyS[yypt-2].addr, NREG, &yyS[yypt-0].addr)
//line a.y:673
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_BRANCH
+ yyVAL.addr.Type = D_BRANCH
yyVAL.addr.Offset = yyS[yypt-3].lval + int64(asm.PC)
}
case 125:
if asm.Pass == 2 && yyS[yypt-1].sym.Type != LLAB {
yyerror("undefined label: %s", yyS[yypt-1].sym.Labelname)
}
- yyVAL.addr.Type_ = D_BRANCH
+ yyVAL.addr.Type = D_BRANCH
yyVAL.addr.Offset = yyS[yypt-1].sym.Value + yyS[yypt-0].lval
}
case 126:
//line a.y:691
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_REG
+ yyVAL.addr.Type = D_REG
yyVAL.addr.Reg = int8(yyS[yypt-0].lval)
}
case 127:
//line a.y:703
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_SPR
+ yyVAL.addr.Type = D_SPR
yyVAL.addr.Offset = yyS[yypt-0].lval
}
case 130:
//line a.y:711
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_CREG
+ yyVAL.addr.Type = D_CREG
yyVAL.addr.Reg = NREG /* whole register */
}
case 131:
//line a.y:718
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_SPR
+ yyVAL.addr.Type = D_SPR
yyVAL.addr.Offset = yyS[yypt-0].lval
}
case 132:
//line a.y:726
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_MSR
+ yyVAL.addr.Type = D_MSR
}
case 133:
//line a.y:733
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_SPR
+ yyVAL.addr.Type = D_SPR
yyVAL.addr.Offset = yyS[yypt-0].lval
}
case 134:
//line a.y:739
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = int16(yyS[yypt-3].lval)
+ yyVAL.addr.Type = int16(yyS[yypt-3].lval)
yyVAL.addr.Offset = yyS[yypt-1].lval
}
case 135:
//line a.y:748
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FPSCR
+ yyVAL.addr.Type = D_FPSCR
yyVAL.addr.Reg = NREG
}
case 137:
//line a.y:756
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FPSCR
+ yyVAL.addr.Type = D_FPSCR
yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
}
case 138:
//line a.y:764
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FREG
+ yyVAL.addr.Type = D_FREG
yyVAL.addr.Reg = int8(yyS[yypt-0].lval)
}
case 139:
//line a.y:770
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FREG
+ yyVAL.addr.Type = D_FREG
yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
}
case 140:
//line a.y:778
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_CREG
+ yyVAL.addr.Type = D_CREG
yyVAL.addr.Reg = int8(yyS[yypt-0].lval)
}
case 141:
//line a.y:784
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_CREG
+ yyVAL.addr.Type = D_CREG
yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
}
case 142:
//line a.y:792
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_REG
+ yyVAL.addr.Type = D_REG
yyVAL.addr.Reg = int8(yyS[yypt-0].lval)
}
case 143:
var v uint32
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_CONST
+ yyVAL.addr.Type = D_CONST
mb = int(yyS[yypt-2].lval)
me = int(yyS[yypt-0].lval)
if mb < 0 || mb > 31 || me < 0 || me > 31 {
//line a.y:823
{
yyVAL.addr = yyS[yypt-0].addr
- yyVAL.addr.Type_ = D_CONST
+ yyVAL.addr.Type = D_CONST
}
case 145:
//line a.y:828
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_SCONST
+ yyVAL.addr.Type = D_SCONST
yyVAL.addr.U.Sval = yyS[yypt-0].sval
}
case 146:
//line a.y:836
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FCONST
+ yyVAL.addr.Type = D_FCONST
yyVAL.addr.U.Dval = yyS[yypt-0].dval
}
case 147:
//line a.y:842
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_FCONST
+ yyVAL.addr.Type = D_FCONST
yyVAL.addr.U.Dval = -yyS[yypt-0].dval
}
case 148:
//line a.y:849
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_CONST
+ yyVAL.addr.Type = D_CONST
yyVAL.addr.Offset = yyS[yypt-0].lval
}
case 149:
//line a.y:867
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_OREG
+ yyVAL.addr.Type = D_OREG
yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
yyVAL.addr.Offset = 0
}
//line a.y:874
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_OREG
+ yyVAL.addr.Type = D_OREG
yyVAL.addr.Reg = int8(yyS[yypt-3].lval)
yyVAL.addr.Scale = int8(yyS[yypt-1].lval)
yyVAL.addr.Offset = 0
//line a.y:885
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_OREG
+ yyVAL.addr.Type = D_OREG
yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
yyVAL.addr.Offset = yyS[yypt-3].lval
}
//line a.y:894
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_OREG
+ yyVAL.addr.Type = D_OREG
yyVAL.addr.Name = int8(yyS[yypt-1].lval)
yyVAL.addr.Sym = nil
yyVAL.addr.Offset = yyS[yypt-3].lval
//line a.y:902
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_OREG
+ yyVAL.addr.Type = D_OREG
yyVAL.addr.Name = int8(yyS[yypt-1].lval)
yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-4].sym.Name, 0)
yyVAL.addr.Offset = yyS[yypt-3].lval
//line a.y:910
{
yyVAL.addr = nullgen
- yyVAL.addr.Type_ = D_OREG
+ yyVAL.addr.Type = D_OREG
yyVAL.addr.Name = D_STATIC
yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-6].sym.Name, 0)
yyVAL.addr.Offset = yyS[yypt-3].lval
delete(undef, s)
s.Name = rdstring(b)
s.Extname = rdstring(b)
- s.Type_ = int16(rdint(b))
+ s.Type = int16(rdint(b))
s.Version = int16(rdint(b))
s.Dupok = uint8(rdint(b))
s.External = uint8(rdint(b))
r.Off = int32(rdint(b))
r.Siz = uint8(rdint(b))
r.Done = uint8(rdint(b))
- r.Type_ = int32(rdint(b))
+ r.Type = int32(rdint(b))
r.Add = rdint(b)
r.Xadd = rdint(b)
r.Sym = rdsym(b)
a.U.Branch = rdprog(b)
a.Sym = rdsym(b)
a.Gotype = rdsym(b)
- a.Type_ = int16(rdint(b))
+ a.Type = int16(rdint(b))
a.Index = uint8(rdint(b))
a.Scale = int8(rdint(b))
a.Reg = int8(rdint(b))