plan9x.go raw
1 // Copyright 2014 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4
5 package x86asm
6
7 import (
8 "fmt"
9 "strings"
10 )
11
12 type SymLookup func(uint64) (string, uint64)
13
14 // GoSyntax returns the Go assembler syntax for the instruction.
15 // The syntax was originally defined by Plan 9.
16 // The pc is the program counter of the instruction, used for expanding
17 // PC-relative addresses into absolute ones.
18 // The symname function queries the symbol table for the program
19 // being disassembled. Given a target address it returns the name and base
20 // address of the symbol containing the target, if any; otherwise it returns "", 0.
21 func GoSyntax(inst Inst, pc uint64, symname SymLookup) string {
22 if symname == nil {
23 symname = func(uint64) (string, uint64) { return "", 0 }
24 }
25 var args []string
26 for i := len(inst.Args) - 1; i >= 0; i-- {
27 a := inst.Args[i]
28 if a == nil {
29 continue
30 }
31 args = append(args, plan9Arg(&inst, pc, symname, a))
32 }
33
34 var rep string
35 var last Prefix
36 for _, p := range inst.Prefix {
37 if p == 0 || p.IsREX() || p.IsVEX() {
38 break
39 }
40
41 switch {
42 // Don't show prefixes implied by the instruction text.
43 case p&0xFF00 == PrefixImplicit:
44 continue
45 // Only REP and REPN are recognized repeaters. Plan 9 syntax
46 // treats them as separate opcodes.
47 case p&0xFF == PrefixREP:
48 rep = "REP; "
49 case p&0xFF == PrefixREPN:
50 rep = "REPNE; "
51 default:
52 last = p
53 }
54 }
55
56 prefix := ""
57 switch last & 0xFF {
58 case 0, 0x66, 0x67:
59 // ignore
60 default:
61 prefix += last.String() + " "
62 }
63
64 op := inst.Op.String()
65 if plan9Suffix[inst.Op] {
66 s := inst.DataSize
67 if inst.MemBytes != 0 {
68 s = inst.MemBytes * 8
69 } else if inst.Args[1] == nil { // look for register-only 64-bit instruction, like PUSHQ AX
70 if r, ok := inst.Args[0].(Reg); ok && RAX <= r && r <= R15 {
71 s = 64
72 }
73 }
74 switch s {
75 case 8:
76 op += "B"
77 case 16:
78 op += "W"
79 case 32:
80 op += "L"
81 case 64:
82 op += "Q"
83 }
84 }
85
86 if inst.Op == CMP {
87 // Use reads-left-to-right ordering for comparisons.
88 // See issue 60920.
89 args[0], args[1] = args[1], args[0]
90 }
91
92 if args != nil {
93 op += " " + strings.Join(args, ", ")
94 }
95
96 return rep + prefix + op
97 }
98
99 func plan9Arg(inst *Inst, pc uint64, symname func(uint64) (string, uint64), arg Arg) string {
100 switch a := arg.(type) {
101 case Reg:
102 return plan9Reg[a]
103 case Rel:
104 if pc == 0 {
105 break
106 }
107 // If the absolute address is the start of a symbol, use the name.
108 // Otherwise use the raw address, so that things like relative
109 // jumps show up as JMP 0x123 instead of JMP f+10(SB).
110 // It is usually easier to search for 0x123 than to do the mental
111 // arithmetic to find f+10.
112 addr := pc + uint64(inst.Len) + uint64(a)
113 if s, base := symname(addr); s != "" && addr == base {
114 return fmt.Sprintf("%s(SB)", s)
115 }
116 return fmt.Sprintf("%#x", addr)
117
118 case Imm:
119 if s, base := symname(uint64(a)); s != "" {
120 suffix := ""
121 if uint64(a) != base {
122 suffix = fmt.Sprintf("%+d", uint64(a)-base)
123 }
124 return fmt.Sprintf("$%s%s(SB)", s, suffix)
125 }
126 if inst.Mode == 32 {
127 return fmt.Sprintf("$%#x", uint32(a))
128 }
129 if Imm(int32(a)) == a {
130 return fmt.Sprintf("$%#x", int64(a))
131 }
132 return fmt.Sprintf("$%#x", uint64(a))
133 case Mem:
134 if s, disp := memArgToSymbol(a, pc, inst.Len, symname); s != "" {
135 suffix := ""
136 if disp != 0 {
137 suffix = fmt.Sprintf("%+d", disp)
138 }
139 return fmt.Sprintf("%s%s(SB)", s, suffix)
140 }
141 s := ""
142 if a.Segment != 0 {
143 s += fmt.Sprintf("%s:", plan9Reg[a.Segment])
144 }
145 if a.Disp != 0 {
146 s += fmt.Sprintf("%#x", a.Disp)
147 } else {
148 s += "0"
149 }
150 if a.Base != 0 {
151 s += fmt.Sprintf("(%s)", plan9Reg[a.Base])
152 }
153 if a.Index != 0 && a.Scale != 0 {
154 s += fmt.Sprintf("(%s*%d)", plan9Reg[a.Index], a.Scale)
155 }
156 return s
157 }
158 return arg.String()
159 }
160
161 func memArgToSymbol(a Mem, pc uint64, instrLen int, symname SymLookup) (string, int64) {
162 if a.Segment != 0 || a.Disp == 0 || a.Index != 0 || a.Scale != 0 {
163 return "", 0
164 }
165
166 var disp uint64
167 switch a.Base {
168 case IP, EIP, RIP:
169 disp = uint64(a.Disp + int64(pc) + int64(instrLen))
170 case 0:
171 disp = uint64(a.Disp)
172 default:
173 return "", 0
174 }
175
176 s, base := symname(disp)
177 return s, int64(disp) - int64(base)
178 }
179
180 var plan9Suffix = [maxOp + 1]bool{
181 ADC: true,
182 ADD: true,
183 AND: true,
184 BSF: true,
185 BSR: true,
186 BT: true,
187 BTC: true,
188 BTR: true,
189 BTS: true,
190 CMP: true,
191 CMPXCHG: true,
192 CVTSI2SD: true,
193 CVTSI2SS: true,
194 CVTSD2SI: true,
195 CVTSS2SI: true,
196 CVTTSD2SI: true,
197 CVTTSS2SI: true,
198 DEC: true,
199 DIV: true,
200 FLDENV: true,
201 FRSTOR: true,
202 IDIV: true,
203 IMUL: true,
204 IN: true,
205 INC: true,
206 LEA: true,
207 MOV: true,
208 MOVNTI: true,
209 MUL: true,
210 NEG: true,
211 NOP: true,
212 NOT: true,
213 OR: true,
214 OUT: true,
215 POP: true,
216 POPA: true,
217 POPCNT: true,
218 PUSH: true,
219 PUSHA: true,
220 RCL: true,
221 RCR: true,
222 ROL: true,
223 ROR: true,
224 SAR: true,
225 SBB: true,
226 SHL: true,
227 SHLD: true,
228 SHR: true,
229 SHRD: true,
230 SUB: true,
231 TEST: true,
232 XADD: true,
233 XCHG: true,
234 XOR: true,
235 }
236
237 var plan9Reg = [...]string{
238 AL: "AL",
239 CL: "CL",
240 BL: "BL",
241 DL: "DL",
242 AH: "AH",
243 CH: "CH",
244 BH: "BH",
245 DH: "DH",
246 SPB: "SP",
247 BPB: "BP",
248 SIB: "SI",
249 DIB: "DI",
250 R8B: "R8",
251 R9B: "R9",
252 R10B: "R10",
253 R11B: "R11",
254 R12B: "R12",
255 R13B: "R13",
256 R14B: "R14",
257 R15B: "R15",
258 AX: "AX",
259 CX: "CX",
260 BX: "BX",
261 DX: "DX",
262 SP: "SP",
263 BP: "BP",
264 SI: "SI",
265 DI: "DI",
266 R8W: "R8",
267 R9W: "R9",
268 R10W: "R10",
269 R11W: "R11",
270 R12W: "R12",
271 R13W: "R13",
272 R14W: "R14",
273 R15W: "R15",
274 EAX: "AX",
275 ECX: "CX",
276 EDX: "DX",
277 EBX: "BX",
278 ESP: "SP",
279 EBP: "BP",
280 ESI: "SI",
281 EDI: "DI",
282 R8L: "R8",
283 R9L: "R9",
284 R10L: "R10",
285 R11L: "R11",
286 R12L: "R12",
287 R13L: "R13",
288 R14L: "R14",
289 R15L: "R15",
290 RAX: "AX",
291 RCX: "CX",
292 RDX: "DX",
293 RBX: "BX",
294 RSP: "SP",
295 RBP: "BP",
296 RSI: "SI",
297 RDI: "DI",
298 R8: "R8",
299 R9: "R9",
300 R10: "R10",
301 R11: "R11",
302 R12: "R12",
303 R13: "R13",
304 R14: "R14",
305 R15: "R15",
306 IP: "IP",
307 EIP: "IP",
308 RIP: "IP",
309 F0: "F0",
310 F1: "F1",
311 F2: "F2",
312 F3: "F3",
313 F4: "F4",
314 F5: "F5",
315 F6: "F6",
316 F7: "F7",
317 M0: "M0",
318 M1: "M1",
319 M2: "M2",
320 M3: "M3",
321 M4: "M4",
322 M5: "M5",
323 M6: "M6",
324 M7: "M7",
325 X0: "X0",
326 X1: "X1",
327 X2: "X2",
328 X3: "X3",
329 X4: "X4",
330 X5: "X5",
331 X6: "X6",
332 X7: "X7",
333 X8: "X8",
334 X9: "X9",
335 X10: "X10",
336 X11: "X11",
337 X12: "X12",
338 X13: "X13",
339 X14: "X14",
340 X15: "X15",
341 CS: "CS",
342 SS: "SS",
343 DS: "DS",
344 ES: "ES",
345 FS: "FS",
346 GS: "GS",
347 GDTR: "GDTR",
348 IDTR: "IDTR",
349 LDTR: "LDTR",
350 MSW: "MSW",
351 TASK: "TASK",
352 CR0: "CR0",
353 CR1: "CR1",
354 CR2: "CR2",
355 CR3: "CR3",
356 CR4: "CR4",
357 CR5: "CR5",
358 CR6: "CR6",
359 CR7: "CR7",
360 CR8: "CR8",
361 CR9: "CR9",
362 CR10: "CR10",
363 CR11: "CR11",
364 CR12: "CR12",
365 CR13: "CR13",
366 CR14: "CR14",
367 CR15: "CR15",
368 DR0: "DR0",
369 DR1: "DR1",
370 DR2: "DR2",
371 DR3: "DR3",
372 DR4: "DR4",
373 DR5: "DR5",
374 DR6: "DR6",
375 DR7: "DR7",
376 DR8: "DR8",
377 DR9: "DR9",
378 DR10: "DR10",
379 DR11: "DR11",
380 DR12: "DR12",
381 DR13: "DR13",
382 DR14: "DR14",
383 DR15: "DR15",
384 TR0: "TR0",
385 TR1: "TR1",
386 TR2: "TR2",
387 TR3: "TR3",
388 TR4: "TR4",
389 TR5: "TR5",
390 TR6: "TR6",
391 TR7: "TR7",
392 }
393