Statistics
| Branch: | Revision:

root / disas.c @ 26a76461

History | View | Annotate | Download (10.4 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 teh 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)
182
        disasm_info.endian = BFD_ENDIAN_LITTLE;
183
#ifdef TARGET_PPC64
184
    disasm_info.mach = bfd_mach_ppc64;
185
#else
186
    disasm_info.mach = bfd_mach_ppc;
187
#endif
188
    print_insn = print_insn_ppc;
189
#elif defined(TARGET_MIPS)
190
#ifdef TARGET_WORDS_BIGENDIAN
191
    print_insn = print_insn_big_mips;
192
#else
193
    print_insn = print_insn_little_mips;
194
#endif
195
#elif defined(TARGET_M68K)
196
    print_insn = print_insn_m68k;
197
#elif defined(TARGET_SH4)
198
    disasm_info.mach = bfd_mach_sh4;
199
    print_insn = print_insn_sh;
200
#else
201
    fprintf(out, "0x" TARGET_FMT_lx
202
            ": Asm output not supported on this arch\n", code);
203
    return;
204
#endif
205

    
206
    for (pc = code; pc < code + size; pc += count) {
207
        fprintf(out, "0x" TARGET_FMT_lx ":  ", pc);
208
        count = print_insn(pc, &disasm_info);
209
#if 0
210
        {
211
            int i;
212
            uint8_t b;
213
            fprintf(out, " {");
214
            for(i = 0; i < count; i++) {
215
                target_read_memory(pc + i, &b, 1, &disasm_info);
216
                fprintf(out, " %02x", b);
217
            }
218
            fprintf(out, " }");
219
        }
220
#endif
221
        fprintf(out, "\n");
222
        if (count < 0)
223
            break;
224
    }
225
}
226

    
227
/* Disassemble this for me please... (debugging). */
228
void disas(FILE *out, void *code, unsigned long size)
229
{
230
    unsigned long pc;
231
    int count;
232
    struct disassemble_info disasm_info;
233
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
234

    
235
    INIT_DISASSEMBLE_INFO(disasm_info, out, fprintf);
236

    
237
    disasm_info.buffer = code;
238
    disasm_info.buffer_vma = (unsigned long)code;
239
    disasm_info.buffer_length = size;
240

    
241
#ifdef WORDS_BIGENDIAN
242
    disasm_info.endian = BFD_ENDIAN_BIG;
243
#else
244
    disasm_info.endian = BFD_ENDIAN_LITTLE;
245
#endif
246
#if defined(__i386__)
247
    disasm_info.mach = bfd_mach_i386_i386;
248
    print_insn = print_insn_i386;
249
#elif defined(__x86_64__)
250
    disasm_info.mach = bfd_mach_x86_64;
251
    print_insn = print_insn_i386;
252
#elif defined(__powerpc__)
253
    print_insn = print_insn_ppc;
254
#elif defined(__alpha__)
255
    print_insn = print_insn_alpha;
256
#elif defined(__sparc__)
257
    print_insn = print_insn_sparc;
258
#elif defined(__arm__) 
259
    print_insn = print_insn_arm;
260
#elif defined(__MIPSEB__)
261
    print_insn = print_insn_big_mips;
262
#elif defined(__MIPSEL__)
263
    print_insn = print_insn_little_mips;
264
#elif defined(__m68k__)
265
    print_insn = print_insn_m68k;
266
#else
267
    fprintf(out, "0x%lx: Asm output not supported on this arch\n",
268
            (long) code);
269
    return;
270
#endif
271
    for (pc = (unsigned long)code; pc < (unsigned long)code + size; pc += count) {
272
        fprintf(out, "0x%08lx:  ", pc);
273
#ifdef __arm__
274
        /* since data are included in the code, it is better to
275
           display code data too */
276
        if (is_host) {
277
            fprintf(out, "%08x  ", (int)bfd_getl32((const bfd_byte *)pc));
278
        }
279
#endif
280
        count = print_insn(pc, &disasm_info);
281
        fprintf(out, "\n");
282
        if (count < 0)
283
            break;
284
    }
285
}
286

    
287
/* Look up symbol for debugging purpose.  Returns "" if unknown. */
288
const char *lookup_symbol(target_ulong orig_addr)
289
{
290
    unsigned int i;
291
    /* Hack, because we know this is x86. */
292
    Elf32_Sym *sym;
293
    struct syminfo *s;
294
    target_ulong addr;
295
    
296
    for (s = syminfos; s; s = s->next) {
297
        sym = s->disas_symtab;
298
        for (i = 0; i < s->disas_num_syms; i++) {
299
            if (sym[i].st_shndx == SHN_UNDEF
300
                || sym[i].st_shndx >= SHN_LORESERVE)
301
                continue;
302

    
303
            if (ELF_ST_TYPE(sym[i].st_info) != STT_FUNC)
304
                continue;
305

    
306
            addr = sym[i].st_value;
307
#ifdef TARGET_ARM
308
            /* The bottom address bit marks a Thumb symbol.  */
309
            addr &= ~(target_ulong)1;
310
#endif
311
            if (orig_addr >= addr
312
                && orig_addr < addr + sym[i].st_size)
313
                return s->disas_strtab + sym[i].st_name;
314
        }
315
    }
316
    return "";
317
}
318

    
319
#if !defined(CONFIG_USER_ONLY)
320

    
321
void term_vprintf(const char *fmt, va_list ap);
322
void term_printf(const char *fmt, ...);
323

    
324
static int monitor_disas_is_physical;
325
static CPUState *monitor_disas_env;
326

    
327
static int
328
monitor_read_memory (memaddr, myaddr, length, info)
329
     bfd_vma memaddr;
330
     bfd_byte *myaddr;
331
     int length;
332
     struct disassemble_info *info;
333
{
334
    if (monitor_disas_is_physical) {
335
        cpu_physical_memory_rw(memaddr, myaddr, length, 0);
336
    } else {
337
        cpu_memory_rw_debug(monitor_disas_env, memaddr,myaddr, length, 0);
338
    }
339
    return 0;
340
}
341

    
342
static int monitor_fprintf(FILE *stream, const char *fmt, ...)
343
{
344
    va_list ap;
345
    va_start(ap, fmt);
346
    term_vprintf(fmt, ap);
347
    va_end(ap);
348
    return 0;
349
}
350

    
351
void monitor_disas(CPUState *env,
352
                   target_ulong pc, int nb_insn, int is_physical, int flags)
353
{
354
    int count, i;
355
    struct disassemble_info disasm_info;
356
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
357

    
358
    INIT_DISASSEMBLE_INFO(disasm_info, NULL, monitor_fprintf);
359

    
360
    monitor_disas_env = env;
361
    monitor_disas_is_physical = is_physical;
362
    disasm_info.read_memory_func = monitor_read_memory;
363

    
364
    disasm_info.buffer_vma = pc;
365

    
366
#ifdef TARGET_WORDS_BIGENDIAN
367
    disasm_info.endian = BFD_ENDIAN_BIG;
368
#else
369
    disasm_info.endian = BFD_ENDIAN_LITTLE;
370
#endif
371
#if defined(TARGET_I386)
372
    if (flags == 2)
373
        disasm_info.mach = bfd_mach_x86_64;
374
    else if (flags == 1) 
375
        disasm_info.mach = bfd_mach_i386_i8086;
376
    else
377
        disasm_info.mach = bfd_mach_i386_i386;
378
    print_insn = print_insn_i386;
379
#elif defined(TARGET_ARM)
380
    print_insn = print_insn_arm;
381
#elif defined(TARGET_SPARC)
382
    print_insn = print_insn_sparc;
383
#elif defined(TARGET_PPC)
384
#ifdef TARGET_PPC64
385
    disasm_info.mach = bfd_mach_ppc64;
386
#else
387
    disasm_info.mach = bfd_mach_ppc;
388
#endif
389
    print_insn = print_insn_ppc;
390
#elif defined(TARGET_MIPS)
391
#ifdef TARGET_WORDS_BIGENDIAN
392
    print_insn = print_insn_big_mips;
393
#else
394
    print_insn = print_insn_little_mips;
395
#endif
396
#elif defined(TARGET_M68K)
397
    print_insn = print_insn_m68k;
398
#else
399
    term_printf("0x" TARGET_FMT_lx
400
                ": Asm output not supported on this arch\n", pc);
401
    return;
402
#endif
403

    
404
    for(i = 0; i < nb_insn; i++) {
405
        term_printf("0x" TARGET_FMT_lx ":  ", pc);
406
        count = print_insn(pc, &disasm_info);
407
        term_printf("\n");
408
        if (count < 0)
409
            break;
410
        pc += count;
411
    }
412
}
413
#endif