Statistics
| Branch: | Revision:

root / disas.c @ f54b3f92

History | View | Annotate | Download (11.1 kB)

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

    
7
#include "cpu.h"
8
#include "exec-all.h"
9
#include "disas.h"
10

    
11
/* Filled in by elfload.c.  Simplistic, but will do for now. */
12
struct syminfo *syminfos = NULL;
13

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

    
31
/* Get LENGTH bytes from info's buffer, at target address memaddr.
32
   Transfer them to myaddr.  */
33
static int
34
target_read_memory (bfd_vma memaddr,
35
                    bfd_byte *myaddr,
36
                    int length,
37
                    struct disassemble_info *info)
38
{
39
    int i;
40
    for(i = 0; i < length; i++) {
41
        myaddr[i] = ldub_code(memaddr + i);
42
    }
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 (status, memaddr, info)
50
     int status;
51
     bfd_vma memaddr;
52
     struct disassemble_info *info;
53
{
54
  if (status != EIO)
55
    /* Can't happen.  */
56
    (*info->fprintf_func) (info->stream, "Unknown error %d\n", status);
57
  else
58
    /* Actually, address between memaddr and memaddr + len was
59
       out of bounds.  */
60
    (*info->fprintf_func) (info->stream,
61
                           "Address 0x%" PRIx64 " is out of bounds.\n", memaddr);
62
}
63

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

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

    
71
void
72
generic_print_address (addr, info)
73
     bfd_vma addr;
74
     struct disassemble_info *info;
75
{
76
    (*info->fprintf_func) (info->stream, "0x%" PRIx64, addr);
77
}
78

    
79
/* Just return the given address.  */
80

    
81
int
82
generic_symbol_at_address (addr, info)
83
     bfd_vma addr;
84
     struct disassemble_info * info;
85
{
86
  return 1;
87
}
88

    
89
bfd_vma bfd_getl32 (const bfd_byte *addr)
90
{
91
  unsigned long v;
92

    
93
  v = (unsigned long) addr[0];
94
  v |= (unsigned long) addr[1] << 8;
95
  v |= (unsigned long) addr[2] << 16;
96
  v |= (unsigned long) addr[3] << 24;
97
  return (bfd_vma) v;
98
}
99

    
100
bfd_vma bfd_getb32 (const bfd_byte *addr)
101
{
102
  unsigned long v;
103

    
104
  v = (unsigned long) addr[0] << 24;
105
  v |= (unsigned long) addr[1] << 16;
106
  v |= (unsigned long) addr[2] << 8;
107
  v |= (unsigned long) addr[3];
108
  return (bfd_vma) v;
109
}
110

    
111
bfd_vma bfd_getl16 (const bfd_byte *addr)
112
{
113
  unsigned long v;
114

    
115
  v = (unsigned long) addr[0];
116
  v |= (unsigned long) addr[1] << 8;
117
  return (bfd_vma) v;
118
}
119

    
120
bfd_vma bfd_getb16 (const bfd_byte *addr)
121
{
122
  unsigned long v;
123

    
124
  v = (unsigned long) addr[0] << 24;
125
  v |= (unsigned long) addr[1] << 16;
126
  return (bfd_vma) v;
127
}
128

    
129
#ifdef TARGET_ARM
130
static int
131
print_insn_thumb1(bfd_vma pc, disassemble_info *info)
132
{
133
  return print_insn_arm(pc | 1, info);
134
}
135
#endif
136

    
137
/* Disassemble this for me please... (debugging). 'flags' has the following
138
   values:
139
    i386 - nonzero means 16 bit code
140
    arm  - nonzero means thumb code
141
    ppc  - nonzero means little endian
142
    other targets - unused
143
 */
144
void target_disas(FILE *out, target_ulong code, target_ulong size, int flags)
145
{
146
    target_ulong pc;
147
    int count;
148
    struct disassemble_info disasm_info;
149
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
150

    
151
    INIT_DISASSEMBLE_INFO(disasm_info, out, fprintf);
152

    
153
    disasm_info.read_memory_func = target_read_memory;
154
    disasm_info.buffer_vma = code;
155
    disasm_info.buffer_length = size;
156

    
157
#ifdef TARGET_WORDS_BIGENDIAN
158
    disasm_info.endian = BFD_ENDIAN_BIG;
159
#else
160
    disasm_info.endian = BFD_ENDIAN_LITTLE;
161
#endif
162
#if defined(TARGET_I386)
163
    if (flags == 2)
164
        disasm_info.mach = bfd_mach_x86_64;
165
    else if (flags == 1)
166
        disasm_info.mach = bfd_mach_i386_i8086;
167
    else
168
        disasm_info.mach = bfd_mach_i386_i386;
169
    print_insn = print_insn_i386;
170
#elif defined(TARGET_ARM)
171
    if (flags)
172
        print_insn = print_insn_thumb1;
173
    else
174
        print_insn = print_insn_arm;
175
#elif defined(TARGET_SPARC)
176
    print_insn = print_insn_sparc;
177
#ifdef TARGET_SPARC64
178
    disasm_info.mach = bfd_mach_sparc_v9b;
179
#endif
180
#elif defined(TARGET_PPC)
181
    if (flags >> 16)
182
        disasm_info.endian = BFD_ENDIAN_LITTLE;
183
    if (flags & 0xFFFF) {
184
        /* If we have a precise definitions of the instructions set, use it */
185
        disasm_info.mach = flags & 0xFFFF;
186
    } else {
187
#ifdef TARGET_PPC64
188
        disasm_info.mach = bfd_mach_ppc64;
189
#else
190
        disasm_info.mach = bfd_mach_ppc;
191
#endif
192
    }
193
    print_insn = print_insn_ppc;
194
#elif defined(TARGET_M68K)
195
    print_insn = print_insn_m68k;
196
#elif defined(TARGET_MIPS)
197
#ifdef TARGET_WORDS_BIGENDIAN
198
    print_insn = print_insn_big_mips;
199
#else
200
    print_insn = print_insn_little_mips;
201
#endif
202
#elif defined(TARGET_SH4)
203
    disasm_info.mach = bfd_mach_sh4;
204
    print_insn = print_insn_sh;
205
#elif defined(TARGET_ALPHA)
206
    disasm_info.mach = bfd_mach_alpha;
207
    print_insn = print_insn_alpha;
208
#elif defined(TARGET_CRIS)
209
    disasm_info.mach = bfd_mach_cris_v32;
210
    print_insn = print_insn_crisv32;
211
#else
212
    fprintf(out, "0x" TARGET_FMT_lx
213
            ": Asm output not supported on this arch\n", code);
214
    return;
215
#endif
216

    
217
    for (pc = code; pc < code + size; pc += count) {
218
        fprintf(out, "0x" TARGET_FMT_lx ":  ", pc);
219
        count = print_insn(pc, &disasm_info);
220
#if 0
221
        {
222
            int i;
223
            uint8_t b;
224
            fprintf(out, " {");
225
            for(i = 0; i < count; i++) {
226
                target_read_memory(pc + i, &b, 1, &disasm_info);
227
                fprintf(out, " %02x", b);
228
            }
229
            fprintf(out, " }");
230
        }
231
#endif
232
        fprintf(out, "\n");
233
        if (count < 0)
234
            break;
235
    }
236
}
237

    
238
/* Disassemble this for me please... (debugging). */
239
void disas(FILE *out, void *code, unsigned long size)
240
{
241
    unsigned long pc;
242
    int count;
243
    struct disassemble_info disasm_info;
244
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
245

    
246
    INIT_DISASSEMBLE_INFO(disasm_info, out, fprintf);
247

    
248
    disasm_info.buffer = code;
249
    disasm_info.buffer_vma = (unsigned long)code;
250
    disasm_info.buffer_length = size;
251

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

    
303
/* Look up symbol for debugging purpose.  Returns "" if unknown. */
304
const char *lookup_symbol(target_ulong orig_addr)
305
{
306
    unsigned int i;
307
    /* Hack, because we know this is x86. */
308
    Elf32_Sym *sym;
309
    struct syminfo *s;
310
    target_ulong addr;
311

    
312
    for (s = syminfos; s; s = s->next) {
313
        sym = s->disas_symtab;
314
        for (i = 0; i < s->disas_num_syms; i++) {
315
            if (sym[i].st_shndx == SHN_UNDEF
316
                || sym[i].st_shndx >= SHN_LORESERVE)
317
                continue;
318

    
319
            if (ELF_ST_TYPE(sym[i].st_info) != STT_FUNC)
320
                continue;
321

    
322
            addr = sym[i].st_value;
323
#if defined(TARGET_ARM) || defined (TARGET_MIPS)
324
            /* The bottom address bit marks a Thumb or MIPS16 symbol.  */
325
            addr &= ~(target_ulong)1;
326
#endif
327
            if (orig_addr >= addr
328
                && orig_addr < addr + sym[i].st_size)
329
                return s->disas_strtab + sym[i].st_name;
330
        }
331
    }
332
    return "";
333
}
334

    
335
#if !defined(CONFIG_USER_ONLY)
336

    
337
void term_vprintf(const char *fmt, va_list ap);
338
void term_printf(const char *fmt, ...);
339

    
340
static int monitor_disas_is_physical;
341
static CPUState *monitor_disas_env;
342

    
343
static int
344
monitor_read_memory (memaddr, myaddr, length, info)
345
     bfd_vma memaddr;
346
     bfd_byte *myaddr;
347
     int length;
348
     struct disassemble_info *info;
349
{
350
    if (monitor_disas_is_physical) {
351
        cpu_physical_memory_rw(memaddr, myaddr, length, 0);
352
    } else {
353
        cpu_memory_rw_debug(monitor_disas_env, memaddr,myaddr, length, 0);
354
    }
355
    return 0;
356
}
357

    
358
static int monitor_fprintf(FILE *stream, const char *fmt, ...)
359
{
360
    va_list ap;
361
    va_start(ap, fmt);
362
    term_vprintf(fmt, ap);
363
    va_end(ap);
364
    return 0;
365
}
366

    
367
void monitor_disas(CPUState *env,
368
                   target_ulong pc, int nb_insn, int is_physical, int flags)
369
{
370
    int count, i;
371
    struct disassemble_info disasm_info;
372
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
373

    
374
    INIT_DISASSEMBLE_INFO(disasm_info, NULL, monitor_fprintf);
375

    
376
    monitor_disas_env = env;
377
    monitor_disas_is_physical = is_physical;
378
    disasm_info.read_memory_func = monitor_read_memory;
379

    
380
    disasm_info.buffer_vma = pc;
381

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

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