/*
* substitute s for v in a
* return failure to substitute
*/
func copysub(a *obj.Addr, v *obj.Addr, s *obj.Addr, f int) int {
if f != 0 {
if copyau(a, v) {
if a.Type == obj.TYPE_SHIFT {
if a.Offset&0xf == int64(v.Reg-arm.REG_R0) {
a.Offset = a.Offset&^0xf | int64(s.Reg)&0xf
}
if (a.Offset&(1<<4) != 0) && (a.Offset>>8)&0xf == int64(v.Reg-arm.REG_R0) {
a.Offset = a.Offset&^(0xf<<8) | (int64(s.Reg)&0xf)<<8
}
} else if a.Type == obj.TYPE_REGREG || a.Type == obj.TYPE_REGREG2 {
if a.Offset == int64(v.Reg) {
a.Offset = int64(s.Reg)
}
if a.Reg == v.Reg {
a.Reg = s.Reg
}
} else {
a.Reg = s.Reg
}
}
}
return 0
}
// scratchFpMem initializes an Addr (field of a Prog)
// to reference the scratchpad memory for movement between
// F and G registers for FP conversions.
func scratchFpMem(s *gc.SSAGenState, a *obj.Addr) {
a.Type = obj.TYPE_MEM
a.Name = obj.NAME_AUTO
a.Node = s.ScratchFpMem
a.Sym = gc.Linksym(s.ScratchFpMem.Sym)
a.Reg = ppc64.REGSP
}
// symbolReference parses a symbol that is known not to be a register.
func (p *Parser) symbolReference(a *obj.Addr, name string, prefix rune) {
// Identifier is a name.
switch prefix {
case 0:
a.Type = obj.TYPE_MEM
case '$':
a.Type = obj.TYPE_ADDR
case '*':
a.Type = obj.TYPE_INDIR
}
// Weirdness with statics: Might now have "<>".
isStatic := 0 // TODO: Really a boolean, but Linklookup wants a "version" integer.
if p.peek() == '<' {
isStatic = 1
p.next()
p.get('>')
}
if p.peek() == '+' || p.peek() == '-' {
a.Offset = int64(p.expr())
}
a.Sym = obj.Linklookup(p.ctxt, name, isStatic)
if p.peek() == scanner.EOF {
if prefix != 0 {
p.errorf("illegal addressing mode for symbol %s", name)
}
return
}
// Expect (SB) or (FP), (PC), (SB), or (SP)
p.get('(')
reg := p.get(scanner.Ident).String()
p.get(')')
p.setPseudoRegister(a, reg, isStatic != 0, prefix)
}
func nacladdr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) {
if p.As == ALEAL || p.As == ALEAQ {
return
}
if a.Reg == REG_BP {
ctxt.Diag("invalid address: %v", p)
return
}
if a.Reg == REG_TLS {
a.Reg = REG_BP
}
if a.Type == obj.TYPE_MEM && a.Name == obj.NAME_NONE {
switch a.Reg {
// all ok
case REG_BP, REG_SP, REG_R15:
break
default:
if a.Index != REG_NONE {
ctxt.Diag("invalid address %v", p)
}
a.Index = a.Reg
if a.Index != REG_NONE {
a.Scale = 1
}
a.Reg = REG_R15
}
}
}
func datagostring(sval string, a *obj.Addr) {
symhdr, _ := stringsym(sval)
a.Type = obj.TYPE_MEM
a.Name = obj.NAME_EXTERN
a.Sym = symhdr
a.Offset = 0
}
// copysub substitute s for v in a.
// copysub returns true on failure to substitute. TODO(dfc) reverse this logic, copysub should return false on failure
func copysub(a *obj.Addr, v *obj.Addr, s *obj.Addr, f bool) bool {
if copyas(a, v) {
if s.Reg >= x86.REG_AX && s.Reg <= x86.REG_R15 || s.Reg >= x86.REG_X0 && s.Reg <= x86.REG_X0+15 {
if f {
a.Reg = s.Reg
}
}
return false
}
if regtyp(v) {
if a.Type == obj.TYPE_MEM && a.Reg == v.Reg {
if (s.Reg == x86.REG_BP || s.Reg == x86.REG_R13) && a.Index != x86.REG_NONE {
return true /* can't use BP-base with index */
}
if f {
a.Reg = s.Reg
}
}
if a.Index == v.Reg {
if f {
a.Index = s.Reg
}
}
}
return false
}
// registerList parses an ARM register list expression, a list of registers in [].
// There may be comma-separated ranges or individual registers, as in
// [R1,R3-R5]. Only R0 through R15 may appear.
// The opening bracket has been consumed.
func (p *Parser) registerList(a *obj.Addr) {
// One range per loop.
var bits uint16
for {
tok := p.next()
if tok.ScanToken == ']' {
break
}
lo := p.registerNumber(tok.String())
hi := lo
if p.peek() == '-' {
p.next()
hi = p.registerNumber(p.next().String())
}
if hi < lo {
lo, hi = hi, lo
}
for lo <= hi {
if bits&(1<<lo) != 0 {
p.errorf("register R%d already in list", lo)
}
bits |= 1 << lo
lo++
}
if p.peek() != ']' {
p.get(',')
}
}
a.Type = obj.TYPE_REGLIST
a.Offset = int64(bits)
}
func Datastring(s string, a *obj.Addr) {
_, symdata := stringsym(s)
a.Type = obj.TYPE_MEM
a.Name = obj.NAME_EXTERN
a.Sym = symdata
a.Offset = 0
a.Etype = uint8(Simtype[TINT])
}
// copysub replaces v with s in a if f!=0 or indicates it if could if f==0.
// Returns 1 on failure to substitute (it always succeeds on mips).
func copysub(a *obj.Addr, v *obj.Addr, s *obj.Addr, f int) int {
if f != 0 {
if copyau(a, v) {
a.Reg = s.Reg
}
}
return 0
}
// setPseudoRegister sets the NAME field of addr for a pseudo-register reference such as (SB).
func (p *Parser) setPseudoRegister(addr *obj.Addr, reg string, isStatic bool, prefix rune) {
if addr.Reg != 0 {
p.errorf("internal error: reg %s already set in pseudo", reg)
}
switch reg {
case "FP":
addr.Name = obj.NAME_PARAM
case "PC":
if prefix != 0 {
p.errorf("illegal addressing mode for PC")
}
addr.Type = obj.TYPE_BRANCH // We set the type and leave NAME untouched. See asmJump.
case "SB":
addr.Name = obj.NAME_EXTERN
if isStatic {
addr.Name = obj.NAME_STATIC
}
case "SP":
addr.Name = obj.NAME_AUTO // The pseudo-stack.
default:
p.errorf("expected pseudo-register; found %s", reg)
}
if prefix == '$' {
addr.Type = obj.TYPE_ADDR
}
}
// registerList parses an ARM register list expression, a list of registers in [].
// There may be comma-separated ranges or individual registers, as in
// [R1,R3-R5]. Only R0 through R15 may appear.
// The opening bracket has been consumed.
func (p *Parser) registerList(a *obj.Addr) {
// One range per loop.
const maxReg = 16
var bits uint16
ListLoop:
for {
tok := p.next()
switch tok.ScanToken {
case ']':
break ListLoop
case scanner.EOF:
p.errorf("missing ']' in register list")
return
}
// Parse the upper and lower bounds.
lo := p.registerNumber(tok.String())
hi := lo
if p.peek() == '-' {
p.next()
hi = p.registerNumber(p.next().String())
}
if hi < lo {
lo, hi = hi, lo
}
// Check there are no duplicates in the register list.
for i := 0; lo <= hi && i < maxReg; i++ {
if bits&(1<<lo) != 0 {
p.errorf("register R%d already in list", lo)
}
bits |= 1 << lo
lo++
}
if p.peek() != ']' {
p.get(',')
}
}
a.Type = obj.TYPE_REGLIST
a.Offset = int64(bits)
}
func Datastring(s string, a *obj.Addr) {
_, symdata := stringsym(s)
a.Type = obj.TYPE_MEM
a.Name = obj.NAME_EXTERN
a.Sym = Linksym(symdata)
a.Node = symdata.Def
a.Offset = 0
a.Etype = Simtype[TINT]
}
func datagostring(sval string, a *obj.Addr) {
symhdr, _ := stringsym(sval)
a.Type = obj.TYPE_MEM
a.Name = obj.NAME_EXTERN
a.Sym = Linksym(symhdr)
a.Node = symhdr.Def
a.Offset = 0
a.Etype = TSTRING
}
func Datastring(s string, a *obj.Addr) {
sym := stringsym(s)
a.Type = obj.TYPE_MEM
a.Name = obj.NAME_EXTERN
a.Sym = Linksym(sym)
a.Node = sym.Def
a.Offset = int64(Widthptr) + int64(Widthint) // skip header
a.Etype = Simtype[TINT]
}
/*
* substitute s for v in a
* return failure to substitute
*/
func copysub(a *obj.Addr, v *obj.Addr, s *obj.Addr, f int) int {
if copyas(a, v) {
reg := int(s.Reg)
if reg >= x86.REG_AX && reg <= x86.REG_DI || reg >= x86.REG_X0 && reg <= x86.REG_X7 {
if f != 0 {
a.Reg = int16(reg)
}
}
return 0
}
if regtyp(v) {
reg := int(v.Reg)
if a.Type == obj.TYPE_MEM && int(a.Reg) == reg {
if (s.Reg == x86.REG_BP) && a.Index != obj.TYPE_NONE {
return 1 /* can't use BP-base with index */
}
if f != 0 {
a.Reg = s.Reg
}
}
// return 0;
if int(a.Index) == reg {
if f != 0 {
a.Index = s.Reg
}
return 0
}
return 0
}
return 0
}
// registerList parses an ARM register list expression, a list of registers in [].
// There may be comma-separated ranges or individual registers, as in
// [R1,R3-R5]. Only R0 through R15 may appear.
// The opening bracket has been consumed.
func (p *Parser) registerList(a *obj.Addr) {
// One range per loop.
var bits uint16
ListLoop:
for {
tok := p.next()
switch tok.ScanToken {
case ']':
break ListLoop
case scanner.EOF:
p.errorf("missing ']' in register list")
return
}
lo := p.registerNumber(tok.String())
hi := lo
if p.peek() == '-' {
p.next()
hi = p.registerNumber(p.next().String())
}
if hi < lo {
lo, hi = hi, lo
}
for lo <= hi {
if bits&(1<<lo) != 0 {
p.errorf("register R%d already in list", lo)
}
bits |= 1 << lo
lo++
}
if p.peek() != ']' {
p.get(',')
}
}
a.Type = obj.TYPE_REGLIST
a.Offset = int64(bits)
}
func addreg(a *obj.Addr, rn int) {
a.Sym = nil
a.Node = nil
a.Offset = 0
a.Type = obj.TYPE_REG
a.Reg = int16(rn)
a.Name = 0
Ostats.Ncvtreg++
}
func indir_cx(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) {
if ctxt.Headtype == obj.Hnacl && p.Mode == 64 {
a.Type = obj.TYPE_MEM
a.Reg = REG_R15
a.Index = REG_CX
a.Scale = 1
return
}
a.Type = obj.TYPE_MEM
a.Reg = REG_CX
}
// Naddr rewrites a to refer to n.
// It assumes that a is zeroed on entry.
func Naddr(a *obj.Addr, n *Node) {
if n == nil {
return
}
if n.Op != ONAME {
Debug['h'] = 1
Dump("naddr", n)
Fatalf("naddr: bad %v %v", n.Op, Ctxt.Dconv(a))
}
a.Offset = n.Xoffset
s := n.Sym
a.Node = n.Orig
if s == nil {
Fatalf("naddr: nil sym %v", n)
}
if n.Name.Method && n.Type != nil && n.Type.Sym != nil && n.Type.Sym.Pkg != nil {
Fatalf("naddr: weird method %v", n)
}
a.Type = obj.TYPE_MEM
switch n.Class {
default:
Fatalf("naddr: ONAME class %v %d\n", n.Sym, n.Class)
case PEXTERN, PFUNC:
a.Name = obj.NAME_EXTERN
case PAUTO:
a.Name = obj.NAME_AUTO
case PPARAM, PPARAMOUT:
a.Name = obj.NAME_PARAM
}
a.Sym = Linksym(s)
}
/*
* ASLL x,y,w
* .. (not use w, not set x y w)
* AXXX w,a,b (a != w)
* .. (not use w)
* (set w)
* ----------- changed to
* ..
* AXXX (x<<y),a,b
* ..
*/
func shiftprop(r *gc.Flow) bool {
p := r.Prog
if p.To.Type != obj.TYPE_REG {
if gc.Debug['P'] != 0 {
fmt.Printf("\tBOTCH: result not reg; FAILURE\n")
}
return false
}
n := p.To.Reg
var a obj.Addr
if p.Reg != 0 && p.Reg != p.To.Reg {
a.Type = obj.TYPE_REG
a.Reg = p.Reg
}
if gc.Debug['P'] != 0 {
fmt.Printf("shiftprop\n%v", p)
}
r1 := r
var p1 *obj.Prog
for {
/* find first use of shift result; abort if shift operands or result are changed */
r1 = gc.Uniqs(r1)
if r1 == nil {
if gc.Debug['P'] != 0 {
fmt.Printf("\tbranch; FAILURE\n")
}
return false
}
if gc.Uniqp(r1) == nil {
if gc.Debug['P'] != 0 {
fmt.Printf("\tmerge; FAILURE\n")
}
return false
}
p1 = r1.Prog
if gc.Debug['P'] != 0 {
fmt.Printf("\n%v", p1)
}
switch copyu(p1, &p.To, nil) {
case 0: /* not used or set */
if (p.From.Type == obj.TYPE_REG && copyu(p1, &p.From, nil) > 1) || (a.Type == obj.TYPE_REG && copyu(p1, &a, nil) > 1) {
if gc.Debug['P'] != 0 {
fmt.Printf("\targs modified; FAILURE\n")
}
return false
}
continue
case 3: /* set, not used */
{
if gc.Debug['P'] != 0 {
fmt.Printf("\tBOTCH: noref; FAILURE\n")
}
return false
}
}
break
}
/* check whether substitution can be done */
switch p1.As {
default:
if gc.Debug['P'] != 0 {
fmt.Printf("\tnon-dpi; FAILURE\n")
}
return false
case arm.AAND,
arm.AEOR,
arm.AADD,
arm.AADC,
arm.AORR,
arm.ASUB,
arm.ASBC,
arm.ARSB,
arm.ARSC:
if p1.Reg == n || (p1.Reg == 0 && p1.To.Type == obj.TYPE_REG && p1.To.Reg == n) {
if p1.From.Type != obj.TYPE_REG {
if gc.Debug['P'] != 0 {
fmt.Printf("\tcan't swap; FAILURE\n")
}
return false
}
p1.Reg = p1.From.Reg
p1.From.Reg = n
switch p1.As {
case arm.ASUB:
p1.As = arm.ARSB
case arm.ARSB:
p1.As = arm.ASUB
case arm.ASBC:
p1.As = arm.ARSC
case arm.ARSC:
p1.As = arm.ASBC
}
if gc.Debug['P'] != 0 {
fmt.Printf("\t=>%v", p1)
}
}
fallthrough
case arm.ABIC,
arm.ATST,
arm.ACMP,
arm.ACMN:
if p1.Reg == n {
if gc.Debug['P'] != 0 {
fmt.Printf("\tcan't swap; FAILURE\n")
}
return false
}
if p1.Reg == 0 && p1.To.Reg == n {
if gc.Debug['P'] != 0 {
fmt.Printf("\tshift result used twice; FAILURE\n")
}
return false
}
// case AMVN:
if p1.From.Type == obj.TYPE_SHIFT {
if gc.Debug['P'] != 0 {
fmt.Printf("\tshift result used in shift; FAILURE\n")
}
return false
}
if p1.From.Type != obj.TYPE_REG || p1.From.Reg != n {
if gc.Debug['P'] != 0 {
fmt.Printf("\tBOTCH: where is it used?; FAILURE\n")
}
return false
}
}
/* check whether shift result is used subsequently */
p2 := p1
if p1.To.Reg != n {
var p1 *obj.Prog
for {
r1 = gc.Uniqs(r1)
if r1 == nil {
if gc.Debug['P'] != 0 {
fmt.Printf("\tinconclusive; FAILURE\n")
}
return false
}
p1 = r1.Prog
if gc.Debug['P'] != 0 {
fmt.Printf("\n%v", p1)
}
switch copyu(p1, &p.To, nil) {
case 0: /* not used or set */
continue
case 3: /* set, not used */
break
default: /* used */
if gc.Debug['P'] != 0 {
fmt.Printf("\treused; FAILURE\n")
}
return false
}
break
}
}
/* make the substitution */
p2.From.Reg = 0
o := p.Reg
if o == 0 {
o = p.To.Reg
}
o &= 15
switch p.From.Type {
case obj.TYPE_CONST:
o |= int16(p.From.Offset&0x1f) << 7
case obj.TYPE_REG:
o |= 1<<4 | (p.From.Reg&15)<<8
}
switch p.As {
case arm.ASLL:
o |= 0 << 5
case arm.ASRL:
o |= 1 << 5
case arm.ASRA:
o |= 2 << 5
}
p2.From = obj.Addr{}
p2.From.Type = obj.TYPE_SHIFT
p2.From.Offset = int64(o)
if gc.Debug['P'] != 0 {
fmt.Printf("\t=>%v\tSUCCEED\n", p2)
}
return true
}
// copysub replaces v with s in a if f==true or indicates it if could if f==false.
// Returns true on failure to substitute (it always succeeds on ppc64).
// TODO(dfc) remove unused return value and callers where f=false.
func copysub(a *obj.Addr, v *obj.Addr, s *obj.Addr, f bool) bool {
if f && copyau(a, v) {
a.Reg = s.Reg
}
return false
}
func mkvar(f *Flow, a *obj.Addr) Bits {
// mark registers used
if a.Type == obj.TYPE_NONE {
return zbits
}
r := f.Data.(*Reg)
r.use1.b[0] |= Thearch.Doregbits(int(a.Index)) // TODO: Use RtoB
var n int
switch a.Type {
default:
regu := Thearch.Doregbits(int(a.Reg)) | Thearch.RtoB(int(a.Reg)) // TODO: Use RtoB
if regu == 0 {
return zbits
}
bit := zbits
bit.b[0] = regu
return bit
// TODO(rsc): Remove special case here.
case obj.TYPE_ADDR:
var bit Bits
if Thearch.Thechar == '0' || Thearch.Thechar == '5' || Thearch.Thechar == '7' || Thearch.Thechar == '9' {
goto memcase
}
a.Type = obj.TYPE_MEM
bit = mkvar(f, a)
setaddrs(bit)
a.Type = obj.TYPE_ADDR
Ostats.Naddr++
return zbits
memcase:
fallthrough
case obj.TYPE_MEM:
if r != nil {
r.use1.b[0] |= Thearch.RtoB(int(a.Reg))
}
/* NOTE: 5g did
if(r->f.prog->scond & (C_PBIT|C_WBIT))
r->set.b[0] |= RtoB(a->reg);
*/
switch a.Name {
default:
// Note: This case handles NAME_EXTERN and NAME_STATIC.
// We treat these as requiring eager writes to memory, due to
// the possibility of a fault handler looking at them, so there is
// not much point in registerizing the loads.
// If we later choose the set of candidate variables from a
// larger list, these cases could be deprioritized instead of
// removed entirely.
return zbits
case obj.NAME_PARAM,
obj.NAME_AUTO:
n = int(a.Name)
}
}
node, _ := a.Node.(*Node)
if node == nil || node.Op != ONAME || node.Orig == nil {
return zbits
}
node = node.Orig
if node.Orig != node {
Fatalf("%v: bad node", Ctxt.Dconv(a))
}
if node.Sym == nil || node.Sym.Name[0] == '.' {
return zbits
}
et := EType(a.Etype)
o := a.Offset
w := a.Width
if w < 0 {
Fatalf("bad width %d for %v", w, Ctxt.Dconv(a))
}
flag := 0
var v *Var
for i := 0; i < nvar; i++ {
v = &vars[i]
if v.node == node && int(v.name) == n {
if v.offset == o {
if v.etype == et {
if int64(v.width) == w {
// TODO(rsc): Remove special case for arm here.
if flag == 0 || Thearch.Thechar != '5' {
return blsh(uint(i))
}
}
}
}
// if they overlap, disable both
if overlap_reg(v.offset, v.width, o, int(w)) {
// print("disable overlap %s %d %d %d %d, %E != %E\n", s->name, v->offset, v->width, o, w, v->etype, et);
v.addr = 1
flag = 1
}
}
}
switch et {
case 0, TFUNC:
return zbits
}
if nvar >= NVAR {
if Debug['w'] > 1 && node != nil {
Fatalf("variable not optimized: %v", Nconv(node, obj.FmtSharp))
}
if Debug['v'] > 0 {
Warn("variable not optimized: %v", Nconv(node, obj.FmtSharp))
}
// If we're not tracking a word in a variable, mark the rest as
// having its address taken, so that we keep the whole thing
// live at all calls. otherwise we might optimize away part of
// a variable but not all of it.
var v *Var
for i := 0; i < nvar; i++ {
v = &vars[i]
if v.node == node {
v.addr = 1
}
}
return zbits
}
i := nvar
nvar++
v = &vars[i]
v.id = i
v.offset = o
v.name = int8(n)
v.etype = et
v.width = int(w)
v.addr = int8(flag) // funny punning
v.node = node
// node->opt is the head of a linked list
// of Vars within the given Node, so that
// we can start at a Var and find all the other
// Vars in the same Go variable.
v.nextinnode, _ = node.Opt().(*Var)
node.SetOpt(v)
bit := blsh(uint(i))
if n == obj.NAME_EXTERN || n == obj.NAME_STATIC {
for z := 0; z < BITS; z++ {
externs.b[z] |= bit.b[z]
}
}
if n == obj.NAME_PARAM {
for z := 0; z < BITS; z++ {
params.b[z] |= bit.b[z]
}
}
if node.Class == PPARAM {
for z := 0; z < BITS; z++ {
ivar.b[z] |= bit.b[z]
}
}
if node.Class == PPARAMOUT {
for z := 0; z < BITS; z++ {
ovar.b[z] |= bit.b[z]
}
}
// Treat values with their address taken as live at calls,
// because the garbage collector's liveness analysis in plive.go does.
// These must be consistent or else we will elide stores and the garbage
// collector will see uninitialized data.
// The typical case where our own analysis is out of sync is when the
// node appears to have its address taken but that code doesn't actually
// get generated and therefore doesn't show up as an address being
// taken when we analyze the instruction stream.
// One instance of this case is when a closure uses the same name as
// an outer variable for one of its own variables declared with :=.
// The parser flags the outer variable as possibly shared, and therefore
// sets addrtaken, even though it ends up not being actually shared.
// If we were better about _ elision, _ = &x would suffice too.
// The broader := in a closure problem is mentioned in a comment in
// closure.go:/^typecheckclosure and dcl.go:/^oldname.
if node.Addrtaken {
v.addr = 1
}
// Disable registerization for globals, because:
// (1) we might panic at any time and we want the recovery code
// to see the latest values (issue 1304).
// (2) we don't know what pointers might point at them and we want
// loads via those pointers to see updated values and vice versa (issue 7995).
//
// Disable registerization for results if using defer, because the deferred func
// might recover and return, causing the current values to be used.
if node.Class == PEXTERN || (hasdefer && node.Class == PPARAMOUT) {
v.addr = 1
}
if Debug['R'] != 0 {
fmt.Printf("bit=%2d et=%v w=%d+%d %v %v flag=%d\n", i, Econv(et), o, w, Nconv(node, obj.FmtSharp), Ctxt.Dconv(a), v.addr)
}
Ostats.Nvar++
return bit
}
// registerIndirect parses the general form of a register indirection.
// It is can be (R1), (R2*scale), or (R1)(R2*scale) where R1 may be a simple
// register or register pair R:R or (R, R) or (R+R).
// Or it might be a pseudo-indirection like (FP).
// We are sitting on the opening parenthesis.
func (p *Parser) registerIndirect(a *obj.Addr, prefix rune) {
p.get('(')
tok := p.next()
name := tok.String()
r1, r2, scale, ok := p.register(name, 0)
if !ok {
p.errorf("indirect through non-register %s", tok)
}
p.get(')')
a.Type = obj.TYPE_MEM
if r1 < 0 {
// Pseudo-register reference.
if r2 != 0 {
p.errorf("cannot use pseudo-register in pair")
return
}
// For SB, SP, and FP, there must be a name here. 0(FP) is not legal.
if name != "PC" && a.Name == obj.NAME_NONE {
p.errorf("cannot reference %s without a symbol", name)
}
p.setPseudoRegister(a, name, false, prefix)
return
}
a.Reg = r1
if r2 != 0 {
// TODO: Consistency in the encoding would be nice here.
if p.arch.Thechar == '5' || p.arch.Thechar == '7' {
// Special form
// ARM: destination register pair (R1, R2).
// ARM64: register pair (R1, R2) for LDP/STP.
if prefix != 0 || scale != 0 {
p.errorf("illegal address mode for register pair")
return
}
a.Type = obj.TYPE_REGREG
a.Offset = int64(r2)
// Nothing may follow
return
}
if p.arch.Thechar == '9' {
// Special form for PPC64: (R1+R2); alias for (R1)(R2*1).
if prefix != 0 || scale != 0 {
p.errorf("illegal address mode for register+register")
return
}
a.Type = obj.TYPE_MEM
a.Scale = 1
a.Index = r2
// Nothing may follow.
return
}
}
if r2 != 0 {
p.errorf("indirect through register pair")
}
if prefix == '$' {
a.Type = obj.TYPE_ADDR
}
if r1 == arch.RPC && prefix != 0 {
p.errorf("illegal addressing mode for PC")
}
if scale == 0 && p.peek() == '(' {
// General form (R)(R*scale).
p.next()
tok := p.next()
r1, r2, scale, ok = p.register(tok.String(), 0)
if !ok {
p.errorf("indirect through non-register %s", tok)
}
if r2 != 0 {
p.errorf("unimplemented two-register form")
}
a.Index = r1
a.Scale = int16(scale)
p.get(')')
} else if scale != 0 {
// First (R) was missing, all we have is (R*scale).
a.Reg = 0
a.Index = r1
a.Scale = int16(scale)
}
}
func Addrconst(a *obj.Addr, v int64) {
a.Sym = nil
a.Type = obj.TYPE_CONST
a.Offset = v
}
/*
* generate code to compute address of n,
* a reference to a (perhaps nested) field inside
* an array or struct.
* return 0 on failure, 1 on success.
* on success, leaves usable address in a.
*
* caller is responsible for calling sudoclean
* after successful sudoaddable,
* to release the register used for a.
*/
func sudoaddable(as int, n *gc.Node, a *obj.Addr) bool {
if n.Type == nil {
return false
}
*a = obj.Addr{}
switch n.Op {
case gc.OLITERAL:
if !gc.Isconst(n, gc.CTINT) {
break
}
v := n.Int()
if v >= 32000 || v <= -32000 {
break
}
switch as {
default:
return false
case arm.AADD,
arm.ASUB,
arm.AAND,
arm.AORR,
arm.AEOR,
arm.AMOVB,
arm.AMOVBS,
arm.AMOVBU,
arm.AMOVH,
arm.AMOVHS,
arm.AMOVHU,
arm.AMOVW:
break
}
cleani += 2
reg := &clean[cleani-1]
reg1 := &clean[cleani-2]
reg.Op = gc.OEMPTY
reg1.Op = gc.OEMPTY
gc.Naddr(a, n)
return true
case gc.ODOT,
gc.ODOTPTR:
cleani += 2
reg := &clean[cleani-1]
reg1 := &clean[cleani-2]
reg.Op = gc.OEMPTY
reg1.Op = gc.OEMPTY
var nn *gc.Node
var oary [10]int64
o := gc.Dotoffset(n, oary[:], &nn)
if nn == nil {
sudoclean()
return false
}
if nn.Addable && o == 1 && oary[0] >= 0 {
// directly addressable set of DOTs
n1 := *nn
n1.Type = n.Type
n1.Xoffset += oary[0]
gc.Naddr(a, &n1)
return true
}
gc.Regalloc(reg, gc.Types[gc.Tptr], nil)
n1 := *reg
n1.Op = gc.OINDREG
if oary[0] >= 0 {
gc.Agen(nn, reg)
n1.Xoffset = oary[0]
} else {
gc.Cgen(nn, reg)
gc.Cgen_checknil(reg)
n1.Xoffset = -(oary[0] + 1)
}
for i := 1; i < o; i++ {
if oary[i] >= 0 {
gc.Fatal("can't happen")
}
gins(arm.AMOVW, &n1, reg)
gc.Cgen_checknil(reg)
n1.Xoffset = -(oary[i] + 1)
}
a.Type = obj.TYPE_NONE
a.Name = obj.NAME_NONE
n1.Type = n.Type
gc.Naddr(a, &n1)
return true
case gc.OINDEX:
return false
}
return false
}
// operand parses a general operand and stores the result in *a.
func (p *Parser) operand(a *obj.Addr) bool {
//fmt.Printf("Operand: %v\n", p.input)
if len(p.input) == 0 {
p.errorf("empty operand: cannot happen")
return false
}
// General address (with a few exceptions) looks like
// $sym±offset(SB)(reg)(index*scale)
// Exceptions are:
//
// R1
// offset
// $offset
// Every piece is optional, so we scan left to right and what
// we discover tells us where we are.
// Prefix: $.
var prefix rune
switch tok := p.peek(); tok {
case '$', '*':
prefix = rune(tok)
p.next()
}
// Symbol: sym±offset(SB)
tok := p.next()
name := tok.String()
if tok.ScanToken == scanner.Ident && !p.atStartOfRegister(name) {
// We have a symbol. Parse $sym±offset(symkind)
p.symbolReference(a, name, prefix)
// fmt.Printf("SYM %s\n", obj.Dconv(&emptyProg, 0, a))
if p.peek() == scanner.EOF {
return true
}
}
// Special register list syntax for arm: [R1,R3-R7]
if tok.ScanToken == '[' {
if prefix != 0 {
p.errorf("illegal use of register list")
}
p.registerList(a)
p.expect(scanner.EOF)
return true
}
// Register: R1
if tok.ScanToken == scanner.Ident && p.atStartOfRegister(name) {
if p.atRegisterShift() {
// ARM shifted register such as R1<<R2 or R1>>2.
a.Type = obj.TYPE_SHIFT
a.Offset = p.registerShift(tok.String(), prefix)
if p.peek() == '(' {
// Can only be a literal register here.
p.next()
tok := p.next()
name := tok.String()
if !p.atStartOfRegister(name) {
p.errorf("expected register; found %s", name)
}
a.Reg, _ = p.registerReference(name)
p.get(')')
}
} else if r1, r2, scale, ok := p.register(tok.String(), prefix); ok {
if scale != 0 {
p.errorf("expected simple register reference")
}
a.Type = obj.TYPE_REG
a.Reg = r1
if r2 != 0 {
// Form is R1:R2. It is on RHS and the second register
// needs to go into the LHS.
panic("cannot happen (Addr.Reg2)")
}
}
// fmt.Printf("REG %s\n", obj.Dconv(&emptyProg, 0, a))
p.expect(scanner.EOF)
return true
}
// Constant.
haveConstant := false
switch tok.ScanToken {
case scanner.Int, scanner.Float, scanner.String, scanner.Char, '+', '-', '~':
haveConstant = true
case '(':
// Could be parenthesized expression or (R).
rname := p.next().String()
p.back()
haveConstant = !p.atStartOfRegister(rname)
if !haveConstant {
p.back() // Put back the '('.
}
}
if haveConstant {
p.back()
if p.have(scanner.Float) {
if prefix != '$' {
p.errorf("floating-point constant must be an immediate")
}
a.Type = obj.TYPE_FCONST
a.Val = p.floatExpr()
// fmt.Printf("FCONST %s\n", obj.Dconv(&emptyProg, 0, a))
p.expect(scanner.EOF)
return true
}
if p.have(scanner.String) {
if prefix != '$' {
p.errorf("string constant must be an immediate")
}
str, err := strconv.Unquote(p.get(scanner.String).String())
if err != nil {
p.errorf("string parse error: %s", err)
}
a.Type = obj.TYPE_SCONST
a.Val = str
// fmt.Printf("SCONST %s\n", obj.Dconv(&emptyProg, 0, a))
p.expect(scanner.EOF)
return true
}
a.Offset = int64(p.expr())
if p.peek() != '(' {
switch prefix {
case '$':
a.Type = obj.TYPE_CONST
case '*':
a.Type = obj.TYPE_INDIR // Can appear but is illegal, will be rejected by the linker.
default:
a.Type = obj.TYPE_MEM
}
// fmt.Printf("CONST %d %s\n", a.Offset, obj.Dconv(&emptyProg, 0, a))
p.expect(scanner.EOF)
return true
}
// fmt.Printf("offset %d \n", a.Offset)
}
// Register indirection: (reg) or (index*scale). We are on the opening paren.
p.registerIndirect(a, prefix)
// fmt.Printf("DONE %s\n", p.arch.Dconv(&emptyProg, 0, a))
p.expect(scanner.EOF)
return true
}
func (yyrcvr *yyParserImpl) Parse(yylex yyLexer) int {
var yyn int
var yylval yySymType
var yyVAL yySymType
var yyDollar []yySymType
yyS := make([]yySymType, yyMaxDepth)
Nerrs := 0 /* number of errors */
Errflag := 0 /* error recovery flag */
yystate := 0
yychar := -1
yytoken := -1 // yychar translated into internal numbering
yyrcvr.lookahead = func() int { return yychar }
defer func() {
// Make sure we report no lookahead when not parsing.
yystate = -1
yychar = -1
yytoken = -1
}()
yyp := -1
goto yystack
ret0:
return 0
ret1:
return 1
yystack:
/* put a state and value onto the stack */
if yyDebug >= 4 {
__yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate))
}
yyp++
if yyp >= len(yyS) {
nyys := make([]yySymType, len(yyS)*2)
copy(nyys, yyS)
yyS = nyys
}
yyS[yyp] = yyVAL
yyS[yyp].yys = yystate
yynewstate:
yyn = yyPact[yystate]
if yyn <= yyFlag {
goto yydefault /* simple state */
}
if yychar < 0 {
yychar, yytoken = yylex1(yylex, &yylval)
}
yyn += yytoken
if yyn < 0 || yyn >= yyLast {
goto yydefault
}
yyn = yyAct[yyn]
if yyChk[yyn] == yytoken { /* valid shift */
yychar = -1
yytoken = -1
yyVAL = yylval
yystate = yyn
if Errflag > 0 {
Errflag--
}
goto yystack
}
yydefault:
/* default state action */
yyn = yyDef[yystate]
if yyn == -2 {
if yychar < 0 {
yychar, yytoken = yylex1(yylex, &yylval)
}
/* look through exception table */
xi := 0
for {
if yyExca[xi+0] == -1 && yyExca[xi+1] == yystate {
break
}
xi += 2
}
for xi += 2; ; xi += 2 {
yyn = yyExca[xi+0]
if yyn < 0 || yyn == yytoken {
break
}
}
yyn = yyExca[xi+1]
if yyn < 0 {
goto ret0
}
}
if yyn == 0 {
/* error ... attempt to resume parsing */
switch Errflag {
case 0: /* brand new error */
yylex.Error(yyErrorMessage(yystate, yytoken))
Nerrs++
if yyDebug >= 1 {
__yyfmt__.Printf("%s", yyStatname(yystate))
__yyfmt__.Printf(" saw %s\n", yyTokname(yytoken))
}
fallthrough
case 1, 2: /* incompletely recovered error ... try again */
Errflag = 3
/* find a state where "error" is a legal shift action */
for yyp >= 0 {
yyn = yyPact[yyS[yyp].yys] + yyErrCode
if yyn >= 0 && yyn < yyLast {
yystate = yyAct[yyn] /* simulate a shift of "error" */
if yyChk[yystate] == yyErrCode {
goto yystack
}
}
/* the current p has no shift on "error", pop stack */
if yyDebug >= 2 {
__yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys)
}
yyp--
}
/* there is no state on the stack with an error shift ... abort */
goto ret1
case 3: /* no shift yet; clobber input char */
if yyDebug >= 2 {
__yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken))
}
if yytoken == yyEofCode {
goto ret1
}
yychar = -1
yytoken = -1
goto yynewstate /* try again in the same state */
}
}
/* reduction by production yyn */
if yyDebug >= 2 {
__yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate))
}
yynt := yyn
yypt := yyp
_ = yypt // guard against "declared and not used"
yyp -= yyR2[yyn]
// yyp is now the index of $0. Perform the default action. Iff the
// reduced production is ε, $1 is possibly out of range.
if yyp+1 >= len(yyS) {
nyys := make([]yySymType, len(yyS)*2)
copy(nyys, yyS)
yyS = nyys
}
yyVAL = yyS[yyp+1]
/* consult goto table to find next state */
yyn = yyR1[yyn]
yyg := yyPgo[yyn]
yyj := yyg + yyS[yyp].yys + 1
if yyj >= yyLast {
yystate = yyAct[yyg]
} else {
yystate = yyAct[yyj]
if yyChk[yystate] != -yyn {
yystate = yyAct[yyg]
}
}
// dummy call; replaced with literal code
switch yynt {
case 2:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:73
{
stmtline = asm.Lineno
}
case 4:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:80
{
yyDollar[1].sym = asm.LabelLookup(yyDollar[1].sym)
if yyDollar[1].sym.Type == LLAB && yyDollar[1].sym.Value != int64(asm.PC) {
yyerror("redeclaration of %s", yyDollar[1].sym.Labelname)
}
yyDollar[1].sym.Type = LLAB
yyDollar[1].sym.Value = int64(asm.PC)
}
case 6:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:90
{
yyDollar[1].sym.Type = LVAR
yyDollar[1].sym.Value = int64(yyDollar[3].lval)
}
case 7:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:95
{
if yyDollar[1].sym.Value != int64(yyDollar[3].lval) {
yyerror("redeclaration of %s", yyDollar[1].sym.Name)
}
yyDollar[1].sym.Value = int64(yyDollar[3].lval)
}
case 11:
yyDollar = yyS[yypt-7 : yypt+1]
//line a.y:110
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, yyDollar[5].lval, &yyDollar[7].addr)
}
case 12:
yyDollar = yyS[yypt-6 : yypt+1]
//line a.y:114
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, yyDollar[5].lval, &nullgen)
}
case 13:
yyDollar = yyS[yypt-5 : yypt+1]
//line a.y:118
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &yyDollar[5].addr)
}
case 14:
yyDollar = yyS[yypt-5 : yypt+1]
//line a.y:125
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &yyDollar[5].addr)
}
case 15:
yyDollar = yyS[yypt-5 : yypt+1]
//line a.y:132
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &yyDollar[5].addr)
}
case 16:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:139
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &nullgen, 0, &yyDollar[4].addr)
}
case 17:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:143
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &nullgen, 0, &yyDollar[4].addr)
}
case 18:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:150
{
outcode(yyDollar[1].lval, Always, &nullgen, 0, &yyDollar[3].addr)
}
case 19:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:157
{
outcode(yyDollar[1].lval, Always, &nullgen, 0, &yyDollar[3].addr)
}
case 20:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:164
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &nullgen, 0, &yyDollar[4].addr)
}
case 21:
yyDollar = yyS[yypt-6 : yypt+1]
//line a.y:171
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, yyDollar[5].lval, &nullgen)
}
case 22:
yyDollar = yyS[yypt-7 : yypt+1]
//line a.y:178
{
var g obj.Addr
g = nullgen
g.Type = obj.TYPE_REGLIST
g.Offset = int64(yyDollar[6].lval)
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &g)
}
case 23:
yyDollar = yyS[yypt-7 : yypt+1]
//line a.y:187
{
var g obj.Addr
g = nullgen
g.Type = obj.TYPE_REGLIST
g.Offset = int64(yyDollar[4].lval)
outcode(yyDollar[1].lval, yyDollar[2].lval, &g, 0, &yyDollar[7].addr)
}
case 24:
yyDollar = yyS[yypt-7 : yypt+1]
//line a.y:199
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[5].addr, int32(yyDollar[3].addr.Reg), &yyDollar[7].addr)
}
case 25:
yyDollar = yyS[yypt-6 : yypt+1]
//line a.y:203
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[5].addr, int32(yyDollar[3].addr.Reg), &yyDollar[3].addr)
}
case 26:
yyDollar = yyS[yypt-6 : yypt+1]
//line a.y:207
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[4].addr, int32(yyDollar[6].addr.Reg), &yyDollar[6].addr)
}
case 27:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:214
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &nullgen, 0, &nullgen)
}
case 28:
yyDollar = yyS[yypt-5 : yypt+1]
//line a.y:221
{
asm.Settext(yyDollar[2].addr.Sym)
outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[5].addr)
if asm.Pass > 1 {
lastpc.From3 = new(obj.Addr)
}
}
case 29:
yyDollar = yyS[yypt-7 : yypt+1]
//line a.y:229
{
asm.Settext(yyDollar[2].addr.Sym)
outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[7].addr)
if asm.Pass > 1 {
lastpc.From3 = new(obj.Addr)
lastpc.From3.Type = obj.TYPE_CONST
lastpc.From3.Offset = int64(yyDollar[4].lval)
}
}
case 30:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:242
{
asm.Settext(yyDollar[2].addr.Sym)
outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[4].addr)
if asm.Pass > 1 {
lastpc.From3 = new(obj.Addr)
}
}
case 31:
yyDollar = yyS[yypt-6 : yypt+1]
//line a.y:250
{
asm.Settext(yyDollar[2].addr.Sym)
outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[6].addr)
if asm.Pass > 1 {
lastpc.From3 = new(obj.Addr)
lastpc.From3.Type = obj.TYPE_CONST
lastpc.From3.Offset = int64(yyDollar[4].lval)
}
}
case 32:
yyDollar = yyS[yypt-6 : yypt+1]
//line a.y:264
{
outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[6].addr)
if asm.Pass > 1 {
lastpc.From3 = new(obj.Addr)
lastpc.From3.Type = obj.TYPE_CONST
lastpc.From3.Offset = int64(yyDollar[4].lval)
}
}
case 33:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:276
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &nullgen)
}
case 34:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:283
{
outcode(yyDollar[1].lval, Always, &nullgen, 0, &yyDollar[3].addr)
}
case 35:
yyDollar = yyS[yypt-5 : yypt+1]
//line a.y:290
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &yyDollar[5].addr)
}
case 36:
yyDollar = yyS[yypt-5 : yypt+1]
//line a.y:294
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, 0, &yyDollar[5].addr)
}
case 37:
yyDollar = yyS[yypt-7 : yypt+1]
//line a.y:298
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, yyDollar[5].lval, &yyDollar[7].addr)
}
case 38:
yyDollar = yyS[yypt-6 : yypt+1]
//line a.y:302
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, int32(yyDollar[5].addr.Reg), &nullgen)
}
case 39:
yyDollar = yyS[yypt-12 : yypt+1]
//line a.y:309
{
var g obj.Addr
g = nullgen
g.Type = obj.TYPE_CONST
g.Offset = int64(
(0xe << 24) | /* opcode */
(yyDollar[1].lval << 20) | /* MCR/MRC */
((yyDollar[2].lval ^ C_SCOND_XOR) << 28) | /* scond */
((yyDollar[3].lval & 15) << 8) | /* coprocessor number */
((yyDollar[5].lval & 7) << 21) | /* coprocessor operation */
((yyDollar[7].lval & 15) << 12) | /* arm register */
((yyDollar[9].lval & 15) << 16) | /* Crn */
((yyDollar[11].lval & 15) << 0) | /* Crm */
((yyDollar[12].lval & 7) << 5) | /* coprocessor information */
(1 << 4)) /* must be set */
outcode(AMRC, Always, &nullgen, 0, &g)
}
case 40:
yyDollar = yyS[yypt-7 : yypt+1]
//line a.y:321
{
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, int32(yyDollar[5].addr.Reg), &yyDollar[7].addr)
}
case 41:
yyDollar = yyS[yypt-9 : yypt+1]
//line a.y:329
{
yyDollar[7].addr.Type = obj.TYPE_REGREG2
yyDollar[7].addr.Offset = int64(yyDollar[9].lval)
outcode(yyDollar[1].lval, yyDollar[2].lval, &yyDollar[3].addr, int32(yyDollar[5].addr.Reg), &yyDollar[7].addr)
}
case 42:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:338
{
outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &nullgen)
}
case 43:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:345
{
if yyDollar[2].addr.Type != obj.TYPE_CONST || yyDollar[4].addr.Type != obj.TYPE_CONST {
yyerror("arguments to PCDATA must be integer constants")
}
outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[4].addr)
}
case 44:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:355
{
if yyDollar[2].addr.Type != obj.TYPE_CONST {
yyerror("index for FUNCDATA must be integer constant")
}
if yyDollar[4].addr.Type != obj.NAME_EXTERN && yyDollar[4].addr.Type != obj.NAME_STATIC && yyDollar[4].addr.Type != obj.TYPE_MEM {
yyerror("value for FUNCDATA must be symbol reference")
}
outcode(yyDollar[1].lval, Always, &yyDollar[2].addr, 0, &yyDollar[4].addr)
}
case 45:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:368
{
outcode(yyDollar[1].lval, Always, &nullgen, 0, &nullgen)
}
case 46:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:374
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_TEXTSIZE
yyVAL.addr.Offset = int64(yyDollar[1].lval)
yyVAL.addr.Val = int32(obj.ArgsSizeUnknown)
}
case 47:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:381
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_TEXTSIZE
yyVAL.addr.Offset = -int64(yyDollar[2].lval)
yyVAL.addr.Val = int32(obj.ArgsSizeUnknown)
}
case 48:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:388
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_TEXTSIZE
yyVAL.addr.Offset = int64(yyDollar[1].lval)
yyVAL.addr.Val = int32(yyDollar[3].lval)
}
case 49:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:395
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_TEXTSIZE
yyVAL.addr.Offset = -int64(yyDollar[2].lval)
yyVAL.addr.Val = int32(yyDollar[4].lval)
}
case 50:
yyDollar = yyS[yypt-0 : yypt+1]
//line a.y:403
{
yyVAL.lval = Always
}
case 51:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:407
{
yyVAL.lval = (yyDollar[1].lval & ^C_SCOND) | yyDollar[2].lval
}
case 52:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:411
{
yyVAL.lval = yyDollar[1].lval | yyDollar[2].lval
}
case 55:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:420
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_BRANCH
yyVAL.addr.Offset = int64(yyDollar[1].lval) + int64(asm.PC)
}
case 56:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:426
{
yyDollar[1].sym = asm.LabelLookup(yyDollar[1].sym)
yyVAL.addr = nullgen
if asm.Pass == 2 && yyDollar[1].sym.Type != LLAB {
yyerror("undefined label: %s", yyDollar[1].sym.Labelname)
}
yyVAL.addr.Type = obj.TYPE_BRANCH
yyVAL.addr.Offset = yyDollar[1].sym.Value + int64(yyDollar[2].lval)
}
case 57:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:437
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_CONST
yyVAL.addr.Offset = int64(yyDollar[2].lval)
}
case 58:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:443
{
yyVAL.addr = yyDollar[2].addr
yyVAL.addr.Type = obj.TYPE_ADDR
}
case 59:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:448
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_SCONST
yyVAL.addr.Val = yyDollar[2].sval
}
case 61:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:457
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_FCONST
yyVAL.addr.Val = yyDollar[2].dval
}
case 62:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:463
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_FCONST
yyVAL.addr.Val = -yyDollar[3].dval
}
case 63:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:471
{
yyVAL.lval = 1 << uint(yyDollar[1].lval&15)
}
case 64:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:475
{
yyVAL.lval = 0
for i := yyDollar[1].lval; i <= yyDollar[3].lval; i++ {
yyVAL.lval |= 1 << uint(i&15)
}
for i := yyDollar[3].lval; i <= yyDollar[1].lval; i++ {
yyVAL.lval |= 1 << uint(i&15)
}
}
case 65:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:485
{
yyVAL.lval = (1 << uint(yyDollar[1].lval&15)) | yyDollar[3].lval
}
case 69:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:494
{
yyVAL.addr = yyDollar[1].addr
yyVAL.addr.Reg = int16(yyDollar[3].lval)
}
case 70:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:499
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_REG
yyVAL.addr.Reg = int16(yyDollar[1].lval)
}
case 71:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:505
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_REG
yyVAL.addr.Reg = int16(yyDollar[1].lval)
}
case 72:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:511
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_MEM
yyVAL.addr.Offset = int64(yyDollar[1].lval)
}
case 76:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:522
{
yyVAL.addr = yyDollar[1].addr
if yyDollar[1].addr.Name != obj.NAME_EXTERN && yyDollar[1].addr.Name != obj.NAME_STATIC {
}
}
case 77:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:530
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_MEM
yyVAL.addr.Reg = int16(yyDollar[2].lval)
yyVAL.addr.Offset = 0
}
case 79:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:540
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_MEM
yyVAL.addr.Reg = int16(yyDollar[3].lval)
yyVAL.addr.Offset = int64(yyDollar[1].lval)
}
case 81:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:550
{
yyVAL.addr = yyDollar[1].addr
yyVAL.addr.Type = obj.TYPE_MEM
yyVAL.addr.Reg = int16(yyDollar[3].lval)
}
case 86:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:563
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_CONST
yyVAL.addr.Offset = int64(yyDollar[2].lval)
}
case 87:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:571
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_REG
yyVAL.addr.Reg = int16(yyDollar[1].lval)
}
case 88:
yyDollar = yyS[yypt-5 : yypt+1]
//line a.y:579
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_REGREG
yyVAL.addr.Reg = int16(yyDollar[2].lval)
yyVAL.addr.Offset = int64(yyDollar[4].lval)
}
case 89:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:588
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_SHIFT
yyVAL.addr.Offset = int64(yyDollar[1].lval&15) | int64(yyDollar[4].lval) | (0 << 5)
}
case 90:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:594
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_SHIFT
yyVAL.addr.Offset = int64(yyDollar[1].lval&15) | int64(yyDollar[4].lval) | (1 << 5)
}
case 91:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:600
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_SHIFT
yyVAL.addr.Offset = int64(yyDollar[1].lval&15) | int64(yyDollar[4].lval) | (2 << 5)
}
case 92:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:606
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_SHIFT
yyVAL.addr.Offset = int64(yyDollar[1].lval&15) | int64(yyDollar[4].lval) | (3 << 5)
}
case 93:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:614
{
if yyVAL.lval < REG_R0 || yyVAL.lval > REG_R15 {
print("register value out of range\n")
}
yyVAL.lval = ((yyDollar[1].lval & 15) << 8) | (1 << 4)
}
case 94:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:621
{
if yyVAL.lval < 0 || yyVAL.lval >= 32 {
print("shift value out of range\n")
}
yyVAL.lval = (yyDollar[1].lval & 31) << 7
}
case 96:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:631
{
yyVAL.lval = REGPC
}
case 97:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:635
{
if yyDollar[3].lval < 0 || yyDollar[3].lval >= NREG {
print("register value out of range\n")
}
yyVAL.lval = REG_R0 + yyDollar[3].lval
}
case 99:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:645
{
yyVAL.lval = REGSP
}
case 101:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:652
{
if yyDollar[3].lval < 0 || yyDollar[3].lval >= NREG {
print("register value out of range\n")
}
yyVAL.lval = yyDollar[3].lval // TODO(rsc): REG_C0+$3
}
case 104:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:665
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_REG
yyVAL.addr.Reg = int16(yyDollar[1].lval)
}
case 105:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:671
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_REG
yyVAL.addr.Reg = int16(REG_F0 + yyDollar[3].lval)
}
case 106:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:679
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_MEM
yyVAL.addr.Name = int8(yyDollar[3].lval)
yyVAL.addr.Sym = nil
yyVAL.addr.Offset = int64(yyDollar[1].lval)
}
case 107:
yyDollar = yyS[yypt-5 : yypt+1]
//line a.y:687
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_MEM
yyVAL.addr.Name = int8(yyDollar[4].lval)
yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyDollar[1].sym.Name, 0)
yyVAL.addr.Offset = int64(yyDollar[2].lval)
}
case 108:
yyDollar = yyS[yypt-7 : yypt+1]
//line a.y:695
{
yyVAL.addr = nullgen
yyVAL.addr.Type = obj.TYPE_MEM
yyVAL.addr.Name = obj.NAME_STATIC
yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyDollar[1].sym.Name, 1)
yyVAL.addr.Offset = int64(yyDollar[4].lval)
}
case 109:
yyDollar = yyS[yypt-0 : yypt+1]
//line a.y:704
{
yyVAL.lval = 0
}
case 110:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:708
{
yyVAL.lval = yyDollar[2].lval
}
case 111:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:712
{
yyVAL.lval = -yyDollar[2].lval
}
case 116:
yyDollar = yyS[yypt-1 : yypt+1]
//line a.y:724
{
yyVAL.lval = int32(yyDollar[1].sym.Value)
}
case 117:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:728
{
yyVAL.lval = -yyDollar[2].lval
}
case 118:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:732
{
yyVAL.lval = yyDollar[2].lval
}
case 119:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:736
{
yyVAL.lval = ^yyDollar[2].lval
}
case 120:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:740
{
yyVAL.lval = yyDollar[2].lval
}
case 121:
yyDollar = yyS[yypt-0 : yypt+1]
//line a.y:745
{
yyVAL.lval = 0
}
case 122:
yyDollar = yyS[yypt-2 : yypt+1]
//line a.y:749
{
yyVAL.lval = yyDollar[2].lval
}
case 124:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:756
{
yyVAL.lval = yyDollar[1].lval + yyDollar[3].lval
}
case 125:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:760
{
yyVAL.lval = yyDollar[1].lval - yyDollar[3].lval
}
case 126:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:764
{
yyVAL.lval = yyDollar[1].lval * yyDollar[3].lval
}
case 127:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:768
{
yyVAL.lval = yyDollar[1].lval / yyDollar[3].lval
}
case 128:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:772
{
yyVAL.lval = yyDollar[1].lval % yyDollar[3].lval
}
case 129:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:776
{
yyVAL.lval = yyDollar[1].lval << uint(yyDollar[4].lval)
}
case 130:
yyDollar = yyS[yypt-4 : yypt+1]
//line a.y:780
{
yyVAL.lval = yyDollar[1].lval >> uint(yyDollar[4].lval)
}
case 131:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:784
{
yyVAL.lval = yyDollar[1].lval & yyDollar[3].lval
}
case 132:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:788
{
yyVAL.lval = yyDollar[1].lval ^ yyDollar[3].lval
}
case 133:
yyDollar = yyS[yypt-3 : yypt+1]
//line a.y:792
{
yyVAL.lval = yyDollar[1].lval | yyDollar[3].lval
}
}
goto yystack /* stack new state and value */
}
func Afunclit(a *obj.Addr, n *Node) {
if a.Type == obj.TYPE_ADDR && a.Name == obj.NAME_EXTERN {
a.Type = obj.TYPE_MEM
a.Sym = Linksym(n.Sym)
}
}
// Naddr rewrites a to refer to n.
// It assumes that a is zeroed on entry.
func Naddr(a *obj.Addr, n *Node) {
if n == nil {
return
}
if n.Type != nil && n.Type.Etype != TIDEAL {
// TODO(rsc): This is undone by the selective clearing of width below,
// to match architectures that were not as aggressive in setting width
// during naddr. Those widths must be cleared to avoid triggering
// failures in gins when it detects real but heretofore latent (and one
// hopes innocuous) type mismatches.
// The type mismatches should be fixed and the clearing below removed.
dowidth(n.Type)
a.Width = n.Type.Width
}
switch n.Op {
default:
a := a // copy to let escape into Ctxt.Dconv
Debug['h'] = 1
Dump("naddr", n)
Fatalf("naddr: bad %v %v", Oconv(int(n.Op), 0), Ctxt.Dconv(a))
case OREGISTER:
a.Type = obj.TYPE_REG
a.Reg = n.Reg
a.Sym = nil
if Thearch.Thechar == '8' { // TODO(rsc): Never clear a->width.
a.Width = 0
}
case OINDREG:
a.Type = obj.TYPE_MEM
a.Reg = n.Reg
a.Sym = Linksym(n.Sym)
a.Offset = n.Xoffset
if a.Offset != int64(int32(a.Offset)) {
Yyerror("offset %d too large for OINDREG", a.Offset)
}
if Thearch.Thechar == '8' { // TODO(rsc): Never clear a->width.
a.Width = 0
}
// n->left is PHEAP ONAME for stack parameter.
// compute address of actual parameter on stack.
case OPARAM:
a.Etype = uint8(Simtype[n.Left.Type.Etype])
a.Width = n.Left.Type.Width
a.Offset = n.Xoffset
a.Sym = Linksym(n.Left.Sym)
a.Type = obj.TYPE_MEM
a.Name = obj.NAME_PARAM
a.Node = n.Left.Orig
case OCLOSUREVAR:
if !Curfn.Func.Needctxt {
Fatalf("closurevar without needctxt")
}
a.Type = obj.TYPE_MEM
a.Reg = int16(Thearch.REGCTXT)
a.Sym = nil
a.Offset = n.Xoffset
case OCFUNC:
Naddr(a, n.Left)
a.Sym = Linksym(n.Left.Sym)
case ONAME:
a.Etype = 0
if n.Type != nil {
a.Etype = uint8(Simtype[n.Type.Etype])
}
a.Offset = n.Xoffset
s := n.Sym
a.Node = n.Orig
//if(a->node >= (Node*)&n)
// fatal("stack node");
if s == nil {
s = Lookup(".noname")
}
if n.Name.Method {
if n.Type != nil {
if n.Type.Sym != nil {
if n.Type.Sym.Pkg != nil {
s = Pkglookup(s.Name, n.Type.Sym.Pkg)
}
}
}
}
a.Type = obj.TYPE_MEM
switch n.Class {
default:
Fatalf("naddr: ONAME class %v %d\n", n.Sym, n.Class)
case PEXTERN:
a.Name = obj.NAME_EXTERN
case PAUTO:
a.Name = obj.NAME_AUTO
case PPARAM, PPARAMOUT:
a.Name = obj.NAME_PARAM
case PFUNC:
a.Name = obj.NAME_EXTERN
a.Type = obj.TYPE_ADDR
a.Width = int64(Widthptr)
s = funcsym(s)
}
a.Sym = Linksym(s)
case OLITERAL:
if Thearch.Thechar == '8' {
a.Width = 0
}
switch n.Val().Ctype() {
default:
Fatalf("naddr: const %v", Tconv(n.Type, obj.FmtLong))
case CTFLT:
a.Type = obj.TYPE_FCONST
a.Val = mpgetflt(n.Val().U.(*Mpflt))
case CTINT, CTRUNE:
a.Sym = nil
a.Type = obj.TYPE_CONST
a.Offset = Mpgetfix(n.Val().U.(*Mpint))
case CTSTR:
datagostring(n.Val().U.(string), a)
case CTBOOL:
a.Sym = nil
a.Type = obj.TYPE_CONST
a.Offset = int64(obj.Bool2int(n.Val().U.(bool)))
case CTNIL:
a.Sym = nil
a.Type = obj.TYPE_CONST
a.Offset = 0
}
case OADDR:
Naddr(a, n.Left)
a.Etype = uint8(Tptr)
if Thearch.Thechar != '0' && Thearch.Thechar != '5' && Thearch.Thechar != '7' && Thearch.Thechar != '9' { // TODO(rsc): Do this even for arm, ppc64.
a.Width = int64(Widthptr)
}
if a.Type != obj.TYPE_MEM {
a := a // copy to let escape into Ctxt.Dconv
Fatalf("naddr: OADDR %v (from %v)", Ctxt.Dconv(a), Oconv(int(n.Left.Op), 0))
}
a.Type = obj.TYPE_ADDR
// itable of interface value
case OITAB:
Naddr(a, n.Left)
if a.Type == obj.TYPE_CONST && a.Offset == 0 {
break // itab(nil)
}
a.Etype = uint8(Tptr)
a.Width = int64(Widthptr)
// pointer in a string or slice
case OSPTR:
Naddr(a, n.Left)
if a.Type == obj.TYPE_CONST && a.Offset == 0 {
break // ptr(nil)
}
a.Etype = uint8(Simtype[Tptr])
a.Offset += int64(Array_array)
a.Width = int64(Widthptr)
// len of string or slice
case OLEN:
Naddr(a, n.Left)
if a.Type == obj.TYPE_CONST && a.Offset == 0 {
break // len(nil)
}
a.Etype = uint8(Simtype[TUINT])
a.Offset += int64(Array_nel)
if Thearch.Thechar != '5' { // TODO(rsc): Do this even on arm.
a.Width = int64(Widthint)
}
// cap of string or slice
case OCAP:
Naddr(a, n.Left)
if a.Type == obj.TYPE_CONST && a.Offset == 0 {
break // cap(nil)
}
a.Etype = uint8(Simtype[TUINT])
a.Offset += int64(Array_cap)
if Thearch.Thechar != '5' { // TODO(rsc): Do this even on arm.
a.Width = int64(Widthint)
}
}
return
}
/*
* xtramodes enables the ARM post increment and
* shift offset addressing modes to transform
* MOVW 0(R3),R1
* ADD $4,R3,R3
* into
* MOVW.P 4(R3),R1
* and
* ADD R0,R1
* MOVBU 0(R1),R0
* into
* MOVBU R0<<0(R1),R0
*/
func xtramodes(g *gc.Graph, r *gc.Flow, a *obj.Addr) bool {
p := (*obj.Prog)(r.Prog)
v := obj.Addr(*a)
v.Type = obj.TYPE_REG
r1 := (*gc.Flow)(findpre(r, &v))
if r1 != nil {
p1 := r1.Prog
if p1.To.Type == obj.TYPE_REG && p1.To.Reg == v.Reg {
switch p1.As {
case arm.AADD:
if p1.Scond&arm.C_SBIT != 0 {
// avoid altering ADD.S/ADC sequences.
break
}
if p1.From.Type == obj.TYPE_REG || (p1.From.Type == obj.TYPE_SHIFT && p1.From.Offset&(1<<4) == 0 && ((p.As != arm.AMOVB && p.As != arm.AMOVBS) || (a == &p.From && p1.From.Offset&^0xf == 0))) || ((p1.From.Type == obj.TYPE_ADDR || p1.From.Type == obj.TYPE_CONST) && p1.From.Offset > -4096 && p1.From.Offset < 4096) {
if nochange(gc.Uniqs(r1), r, p1) {
if a != &p.From || v.Reg != p.To.Reg {
if finduse(g, r.S1, &v) {
if p1.Reg == 0 || p1.Reg == v.Reg {
/* pre-indexing */
p.Scond |= arm.C_WBIT
} else {
return false
}
}
}
switch p1.From.Type {
/* register offset */
case obj.TYPE_REG:
if gc.Nacl {
return false
}
*a = obj.Addr{}
a.Type = obj.TYPE_SHIFT
a.Offset = int64(p1.From.Reg) & 15
/* scaled register offset */
case obj.TYPE_SHIFT:
if gc.Nacl {
return false
}
*a = obj.Addr{}
a.Type = obj.TYPE_SHIFT
fallthrough
/* immediate offset */
case obj.TYPE_CONST,
obj.TYPE_ADDR:
a.Offset = p1.From.Offset
}
if p1.Reg != 0 {
a.Reg = p1.Reg
}
excise(r1)
return true
}
}
case arm.AMOVW:
if p1.From.Type == obj.TYPE_REG {
r2 := (*gc.Flow)(findinc(r1, r, &p1.From))
if r2 != nil {
var r3 *gc.Flow
for r3 = gc.Uniqs(r2); r3.Prog.As == obj.ANOP; r3 = gc.Uniqs(r3) {
}
if r3 == r {
/* post-indexing */
p1 := r2.Prog
a.Reg = p1.To.Reg
a.Offset = p1.From.Offset
p.Scond |= arm.C_PBIT
if !finduse(g, r, &r1.Prog.To) {
excise(r1)
}
excise(r2)
return true
}
}
}
}
}
}
if a != &p.From || a.Reg != p.To.Reg {
r1 := (*gc.Flow)(findinc(r, nil, &v))
if r1 != nil {
/* post-indexing */
p1 := r1.Prog
a.Offset = p1.From.Offset
p.Scond |= arm.C_PBIT
excise(r1)
return true
}
}
return false
}