Statistics
| Branch: | Revision:

root / disas.c @ 41cb62c2

History | View | Annotate | Download (12.8 kB)

1
/* General "disassemble this chunk" code.  Used for debugging. */
2
#include "config.h"
3
#include "disas/bfd.h"
4
#include "elf.h"
5
#include <errno.h>
6

    
7
#include "cpu.h"
8
#include "disas/disas.h"
9

    
10
typedef struct CPUDebug {
11
    struct disassemble_info info;
12
    CPUArchState *env;
13
} CPUDebug;
14

    
15
/* Filled in by elfload.c.  Simplistic, but will do for now. */
16
struct syminfo *syminfos = NULL;
17

    
18
/* Get LENGTH bytes from info's buffer, at target address memaddr.
19
   Transfer them to myaddr.  */
20
int
21
buffer_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
22
                   struct disassemble_info *info)
23
{
24
    if (memaddr < info->buffer_vma
25
        || memaddr + length > info->buffer_vma + info->buffer_length)
26
        /* Out of bounds.  Use EIO because GDB uses it.  */
27
        return EIO;
28
    memcpy (myaddr, info->buffer + (memaddr - info->buffer_vma), length);
29
    return 0;
30
}
31

    
32
/* Get LENGTH bytes from info's buffer, at target address memaddr.
33
   Transfer them to myaddr.  */
34
static int
35
target_read_memory (bfd_vma memaddr,
36
                    bfd_byte *myaddr,
37
                    int length,
38
                    struct disassemble_info *info)
39
{
40
    CPUDebug *s = container_of(info, CPUDebug, info);
41

    
42
    cpu_memory_rw_debug(s->env, memaddr, myaddr, length, 0);
43
    return 0;
44
}
45

    
46
/* Print an error message.  We can assume that this is in response to
47
   an error return from buffer_read_memory.  */
48
void
49
perror_memory (int status, bfd_vma memaddr, struct disassemble_info *info)
50
{
51
  if (status != EIO)
52
    /* Can't happen.  */
53
    (*info->fprintf_func) (info->stream, "Unknown error %d\n", status);
54
  else
55
    /* Actually, address between memaddr and memaddr + len was
56
       out of bounds.  */
57
    (*info->fprintf_func) (info->stream,
58
                           "Address 0x%" PRIx64 " is out of bounds.\n", memaddr);
59
}
60

    
61
/* This could be in a separate file, to save minuscule amounts of space
62
   in statically linked executables.  */
63

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

    
68
void
69
generic_print_address (bfd_vma addr, struct disassemble_info *info)
70
{
71
    (*info->fprintf_func) (info->stream, "0x%" PRIx64, addr);
72
}
73

    
74
/* Print address in hex, truncated to the width of a target virtual address. */
75
static void
76
generic_print_target_address(bfd_vma addr, struct disassemble_info *info)
77
{
78
    uint64_t mask = ~0ULL >> (64 - TARGET_VIRT_ADDR_SPACE_BITS);
79
    generic_print_address(addr & mask, info);
80
}
81

    
82
/* Print address in hex, truncated to the width of a host virtual address. */
83
static void
84
generic_print_host_address(bfd_vma addr, struct disassemble_info *info)
85
{
86
    uint64_t mask = ~0ULL >> (64 - (sizeof(void *) * 8));
87
    generic_print_address(addr & mask, info);
88
}
89

    
90
/* Just return the given address.  */
91

    
92
int
93
generic_symbol_at_address (bfd_vma addr, struct disassemble_info *info)
94
{
95
  return 1;
96
}
97

    
98
bfd_vma bfd_getl64 (const bfd_byte *addr)
99
{
100
  unsigned long long v;
101

    
102
  v = (unsigned long long) addr[0];
103
  v |= (unsigned long long) addr[1] << 8;
104
  v |= (unsigned long long) addr[2] << 16;
105
  v |= (unsigned long long) addr[3] << 24;
106
  v |= (unsigned long long) addr[4] << 32;
107
  v |= (unsigned long long) addr[5] << 40;
108
  v |= (unsigned long long) addr[6] << 48;
109
  v |= (unsigned long long) addr[7] << 56;
110
  return (bfd_vma) v;
111
}
112

    
113
bfd_vma bfd_getl32 (const bfd_byte *addr)
114
{
115
  unsigned long v;
116

    
117
  v = (unsigned long) addr[0];
118
  v |= (unsigned long) addr[1] << 8;
119
  v |= (unsigned long) addr[2] << 16;
120
  v |= (unsigned long) addr[3] << 24;
121
  return (bfd_vma) v;
122
}
123

    
124
bfd_vma bfd_getb32 (const bfd_byte *addr)
125
{
126
  unsigned long v;
127

    
128
  v = (unsigned long) addr[0] << 24;
129
  v |= (unsigned long) addr[1] << 16;
130
  v |= (unsigned long) addr[2] << 8;
131
  v |= (unsigned long) addr[3];
132
  return (bfd_vma) v;
133
}
134

    
135
bfd_vma bfd_getl16 (const bfd_byte *addr)
136
{
137
  unsigned long v;
138

    
139
  v = (unsigned long) addr[0];
140
  v |= (unsigned long) addr[1] << 8;
141
  return (bfd_vma) v;
142
}
143

    
144
bfd_vma bfd_getb16 (const bfd_byte *addr)
145
{
146
  unsigned long v;
147

    
148
  v = (unsigned long) addr[0] << 24;
149
  v |= (unsigned long) addr[1] << 16;
150
  return (bfd_vma) v;
151
}
152

    
153
#ifdef TARGET_ARM
154
static int
155
print_insn_thumb1(bfd_vma pc, disassemble_info *info)
156
{
157
  return print_insn_arm(pc | 1, info);
158
}
159
#endif
160

    
161
/* Disassemble this for me please... (debugging). 'flags' has the following
162
   values:
163
    i386 - 1 means 16 bit code, 2 means 64 bit code
164
    arm  - bit 0 = thumb, bit 1 = reverse endian
165
    ppc  - nonzero means little endian
166
    other targets - unused
167
 */
168
void target_disas(FILE *out, CPUArchState *env, target_ulong code,
169
                  target_ulong size, int flags)
170
{
171
    target_ulong pc;
172
    int count;
173
    CPUDebug s;
174
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
175

    
176
    INIT_DISASSEMBLE_INFO(s.info, out, fprintf);
177

    
178
    s.env = env;
179
    s.info.read_memory_func = target_read_memory;
180
    s.info.buffer_vma = code;
181
    s.info.buffer_length = size;
182
    s.info.print_address_func = generic_print_target_address;
183

    
184
#ifdef TARGET_WORDS_BIGENDIAN
185
    s.info.endian = BFD_ENDIAN_BIG;
186
#else
187
    s.info.endian = BFD_ENDIAN_LITTLE;
188
#endif
189
#if defined(TARGET_I386)
190
    if (flags == 2) {
191
        s.info.mach = bfd_mach_x86_64;
192
    } else if (flags == 1) {
193
        s.info.mach = bfd_mach_i386_i8086;
194
    } else {
195
        s.info.mach = bfd_mach_i386_i386;
196
    }
197
    print_insn = print_insn_i386;
198
#elif defined(TARGET_ARM)
199
    if (flags & 1) {
200
        print_insn = print_insn_thumb1;
201
    } else {
202
        print_insn = print_insn_arm;
203
    }
204
    if (flags & 2) {
205
#ifdef TARGET_WORDS_BIGENDIAN
206
        s.info.endian = BFD_ENDIAN_LITTLE;
207
#else
208
        s.info.endian = BFD_ENDIAN_BIG;
209
#endif
210
    }
211
#elif defined(TARGET_SPARC)
212
    print_insn = print_insn_sparc;
213
#ifdef TARGET_SPARC64
214
    s.info.mach = bfd_mach_sparc_v9b;
215
#endif
216
#elif defined(TARGET_PPC)
217
    if (flags >> 16) {
218
        s.info.endian = BFD_ENDIAN_LITTLE;
219
    }
220
    if (flags & 0xFFFF) {
221
        /* If we have a precise definitions of the instructions set, use it */
222
        s.info.mach = flags & 0xFFFF;
223
    } else {
224
#ifdef TARGET_PPC64
225
        s.info.mach = bfd_mach_ppc64;
226
#else
227
        s.info.mach = bfd_mach_ppc;
228
#endif
229
    }
230
    print_insn = print_insn_ppc;
231
#elif defined(TARGET_M68K)
232
    print_insn = print_insn_m68k;
233
#elif defined(TARGET_MIPS)
234
#ifdef TARGET_WORDS_BIGENDIAN
235
    print_insn = print_insn_big_mips;
236
#else
237
    print_insn = print_insn_little_mips;
238
#endif
239
#elif defined(TARGET_SH4)
240
    s.info.mach = bfd_mach_sh4;
241
    print_insn = print_insn_sh;
242
#elif defined(TARGET_ALPHA)
243
    s.info.mach = bfd_mach_alpha_ev6;
244
    print_insn = print_insn_alpha;
245
#elif defined(TARGET_CRIS)
246
    if (flags != 32) {
247
        s.info.mach = bfd_mach_cris_v0_v10;
248
        print_insn = print_insn_crisv10;
249
    } else {
250
        s.info.mach = bfd_mach_cris_v32;
251
        print_insn = print_insn_crisv32;
252
    }
253
#elif defined(TARGET_S390X)
254
    s.info.mach = bfd_mach_s390_64;
255
    print_insn = print_insn_s390;
256
#elif defined(TARGET_MICROBLAZE)
257
    s.info.mach = bfd_arch_microblaze;
258
    print_insn = print_insn_microblaze;
259
#elif defined(TARGET_MOXIE)
260
    s.info.mach = bfd_arch_moxie;
261
    print_insn = print_insn_moxie;
262
#elif defined(TARGET_LM32)
263
    s.info.mach = bfd_mach_lm32;
264
    print_insn = print_insn_lm32;
265
#else
266
    fprintf(out, "0x" TARGET_FMT_lx
267
            ": Asm output not supported on this arch\n", code);
268
    return;
269
#endif
270

    
271
    for (pc = code; size > 0; pc += count, size -= count) {
272
        fprintf(out, "0x" TARGET_FMT_lx ":  ", pc);
273
        count = print_insn(pc, &s.info);
274
#if 0
275
        {
276
            int i;
277
            uint8_t b;
278
            fprintf(out, " {");
279
            for(i = 0; i < count; i++) {
280
                target_read_memory(pc + i, &b, 1, &s.info);
281
                fprintf(out, " %02x", b);
282
            }
283
            fprintf(out, " }");
284
        }
285
#endif
286
        fprintf(out, "\n");
287
        if (count < 0)
288
            break;
289
        if (size < count) {
290
            fprintf(out,
291
                    "Disassembler disagrees with translator over instruction "
292
                    "decoding\n"
293
                    "Please report this to qemu-devel@nongnu.org\n");
294
            break;
295
        }
296
    }
297
}
298

    
299
/* Disassemble this for me please... (debugging). */
300
void disas(FILE *out, void *code, unsigned long size)
301
{
302
    uintptr_t pc;
303
    int count;
304
    CPUDebug s;
305
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
306

    
307
    INIT_DISASSEMBLE_INFO(s.info, out, fprintf);
308
    s.info.print_address_func = generic_print_host_address;
309

    
310
    s.info.buffer = code;
311
    s.info.buffer_vma = (uintptr_t)code;
312
    s.info.buffer_length = size;
313

    
314
#ifdef HOST_WORDS_BIGENDIAN
315
    s.info.endian = BFD_ENDIAN_BIG;
316
#else
317
    s.info.endian = BFD_ENDIAN_LITTLE;
318
#endif
319
#if defined(CONFIG_TCG_INTERPRETER)
320
    print_insn = print_insn_tci;
321
#elif defined(__i386__)
322
    s.info.mach = bfd_mach_i386_i386;
323
    print_insn = print_insn_i386;
324
#elif defined(__x86_64__)
325
    s.info.mach = bfd_mach_x86_64;
326
    print_insn = print_insn_i386;
327
#elif defined(_ARCH_PPC)
328
    print_insn = print_insn_ppc;
329
#elif defined(__alpha__)
330
    print_insn = print_insn_alpha;
331
#elif defined(__sparc__)
332
    print_insn = print_insn_sparc;
333
    s.info.mach = bfd_mach_sparc_v9b;
334
#elif defined(__arm__)
335
    print_insn = print_insn_arm;
336
#elif defined(__MIPSEB__)
337
    print_insn = print_insn_big_mips;
338
#elif defined(__MIPSEL__)
339
    print_insn = print_insn_little_mips;
340
#elif defined(__m68k__)
341
    print_insn = print_insn_m68k;
342
#elif defined(__s390__)
343
    print_insn = print_insn_s390;
344
#elif defined(__hppa__)
345
    print_insn = print_insn_hppa;
346
#elif defined(__ia64__)
347
    print_insn = print_insn_ia64;
348
#else
349
    fprintf(out, "0x%lx: Asm output not supported on this arch\n",
350
            (long) code);
351
    return;
352
#endif
353
    for (pc = (uintptr_t)code; size > 0; pc += count, size -= count) {
354
        fprintf(out, "0x%08" PRIxPTR ":  ", pc);
355
        count = print_insn(pc, &s.info);
356
        fprintf(out, "\n");
357
        if (count < 0)
358
            break;
359
    }
360
}
361

    
362
/* Look up symbol for debugging purpose.  Returns "" if unknown. */
363
const char *lookup_symbol(target_ulong orig_addr)
364
{
365
    const char *symbol = "";
366
    struct syminfo *s;
367

    
368
    for (s = syminfos; s; s = s->next) {
369
        symbol = s->lookup_symbol(s, orig_addr);
370
        if (symbol[0] != '\0') {
371
            break;
372
        }
373
    }
374

    
375
    return symbol;
376
}
377

    
378
#if !defined(CONFIG_USER_ONLY)
379

    
380
#include "monitor/monitor.h"
381

    
382
static int monitor_disas_is_physical;
383

    
384
static int
385
monitor_read_memory (bfd_vma memaddr, bfd_byte *myaddr, int length,
386
                     struct disassemble_info *info)
387
{
388
    CPUDebug *s = container_of(info, CPUDebug, info);
389

    
390
    if (monitor_disas_is_physical) {
391
        cpu_physical_memory_read(memaddr, myaddr, length);
392
    } else {
393
        cpu_memory_rw_debug(s->env, memaddr,myaddr, length, 0);
394
    }
395
    return 0;
396
}
397

    
398
static int GCC_FMT_ATTR(2, 3)
399
monitor_fprintf(FILE *stream, const char *fmt, ...)
400
{
401
    va_list ap;
402
    va_start(ap, fmt);
403
    monitor_vprintf((Monitor *)stream, fmt, ap);
404
    va_end(ap);
405
    return 0;
406
}
407

    
408
void monitor_disas(Monitor *mon, CPUArchState *env,
409
                   target_ulong pc, int nb_insn, int is_physical, int flags)
410
{
411
    int count, i;
412
    CPUDebug s;
413
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
414

    
415
    INIT_DISASSEMBLE_INFO(s.info, (FILE *)mon, monitor_fprintf);
416

    
417
    s.env = env;
418
    monitor_disas_is_physical = is_physical;
419
    s.info.read_memory_func = monitor_read_memory;
420
    s.info.print_address_func = generic_print_target_address;
421

    
422
    s.info.buffer_vma = pc;
423

    
424
#ifdef TARGET_WORDS_BIGENDIAN
425
    s.info.endian = BFD_ENDIAN_BIG;
426
#else
427
    s.info.endian = BFD_ENDIAN_LITTLE;
428
#endif
429
#if defined(TARGET_I386)
430
    if (flags == 2) {
431
        s.info.mach = bfd_mach_x86_64;
432
    } else if (flags == 1) {
433
        s.info.mach = bfd_mach_i386_i8086;
434
    } else {
435
        s.info.mach = bfd_mach_i386_i386;
436
    }
437
    print_insn = print_insn_i386;
438
#elif defined(TARGET_ARM)
439
    print_insn = print_insn_arm;
440
#elif defined(TARGET_ALPHA)
441
    print_insn = print_insn_alpha;
442
#elif defined(TARGET_SPARC)
443
    print_insn = print_insn_sparc;
444
#ifdef TARGET_SPARC64
445
    s.info.mach = bfd_mach_sparc_v9b;
446
#endif
447
#elif defined(TARGET_PPC)
448
#ifdef TARGET_PPC64
449
    s.info.mach = bfd_mach_ppc64;
450
#else
451
    s.info.mach = bfd_mach_ppc;
452
#endif
453
    print_insn = print_insn_ppc;
454
#elif defined(TARGET_M68K)
455
    print_insn = print_insn_m68k;
456
#elif defined(TARGET_MIPS)
457
#ifdef TARGET_WORDS_BIGENDIAN
458
    print_insn = print_insn_big_mips;
459
#else
460
    print_insn = print_insn_little_mips;
461
#endif
462
#elif defined(TARGET_SH4)
463
    s.info.mach = bfd_mach_sh4;
464
    print_insn = print_insn_sh;
465
#elif defined(TARGET_S390X)
466
    s.info.mach = bfd_mach_s390_64;
467
    print_insn = print_insn_s390;
468
#elif defined(TARGET_MOXIE)
469
    s.info.mach = bfd_arch_moxie;
470
    print_insn = print_insn_moxie;
471
#elif defined(TARGET_LM32)
472
    s.info.mach = bfd_mach_lm32;
473
    print_insn = print_insn_lm32;
474
#else
475
    monitor_printf(mon, "0x" TARGET_FMT_lx
476
                   ": Asm output not supported on this arch\n", pc);
477
    return;
478
#endif
479

    
480
    for(i = 0; i < nb_insn; i++) {
481
        monitor_printf(mon, "0x" TARGET_FMT_lx ":  ", pc);
482
        count = print_insn(pc, &s.info);
483
        monitor_printf(mon, "\n");
484
        if (count < 0)
485
            break;
486
        pc += count;
487
    }
488
}
489
#endif