cybercyst/go
1
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-05-30 19:52:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

cmd/internal/obj: make Dconv a portable top-level function

Browse Source 
Each architecture had its own Dconv (operand printer) but the syntax is
close to uniform and the code overlap was considerable. Consolidate these
into a single top-level function. A similar but smaller unification is done
for Mconv ("Name" formatter) as well.

The signature is changed. The flag was unused so drop it. Add a
function argument, Rconv, that must be supplied by the caller.
TODO: A future change will unify Rconv as well and this argument
will go away.

Some formats changed, because of the automatic consistency
created by unification. For instance, 0(R1) always prints as (R1)
now, and foo+0(SB) is just foo(SB). Before, some made these
simplifications and some didn't; now they all do.

Update the asm tests that depend on the format.

Change-Id: I6e3310bc19814c0c784ff0b960a154521acd9532
Reviewed-on: https://go-review.googlesource.com/5920
Reviewed-by: Russ Cox <rsc@golang.org>
This commit is contained in:
Rob Pike 2015-02-25 09:07:02 -08:00
parent 77d7771a82
commit 29421cbb5b
21 changed files with 348 additions and 634 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/cmd/asm/internal/arch/arch.go
View File

@ -38,8 +38,8 @@ type Arch struct {
IsJump func(word string) bool IsJump func(word string) bool
// Aconv pretty-prints an instruction opcode for this architecture. // Aconv pretty-prints an instruction opcode for this architecture.
Aconv func(int) string Aconv func(int) string
// Dconv pretty-prints an address for this architecture. // Rconv pretty-prints a register for this architecture.
Dconv func(p *obj.Prog, flag int, a *obj.Addr) string Rconv func(int) string
} }
// nilRegisterNumber is the register number function for architectures // nilRegisterNumber is the register number function for architectures
@ -188,7 +188,7 @@ func arch386() *Arch {
UnaryDestination: unaryDestination, UnaryDestination: unaryDestination,
IsJump: jump386, IsJump: jump386,
Aconv: i386.Aconv, Aconv: i386.Aconv,
Dconv: i386.Dconv, Rconv: i386.Rconv,
} }
} }
@ -309,7 +309,7 @@ func archAmd64() *Arch {
UnaryDestination: unaryDestination, UnaryDestination: unaryDestination,
IsJump: jump386, IsJump: jump386,
Aconv: x86.Aconv, Aconv: x86.Aconv,
Dconv: x86.Dconv, Rconv: x86.Rconv,
} }
} }
@ -362,7 +362,7 @@ func archArm() *Arch {
UnaryDestination: unaryDestination, UnaryDestination: unaryDestination,
IsJump: jumpArm, IsJump: jumpArm,
Aconv: arm.Aconv, Aconv: arm.Aconv,
Dconv: arm.Dconv, Rconv: arm.Rconv,
} }
} }
@ -422,6 +422,6 @@ func archPPC64() *Arch {
UnaryDestination: nil, UnaryDestination: nil,
IsJump: jumpPPC64, IsJump: jumpPPC64,
Aconv: ppc64.Aconv, Aconv: ppc64.Aconv,
Dconv: ppc64.Dconv, Rconv: ppc64.Rconv,
} }
} }

24
src/cmd/asm/internal/asm/asm.go
View File

@ -73,7 +73,7 @@ func (p *Parser) evalInteger(pseudo string, operands []lex.Token) int64 {
// validateImmediate checks that addr represents an immediate constant. // validateImmediate checks that addr represents an immediate constant.
func (p *Parser) validateImmediate(pseudo string, addr *obj.Addr) { func (p *Parser) validateImmediate(pseudo string, addr *obj.Addr) {
if addr.Type != obj.TYPE_CONST || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 { if addr.Type != obj.TYPE_CONST || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 {
p.errorf("%s: expected immediate constant; found %s", pseudo, p.arch.Dconv(&emptyProg, 0, addr)) p.errorf("%s: expected immediate constant; found %s", pseudo, obj.Dconv(&emptyProg, p.arch.Rconv, addr))
} }
} }
@ -138,7 +138,7 @@ func (p *Parser) asmText(word string, operands [][]lex.Token) {
argSize = p.positiveAtoi(op[1].String()) argSize = p.positiveAtoi(op[1].String())
} }
prog := &obj.Prog{ prog := &obj.Prog{
Ctxt: p.linkCtxt, Ctxt: p.ctxt,
As: obj.ATEXT, As: obj.ATEXT,
Lineno: p.histLineNum, Lineno: p.histLineNum,
From: nameAddr, From: nameAddr,
@ -191,7 +191,7 @@ func (p *Parser) asmData(word string, operands [][]lex.Token) {
p.dataAddr[name] = nameAddr.Offset + int64(scale) p.dataAddr[name] = nameAddr.Offset + int64(scale)
prog := &obj.Prog{ prog := &obj.Prog{
Ctxt: p.linkCtxt, Ctxt: p.ctxt,
As: obj.ADATA, As: obj.ADATA,
Lineno: p.histLineNum, Lineno: p.histLineNum,
From: nameAddr, From: nameAddr,
@ -230,7 +230,7 @@ func (p *Parser) asmGlobl(word string, operands [][]lex.Token) {
// log.Printf("GLOBL %s %d, $%d", name, flag, size) // log.Printf("GLOBL %s %d, $%d", name, flag, size)
prog := &obj.Prog{ prog := &obj.Prog{
Ctxt: p.linkCtxt, Ctxt: p.ctxt,
As: obj.AGLOBL, As: obj.AGLOBL,
Lineno: p.histLineNum, Lineno: p.histLineNum,
From: nameAddr, From: nameAddr,
@ -259,7 +259,7 @@ func (p *Parser) asmPCData(word string, operands [][]lex.Token) {
// log.Printf("PCDATA $%d, $%d", key.Offset, value.Offset) // log.Printf("PCDATA $%d, $%d", key.Offset, value.Offset)
prog := &obj.Prog{ prog := &obj.Prog{
Ctxt: p.linkCtxt, Ctxt: p.ctxt,
As: obj.APCDATA, As: obj.APCDATA,
Lineno: p.histLineNum, Lineno: p.histLineNum,
From: key, From: key,
@ -284,7 +284,7 @@ func (p *Parser) asmFuncData(word string, operands [][]lex.Token) {
p.validateSymbol("FUNCDATA", &nameAddr, true) p.validateSymbol("FUNCDATA", &nameAddr, true)
prog := &obj.Prog{ prog := &obj.Prog{
Ctxt: p.linkCtxt, Ctxt: p.ctxt,
As: obj.AFUNCDATA, As: obj.AFUNCDATA,
Lineno: p.histLineNum, Lineno: p.histLineNum,
From: valueAddr, From: valueAddr,
@ -300,7 +300,7 @@ func (p *Parser) asmFuncData(word string, operands [][]lex.Token) {
func (p *Parser) asmJump(op int, cond string, a []obj.Addr) { func (p *Parser) asmJump(op int, cond string, a []obj.Addr) {
var target *obj.Addr var target *obj.Addr
prog := &obj.Prog{ prog := &obj.Prog{
Ctxt: p.linkCtxt, Ctxt: p.ctxt,
Lineno: p.histLineNum, Lineno: p.histLineNum,
As: int16(op), As: int16(op),
} }
@ -404,7 +404,7 @@ func (p *Parser) branch(jmp, target *obj.Prog) {
func (p *Parser) asmInstruction(op int, cond string, a []obj.Addr) { func (p *Parser) asmInstruction(op int, cond string, a []obj.Addr) {
// fmt.Printf("%s %+v\n", p.arch.Aconv(op), a) // fmt.Printf("%s %+v\n", p.arch.Aconv(op), a)
prog := &obj.Prog{ prog := &obj.Prog{
Ctxt: p.linkCtxt, Ctxt: p.ctxt,
Lineno: p.histLineNum, Lineno: p.histLineNum,
As: int16(op), As: int16(op),
} }
@ -642,7 +642,7 @@ var emptyProg obj.Prog
// getConstantPseudo checks that addr represents a plain constant and returns its value. // getConstantPseudo checks that addr represents a plain constant and returns its value.
func (p *Parser) getConstantPseudo(pseudo string, addr *obj.Addr) int64 { func (p *Parser) getConstantPseudo(pseudo string, addr *obj.Addr) int64 {
if addr.Type != obj.TYPE_MEM || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 { if addr.Type != obj.TYPE_MEM || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 {
p.errorf("%s: expected integer constant; found %s", pseudo, p.arch.Dconv(&emptyProg, 0, addr)) p.errorf("%s: expected integer constant; found %s", pseudo, obj.Dconv(&emptyProg, p.arch.Rconv, addr))
} }
return addr.Offset return addr.Offset
} }
@ -650,7 +650,7 @@ func (p *Parser) getConstantPseudo(pseudo string, addr *obj.Addr) int64 {
// getConstant checks that addr represents a plain constant and returns its value. // getConstant checks that addr represents a plain constant and returns its value.
func (p *Parser) getConstant(prog *obj.Prog, op int, addr *obj.Addr) int64 { func (p *Parser) getConstant(prog *obj.Prog, op int, addr *obj.Addr) int64 {
if addr.Type != obj.TYPE_MEM || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 { if addr.Type != obj.TYPE_MEM || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 {
p.errorf("%s: expected integer constant; found %s", p.arch.Aconv(op), p.arch.Dconv(prog, 0, addr)) p.errorf("%s: expected integer constant; found %s", p.arch.Aconv(op), obj.Dconv(prog, p.arch.Rconv, addr))
} }
return addr.Offset return addr.Offset
} }
@ -658,7 +658,7 @@ func (p *Parser) getConstant(prog *obj.Prog, op int, addr *obj.Addr) int64 {
// getImmediate checks that addr represents an immediate constant and returns its value. // getImmediate checks that addr represents an immediate constant and returns its value.
func (p *Parser) getImmediate(prog *obj.Prog, op int, addr *obj.Addr) int64 { func (p *Parser) getImmediate(prog *obj.Prog, op int, addr *obj.Addr) int64 {
if addr.Type != obj.TYPE_CONST || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 { if addr.Type != obj.TYPE_CONST || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 {
p.errorf("%s: expected immediate constant; found %s", p.arch.Aconv(op), p.arch.Dconv(prog, 0, addr)) p.errorf("%s: expected immediate constant; found %s", p.arch.Aconv(op), obj.Dconv(prog, p.arch.Rconv, addr))
} }
return addr.Offset return addr.Offset
} }
@ -666,7 +666,7 @@ func (p *Parser) getImmediate(prog *obj.Prog, op int, addr *obj.Addr) int64 {
// getRegister checks that addr represents a register and returns its value. // getRegister checks that addr represents a register and returns its value.
func (p *Parser) getRegister(prog *obj.Prog, op int, addr *obj.Addr) int16 { func (p *Parser) getRegister(prog *obj.Prog, op int, addr *obj.Addr) int16 {
if addr.Type != obj.TYPE_REG || addr.Offset != 0 || addr.Name != 0 || addr.Index != 0 { if addr.Type != obj.TYPE_REG || addr.Offset != 0 || addr.Name != 0 || addr.Index != 0 {
p.errorf("%s: expected register; found %s", p.arch.Aconv(op), p.arch.Dconv(prog, 0, addr)) p.errorf("%s: expected register; found %s", p.arch.Aconv(op), obj.Dconv(prog, p.arch.Rconv, addr))
} }
return addr.Reg return addr.Reg
} }

104
src/cmd/asm/internal/asm/operand_test.go
View File

@ -34,7 +34,7 @@ func testOperandParser(t *testing.T, parser *Parser, tests []operandTest) {
parser.start(lex.Tokenize(test.input)) parser.start(lex.Tokenize(test.input))
addr := obj.Addr{} addr := obj.Addr{}
parser.operand(&addr) parser.operand(&addr)
result := parser.arch.Dconv(&emptyProg, 0, &addr) result := obj.Dconv(&emptyProg, parser.arch.Rconv, &addr)
if result != test.output { if result != test.output {
t.Errorf("fail at %s: got %s; expected %s\n", test.input, result, test.output) t.Errorf("fail at %s: got %s; expected %s\n", test.input, result, test.output)
} }
@ -64,7 +64,7 @@ func testX86RegisterPair(t *testing.T, parser *Parser) {
Type: obj.TYPE_MEM, Type: obj.TYPE_MEM,
Name: obj.NAME_EXTERN, Name: obj.NAME_EXTERN,
Offset: 4, Offset: 4,
Sym: obj.Linklookup(parser.linkCtxt, "foo", 0), Sym: obj.Linklookup(parser.ctxt, "foo", 0),
Class: int8(parser.arch.Register["AX"]), // TODO: clean up how this is encoded in parse.go Class: int8(parser.arch.Register["AX"]), // TODO: clean up how this is encoded in parse.go
} }
if want != addr { if want != addr {
@ -114,8 +114,8 @@ type operandTest struct {
var amd64OperandTests = []operandTest{ var amd64OperandTests = []operandTest{
// {"AX:DX", "AX:DX"}, Handled in TestAMD64OperandParser directly. // {"AX:DX", "AX:DX"}, Handled in TestAMD64OperandParser directly.
{"$(-1.0)", "$(-1)"}, // TODO: Should print as a float. {"$(-1.0)", "$(-1.0)"},
{"$(0.0)", "$(0)"}, // TODO: Should print as a float. {"$(0.0)", "$(0.0)"},
{"$(0x2000000+116)", "$33554548"}, {"$(0x2000000+116)", "$33554548"},
{"$(0x3F<<7)", "$8064"}, {"$(0x3F<<7)", "$8064"},
{"$(112+8)", "$120"}, {"$(112+8)", "$120"},
@ -132,16 +132,16 @@ var amd64OperandTests = []operandTest{
{"$0x7fffffe00000", "$140737486258176"}, {"$0x7fffffe00000", "$140737486258176"},
{"$0xfffffffffffff001", "$-4095"}, {"$0xfffffffffffff001", "$-4095"},
{"$1", "$1"}, {"$1", "$1"},
{"$1.0", "$(1)"}, // TODO: should print as float. {"$1.0", "$(1.0)"},
{"$10", "$10"}, {"$10", "$10"},
{"$1000", "$1000"}, {"$1000", "$1000"},
{"$1000000", "$1000000"}, {"$1000000", "$1000000"},
{"$1000000000", "$1000000000"}, {"$1000000000", "$1000000000"},
{"$__tsan_func_enter(SB)", "$__tsan_func_enter+0(SB)"}, {"$__tsan_func_enter(SB)", "$__tsan_func_enter(SB)"},
{"$main(SB)", "$main+0(SB)"}, {"$main(SB)", "$main(SB)"},
{"$masks<>(SB)", "$masks<>+0(SB)"}, {"$masks<>(SB)", "$masks<>(SB)"},
{"$setg_gcc<>(SB)", "$setg_gcc<>+0(SB)"}, {"$setg_gcc<>(SB)", "$setg_gcc<>(SB)"},
{"$shifts<>(SB)", "$shifts<>+0(SB)"}, {"$shifts<>(SB)", "$shifts<>(SB)"},
{"$~(1<<63)", "$9223372036854775807"}, {"$~(1<<63)", "$9223372036854775807"},
{"$~0x3F", "$-64"}, {"$~0x3F", "$-64"},
{"$~15", "$-16"}, {"$~15", "$-16"},
@ -203,28 +203,28 @@ var amd64OperandTests = []operandTest{
{"X7", "X7"}, {"X7", "X7"},
{"X8", "X8"}, {"X8", "X8"},
{"X9", "X9"}, {"X9", "X9"},
{"_expand_key_128<>(SB)", "_expand_key_128<>+0(SB)"}, {"_expand_key_128<>(SB)", "_expand_key_128<>(SB)"},
{"_seek<>(SB)", "_seek<>+0(SB)"}, {"_seek<>(SB)", "_seek<>(SB)"},
{"a2+16(FP)", "a2+16(FP)"}, {"a2+16(FP)", "a2+16(FP)"},
{"addr2+24(FP)", "addr2+24(FP)"}, {"addr2+24(FP)", "addr2+24(FP)"},
{"asmcgocall<>(SB)", "asmcgocall<>+0(SB)"}, {"asmcgocall<>(SB)", "asmcgocall<>(SB)"},
{"b+24(FP)", "b+24(FP)"}, {"b+24(FP)", "b+24(FP)"},
{"b_len+32(FP)", "b_len+32(FP)"}, {"b_len+32(FP)", "b_len+32(FP)"},
{"racecall<>(SB)", "racecall<>+0(SB)"}, {"racecall<>(SB)", "racecall<>(SB)"},
{"rcv_name+20(FP)", "rcv_name+20(FP)"}, {"rcv_name+20(FP)", "rcv_name+20(FP)"},
{"retoffset+28(FP)", "retoffset+28(FP)"}, {"retoffset+28(FP)", "retoffset+28(FP)"},
{"runtime·_GetStdHandle(SB)", "runtime._GetStdHandle+0(SB)"}, {"runtime·_GetStdHandle(SB)", "runtime._GetStdHandle(SB)"},
{"sync\u2215atomic·AddInt64(SB)", "sync/atomic.AddInt64+0(SB)"}, {"sync\u2215atomic·AddInt64(SB)", "sync/atomic.AddInt64(SB)"},
{"timeout+20(FP)", "timeout+20(FP)"}, {"timeout+20(FP)", "timeout+20(FP)"},
{"ts+16(FP)", "ts+16(FP)"}, {"ts+16(FP)", "ts+16(FP)"},
{"x+24(FP)", "x+24(FP)"}, {"x+24(FP)", "x+24(FP)"},
{"x·y(SB)", "x.y+0(SB)"}, {"x·y(SB)", "x.y(SB)"},
{"x·y(SP)", "x.y+0(SP)"}, {"x·y(SP)", "x.y(SP)"},
{"x·y+8(SB)", "x.y+8(SB)"}, {"x·y+8(SB)", "x.y+8(SB)"},
{"x·y+8(SP)", "x.y+8(SP)"}, {"x·y+8(SP)", "x.y+8(SP)"},
{"y+56(FP)", "y+56(FP)"}, {"y+56(FP)", "y+56(FP)"},
{"·AddUint32(SB", "\"\".AddUint32+0(SB)"}, {"·AddUint32(SB", "\"\".AddUint32(SB)"},
{"·callReflect(SB)", "\"\".callReflect+0(SB)"}, {"·callReflect(SB)", "\"\".callReflect(SB)"},
} }
var x86OperandTests = []operandTest{ var x86OperandTests = []operandTest{
@ -232,8 +232,8 @@ var x86OperandTests = []operandTest{
{"$-1", "$-1"}, {"$-1", "$-1"},
{"$0", "$0"}, {"$0", "$0"},
{"$0x00000000", "$0"}, {"$0x00000000", "$0"},
{"$runtime·badmcall(SB)", "$runtime.badmcall+0(SB)"}, {"$runtime·badmcall(SB)", "$runtime.badmcall(SB)"},
{"$setg_gcc<>(SB)", "$setg_gcc<>+0(SB)"}, {"$setg_gcc<>(SB)", "$setg_gcc<>(SB)"},
{"$~15", "$-16"}, {"$~15", "$-16"},
{"(-64*1024+104)(SP)", "-65432(SP)"}, {"(-64*1024+104)(SP)", "-65432(SP)"},
{"(0*4)(BP)", "(BP)"}, {"(0*4)(BP)", "(BP)"},
@ -241,7 +241,7 @@ var x86OperandTests = []operandTest{
{"(4*4)(BP)", "16(BP)"}, {"(4*4)(BP)", "16(BP)"},
{"(AX)", "(AX)"}, {"(AX)", "(AX)"},
{"(BP)(CX*4)", "(BP)(CX*4)"}, {"(BP)(CX*4)", "(BP)(CX*4)"},
{"(BP*8)", "(NONE)(BP*8)"}, // TODO: odd printout. {"(BP*8)", "0(BP*8)"},
{"(BX)", "(BX)"}, {"(BX)", "(BX)"},
{"(SP)", "(SP)"}, {"(SP)", "(SP)"},
{"*AX", "AX"}, // TODO: Should make * illegal here; a simple alias for JMP AX. {"*AX", "AX"}, // TODO: Should make * illegal here; a simple alias for JMP AX.
@ -272,24 +272,24 @@ var x86OperandTests = []operandTest{
{"X5", "X5"}, {"X5", "X5"},
{"X6", "X6"}, {"X6", "X6"},
{"X7", "X7"}, {"X7", "X7"},
{"asmcgocall<>(SB)", "asmcgocall<>+0(SB)"}, {"asmcgocall<>(SB)", "asmcgocall<>(SB)"},
{"ax+4(FP)", "ax+4(FP)"}, {"ax+4(FP)", "ax+4(FP)"},
{"ptime-12(SP)", "ptime+-12(SP)"}, {"ptime-12(SP)", "ptime-12(SP)"},
{"runtime·_NtWaitForSingleObject(SB)", "runtime._NtWaitForSingleObject+0(SB)"}, {"runtime·_NtWaitForSingleObject(SB)", "runtime._NtWaitForSingleObject(SB)"},
{"s(FP)", "s+0(FP)"}, {"s(FP)", "s(FP)"},
{"sec+4(FP)", "sec+4(FP)"}, {"sec+4(FP)", "sec+4(FP)"},
{"shifts<>(SB)(CX*8)", "shifts<>+0(SB)(CX*8)"}, {"shifts<>(SB)(CX*8)", "shifts<>(SB)(CX*8)"},
{"x+4(FP)", "x+4(FP)"}, {"x+4(FP)", "x+4(FP)"},
{"·AddUint32(SB)", "\"\".AddUint32+0(SB)"}, {"·AddUint32(SB)", "\"\".AddUint32(SB)"},
{"·reflectcall(SB)", "\"\".reflectcall+0(SB)"}, {"·reflectcall(SB)", "\"\".reflectcall(SB)"},
} }
var armOperandTests = []operandTest{ var armOperandTests = []operandTest{
{"$0", "$0"}, {"$0", "$0"},
{"$256", "$256"}, {"$256", "$256"},
{"(R0)", "0(R0)"}, {"(R0)", "(R0)"},
{"(R11)", "0(R11)"}, {"(R11)", "(R11)"},
{"(g)", "0(R10)"}, // TODO: Should print 0(g). {"(g)", "(R10)"}, // TODO: Should print 0(g).
{"-12(R4)", "-12(R4)"}, {"-12(R4)", "-12(R4)"},
{"0(PC)", "0(PC)"}, {"0(PC)", "0(PC)"},
{"1024", "1024"}, {"1024", "1024"},
@ -322,44 +322,44 @@ var armOperandTests = []operandTest{
{"[R(0)-R(7)]", "$255"}, {"[R(0)-R(7)]", "$255"},
{"[R0]", "$1"}, {"[R0]", "$1"},
{"[R1-R12]", "$8190"}, {"[R1-R12]", "$8190"},
{"armCAS64(SB)", "armCAS64+0(SB)"}, {"armCAS64(SB)", "armCAS64(SB)"},
{"asmcgocall<>(SB)", "asmcgocall<>+0(SB)"}, {"asmcgocall<>(SB)", "asmcgocall<>(SB)"},
{"c+28(FP)", "c+28(FP)"}, {"c+28(FP)", "c+28(FP)"},
{"g", "R10"}, // TODO: Should print g. {"g", "R10"}, // TODO: Should print g.
{"gosave<>(SB)", "gosave<>+0(SB)"}, {"gosave<>(SB)", "gosave<>(SB)"},
{"retlo+12(FP)", "retlo+12(FP)"}, {"retlo+12(FP)", "retlo+12(FP)"},
{"runtime·_sfloat2(SB)", "runtime._sfloat2+0(SB)"}, {"runtime·_sfloat2(SB)", "runtime._sfloat2(SB)"},
{"·AddUint32(SB)", "\"\".AddUint32+0(SB)"}, {"·AddUint32(SB)", "\"\".AddUint32(SB)"},
} }
var ppc64OperandTests = []operandTest{ var ppc64OperandTests = []operandTest{
{"$((1<<63)-1)", "$0x7fffffffffffffff"}, {"$((1<<63)-1)", "$9223372036854775807"},
{"$(-64*1024)", "$-65536"}, {"$(-64*1024)", "$-65536"},
{"$(1024 * 8)", "$8192"}, {"$(1024 * 8)", "$8192"},
{"$-1", "$-1"}, {"$-1", "$-1"},
{"$-24(R4)", "$-24(R4)"}, {"$-24(R4)", "$-24(R4)"},
{"$0", "$0"}, {"$0", "$0"},
{"$0(R1)", "$0(R1)"}, {"$0(R1)", "$(R1)"},
{"$0.5", "$0.5"}, {"$0.5", "$(0.5)"},
{"$0x7000", "$28672"}, {"$0x7000", "$28672"},
{"$0x88888eef", "$0x88888eef"}, {"$0x88888eef", "$2290650863"},
{"$1", "$1"}, {"$1", "$1"},
{"$_main<>(SB)", "$_main<>+0(SB)"}, {"$_main<>(SB)", "$_main<>(SB)"},
{"$argframe+0(FP)", "$argframe+0(FP)"}, {"$argframe(FP)", "$argframe(FP)"},
{"$runtime·tlsg(SB)", "$runtime.tlsg(SB)"}, {"$runtime·tlsg(SB)", "$runtime.tlsg(SB)"},
{"$~3", "$-4"}, {"$~3", "$-4"},
{"(-288-3*8)(R1)", "-312(R1)"}, {"(-288-3*8)(R1)", "-312(R1)"},
{"(16)(R7)", "16(R7)"}, {"(16)(R7)", "16(R7)"},
{"(8)(g)", "8(R30)"}, // TODO: Should print 8(g) {"(8)(g)", "8(R30)"}, // TODO: Should print 8(g)
{"(CTR)", "0(CTR)"}, {"(CTR)", "(CTR)"},
{"(R0)", "0(R0)"}, {"(R0)", "(R0)"},
{"(R3)", "0(R3)"}, {"(R3)", "(R3)"},
{"(R4)", "0(R4)"}, {"(R4)", "(R4)"},
{"(R5)", "0(R5)"}, {"(R5)", "(R5)"},
{"-1(R4)", "-1(R4)"}, {"-1(R4)", "-1(R4)"},
{"-1(R5)", "-1(R5)"}, {"-1(R5)", "-1(R5)"},
{"6(PC)", "6(APC)"}, // TODO: Should print 6(PC). {"6(PC)", "6(PC)"},
{"CR7", "C7"}, // TODO: Should print CR7. {"CR7", "C7"}, // TODO: Should print CR7.
{"CTR", "CTR"}, {"CTR", "CTR"},
{"F14", "F14"}, {"F14", "F14"},
{"F15", "F15"}, {"F15", "F15"},
@ -411,7 +411,7 @@ var ppc64OperandTests = []operandTest{
{"R8", "R8"}, {"R8", "R8"},
{"R9", "R9"}, {"R9", "R9"},
{"SPR(269)", "SPR(269)"}, {"SPR(269)", "SPR(269)"},
{"a+0(FP)", "a+0(FP)"}, {"a(FP)", "a(FP)"},
{"g", "R30"}, // TODO: Should print g. {"g", "R30"}, // TODO: Should print g.
{"ret+8(FP)", "ret+8(FP)"}, {"ret+8(FP)", "ret+8(FP)"},
{"runtime·abort(SB)", "runtime.abort(SB)"}, {"runtime·abort(SB)", "runtime.abort(SB)"},

16
src/cmd/asm/internal/asm/parse.go
View File

@ -33,7 +33,7 @@ type Parser struct {
toPatch []Patch toPatch []Patch
addr []obj.Addr addr []obj.Addr
arch *arch.Arch arch *arch.Arch
linkCtxt *obj.Link ctxt *obj.Link
firstProg *obj.Prog firstProg *obj.Prog
lastProg *obj.Prog lastProg *obj.Prog
dataAddr map[string]int64 // Most recent address for DATA for this symbol. dataAddr map[string]int64 // Most recent address for DATA for this symbol.
@ -46,7 +46,7 @@ type Patch struct {
func NewParser(ctxt *obj.Link, ar *arch.Arch, lexer lex.TokenReader) *Parser { func NewParser(ctxt *obj.Link, ar *arch.Arch, lexer lex.TokenReader) *Parser {
return &Parser{ return &Parser{
linkCtxt: ctxt, ctxt: ctxt,
arch: ar, arch: ar,
lex: lexer, lex: lexer,
labels: make(map[string]*obj.Prog), labels: make(map[string]*obj.Prog),
@ -255,7 +255,7 @@ func (p *Parser) operand(a *obj.Addr) bool {
if tok.ScanToken == scanner.Ident && !p.atStartOfRegister(name) { if tok.ScanToken == scanner.Ident && !p.atStartOfRegister(name) {
// We have a symbol. Parse $sym±offset(symkind) // We have a symbol. Parse $sym±offset(symkind)
p.symbolReference(a, name, prefix) p.symbolReference(a, name, prefix)
// fmt.Printf("SYM %s\n", p.arch.Dconv(&emptyProg, 0, a)) // fmt.Printf("SYM %s\n", obj.Dconv(&emptyProg, 0, p.arch.Rconv, a))
if p.peek() == scanner.EOF { if p.peek() == scanner.EOF {
return true return true
} }
@ -300,7 +300,7 @@ func (p *Parser) operand(a *obj.Addr) bool {
a.Class = int8(r2) a.Class = int8(r2)
} }
} }
// fmt.Printf("REG %s\n", p.arch.Dconv(&emptyProg, 0, a)) // fmt.Printf("REG %s\n", obj.Dconv(&emptyProg, 0, p.arch.Rconv, a))
p.expect(scanner.EOF) p.expect(scanner.EOF)
return true return true
} }
@ -327,7 +327,7 @@ func (p *Parser) operand(a *obj.Addr) bool {
} }
a.Type = obj.TYPE_FCONST a.Type = obj.TYPE_FCONST
a.U.Dval = p.floatExpr() a.U.Dval = p.floatExpr()
// fmt.Printf("FCONST %s\n", p.arch.Dconv(&emptyProg, 0, a)) // fmt.Printf("FCONST %s\n", obj.Dconv(&emptyProg, 0, p.arch.Rconv, a))
p.expect(scanner.EOF) p.expect(scanner.EOF)
return true return true
} }
@ -341,7 +341,7 @@ func (p *Parser) operand(a *obj.Addr) bool {
} }
a.Type = obj.TYPE_SCONST a.Type = obj.TYPE_SCONST
a.U.Sval = str a.U.Sval = str
// fmt.Printf("SCONST %s\n", p.arch.Dconv(&emptyProg, 0, a)) // fmt.Printf("SCONST %s\n", obj.Dconv(&emptyProg, 0, p.arch.Rconv, a))
p.expect(scanner.EOF) p.expect(scanner.EOF)
return true return true
} }
@ -355,7 +355,7 @@ func (p *Parser) operand(a *obj.Addr) bool {
default: default:
a.Type = obj.TYPE_MEM a.Type = obj.TYPE_MEM
} }
// fmt.Printf("CONST %d %s\n", a.Offset, p.arch.Dconv(&emptyProg, 0, a)) // fmt.Printf("CONST %d %s\n", a.Offset, obj.Dconv(&emptyProg, 0, p.arch.Rconv, a))
p.expect(scanner.EOF) p.expect(scanner.EOF)
return true return true
} }
@ -554,7 +554,7 @@ func (p *Parser) symbolReference(a *obj.Addr, name string, prefix rune) {
if p.peek() == '+' || p.peek() == '-' { if p.peek() == '+' || p.peek() == '-' {
a.Offset = int64(p.expr()) a.Offset = int64(p.expr())
} }
a.Sym = obj.Linklookup(p.linkCtxt, name, isStatic) a.Sym = obj.Linklookup(p.ctxt, name, isStatic)
if p.peek() == scanner.EOF { if p.peek() == scanner.EOF {
if prefix != 0 { if prefix != 0 {
p.errorf("illegal addressing mode for symbol %s", name) p.errorf("illegal addressing mode for symbol %s", name)

4
src/cmd/asm/internal/asm/testdata/386.out vendored
View File

@ -1,4 +1,4 @@
5 00001 (testdata/386.s:5) TEXT foo+0(SB),$0 5 00001 (testdata/386.s:5) TEXT foo(SB),$0
8 00002 (testdata/386.s:8) SETCC ,AX 8 00002 (testdata/386.s:8) SETCC ,AX
9 00003 (testdata/386.s:9) SETCC ,foo+4(SB) 9 00003 (testdata/386.s:9) SETCC ,foo+4(SB)
12 00004 (testdata/386.s:12) DIVB AX, 12 00004 (testdata/386.s:12) DIVB AX,
@ -20,7 +20,7 @@
37 00020 (testdata/386.s:37) CALL ,type=16 37 00020 (testdata/386.s:37) CALL ,type=16
38 00021 (testdata/386.s:38) JMP ,$4 38 00021 (testdata/386.s:38) JMP ,$4
39 00022 (testdata/386.s:39) JMP ,16 39 00022 (testdata/386.s:39) JMP ,16
40 00023 (testdata/386.s:40) CALL ,foo+0(SB) 40 00023 (testdata/386.s:40) CALL ,foo(SB)
42 00024 (testdata/386.s:42) CALL ,foo+4(SB)(AX*4) 42 00024 (testdata/386.s:42) CALL ,foo+4(SB)(AX*4)
43 00025 (testdata/386.s:43) CALL ,4(SP) 43 00025 (testdata/386.s:43) CALL ,4(SP)
44 00026 (testdata/386.s:44) CALL ,(AX) 44 00026 (testdata/386.s:44) CALL ,(AX)

2
src/cmd/asm/internal/asm/testdata/amd64.out vendored
View File

@ -1,4 +1,4 @@
5 00001 (testdata/amd64.s:5) TEXT foo+0(SB),$0 5 00001 (testdata/amd64.s:5) TEXT foo(SB),$0
8 00002 (testdata/amd64.s:8) NEGQ ,R11 8 00002 (testdata/amd64.s:8) NEGQ ,R11
9 00003 (testdata/amd64.s:9) NEGQ ,4(R11) 9 00003 (testdata/amd64.s:9) NEGQ ,4(R11)
10 00004 (testdata/amd64.s:10) NEGQ ,foo+4(SB) 10 00004 (testdata/amd64.s:10) NEGQ ,foo+4(SB)

38
src/cmd/asm/internal/asm/testdata/arm.out vendored
View File

@ -1,4 +1,4 @@
5 00001 (testdata/arm.s:5) TEXT foo+0(SB),0,$0 5 00001 (testdata/arm.s:5) TEXT foo(SB),0,$0
14 00002 (testdata/arm.s:14) ADD $1,R2,R3 14 00002 (testdata/arm.s:14) ADD $1,R2,R3
15 00003 (testdata/arm.s:15) ADD R1<<R2,R3,R4 15 00003 (testdata/arm.s:15) ADD R1<<R2,R3,R4
16 00004 (testdata/arm.s:16) ADD R1>>R2,R3,R4 16 00004 (testdata/arm.s:16) ADD R1>>R2,R3,R4
@ -17,37 +17,37 @@
54 00017 (testdata/arm.s:54) MOVW.S $1,R2 54 00017 (testdata/arm.s:54) MOVW.S $1,R2
55 00018 (testdata/arm.s:55) MOVW.S R1<<R2,R3 55 00018 (testdata/arm.s:55) MOVW.S R1<<R2,R3
64 00019 (testdata/arm.s:64) JMP.S ,20(PC) 64 00019 (testdata/arm.s:64) JMP.S ,20(PC)
70 00020 (testdata/arm.s:70) JMP.S ,0(R2) 70 00020 (testdata/arm.s:70) JMP.S ,(R2)
71 00021 (testdata/arm.s:71) JMP.S ,foo+0(SB) 71 00021 (testdata/arm.s:71) JMP.S ,foo(SB)
72 00022 (testdata/arm.s:72) JMP.S ,bar<>+0(SB) 72 00022 (testdata/arm.s:72) JMP.S ,bar<>(SB)
81 00023 (testdata/arm.s:81) BX 0(R2), 81 00023 (testdata/arm.s:81) BX (R2),
90 00024 (testdata/arm.s:90) BEQ ,25(PC) 90 00024 (testdata/arm.s:90) BEQ ,25(PC)
99 00025 (testdata/arm.s:99) SWI.S ,R1 99 00025 (testdata/arm.s:99) SWI.S ,R1
100 00026 (testdata/arm.s:100) SWI.S ,0(R1) 100 00026 (testdata/arm.s:100) SWI.S ,(R1)
101 00027 (testdata/arm.s:101) SWI.S ,foo+0(SB) 101 00027 (testdata/arm.s:101) SWI.S ,foo(SB)
110 00028 (testdata/arm.s:110) CMP.S $1,R2, 110 00028 (testdata/arm.s:110) CMP.S $1,R2,
111 00029 (testdata/arm.s:111) CMP.S R1<<R2,R3, 111 00029 (testdata/arm.s:111) CMP.S R1<<R2,R3,
112 00030 (testdata/arm.s:112) CMP.S R1,R2, 112 00030 (testdata/arm.s:112) CMP.S R1,R2,
126 00031 (testdata/arm.s:126) MOVM 0(R1),[R2,R5,R8,R10] 126 00031 (testdata/arm.s:126) MOVM (R1),[R2,R5,R8,R10]
127 00032 (testdata/arm.s:127) MOVM 0(R1),[R2,R3,R4,R5] 127 00032 (testdata/arm.s:127) MOVM (R1),[R2,R3,R4,R5]
128 00033 (testdata/arm.s:128) MOVM.S 0(R1),[R2] 128 00033 (testdata/arm.s:128) MOVM.S (R1),[R2]
139 00034 (testdata/arm.s:139) MOVM [R2,R5,R8,R10],0(R1) 139 00034 (testdata/arm.s:139) MOVM [R2,R5,R8,R10],(R1)
140 00035 (testdata/arm.s:140) MOVM [R2,R3,R4,R5],0(R1) 140 00035 (testdata/arm.s:140) MOVM [R2,R3,R4,R5],(R1)
141 00036 (testdata/arm.s:141) MOVM.S [R2],0(R1) 141 00036 (testdata/arm.s:141) MOVM.S [R2],(R1)
150 00037 (testdata/arm.s:150) STREX.S 0(R2),R1,R3 150 00037 (testdata/arm.s:150) STREX.S (R2),R1,R3
156 00038 (testdata/arm.s:156) STREX.S 0(R2),R1,R1 156 00038 (testdata/arm.s:156) STREX.S (R2),R1,R1
162 00039 (testdata/arm.s:162) STREX.S 0(R2),R3,R3 162 00039 (testdata/arm.s:162) STREX.S (R2),R3,R3
170 00040 (testdata/arm.s:170) CASE.S R1, 170 00040 (testdata/arm.s:170) CASE.S R1,
179 00041 (testdata/arm.s:179) WORD ,$1234 179 00041 (testdata/arm.s:179) WORD ,$1234
188 00042 (testdata/arm.s:188) ABSF.S F1,F2 188 00042 (testdata/arm.s:188) ABSF.S F1,F2
194 00043 (testdata/arm.s:194) ADDD.S F1,F2 194 00043 (testdata/arm.s:194) ADDD.S F1,F2
195 00044 (testdata/arm.s:195) ADDD.S $0.5,F2 195 00044 (testdata/arm.s:195) ADDD.S $(0.5),F2
201 00045 (testdata/arm.s:201) ADDD.S F1,F2,F3 201 00045 (testdata/arm.s:201) ADDD.S F1,F2,F3
202 00046 (testdata/arm.s:202) ADDD.S $0.5,F2,F3 202 00046 (testdata/arm.s:202) ADDD.S $(0.5),F2,F3
208 00047 (testdata/arm.s:208) CMPD.S F1,F2 208 00047 (testdata/arm.s:208) CMPD.S F1,F2
242 00048 (testdata/arm.s:242) MULL R1,R2,(R3, R4) 242 00048 (testdata/arm.s:242) MULL R1,R2,(R3, R4)
254 00049 (testdata/arm.s:254) MULAWT R1,R2,R3, R4 254 00049 (testdata/arm.s:254) MULAWT R1,R2,R3, R4
262 00050 (testdata/arm.s:262) PLD 0(R1), 262 00050 (testdata/arm.s:262) PLD (R1),
263 00051 (testdata/arm.s:263) PLD 4(R1), 263 00051 (testdata/arm.s:263) PLD 4(R1),
272 00052 (testdata/arm.s:272) RET , 272 00052 (testdata/arm.s:272) RET ,
281 00053 (testdata/arm.s:281) END , 281 00053 (testdata/arm.s:281) END ,

56
src/cmd/asm/internal/asm/testdata/ppc64.out vendored
View File

@ -2,32 +2,32 @@
15 00002 (testdata/ppc64.s:15) MOVW R1,R2 15 00002 (testdata/ppc64.s:15) MOVW R1,R2
21 00003 (testdata/ppc64.s:21) MOVW foo<>+3(SB),R2 21 00003 (testdata/ppc64.s:21) MOVW foo<>+3(SB),R2
22 00004 (testdata/ppc64.s:22) MOVW 16(R1),R2 22 00004 (testdata/ppc64.s:22) MOVW 16(R1),R2
28 00005 (testdata/ppc64.s:28) MOVW 0(R1),R2 28 00005 (testdata/ppc64.s:28) MOVW (R1),R2
29 00006 (testdata/ppc64.s:29) MOVW 0(R1+R2),R3 29 00006 (testdata/ppc64.s:29) MOVW (R1+R2),R3
35 00007 (testdata/ppc64.s:35) MOVW R1,R2 35 00007 (testdata/ppc64.s:35) MOVW R1,R2
41 00008 (testdata/ppc64.s:41) MOVB foo<>+3(SB),R2 41 00008 (testdata/ppc64.s:41) MOVB foo<>+3(SB),R2
42 00009 (testdata/ppc64.s:42) MOVB 16(R1),R2 42 00009 (testdata/ppc64.s:42) MOVB 16(R1),R2
48 00010 (testdata/ppc64.s:48) MOVB 0(R1),R2 48 00010 (testdata/ppc64.s:48) MOVB (R1),R2
49 00011 (testdata/ppc64.s:49) MOVB 0(R1+R2),R3 49 00011 (testdata/ppc64.s:49) MOVB (R1+R2),R3
58 00012 (testdata/ppc64.s:58) FMOVD foo<>+3(SB),F2 58 00012 (testdata/ppc64.s:58) FMOVD foo<>+3(SB),F2
59 00013 (testdata/ppc64.s:59) FMOVD 16(R1),F2 59 00013 (testdata/ppc64.s:59) FMOVD 16(R1),F2
65 00014 (testdata/ppc64.s:65) FMOVD 0(R1),F2 65 00014 (testdata/ppc64.s:65) FMOVD (R1),F2
71 00015 (testdata/ppc64.s:71) FMOVD $0.10000000000000001,F2 71 00015 (testdata/ppc64.s:71) FMOVD $(0.10000000000000001),F2
77 00016 (testdata/ppc64.s:77) FMOVD F1,F2 77 00016 (testdata/ppc64.s:77) FMOVD F1,F2
83 00017 (testdata/ppc64.s:83) FMOVD F2,foo<>+3(SB) 83 00017 (testdata/ppc64.s:83) FMOVD F2,foo<>+3(SB)
84 00018 (testdata/ppc64.s:84) FMOVD F2,16(R1) 84 00018 (testdata/ppc64.s:84) FMOVD F2,16(R1)
90 00019 (testdata/ppc64.s:90) FMOVD F2,0(R1) 90 00019 (testdata/ppc64.s:90) FMOVD F2,(R1)
99 00020 (testdata/ppc64.s:99) MOVW R1,foo<>+3(SB) 99 00020 (testdata/ppc64.s:99) MOVW R1,foo<>+3(SB)
100 00021 (testdata/ppc64.s:100) MOVW R1,16(R2) 100 00021 (testdata/ppc64.s:100) MOVW R1,16(R2)
106 00022 (testdata/ppc64.s:106) MOVW R1,0(R1) 106 00022 (testdata/ppc64.s:106) MOVW R1,(R1)
107 00023 (testdata/ppc64.s:107) MOVW R1,0(R2+R3) 107 00023 (testdata/ppc64.s:107) MOVW R1,(R2+R3)
113 00024 (testdata/ppc64.s:113) MOVB R1,foo<>+3(SB) 113 00024 (testdata/ppc64.s:113) MOVB R1,foo<>+3(SB)
114 00025 (testdata/ppc64.s:114) MOVB R1,16(R2) 114 00025 (testdata/ppc64.s:114) MOVB R1,16(R2)
120 00026 (testdata/ppc64.s:120) MOVB R1,0(R1) 120 00026 (testdata/ppc64.s:120) MOVB R1,(R1)
121 00027 (testdata/ppc64.s:121) MOVB R1,0(R2+R3) 121 00027 (testdata/ppc64.s:121) MOVB R1,(R2+R3)
129 00028 (testdata/ppc64.s:129) FMOVD F1,foo<>+3(SB) 129 00028 (testdata/ppc64.s:129) FMOVD F1,foo<>+3(SB)
130 00029 (testdata/ppc64.s:130) FMOVD F1,16(R2) 130 00029 (testdata/ppc64.s:130) FMOVD F1,16(R2)
136 00030 (testdata/ppc64.s:136) FMOVD F1,0(R1) 136 00030 (testdata/ppc64.s:136) FMOVD F1,(R1)
145 00031 (testdata/ppc64.s:145) MOVFL FPSCR,F1 145 00031 (testdata/ppc64.s:145) MOVFL FPSCR,F1
151 00032 (testdata/ppc64.s:151) MOVFL F1,FPSCR 151 00032 (testdata/ppc64.s:151) MOVFL F1,FPSCR
157 00033 (testdata/ppc64.s:157) MOVFL F1,$4,FPSCR 157 00033 (testdata/ppc64.s:157) MOVFL F1,$4,FPSCR
@ -58,12 +58,12 @@
355 00058 (testdata/ppc64.s:355) MOVW R1,LR 355 00058 (testdata/ppc64.s:355) MOVW R1,LR
356 00059 (testdata/ppc64.s:356) MOVW R1,CTR 356 00059 (testdata/ppc64.s:356) MOVW R1,CTR
368 00060 (testdata/ppc64.s:368) MOVW R1,SPR(7) 368 00060 (testdata/ppc64.s:368) MOVW R1,SPR(7)
380 00061 (testdata/ppc64.s:380) JMP ,62(APC) 380 00061 (testdata/ppc64.s:380) JMP ,62(PC)
381 00062 (testdata/ppc64.s:381) JMP ,61 381 00062 (testdata/ppc64.s:381) JMP ,61
387 00063 (testdata/ppc64.s:387) JMP ,4(R1) 387 00063 (testdata/ppc64.s:387) JMP ,4(R1)
388 00064 (testdata/ppc64.s:388) JMP ,foo(SB) 388 00064 (testdata/ppc64.s:388) JMP ,foo(SB)
394 00065 (testdata/ppc64.s:394) JMP ,CTR 394 00065 (testdata/ppc64.s:394) JMP ,CTR
413 00066 (testdata/ppc64.s:413) BEQ C1,67(APC) 413 00066 (testdata/ppc64.s:413) BEQ C1,67(PC)
414 00067 (testdata/ppc64.s:414) BEQ C1,66 414 00067 (testdata/ppc64.s:414) BEQ C1,66
440 00068 (testdata/ppc64.s:440) BC 4,CTR 440 00068 (testdata/ppc64.s:440) BC 4,CTR
450 00069 (testdata/ppc64.s:450) BC $3,R4,66 450 00069 (testdata/ppc64.s:450) BC $3,R4,66
@ -86,20 +86,20 @@
594 00086 (testdata/ppc64.s:594) MOVMW 4(R1),R2 594 00086 (testdata/ppc64.s:594) MOVMW 4(R1),R2
600 00087 (testdata/ppc64.s:600) MOVMW R1,foo(SB) 600 00087 (testdata/ppc64.s:600) MOVMW R1,foo(SB)
601 00088 (testdata/ppc64.s:601) MOVMW R1,4(R2) 601 00088 (testdata/ppc64.s:601) MOVMW R1,4(R2)
611 00089 (testdata/ppc64.s:611) LSW 0(R1),R2 611 00089 (testdata/ppc64.s:611) LSW (R1),R2
612 00090 (testdata/ppc64.s:612) LSW 0(R1+R2),R3 612 00090 (testdata/ppc64.s:612) LSW (R1+R2),R3
618 00091 (testdata/ppc64.s:618) LSW 0(R1+NONE),R2 618 00091 (testdata/ppc64.s:618) LSW (R1+NONE),R2
619 00092 (testdata/ppc64.s:619) LSW 0(R1+NONE),R3 619 00092 (testdata/ppc64.s:619) LSW (R1+NONE),R3
625 00093 (testdata/ppc64.s:625) STSW R1,0(R2) 625 00093 (testdata/ppc64.s:625) STSW R1,(R2)
626 00094 (testdata/ppc64.s:626) STSW R1,0(R2+R3) 626 00094 (testdata/ppc64.s:626) STSW R1,(R2+R3)
632 00095 (testdata/ppc64.s:632) STSW R1,0(R2+NONE) 632 00095 (testdata/ppc64.s:632) STSW R1,(R2+NONE)
633 00096 (testdata/ppc64.s:633) STSW R1,0(R2+NONE) 633 00096 (testdata/ppc64.s:633) STSW R1,(R2+NONE)
639 00097 (testdata/ppc64.s:639) MOVHBR 0(R1),R2 639 00097 (testdata/ppc64.s:639) MOVHBR (R1),R2
640 00098 (testdata/ppc64.s:640) MOVHBR 0(R1+R2),R3 640 00098 (testdata/ppc64.s:640) MOVHBR (R1+R2),R3
646 00099 (testdata/ppc64.s:646) MOVHBR R1,0(R2) 646 00099 (testdata/ppc64.s:646) MOVHBR R1,(R2)
647 00100 (testdata/ppc64.s:647) MOVHBR R1,0(R2+R3) 647 00100 (testdata/ppc64.s:647) MOVHBR R1,(R2+R3)
653 00101 (testdata/ppc64.s:653) DCBF 0(R1), 653 00101 (testdata/ppc64.s:653) DCBF (R1),
654 00102 (testdata/ppc64.s:654) DCBF 0(R1), 654 00102 (testdata/ppc64.s:654) DCBF (R1),
663 00103 (testdata/ppc64.s:663) NOP , 663 00103 (testdata/ppc64.s:663) NOP ,
669 00104 (testdata/ppc64.s:669) NOP R2, 669 00104 (testdata/ppc64.s:669) NOP R2,
675 00105 (testdata/ppc64.s:675) NOP F2, 675 00105 (testdata/ppc64.s:675) NOP F2,

143
src/cmd/internal/obj/arm/list5.go
View File

@ -85,20 +85,27 @@ func Pconv(p *obj.Prog) string {
} }
if a == AMOVM { if a == AMOVM {
if p.From.Type == obj.TYPE_CONST { if p.From.Type == obj.TYPE_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)) str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v",
p.Pc, p.Line(), Aconv(a), sc, RAconv(&p.From), obj.Dconv(p, Rconv, &p.To))
} else if p.To.Type == obj.TYPE_CONST { } else if p.To.Type == obj.TYPE_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)) str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v",
p.Pc, p.Line(), Aconv(a), sc, obj.Dconv(p, Rconv, &p.From), RAconv(&p.To))
} else { } else {
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)) str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v",
p.Pc, p.Line(), Aconv(a), sc, obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
} }
} else if a == obj.ADATA { } else if a == obj.ADATA {
str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v", p.Pc, p.Line(), Aconv(a), Dconv(p, 0, &p.From), p.From3.Offset, Dconv(p, 0, &p.To)) str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v",
p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
} else if p.As == obj.ATEXT { } else if p.As == obj.ATEXT {
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v", p.Pc, p.Line(), Aconv(a), Dconv(p, 0, &p.From), p.From3.Offset, Dconv(p, 0, &p.To)) str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v",
p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
} else if p.Reg == 0 { } else if p.Reg == 0 {
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)) str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v",
p.Pc, p.Line(), Aconv(a), sc, obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
} else { } else {
str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v,%v", p.Pc, p.Line(), Aconv(a), sc, Dconv(p, 0, &p.From), Rconv(int(p.Reg)), Dconv(p, 0, &p.To)) str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v,%v",
p.Pc, p.Line(), Aconv(a), sc, obj.Dconv(p, Rconv, &p.From), Rconv(int(p.Reg)), obj.Dconv(p, Rconv, &p.To))
} }
fp += str fp += str
@ -117,91 +124,6 @@ func Aconv(a int) string {
return fp return fp
} }
func Dconv(p *obj.Prog, flag int, a *obj.Addr) string {
var str string
var fp string
var op string
var v int
switch a.Type {
default:
str = fmt.Sprintf("GOK-type(%d)", a.Type)
case obj.TYPE_NONE:
str = ""
if a.Name != obj.TYPE_NONE || a.Reg != 0 || a.Sym != nil {
str = fmt.Sprintf("%v(%v)(NONE)", Mconv(a), Rconv(int(a.Reg)))
}
case obj.TYPE_CONST,
obj.TYPE_ADDR:
if a.Reg != 0 {
str = fmt.Sprintf("$%v(%v)", Mconv(a), Rconv(int(a.Reg)))
} else {
str = fmt.Sprintf("$%v", Mconv(a))
}
case obj.TYPE_TEXTSIZE:
if a.U.Argsize == obj.ArgsSizeUnknown {
str = fmt.Sprintf("$%d", a.Offset)
} else {
str = fmt.Sprintf("$%d-%d", a.Offset, a.U.Argsize)
}
case obj.TYPE_SHIFT:
v = int(a.Offset)
op = string("<<>>->@>"[((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 obj.TYPE_MEM:
if a.Reg != 0 {
str = fmt.Sprintf("%v(%v)", Mconv(a), Rconv(int(a.Reg)))
} else {
str = fmt.Sprintf("%v", Mconv(a))
}
case obj.TYPE_REG:
str = fmt.Sprintf("%v", Rconv(int(a.Reg)))
if a.Name != obj.TYPE_NONE || a.Sym != nil {
str = fmt.Sprintf("%v(%v)(REG)", Mconv(a), Rconv(int(a.Reg)))
}
case obj.TYPE_BRANCH:
if a.Sym != nil {
str = fmt.Sprintf("%s(SB)", a.Sym.Name)
} else if p != nil && p.Pcond != nil {
str = fmt.Sprintf("%d", p.Pcond.Pc)
} else if a.U.Branch != nil {
str = fmt.Sprintf("%d", a.U.Branch.Pc)
} else {
str = fmt.Sprintf("%d(PC)", a.Offset) /*-pc*/
}
case obj.TYPE_FCONST:
str = fmt.Sprintf("$%.17g", a.U.Dval)
case obj.TYPE_SCONST:
str = fmt.Sprintf("$%q", a.U.Sval)
case obj.TYPE_REGREG:
str = fmt.Sprintf("(%v, %v)", Rconv(int(a.Reg)), Rconv(int(a.Offset)))
case obj.TYPE_REGREG2:
str = fmt.Sprintf("%v, %v", Rconv(int(a.Reg)), Rconv(int(a.Offset)))
}
fp += str
return fp
}
func RAconv(a *obj.Addr) string { func RAconv(a *obj.Addr) string {
var str string var str string
var fp string var fp string
@ -287,40 +209,3 @@ func DRconv(a int) string {
fp += s fp += s
return fp return fp
} }
func Mconv(a *obj.Addr) string {
var str string
var fp string
var s *obj.LSym
s = a.Sym
if s == nil {
str = fmt.Sprintf("%d", int(a.Offset))
goto out
}
switch a.Name {
default:
str = fmt.Sprintf("GOK-name(%d)", a.Name)
case obj.NAME_NONE:
str = fmt.Sprintf("%d", a.Offset)
case obj.NAME_EXTERN:
str = fmt.Sprintf("%s+%d(SB)", s.Name, int(a.Offset))
case obj.NAME_STATIC:
str = fmt.Sprintf("%s<>+%d(SB)", s.Name, int(a.Offset))
case obj.NAME_AUTO:
str = fmt.Sprintf("%s-%d(SP)", s.Name, int(-a.Offset))
case obj.NAME_PARAM:
str = fmt.Sprintf("%s+%d(FP)", s.Name, int(a.Offset))
}
out:
fp += str
return fp
}

1
src/cmd/internal/obj/arm/obj5.go
View File

@ -1061,7 +1061,6 @@ loop:
} }
var Linkarm = obj.LinkArch{ var Linkarm = obj.LinkArch{
Dconv: Dconv,
Rconv: Rconv, Rconv: Rconv,
ByteOrder: binary.LittleEndian, ByteOrder: binary.LittleEndian,
Pconv: Pconv, Pconv: Pconv,

2
src/cmd/internal/obj/data.go
View File

@ -43,7 +43,7 @@ func mangle(file string) {
func Symgrow(ctxt *Link, s *LSym, lsiz int64) { func Symgrow(ctxt *Link, s *LSym, lsiz int64) {
siz := int(lsiz) siz := int(lsiz)
if int64(siz) != lsiz { if int64(siz) != lsiz {
log.Fatal("Symgrow size %d too long", lsiz) log.Fatalf("Symgrow size %d too long", lsiz)
} }
if len(s.P) >= siz { if len(s.P) >= siz {
return return

12
src/cmd/internal/obj/i386/asm8.go
View File

@ -1501,7 +1501,7 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
} }
if a.Sym != nil || a.Name != obj.NAME_NONE { if a.Sym != nil || a.Name != obj.NAME_NONE {
ctxt.Diag("unexpected addr: %v", Dconv(p, 0, a)) ctxt.Diag("unexpected addr: %v", obj.Dconv(p, Rconv, a))
} }
fallthrough fallthrough
@ -1509,7 +1509,7 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
case obj.TYPE_CONST: case obj.TYPE_CONST:
if a.Sym != nil { if a.Sym != nil {
ctxt.Diag("TYPE_CONST with symbol: %v", Dconv(p, 0, a)) ctxt.Diag("TYPE_CONST with symbol: %v", obj.Dconv(p, Rconv, a))
} }
v = int32(a.Offset) v = int32(a.Offset)
@ -1529,7 +1529,7 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
} }
if a.Type != obj.TYPE_REG { if a.Type != obj.TYPE_REG {
ctxt.Diag("unexpected addr1: type=%d %v", a.Type, Dconv(p, 0, a)) ctxt.Diag("unexpected addr1: type=%d %v", a.Type, obj.Dconv(p, Rconv, a))
return Yxxx return Yxxx
} }
@ -1772,7 +1772,7 @@ func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int32 {
s = a.Sym s = a.Sym
if s != nil { if s != nil {
if r == nil { if r == nil {
ctxt.Diag("need reloc for %v", Dconv(p, 0, a)) ctxt.Diag("need reloc for %v", obj.Dconv(p, Rconv, a))
log.Fatalf("bad code") log.Fatalf("bad code")
} }
@ -1789,7 +1789,7 @@ func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int32 {
if (a.Type == obj.TYPE_MEM || a.Type == obj.TYPE_ADDR) && a.Reg == REG_TLS { if (a.Type == obj.TYPE_MEM || a.Type == obj.TYPE_ADDR) && a.Reg == REG_TLS {
if r == nil { if r == nil {
ctxt.Diag("need reloc for %v", Dconv(p, 0, a)) ctxt.Diag("need reloc for %v", obj.Dconv(p, Rconv, a))
log.Fatalf("bad code") log.Fatalf("bad code")
} }
@ -1972,7 +1972,7 @@ putrelv:
return return
bad: bad:
ctxt.Diag("asmand: bad address %v", Dconv(p, 0, a)) ctxt.Diag("asmand: bad address %v", obj.Dconv(p, Rconv, a))
return return
} }

111
src/cmd/internal/obj/i386/list8.go
View File

@ -47,18 +47,22 @@ func Pconv(p *obj.Prog) string {
switch p.As { switch p.As {
case obj.ADATA: case obj.ADATA:
str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v", p.Pc, p.Line(), Aconv(int(p.As)), Dconv(p, 0, &p.From), p.From3.Offset, Dconv(p, 0, &p.To)) str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v",
p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
case obj.ATEXT: case obj.ATEXT:
if p.From3.Offset != 0 { if p.From3.Offset != 0 {
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v", p.Pc, p.Line(), Aconv(int(p.As)), Dconv(p, 0, &p.From), p.From3.Offset, Dconv(p, 0, &p.To)) str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v",
p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
break break
} }
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v", p.Pc, p.Line(), Aconv(int(p.As)), Dconv(p, 0, &p.From), Dconv(p, 0, &p.To)) str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
default: default:
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v", p.Pc, p.Line(), Aconv(int(p.As)), Dconv(p, 0, &p.From), Dconv(p, 0, &p.To)) str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
// TODO(rsc): This special case is for SHRQ $32, AX:DX, which encodes as // TODO(rsc): This special case is for SHRQ $32, AX:DX, which encodes as
// SHRQ $32(DX*0), AX // SHRQ $32(DX*0), AX
@ -79,105 +83,6 @@ func Aconv(i int) string {
return fp return fp
} }
func Dconv(p *obj.Prog, flag int, a *obj.Addr) string {
var str string
var s string
var fp string
switch a.Type {
default:
str = fmt.Sprintf("type=%d", a.Type)
case obj.TYPE_NONE:
str = ""
// TODO(rsc): This special case is for instructions like
// PINSRQ CX,$1,X6
// where the $1 is included in the p->to Addr.
// Move into a new field.
case obj.TYPE_REG:
if a.Offset != 0 {
str = fmt.Sprintf("$%d,%v", a.Offset, Rconv(int(a.Reg)))
break
}
str = fmt.Sprintf("%v", Rconv(int(a.Reg)))
case obj.TYPE_BRANCH:
if a.Sym != nil {
str = fmt.Sprintf("%s(SB)", a.Sym.Name)
} else if p != nil && p.Pcond != nil {
str = fmt.Sprintf("%d", p.Pcond.Pc)
} else if a.U.Branch != nil {
str = fmt.Sprintf("%d", a.U.Branch.Pc)
} else {
str = fmt.Sprintf("%d(PC)", a.Offset)
}
case obj.TYPE_MEM:
switch a.Name {
default:
str = fmt.Sprintf("name=%d", a.Name)
case obj.NAME_NONE:
if a.Offset != 0 {
str = fmt.Sprintf("%d(%v)", a.Offset, Rconv(int(a.Reg)))
} else {
str = fmt.Sprintf("(%v)", Rconv(int(a.Reg)))
}
case obj.NAME_EXTERN:
str = fmt.Sprintf("%s+%d(SB)", a.Sym.Name, a.Offset)
case obj.NAME_STATIC:
str = fmt.Sprintf("%s<>+%d(SB)", a.Sym.Name, a.Offset)
case obj.NAME_AUTO:
if a.Sym != nil {
str = fmt.Sprintf("%s+%d(SP)", a.Sym.Name, a.Offset)
} else {
str = fmt.Sprintf("%d(SP)", a.Offset)
}
case obj.NAME_PARAM:
if a.Sym != nil {
str = fmt.Sprintf("%s+%d(FP)", a.Sym.Name, a.Offset)
} else {
str = fmt.Sprintf("%d(FP)", a.Offset)
}
}
if a.Index != REG_NONE {
s = fmt.Sprintf("(%v*%d)", Rconv(int(a.Index)), int(a.Scale))
str += s
}
case obj.TYPE_CONST:
str = fmt.Sprintf("$%d", a.Offset)
case obj.TYPE_TEXTSIZE:
if a.U.Argsize == obj.ArgsSizeUnknown {
str = fmt.Sprintf("$%d", a.Offset)
} else {
str = fmt.Sprintf("$%d-%d", a.Offset, a.U.Argsize)
}
case obj.TYPE_FCONST:
str = fmt.Sprintf("$(%.17g)", a.U.Dval)
case obj.TYPE_SCONST:
str = fmt.Sprintf("$%q", a.U.Sval)
case obj.TYPE_ADDR:
a.Type = obj.TYPE_MEM
str = fmt.Sprintf("$%v", Dconv(p, 0, a))
a.Type = obj.TYPE_ADDR
}
fp += str
return fp
}
var Register = []string{ var Register = []string{
"AL", /* [REG_AL] */ "AL", /* [REG_AL] */
"CL", "CL",

1
src/cmd/internal/obj/i386/obj8.go
View File

@ -909,7 +909,6 @@ loop:
} }
var Link386 = obj.LinkArch{ var Link386 = obj.LinkArch{
Dconv: Dconv,
Rconv: Rconv, Rconv: Rconv,
ByteOrder: binary.LittleEndian, ByteOrder: binary.LittleEndian,
Pconv: Pconv, Pconv: Pconv,

1
src/cmd/internal/obj/link.go
View File

@ -241,7 +241,6 @@ type Plist struct {
type LinkArch struct { type LinkArch struct {
Pconv func(*Prog) string Pconv func(*Prog) string
Dconv func(*Prog, int, *Addr) string
Rconv func(int) string Rconv func(int) string
ByteOrder binary.ByteOrder ByteOrder binary.ByteOrder
Name string Name string

167
src/cmd/internal/obj/ppc64/list9.go
View File

@ -63,32 +63,47 @@ func Pconv(p *obj.Prog) string {
str = "" str = ""
if a == obj.ADATA { if a == obj.ADATA {
str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v", p.Pc, p.Line(), Aconv(a), Dconv(p, 0, &p.From), p.From3.Offset, Dconv(p, 0, &p.To)) str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v",
p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
} else if a == obj.ATEXT || a == obj.AGLOBL { } else if a == obj.ATEXT || a == obj.AGLOBL {
if p.From3.Offset != 0 { if p.From3.Offset != 0 {
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v", p.Pc, p.Line(), Aconv(a), Dconv(p, 0, &p.From), p.From3.Offset, Dconv(p, 0, &p.To)) str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v",
p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
} else { } else {
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)) str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
} }
} else { } else {
if p.Mark&NOSCHED != 0 { if p.Mark&NOSCHED != 0 {
str += fmt.Sprintf("*") str += fmt.Sprintf("*")
} }
if p.Reg == 0 && p.From3.Type == obj.TYPE_NONE { if p.Reg == 0 && p.From3.Type == obj.TYPE_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)) str += fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
} else if a != obj.ATEXT && p.From.Type == obj.TYPE_MEM { } else if a != obj.ATEXT && p.From.Type == obj.TYPE_MEM {
str += fmt.Sprintf("%.5d (%v)\t%v\t%d(%v+%v),%v", p.Pc, p.Line(), Aconv(a), p.From.Offset, Rconv(int(p.From.Reg)), Rconv(int(p.Reg)), Dconv(p, 0, &p.To)) off := ""
if p.From.Offset != 0 {
off = fmt.Sprintf("%d", p.From.Offset)
}
str += fmt.Sprintf("%.5d (%v)\t%v\t%s(%v+%v),%v",
p.Pc, p.Line(), Aconv(a), off, Rconv(int(p.From.Reg)), Rconv(int(p.Reg)), obj.Dconv(p, Rconv, &p.To))
} else if p.To.Type == obj.TYPE_MEM { } else if p.To.Type == obj.TYPE_MEM {
str += fmt.Sprintf("%.5d (%v)\t%v\t%v,%d(%v+%v)", p.Pc, p.Line(), Aconv(a), Dconv(p, 0, &p.From), p.To.Offset, Rconv(int(p.To.Reg)), Rconv(int(p.Reg))) off := ""
if p.From.Offset != 0 {
off = fmt.Sprintf("%d", p.From.Offset)
}
str += fmt.Sprintf("%.5d (%v)\t%v\t%v,%s(%v+%v)",
p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From), off, Rconv(int(p.To.Reg)), Rconv(int(p.Reg)))
} else { } else {
str += fmt.Sprintf("%.5d (%v)\t%v\t%v", p.Pc, p.Line(), Aconv(a), Dconv(p, 0, &p.From)) str += fmt.Sprintf("%.5d (%v)\t%v\t%v",
p.Pc, p.Line(), Aconv(a), obj.Dconv(p, Rconv, &p.From))
if p.Reg != 0 { if p.Reg != 0 {
str += fmt.Sprintf(",%v", Rconv(int(p.Reg))) str += fmt.Sprintf(",%v", Rconv(int(p.Reg)))
} }
if p.From3.Type != obj.TYPE_NONE { if p.From3.Type != obj.TYPE_NONE {
str += fmt.Sprintf(",%v", Dconv(p, 0, &p.From3)) str += fmt.Sprintf(",%v", obj.Dconv(p, Rconv, &p.From3))
} }
str += fmt.Sprintf(",%v", Dconv(p, 0, &p.To)) str += fmt.Sprintf(",%v", obj.Dconv(p, Rconv, &p.To))
} }
if p.Spadj != 0 { if p.Spadj != 0 {
@ -113,140 +128,6 @@ func Aconv(a int) string {
return fp return fp
} }
func Dconv(p *obj.Prog, flag int, a *obj.Addr) string {
var str string
var fp string
var v int32
switch a.Type {
default:
str = fmt.Sprintf("GOK-type(%d)", a.Type)
case obj.TYPE_NONE:
str = ""
if a.Name != obj.TYPE_NONE || a.Reg != 0 || a.Sym != nil {
str = fmt.Sprintf("%v(%v)(NONE)", Mconv(a), Rconv(int(a.Reg)))
}
case obj.TYPE_CONST,
obj.TYPE_ADDR:
if a.Reg != 0 {
str = fmt.Sprintf("$%v(%v)", Mconv(a), Rconv(int(a.Reg)))
} else {
str = fmt.Sprintf("$%v", Mconv(a))
}
case obj.TYPE_TEXTSIZE:
if a.U.Argsize == obj.ArgsSizeUnknown {
str = fmt.Sprintf("$%d", a.Offset)
} else {
str = fmt.Sprintf("$%d-%d", a.Offset, a.U.Argsize)
}
case obj.TYPE_MEM:
if a.Reg != 0 {
str = fmt.Sprintf("%v(%v)", Mconv(a), Rconv(int(a.Reg)))
} else {
str = fmt.Sprintf("%v", Mconv(a))
}
case obj.TYPE_REG:
str = fmt.Sprintf("%v", Rconv(int(a.Reg)))
if a.Name != obj.TYPE_NONE || a.Sym != nil {
str = fmt.Sprintf("%v(%v)(REG)", Mconv(a), Rconv(int(a.Reg)))
}
case obj.TYPE_BRANCH:
if p.Pcond != nil {
v = int32(p.Pcond.Pc)
//if(v >= INITTEXT)
// v -= INITTEXT-HEADR;
if a.Sym != nil {
str = fmt.Sprintf("%s+%.5x(BRANCH)", a.Sym.Name, uint32(v))
} else {
str = fmt.Sprintf("%.5x(BRANCH)", uint32(v))
}
} else if a.U.Branch != nil {
str = fmt.Sprintf("%d", a.U.Branch.Pc)
} else if a.Sym != nil {
str = fmt.Sprintf("%s+%d(APC)", a.Sym.Name, a.Offset)
} else {
str = fmt.Sprintf("%d(APC)", a.Offset)
}
//sprint(str, "$%lux-%lux", a->ieee.h, a->ieee.l);
case obj.TYPE_FCONST:
str = fmt.Sprintf("$%.17g", a.U.Dval)
case obj.TYPE_SCONST:
str = fmt.Sprintf("$%q", a.U.Sval)
}
fp += str
return fp
}
func Mconv(a *obj.Addr) string {
var str string
var fp string
var s *obj.LSym
var l int32
s = a.Sym
//if(s == nil) {
// l = a->offset;
// if((vlong)l != a->offset)
// sprint(str, "0x%llux", a->offset);
// else
// sprint(str, "%lld", a->offset);
// goto out;
//}
switch a.Name {
default:
str = fmt.Sprintf("GOK-name(%d)", a.Name)
case obj.TYPE_NONE:
l = int32(a.Offset)
if int64(l) != a.Offset {
str = fmt.Sprintf("0x%x", uint64(a.Offset))
} else {
str = fmt.Sprintf("%d", a.Offset)
}
case obj.NAME_EXTERN:
if a.Offset != 0 {
str = fmt.Sprintf("%s+%d(SB)", s.Name, a.Offset)
} else {
str = fmt.Sprintf("%s(SB)", s.Name)
}
case obj.NAME_STATIC:
str = fmt.Sprintf("%s<>+%d(SB)", s.Name, a.Offset)
case obj.NAME_AUTO:
if s == nil {
str = fmt.Sprintf("%d(SP)", -a.Offset)
} else {
str = fmt.Sprintf("%s-%d(SP)", s.Name, -a.Offset)
}
case obj.NAME_PARAM:
if s == nil {
str = fmt.Sprintf("%d(FP)", a.Offset)
} else {
str = fmt.Sprintf("%s+%d(FP)", s.Name, a.Offset)
}
}
//out:
fp += str
return fp
}
func Rconv(r int) string { func Rconv(r int) string {
var fp string var fp string

2
src/cmd/internal/obj/ppc64/obj9.go
View File

@ -965,7 +965,6 @@ loop:
} }
var Linkppc64 = obj.LinkArch{ var Linkppc64 = obj.LinkArch{
Dconv: Dconv,
Rconv: Rconv, Rconv: Rconv,
ByteOrder: binary.BigEndian, ByteOrder: binary.BigEndian,
Pconv: Pconv, Pconv: Pconv,
@ -982,7 +981,6 @@ var Linkppc64 = obj.LinkArch{
} }
var Linkppc64le = obj.LinkArch{ var Linkppc64le = obj.LinkArch{
Dconv: Dconv,
Rconv: Rconv, Rconv: Rconv,
ByteOrder: binary.LittleEndian, ByteOrder: binary.LittleEndian,
Pconv: Pconv, Pconv: Pconv,

161
src/cmd/internal/obj/util.go
View File

@ -11,9 +11,12 @@ import (
"log" "log"
"os" "os"
"strconv" "strconv"
"strings"
"time" "time"
) )
const REG_NONE = 0
var start time.Time var start time.Time
func Cputime() float64 { func Cputime() float64 {
@ -63,7 +66,7 @@ func Bwritestring(b *Biobuf, p string) (int, error) {
func Bseek(b *Biobuf, offset int64, whence int) int64 { func Bseek(b *Biobuf, offset int64, whence int) int64 {
if b.w != nil { if b.w != nil {
if err := b.w.Flush(); err != nil { if err := b.w.Flush(); err != nil {
log.Fatal("writing output: %v", err) log.Fatalf("writing output: %v", err)
} }
} else if b.r != nil { } else if b.r != nil {
if whence == 1 { if whence == 1 {
@ -72,7 +75,7 @@ func Bseek(b *Biobuf, offset int64, whence int) int64 {
} }
off, err := b.f.Seek(offset, whence) off, err := b.f.Seek(offset, whence)
if err != nil { if err != nil {
log.Fatal("seeking in output: %v", err) log.Fatalf("seeking in output: %v", err)
} }
if b.r != nil { if b.r != nil {
b.r.Reset(b.f) b.r.Reset(b.f)
@ -82,11 +85,11 @@ func Bseek(b *Biobuf, offset int64, whence int) int64 {
func Boffset(b *Biobuf) int64 { func Boffset(b *Biobuf) int64 {
if err := b.w.Flush(); err != nil { if err := b.w.Flush(); err != nil {
log.Fatal("writing output: %v", err) log.Fatalf("writing output: %v", err)
} }
off, err := b.f.Seek(0, 1) off, err := b.f.Seek(0, 1)
if err != nil { if err != nil {
log.Fatal("seeking in output: %v", err) log.Fatalf("seeking in output: %v", err)
} }
return off return off
} }
@ -258,10 +261,6 @@ func (ctxt *Link) Line(n int) string {
return Linklinefmt(ctxt, n, false, false) return Linklinefmt(ctxt, n, false, false)
} }
func (ctxt *Link) Dconv(a *Addr) string {
return ctxt.Arch.Dconv(nil, 0, a)
}
func (ctxt *Link) Rconv(reg int) string { func (ctxt *Link) Rconv(reg int) string {
return ctxt.Arch.Rconv(reg) return ctxt.Arch.Rconv(reg)
} }
@ -269,3 +268,149 @@ func (ctxt *Link) Rconv(reg int) string {
func Getcallerpc(interface{}) uintptr { func Getcallerpc(interface{}) uintptr {
return 1 return 1
} }
func (ctxt *Link) Dconv(a *Addr) string {
return Dconv(nil, ctxt.Rconv, a)
}
func Dconv(p *Prog, Rconv func(int) string, 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(Rconv, 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 = fmt.Sprintf("%v", Rconv(int(a.Reg)))
if a.Name != TYPE_NONE || a.Sym != nil {
str = fmt.Sprintf("%v(%v)(REG)", Mconv(Rconv, 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.Sprintf("%d", p.Pcond.Pc)
} else if a.U.Branch != nil {
str = fmt.Sprintf("%d", a.U.Branch.Pc)
} else {
str = fmt.Sprintf("%d(PC)", a.Offset)
}
case TYPE_MEM:
str = Mconv(Rconv, 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(Rconv, a), Rconv(int(a.Reg)))
} else {
str = fmt.Sprintf("$%v", Mconv(Rconv, a))
}
case TYPE_TEXTSIZE:
if a.U.Argsize == ArgsSizeUnknown {
str = fmt.Sprintf("$%d", a.Offset)
} else {
str = fmt.Sprintf("$%d-%d", a.Offset, a.U.Argsize)
}
case TYPE_FCONST:
str = fmt.Sprintf("%.17g", a.U.Dval)
// 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.U.Sval)
case TYPE_ADDR:
str = fmt.Sprintf("$%s", Mconv(Rconv, a))
case TYPE_SHIFT:
v := int(a.Offset)
op := string("<<>>->@>"[((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 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.Reg)), Rconv(int(a.Offset)))
}
return str
}
func Mconv(Rconv func(int) string, 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.Sprintf("%d", 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)))
}
case NAME_EXTERN:
str = fmt.Sprintf("%s%s(SB)", a.Sym.Name, offConv(a.Offset))
case NAME_STATIC:
str = fmt.Sprintf("%s<>%s(SB)", a.Sym.Name, offConv(a.Offset))
case NAME_AUTO:
if a.Sym != nil {
str = fmt.Sprintf("%s%s(SP)", a.Sym.Name, offConv(a.Offset))
} else {
str = fmt.Sprintf("%s(SP)", offConv(a.Offset))
}
case NAME_PARAM:
if a.Sym != nil {
str = fmt.Sprintf("%s%s(FP)", a.Sym.Name, offConv(a.Offset))
} else {
str = fmt.Sprintf("%s(FP)", offConv(a.Offset))
}
}
return str
}
func offConv(off int64) string {
if off == 0 {
return ""
}
return fmt.Sprintf("%+d", off)
}

12
src/cmd/internal/obj/x86/asm6.go
View File

@ -1931,7 +1931,7 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
} }
if a.Sym != nil || a.Name != obj.NAME_NONE { if a.Sym != nil || a.Name != obj.NAME_NONE {
ctxt.Diag("unexpected addr: %v", Dconv(p, 0, a)) ctxt.Diag("unexpected addr: %v", obj.Dconv(p, Rconv, a))
} }
fallthrough fallthrough
@ -1939,7 +1939,7 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
case obj.TYPE_CONST: case obj.TYPE_CONST:
if a.Sym != nil { if a.Sym != nil {
ctxt.Diag("TYPE_CONST with symbol: %v", Dconv(p, 0, a)) ctxt.Diag("TYPE_CONST with symbol: %v", obj.Dconv(p, Rconv, a))
} }
v = a.Offset v = a.Offset
@ -1966,7 +1966,7 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
} }
if a.Type != obj.TYPE_REG { if a.Type != obj.TYPE_REG {
ctxt.Diag("unexpected addr1: type=%d %v", a.Type, Dconv(p, 0, a)) ctxt.Diag("unexpected addr1: type=%d %v", a.Type, obj.Dconv(p, Rconv, a))
return Yxxx return Yxxx
} }
@ -2317,7 +2317,7 @@ func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int64 {
obj.NAME_EXTERN: obj.NAME_EXTERN:
s = a.Sym s = a.Sym
if r == nil { if r == nil {
ctxt.Diag("need reloc for %v", Dconv(p, 0, a)) ctxt.Diag("need reloc for %v", obj.Dconv(p, Rconv, a))
log.Fatalf("reloc") log.Fatalf("reloc")
} }
@ -2343,7 +2343,7 @@ func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int64 {
if (a.Type == obj.TYPE_MEM || a.Type == obj.TYPE_ADDR) && a.Reg == REG_TLS { if (a.Type == obj.TYPE_MEM || a.Type == obj.TYPE_ADDR) && a.Reg == REG_TLS {
if r == nil { if r == nil {
ctxt.Diag("need reloc for %v", Dconv(p, 0, a)) ctxt.Diag("need reloc for %v", obj.Dconv(p, Rconv, a))
log.Fatalf("reloc") log.Fatalf("reloc")
} }
@ -2545,7 +2545,7 @@ putrelv:
return return
bad: bad:
ctxt.Diag("asmand: bad address %v", Dconv(p, 0, a)) ctxt.Diag("asmand: bad address %v", obj.Dconv(p, Rconv, a))
return return
} }

111
src/cmd/internal/obj/x86/list6.go
View File

@ -59,18 +59,22 @@ func Pconv(p *obj.Prog) string {
switch p.As { switch p.As {
case obj.ADATA: case obj.ADATA:
str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v", p.Pc, p.Line(), Aconv(int(p.As)), Dconv(p, 0, &p.From), p.From3.Offset, Dconv(p, 0, &p.To)) str = fmt.Sprintf("%.5d (%v)\t%v\t%v/%d,%v",
p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
case obj.ATEXT: case obj.ATEXT:
if p.From3.Offset != 0 { if p.From3.Offset != 0 {
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v", p.Pc, p.Line(), Aconv(int(p.As)), Dconv(p, 0, &p.From), p.From3.Offset, Dconv(p, 0, &p.To)) str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v",
p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), p.From3.Offset, obj.Dconv(p, Rconv, &p.To))
break break
} }
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v", p.Pc, p.Line(), Aconv(int(p.As)), Dconv(p, 0, &p.From), Dconv(p, 0, &p.To)) str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
default: default:
str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v", p.Pc, p.Line(), Aconv(int(p.As)), Dconv(p, 0, &p.From), Dconv(p, 0, &p.To)) str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%v",
p.Pc, p.Line(), Aconv(int(p.As)), obj.Dconv(p, Rconv, &p.From), obj.Dconv(p, Rconv, &p.To))
// TODO(rsc): This special case is for SHRQ $32, AX:DX, which encodes as // TODO(rsc): This special case is for SHRQ $32, AX:DX, which encodes as
// SHRQ $32(DX*0), AX // SHRQ $32(DX*0), AX
@ -91,105 +95,6 @@ func Aconv(i int) string {
return fp return fp
} }
func Dconv(p *obj.Prog, flag int, a *obj.Addr) string {
var str string
var s string
var fp string
switch a.Type {
default:
str = fmt.Sprintf("type=%d", a.Type)
case obj.TYPE_NONE:
str = ""
// TODO(rsc): This special case is for instructions like
// PINSRQ CX,$1,X6
// where the $1 is included in the p->to Addr.
// Move into a new field.
case obj.TYPE_REG:
if a.Offset != 0 {
str = fmt.Sprintf("$%d,%v", a.Offset, Rconv(int(a.Reg)))
break
}
str = fmt.Sprintf("%v", Rconv(int(a.Reg)))
case obj.TYPE_BRANCH:
if a.Sym != nil {
str = fmt.Sprintf("%s(SB)", a.Sym.Name)
} else if p != nil && p.Pcond != nil {
str = fmt.Sprintf("%d", p.Pcond.Pc)
} else if a.U.Branch != nil {
str = fmt.Sprintf("%d", a.U.Branch.Pc)
} else {
str = fmt.Sprintf("%d(PC)", a.Offset)
}
case obj.TYPE_MEM:
switch a.Name {
default:
str = fmt.Sprintf("name=%d", a.Name)
case obj.NAME_NONE:
if a.Offset != 0 {
str = fmt.Sprintf("%d(%v)", a.Offset, Rconv(int(a.Reg)))
} else {
str = fmt.Sprintf("(%v)", Rconv(int(a.Reg)))
}
case obj.NAME_EXTERN:
str = fmt.Sprintf("%s+%d(SB)", a.Sym.Name, a.Offset)
case obj.NAME_STATIC:
str = fmt.Sprintf("%s<>+%d(SB)", a.Sym.Name, a.Offset)
case obj.NAME_AUTO:
if a.Sym != nil {
str = fmt.Sprintf("%s+%d(SP)", a.Sym.Name, a.Offset)
} else {
str = fmt.Sprintf("%d(SP)", a.Offset)
}
case obj.NAME_PARAM:
if a.Sym != nil {
str = fmt.Sprintf("%s+%d(FP)", a.Sym.Name, a.Offset)
} else {
str = fmt.Sprintf("%d(FP)", a.Offset)
}
}
if a.Index != REG_NONE {
s = fmt.Sprintf("(%v*%d)", Rconv(int(a.Index)), int(a.Scale))
str += s
}
case obj.TYPE_CONST:
str = fmt.Sprintf("$%d", a.Offset)
case obj.TYPE_TEXTSIZE:
if a.U.Argsize == obj.ArgsSizeUnknown {
str = fmt.Sprintf("$%d", a.Offset)
} else {
str = fmt.Sprintf("$%d-%d", a.Offset, a.U.Argsize)
}
case obj.TYPE_FCONST:
str = fmt.Sprintf("$(%.17g)", a.U.Dval)
case obj.TYPE_SCONST:
str = fmt.Sprintf("$%q", a.U.Sval)
case obj.TYPE_ADDR:
a.Type = obj.TYPE_MEM
str = fmt.Sprintf("$%v", Dconv(p, 0, a))
a.Type = obj.TYPE_ADDR
}
fp += str
return fp
}
var Register = []string{ var Register = []string{
"AL", /* [D_AL] */ "AL", /* [D_AL] */
"CL", "CL",

2
src/cmd/internal/obj/x86/obj6.go
View File

@ -1111,7 +1111,6 @@ loop:
} }
var Linkamd64 = obj.LinkArch{ var Linkamd64 = obj.LinkArch{
Dconv: Dconv,
Rconv: Rconv, Rconv: Rconv,
ByteOrder: binary.LittleEndian, ByteOrder: binary.LittleEndian,
Pconv: Pconv, Pconv: Pconv,
@ -1128,7 +1127,6 @@ var Linkamd64 = obj.LinkArch{
} }
var Linkamd64p32 = obj.LinkArch{ var Linkamd64p32 = obj.LinkArch{
Dconv: Dconv,
Rconv: Rconv, Rconv: Rconv,
ByteOrder: binary.LittleEndian, ByteOrder: binary.LittleEndian,
Pconv: Pconv, Pconv: Pconv,