| // Copyright 2015 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package obj |
| |
| import ( |
| "bytes" |
| "cmd/internal/objabi" |
| "fmt" |
| "strings" |
| ) |
| |
| const REG_NONE = 0 |
| |
| func (p *Prog) Line() string { |
| return p.Ctxt.OutermostPos(p.Pos).Format(false) |
| } |
| |
| var armCondCode = []string{ |
| ".EQ", |
| ".NE", |
| ".CS", |
| ".CC", |
| ".MI", |
| ".PL", |
| ".VS", |
| ".VC", |
| ".HI", |
| ".LS", |
| ".GE", |
| ".LT", |
| ".GT", |
| ".LE", |
| "", |
| ".NV", |
| } |
| |
| /* ARM scond byte */ |
| const ( |
| C_SCOND = (1 << 4) - 1 |
| C_SBIT = 1 << 4 |
| C_PBIT = 1 << 5 |
| C_WBIT = 1 << 6 |
| C_FBIT = 1 << 7 |
| C_UBIT = 1 << 7 |
| C_SCOND_XOR = 14 |
| ) |
| |
| // CConv formats ARM condition codes. |
| func CConv(s uint8) string { |
| if s == 0 { |
| return "" |
| } |
| sc := armCondCode[(s&C_SCOND)^C_SCOND_XOR] |
| if s&C_SBIT != 0 { |
| sc += ".S" |
| } |
| if s&C_PBIT != 0 { |
| sc += ".P" |
| } |
| if s&C_WBIT != 0 { |
| sc += ".W" |
| } |
| if s&C_UBIT != 0 { /* ambiguous with FBIT */ |
| sc += ".U" |
| } |
| return sc |
| } |
| |
| func (p *Prog) String() string { |
| if p == nil { |
| return "<nil Prog>" |
| } |
| |
| if p.Ctxt == nil { |
| return "<Prog without ctxt>" |
| } |
| |
| sc := CConv(p.Scond) |
| |
| var buf bytes.Buffer |
| |
| fmt.Fprintf(&buf, "%.5d (%v)\t%v%s", p.Pc, p.Line(), p.As, sc) |
| sep := "\t" |
| quadOpAmd64 := p.RegTo2 == -1 |
| if quadOpAmd64 { |
| fmt.Fprintf(&buf, "%s$%d", sep, p.From3.Offset) |
| sep = ", " |
| } |
| if p.From.Type != TYPE_NONE { |
| fmt.Fprintf(&buf, "%s%v", sep, Dconv(p, &p.From)) |
| sep = ", " |
| } |
| if p.Reg != REG_NONE { |
| // Should not happen but might as well show it if it does. |
| fmt.Fprintf(&buf, "%s%v", sep, Rconv(int(p.Reg))) |
| sep = ", " |
| } |
| if p.From3Type() != TYPE_NONE { |
| if quadOpAmd64 { |
| fmt.Fprintf(&buf, "%s%v", sep, Rconv(int(p.From3.Reg))) |
| } else { |
| fmt.Fprintf(&buf, "%s%v", sep, Dconv(p, p.From3)) |
| } |
| sep = ", " |
| } |
| if p.As == ATEXT { |
| // If there are attributes, print them. Otherwise, skip the comma. |
| // In short, print one of these two: |
| // TEXT foo(SB), DUPOK|NOSPLIT, $0 |
| // TEXT foo(SB), $0 |
| s := p.From.Sym.Attribute.TextAttrString() |
| if s != "" { |
| fmt.Fprintf(&buf, "%s%s", sep, s) |
| sep = ", " |
| } |
| } |
| if p.To.Type != TYPE_NONE { |
| fmt.Fprintf(&buf, "%s%v", sep, Dconv(p, &p.To)) |
| } |
| if p.RegTo2 != REG_NONE && !quadOpAmd64 { |
| fmt.Fprintf(&buf, "%s%v", sep, Rconv(int(p.RegTo2))) |
| } |
| return buf.String() |
| } |
| |
| func (ctxt *Link) NewProg() *Prog { |
| p := new(Prog) |
| p.Ctxt = ctxt |
| return p |
| } |
| |
| func (ctxt *Link) CanReuseProgs() bool { |
| return !ctxt.Debugasm |
| } |
| |
| func (ctxt *Link) Dconv(a *Addr) string { |
| return Dconv(nil, a) |
| } |
| |
| func Dconv(p *Prog, a *Addr) string { |
| var str string |
| |
| switch a.Type { |
| default: |
| str = fmt.Sprintf("type=%d", a.Type) |
| |
| case TYPE_NONE: |
| str = "" |
| if a.Name != NAME_NONE || a.Reg != 0 || a.Sym != nil { |
| str = fmt.Sprintf("%v(%v)(NONE)", Mconv(a), Rconv(int(a.Reg))) |
| } |
| |
| case TYPE_REG: |
| // TODO(rsc): This special case is for x86 instructions like |
| // PINSRQ CX,$1,X6 |
| // where the $1 is included in the p->to Addr. |
| // Move into a new field. |
| if a.Offset != 0 { |
| str = fmt.Sprintf("$%d,%v", a.Offset, Rconv(int(a.Reg))) |
| break |
| } |
| |
| str = Rconv(int(a.Reg)) |
| if a.Name != NAME_NONE || a.Sym != nil { |
| str = fmt.Sprintf("%v(%v)(REG)", Mconv(a), Rconv(int(a.Reg))) |
| } |
| |
| case TYPE_BRANCH: |
| if a.Sym != nil { |
| str = fmt.Sprintf("%s(SB)", a.Sym.Name) |
| } else if p != nil && p.Pcond != nil { |
| str = fmt.Sprint(p.Pcond.Pc) |
| } else if a.Val != nil { |
| str = fmt.Sprint(a.Val.(*Prog).Pc) |
| } else { |
| str = fmt.Sprintf("%d(PC)", a.Offset) |
| } |
| |
| case TYPE_INDIR: |
| str = fmt.Sprintf("*%s", Mconv(a)) |
| |
| case TYPE_MEM: |
| str = Mconv(a) |
| if a.Index != REG_NONE { |
| str += fmt.Sprintf("(%v*%d)", Rconv(int(a.Index)), int(a.Scale)) |
| } |
| |
| case TYPE_CONST: |
| if a.Reg != 0 { |
| str = fmt.Sprintf("$%v(%v)", Mconv(a), Rconv(int(a.Reg))) |
| } else { |
| str = fmt.Sprintf("$%v", Mconv(a)) |
| } |
| |
| case TYPE_TEXTSIZE: |
| if a.Val.(int32) == objabi.ArgsSizeUnknown { |
| str = fmt.Sprintf("$%d", a.Offset) |
| } else { |
| str = fmt.Sprintf("$%d-%d", a.Offset, a.Val.(int32)) |
| } |
| |
| case TYPE_FCONST: |
| str = fmt.Sprintf("%.17g", a.Val.(float64)) |
| // Make sure 1 prints as 1.0 |
| if !strings.ContainsAny(str, ".e") { |
| str += ".0" |
| } |
| str = fmt.Sprintf("$(%s)", str) |
| |
| case TYPE_SCONST: |
| str = fmt.Sprintf("$%q", a.Val.(string)) |
| |
| case TYPE_ADDR: |
| str = fmt.Sprintf("$%s", Mconv(a)) |
| |
| case TYPE_SHIFT: |
| v := int(a.Offset) |
| ops := "<<>>->@>" |
| switch objabi.GOARCH { |
| case "arm": |
| op := ops[((v>>5)&3)<<1:] |
| if v&(1<<4) != 0 { |
| str = fmt.Sprintf("R%d%c%cR%d", v&15, op[0], op[1], (v>>8)&15) |
| } else { |
| str = fmt.Sprintf("R%d%c%c%d", v&15, op[0], op[1], (v>>7)&31) |
| } |
| if a.Reg != 0 { |
| str += fmt.Sprintf("(%v)", Rconv(int(a.Reg))) |
| } |
| case "arm64": |
| op := ops[((v>>22)&3)<<1:] |
| str = fmt.Sprintf("R%d%c%c%d", (v>>16)&31, op[0], op[1], (v>>10)&63) |
| default: |
| panic("TYPE_SHIFT is not supported on " + objabi.GOARCH) |
| } |
| |
| case TYPE_REGREG: |
| str = fmt.Sprintf("(%v, %v)", Rconv(int(a.Reg)), Rconv(int(a.Offset))) |
| |
| case TYPE_REGREG2: |
| str = fmt.Sprintf("%v, %v", Rconv(int(a.Offset)), Rconv(int(a.Reg))) |
| |
| case TYPE_REGLIST: |
| str = regListConv(int(a.Offset)) |
| } |
| |
| return str |
| } |
| |
| func Mconv(a *Addr) string { |
| var str string |
| |
| switch a.Name { |
| default: |
| str = fmt.Sprintf("name=%d", a.Name) |
| |
| case NAME_NONE: |
| switch { |
| case a.Reg == REG_NONE: |
| str = fmt.Sprint(a.Offset) |
| case a.Offset == 0: |
| str = fmt.Sprintf("(%v)", Rconv(int(a.Reg))) |
| case a.Offset != 0: |
| str = fmt.Sprintf("%d(%v)", a.Offset, Rconv(int(a.Reg))) |
| } |
| |
| // Note: a.Reg == REG_NONE encodes the default base register for the NAME_ type. |
| case NAME_EXTERN: |
| reg := "SB" |
| if a.Reg != REG_NONE { |
| reg = Rconv(int(a.Reg)) |
| } |
| if a.Sym != nil { |
| str = fmt.Sprintf("%s%s(%s)", a.Sym.Name, offConv(a.Offset), reg) |
| } else { |
| str = fmt.Sprintf("%s(%s)", offConv(a.Offset), reg) |
| } |
| |
| case NAME_GOTREF: |
| reg := "SB" |
| if a.Reg != REG_NONE { |
| reg = Rconv(int(a.Reg)) |
| } |
| if a.Sym != nil { |
| str = fmt.Sprintf("%s%s@GOT(%s)", a.Sym.Name, offConv(a.Offset), reg) |
| } else { |
| str = fmt.Sprintf("%s@GOT(%s)", offConv(a.Offset), reg) |
| } |
| |
| case NAME_STATIC: |
| reg := "SB" |
| if a.Reg != REG_NONE { |
| reg = Rconv(int(a.Reg)) |
| } |
| if a.Sym != nil { |
| str = fmt.Sprintf("%s<>%s(%s)", a.Sym.Name, offConv(a.Offset), reg) |
| } else { |
| str = fmt.Sprintf("<>%s(%s)", offConv(a.Offset), reg) |
| } |
| |
| case NAME_AUTO: |
| reg := "SP" |
| if a.Reg != REG_NONE { |
| reg = Rconv(int(a.Reg)) |
| } |
| if a.Sym != nil { |
| str = fmt.Sprintf("%s%s(%s)", a.Sym.Name, offConv(a.Offset), reg) |
| } else { |
| str = fmt.Sprintf("%s(%s)", offConv(a.Offset), reg) |
| } |
| |
| case NAME_PARAM: |
| reg := "FP" |
| if a.Reg != REG_NONE { |
| reg = Rconv(int(a.Reg)) |
| } |
| if a.Sym != nil { |
| str = fmt.Sprintf("%s%s(%s)", a.Sym.Name, offConv(a.Offset), reg) |
| } else { |
| str = fmt.Sprintf("%s(%s)", offConv(a.Offset), reg) |
| } |
| } |
| return str |
| } |
| |
| func offConv(off int64) string { |
| if off == 0 { |
| return "" |
| } |
| return fmt.Sprintf("%+d", off) |
| } |
| |
| type regSet struct { |
| lo int |
| hi int |
| Rconv func(int) string |
| } |
| |
| // Few enough architectures that a linear scan is fastest. |
| // Not even worth sorting. |
| var regSpace []regSet |
| |
| /* |
| Each architecture defines a register space as a unique |
| integer range. |
| Here is the list of architectures and the base of their register spaces. |
| */ |
| |
| const ( |
| // Because of masking operations in the encodings, each register |
| // space should start at 0 modulo some power of 2. |
| RBase386 = 1 * 1024 |
| RBaseAMD64 = 2 * 1024 |
| RBaseARM = 3 * 1024 |
| RBasePPC64 = 4 * 1024 // range [4k, 8k) |
| RBaseARM64 = 8 * 1024 // range [8k, 13k) |
| RBaseMIPS = 13 * 1024 // range [13k, 14k) |
| RBaseS390X = 14 * 1024 // range [14k, 15k) |
| ) |
| |
| // RegisterRegister binds a pretty-printer (Rconv) for register |
| // numbers to a given register number range. Lo is inclusive, |
| // hi exclusive (valid registers are lo through hi-1). |
| func RegisterRegister(lo, hi int, Rconv func(int) string) { |
| regSpace = append(regSpace, regSet{lo, hi, Rconv}) |
| } |
| |
| func Rconv(reg int) string { |
| if reg == REG_NONE { |
| return "NONE" |
| } |
| for i := range regSpace { |
| rs := ®Space[i] |
| if rs.lo <= reg && reg < rs.hi { |
| return rs.Rconv(reg) |
| } |
| } |
| return fmt.Sprintf("R???%d", reg) |
| } |
| |
| func regListConv(list int) string { |
| str := "" |
| |
| for i := 0; i < 16; i++ { // TODO: 16 is ARM-specific. |
| if list&(1<<uint(i)) != 0 { |
| if str == "" { |
| str += "[" |
| } else { |
| str += "," |
| } |
| // This is ARM-specific; R10 is g. |
| if i == 10 { |
| str += "g" |
| } else { |
| str += fmt.Sprintf("R%d", i) |
| } |
| } |
| } |
| |
| str += "]" |
| return str |
| } |
| |
| type opSet struct { |
| lo As |
| names []string |
| } |
| |
| // Not even worth sorting |
| var aSpace []opSet |
| |
| // RegisterOpcode binds a list of instruction names |
| // to a given instruction number range. |
| func RegisterOpcode(lo As, Anames []string) { |
| if len(Anames) > AllowedOpCodes { |
| panic(fmt.Sprintf("too many instructions, have %d max %d", len(Anames), AllowedOpCodes)) |
| } |
| aSpace = append(aSpace, opSet{lo, Anames}) |
| } |
| |
| func (a As) String() string { |
| if 0 <= a && int(a) < len(Anames) { |
| return Anames[a] |
| } |
| for i := range aSpace { |
| as := &aSpace[i] |
| if as.lo <= a && int(a-as.lo) < len(as.names) { |
| return as.names[a-as.lo] |
| } |
| } |
| return fmt.Sprintf("A???%d", a) |
| } |
| |
| var Anames = []string{ |
| "XXX", |
| "CALL", |
| "DUFFCOPY", |
| "DUFFZERO", |
| "END", |
| "FUNCDATA", |
| "JMP", |
| "NOP", |
| "PCDATA", |
| "RET", |
| "TEXT", |
| "UNDEF", |
| } |
| |
| func Bool2int(b bool) int { |
| // The compiler currently only optimizes this form. |
| // See issue 6011. |
| var i int |
| if b { |
| i = 1 |
| } else { |
| i = 0 |
| } |
| return i |
| } |