Blame view

disas.c 11.1 KB
bellard authored
1
/* General "disassemble this chunk" code.  Used for debugging. */
bellard authored
2
#include "config.h"
bellard authored
3
4
#include "dis-asm.h"
#include "elf.h"
5
#include <errno.h>
bellard authored
6
7
8
#include "cpu.h"
#include "exec-all.h"
9
#include "disas.h"
10
bellard authored
11
/* Filled in by elfload.c.  Simplistic, but will do for now. */
bellard authored
12
struct syminfo *syminfos = NULL;
bellard authored
13
14
15
16
17
18
19
20
21
22
/* Get LENGTH bytes from info's buffer, at target address memaddr.
   Transfer them to myaddr.  */
int
buffer_read_memory (memaddr, myaddr, length, info)
     bfd_vma memaddr;
     bfd_byte *myaddr;
     int length;
     struct disassemble_info *info;
{
23
24
25
26
27
28
    if (memaddr < info->buffer_vma
        || memaddr + length > info->buffer_vma + info->buffer_length)
        /* Out of bounds.  Use EIO because GDB uses it.  */
        return EIO;
    memcpy (myaddr, info->buffer + (memaddr - info->buffer_vma), length);
    return 0;
29
30
}
31
32
33
/* Get LENGTH bytes from info's buffer, at target address memaddr.
   Transfer them to myaddr.  */
static int
bellard authored
34
35
36
37
target_read_memory (bfd_vma memaddr,
                    bfd_byte *myaddr,
                    int length,
                    struct disassemble_info *info)
38
39
40
{
    int i;
    for(i = 0; i < length; i++) {
bellard authored
41
        myaddr[i] = ldub_code(memaddr + i);
42
43
44
45
    }
    return 0;
}
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/* Print an error message.  We can assume that this is in response to
   an error return from buffer_read_memory.  */
void
perror_memory (status, memaddr, info)
     int status;
     bfd_vma memaddr;
     struct disassemble_info *info;
{
  if (status != EIO)
    /* Can't happen.  */
    (*info->fprintf_func) (info->stream, "Unknown error %d\n", status);
  else
    /* Actually, address between memaddr and memaddr + len was
       out of bounds.  */
    (*info->fprintf_func) (info->stream,
bellard authored
61
			   "Address 0x%" PRIx64 " is out of bounds.\n", memaddr);
62
63
64
65
66
67
68
69
70
71
72
73
74
75
}

/* This could be in a separate file, to save miniscule amounts of space
   in statically linked executables.  */

/* Just print the address is hex.  This is included for completeness even
   though both GDB and objdump provide their own (to print symbolic
   addresses).  */

void
generic_print_address (addr, info)
     bfd_vma addr;
     struct disassemble_info *info;
{
bellard authored
76
    (*info->fprintf_func) (info->stream, "0x%" PRIx64, addr);
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
}

/* Just return the given address.  */

int
generic_symbol_at_address (addr, info)
     bfd_vma addr;
     struct disassemble_info * info;
{
  return 1;
}

bfd_vma bfd_getl32 (const bfd_byte *addr)
{
  unsigned long v;

  v = (unsigned long) addr[0];
  v |= (unsigned long) addr[1] << 8;
  v |= (unsigned long) addr[2] << 16;
  v |= (unsigned long) addr[3] << 24;
  return (bfd_vma) v;
}

bfd_vma bfd_getb32 (const bfd_byte *addr)
{
  unsigned long v;

  v = (unsigned long) addr[0] << 24;
  v |= (unsigned long) addr[1] << 16;
  v |= (unsigned long) addr[2] << 8;
  v |= (unsigned long) addr[3];
  return (bfd_vma) v;
}
bellard authored
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
bfd_vma bfd_getl16 (const bfd_byte *addr)
{
  unsigned long v;

  v = (unsigned long) addr[0];
  v |= (unsigned long) addr[1] << 8;
  return (bfd_vma) v;
}

bfd_vma bfd_getb16 (const bfd_byte *addr)
{
  unsigned long v;

  v = (unsigned long) addr[0] << 24;
  v |= (unsigned long) addr[1] << 16;
  return (bfd_vma) v;
}
129
130
131
132
133
134
135
136
#ifdef TARGET_ARM
static int
print_insn_thumb1(bfd_vma pc, disassemble_info *info)
{
  return print_insn_arm(pc | 1, info);
}
#endif
ths authored
137
/* Disassemble this for me please... (debugging). 'flags' has the following
138
139
   values:
    i386 - nonzero means 16 bit code
140
    arm  - nonzero means thumb code
bellard authored
141
    ppc  - nonzero means little endian
142
143
    other targets - unused
 */
144
void target_disas(FILE *out, target_ulong code, target_ulong size, int flags)
bellard authored
145
{
bellard authored
146
    target_ulong pc;
bellard authored
147
148
149
150
151
152
    int count;
    struct disassemble_info disasm_info;
    int (*print_insn)(bfd_vma pc, disassemble_info *info);

    INIT_DISASSEMBLE_INFO(disasm_info, out, fprintf);
bellard authored
153
154
155
156
157
158
159
160
161
162
163
164
    disasm_info.read_memory_func = target_read_memory;
    disasm_info.buffer_vma = code;
    disasm_info.buffer_length = size;

#ifdef TARGET_WORDS_BIGENDIAN
    disasm_info.endian = BFD_ENDIAN_BIG;
#else
    disasm_info.endian = BFD_ENDIAN_LITTLE;
#endif
#if defined(TARGET_I386)
    if (flags == 2)
        disasm_info.mach = bfd_mach_x86_64;
165
    else if (flags == 1)
bellard authored
166
167
168
169
170
        disasm_info.mach = bfd_mach_i386_i8086;
    else
        disasm_info.mach = bfd_mach_i386_i386;
    print_insn = print_insn_i386;
#elif defined(TARGET_ARM)
171
172
173
174
    if (flags)
	print_insn = print_insn_thumb1;
    else
	print_insn = print_insn_arm;
bellard authored
175
176
#elif defined(TARGET_SPARC)
    print_insn = print_insn_sparc;
bellard authored
177
178
#ifdef TARGET_SPARC64
    disasm_info.mach = bfd_mach_sparc_v9b;
179
#endif
bellard authored
180
#elif defined(TARGET_PPC)
181
    if (flags >> 16)
182
        disasm_info.endian = BFD_ENDIAN_LITTLE;
183
184
185
186
    if (flags & 0xFFFF) {
        /* If we have a precise definitions of the instructions set, use it */
        disasm_info.mach = flags & 0xFFFF;
    } else {
bellard authored
187
#ifdef TARGET_PPC64
188
        disasm_info.mach = bfd_mach_ppc64;
bellard authored
189
#else
190
        disasm_info.mach = bfd_mach_ppc;
bellard authored
191
#endif
192
    }
bellard authored
193
    print_insn = print_insn_ppc;
pbrook authored
194
195
#elif defined(TARGET_M68K)
    print_insn = print_insn_m68k;
bellard authored
196
#elif defined(TARGET_MIPS)
bellard authored
197
#ifdef TARGET_WORDS_BIGENDIAN
bellard authored
198
    print_insn = print_insn_big_mips;
bellard authored
199
200
201
#else
    print_insn = print_insn_little_mips;
#endif
bellard authored
202
203
204
#elif defined(TARGET_SH4)
    disasm_info.mach = bfd_mach_sh4;
    print_insn = print_insn_sh;
205
206
207
#elif defined(TARGET_ALPHA)
    disasm_info.mach = bfd_mach_alpha;
    print_insn = print_insn_alpha;
208
209
210
#elif defined(TARGET_CRIS)
    disasm_info.mach = bfd_mach_cris_v32;
    print_insn = print_insn_crisv32;
bellard authored
211
#else
212
213
    fprintf(out, "0x" TARGET_FMT_lx
	    ": Asm output not supported on this arch\n", code);
bellard authored
214
    return;
215
216
#endif
bellard authored
217
    for (pc = code; pc < code + size; pc += count) {
bellard authored
218
	fprintf(out, "0x" TARGET_FMT_lx ":  ", pc);
bellard authored
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
	count = print_insn(pc, &disasm_info);
#if 0
        {
            int i;
            uint8_t b;
            fprintf(out, " {");
            for(i = 0; i < count; i++) {
                target_read_memory(pc + i, &b, 1, &disasm_info);
                fprintf(out, " %02x", b);
            }
            fprintf(out, " }");
        }
#endif
	fprintf(out, "\n");
	if (count < 0)
	    break;
    }
}

/* Disassemble this for me please... (debugging). */
void disas(FILE *out, void *code, unsigned long size)
{
    unsigned long pc;
    int count;
    struct disassemble_info disasm_info;
    int (*print_insn)(bfd_vma pc, disassemble_info *info);

    INIT_DISASSEMBLE_INFO(disasm_info, out, fprintf);
bellard authored
248
249
250
251
252
    disasm_info.buffer = code;
    disasm_info.buffer_vma = (unsigned long)code;
    disasm_info.buffer_length = size;

#ifdef WORDS_BIGENDIAN
bellard authored
253
    disasm_info.endian = BFD_ENDIAN_BIG;
bellard authored
254
#else
bellard authored
255
    disasm_info.endian = BFD_ENDIAN_LITTLE;
bellard authored
256
#endif
257
#if defined(__i386__)
bellard authored
258
259
    disasm_info.mach = bfd_mach_i386_i386;
    print_insn = print_insn_i386;
260
#elif defined(__x86_64__)
bellard authored
261
262
    disasm_info.mach = bfd_mach_x86_64;
    print_insn = print_insn_i386;
bellard authored
263
#elif defined(__powerpc__)
bellard authored
264
    print_insn = print_insn_ppc;
bellard authored
265
#elif defined(__alpha__)
bellard authored
266
    print_insn = print_insn_alpha;
267
#elif defined(__sparc__)
bellard authored
268
    print_insn = print_insn_sparc;
269
270
271
#if defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
    disasm_info.mach = bfd_mach_sparc_v9b;
#endif
272
#elif defined(__arm__)
bellard authored
273
    print_insn = print_insn_arm;
bellard authored
274
275
276
277
#elif defined(__MIPSEB__)
    print_insn = print_insn_big_mips;
#elif defined(__MIPSEL__)
    print_insn = print_insn_little_mips;
278
279
#elif defined(__m68k__)
    print_insn = print_insn_m68k;
280
281
#elif defined(__s390__)
    print_insn = print_insn_s390;
aurel32 authored
282
283
#elif defined(__hppa__)
    print_insn = print_insn_hppa;
bellard authored
284
#else
285
286
    fprintf(out, "0x%lx: Asm output not supported on this arch\n",
	    (long) code);
bellard authored
287
    return;
bellard authored
288
#endif
bellard authored
289
290
    for (pc = (unsigned long)code; pc < (unsigned long)code + size; pc += count) {
	fprintf(out, "0x%08lx:  ", pc);
291
#ifdef __arm__
pbrook authored
292
        /* since data is included in the code, it is better to
293
           display code data too */
pbrook authored
294
        fprintf(out, "%08x  ", (int)bfd_getl32((const bfd_byte *)pc));
295
#endif
bellard authored
296
	count = print_insn(pc, &disasm_info);
bellard authored
297
298
299
300
301
302
303
	fprintf(out, "\n");
	if (count < 0)
	    break;
    }
}

/* Look up symbol for debugging purpose.  Returns "" if unknown. */
bellard authored
304
const char *lookup_symbol(target_ulong orig_addr)
bellard authored
305
306
307
{
    unsigned int i;
    /* Hack, because we know this is x86. */
bellard authored
308
309
    Elf32_Sym *sym;
    struct syminfo *s;
310
    target_ulong addr;
311
bellard authored
312
313
314
315
316
317
    for (s = syminfos; s; s = s->next) {
	sym = s->disas_symtab;
	for (i = 0; i < s->disas_num_syms; i++) {
	    if (sym[i].st_shndx == SHN_UNDEF
		|| sym[i].st_shndx >= SHN_LORESERVE)
		continue;
bellard authored
318
bellard authored
319
320
	    if (ELF_ST_TYPE(sym[i].st_info) != STT_FUNC)
		continue;
bellard authored
321
322
	    addr = sym[i].st_value;
323
324
#if defined(TARGET_ARM) || defined (TARGET_MIPS)
            /* The bottom address bit marks a Thumb or MIPS16 symbol.  */
325
326
327
328
            addr &= ~(target_ulong)1;
#endif
	    if (orig_addr >= addr
		&& orig_addr < addr + sym[i].st_size)
bellard authored
329
330
		return s->disas_strtab + sym[i].st_name;
	}
bellard authored
331
332
333
    }
    return "";
}
334
335
336

#if !defined(CONFIG_USER_ONLY)
337
338
339
void term_vprintf(const char *fmt, va_list ap);
void term_printf(const char *fmt, ...);
340
static int monitor_disas_is_physical;
bellard authored
341
static CPUState *monitor_disas_env;
342
343
344
345
346
347
348
349
350
351
352

static int
monitor_read_memory (memaddr, myaddr, length, info)
     bfd_vma memaddr;
     bfd_byte *myaddr;
     int length;
     struct disassemble_info *info;
{
    if (monitor_disas_is_physical) {
        cpu_physical_memory_rw(memaddr, myaddr, length, 0);
    } else {
bellard authored
353
        cpu_memory_rw_debug(monitor_disas_env, memaddr,myaddr, length, 0);
354
355
356
357
    }
    return 0;
}
358
359
360
361
362
363
364
365
366
static int monitor_fprintf(FILE *stream, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    term_vprintf(fmt, ap);
    va_end(ap);
    return 0;
}
bellard authored
367
368
void monitor_disas(CPUState *env,
                   target_ulong pc, int nb_insn, int is_physical, int flags)
369
370
371
372
373
{
    int count, i;
    struct disassemble_info disasm_info;
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
374
    INIT_DISASSEMBLE_INFO(disasm_info, NULL, monitor_fprintf);
375
bellard authored
376
    monitor_disas_env = env;
377
378
379
380
381
382
383
384
385
386
387
    monitor_disas_is_physical = is_physical;
    disasm_info.read_memory_func = monitor_read_memory;

    disasm_info.buffer_vma = pc;

#ifdef TARGET_WORDS_BIGENDIAN
    disasm_info.endian = BFD_ENDIAN_BIG;
#else
    disasm_info.endian = BFD_ENDIAN_LITTLE;
#endif
#if defined(TARGET_I386)
bellard authored
388
389
    if (flags == 2)
        disasm_info.mach = bfd_mach_x86_64;
390
    else if (flags == 1)
391
        disasm_info.mach = bfd_mach_i386_i8086;
bellard authored
392
393
    else
        disasm_info.mach = bfd_mach_i386_i386;
394
395
396
    print_insn = print_insn_i386;
#elif defined(TARGET_ARM)
    print_insn = print_insn_arm;
ths authored
397
398
#elif defined(TARGET_ALPHA)
    print_insn = print_insn_alpha;
399
400
#elif defined(TARGET_SPARC)
    print_insn = print_insn_sparc;
401
402
403
#ifdef TARGET_SPARC64
    disasm_info.mach = bfd_mach_sparc_v9b;
#endif
404
#elif defined(TARGET_PPC)
bellard authored
405
406
407
408
409
#ifdef TARGET_PPC64
    disasm_info.mach = bfd_mach_ppc64;
#else
    disasm_info.mach = bfd_mach_ppc;
#endif
410
    print_insn = print_insn_ppc;
pbrook authored
411
412
#elif defined(TARGET_M68K)
    print_insn = print_insn_m68k;
bellard authored
413
#elif defined(TARGET_MIPS)
bellard authored
414
#ifdef TARGET_WORDS_BIGENDIAN
bellard authored
415
    print_insn = print_insn_big_mips;
bellard authored
416
417
418
#else
    print_insn = print_insn_little_mips;
#endif
419
#else
420
421
    term_printf("0x" TARGET_FMT_lx
		": Asm output not supported on this arch\n", pc);
422
423
424
425
    return;
#endif

    for(i = 0; i < nb_insn; i++) {
bellard authored
426
	term_printf("0x" TARGET_FMT_lx ":  ", pc);
427
	count = print_insn(pc, &disasm_info);
428
	term_printf("\n");
429
430
431
432
433
434
	if (count < 0)
	    break;
        pc += count;
    }
}
#endif