Statistics
| Branch: | Revision:

root / disas.c @ 6af0bf9c

History | View | Annotate | Download (9.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%llx 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%llx", 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
    other targets - unused
142
 */
143
void target_disas(FILE *out, target_ulong code, target_ulong size, int flags)
144
{
145
    target_ulong pc;
146
    int count;
147
    struct disassemble_info disasm_info;
148
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
149

    
150
    INIT_DISASSEMBLE_INFO(disasm_info, out, fprintf);
151

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

    
156
#ifdef TARGET_WORDS_BIGENDIAN
157
    disasm_info.endian = BFD_ENDIAN_BIG;
158
#else
159
    disasm_info.endian = BFD_ENDIAN_LITTLE;
160
#endif
161
#if defined(TARGET_I386)
162
    if (flags == 2)
163
        disasm_info.mach = bfd_mach_x86_64;
164
    else if (flags == 1) 
165
        disasm_info.mach = bfd_mach_i386_i8086;
166
    else
167
        disasm_info.mach = bfd_mach_i386_i386;
168
    print_insn = print_insn_i386;
169
#elif defined(TARGET_ARM)
170
    if (flags)
171
        print_insn = print_insn_thumb1;
172
    else
173
        print_insn = print_insn_arm;
174
#elif defined(TARGET_SPARC)
175
    print_insn = print_insn_sparc;
176
#ifdef TARGET_SPARC64
177
    disasm_info.mach = bfd_mach_sparc_v9b;
178
#endif    
179
#elif defined(TARGET_PPC)
180
    if (cpu_single_env->msr[MSR_LE])
181
        disasm_info.endian = BFD_ENDIAN_LITTLE;
182
    print_insn = print_insn_ppc;
183
#elif defined(TARGET_MIPS)
184
    print_insn = print_insn_big_mips;
185
#else
186
    fprintf(out, "0x" TARGET_FMT_lx
187
            ": Asm output not supported on this arch\n", code);
188
    return;
189
#endif
190

    
191
    for (pc = code; pc < code + size; pc += count) {
192
        fprintf(out, "0x" TARGET_FMT_lx ":  ", pc);
193
        count = print_insn(pc, &disasm_info);
194
#if 0
195
        {
196
            int i;
197
            uint8_t b;
198
            fprintf(out, " {");
199
            for(i = 0; i < count; i++) {
200
                target_read_memory(pc + i, &b, 1, &disasm_info);
201
                fprintf(out, " %02x", b);
202
            }
203
            fprintf(out, " }");
204
        }
205
#endif
206
        fprintf(out, "\n");
207
        if (count < 0)
208
            break;
209
    }
210
}
211

    
212
/* Disassemble this for me please... (debugging). */
213
void disas(FILE *out, void *code, unsigned long size)
214
{
215
    unsigned long pc;
216
    int count;
217
    struct disassemble_info disasm_info;
218
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
219

    
220
    INIT_DISASSEMBLE_INFO(disasm_info, out, fprintf);
221

    
222
    disasm_info.buffer = code;
223
    disasm_info.buffer_vma = (unsigned long)code;
224
    disasm_info.buffer_length = size;
225

    
226
#ifdef WORDS_BIGENDIAN
227
    disasm_info.endian = BFD_ENDIAN_BIG;
228
#else
229
    disasm_info.endian = BFD_ENDIAN_LITTLE;
230
#endif
231
#if defined(__i386__)
232
    disasm_info.mach = bfd_mach_i386_i386;
233
    print_insn = print_insn_i386;
234
#elif defined(__x86_64__)
235
    disasm_info.mach = bfd_mach_x86_64;
236
    print_insn = print_insn_i386;
237
#elif defined(__powerpc__)
238
    print_insn = print_insn_ppc;
239
#elif defined(__alpha__)
240
    print_insn = print_insn_alpha;
241
#elif defined(__sparc__)
242
    print_insn = print_insn_sparc;
243
#elif defined(__arm__) 
244
    print_insn = print_insn_arm;
245
#elif defined(__MIPSEB__)
246
    print_insn = print_insn_big_mips;
247
#elif defined(__MIPSEL__)
248
    print_insn = print_insn_little_mips;
249
#else
250
    fprintf(out, "0x%lx: Asm output not supported on this arch\n",
251
            (long) code);
252
    return;
253
#endif
254
    for (pc = (unsigned long)code; pc < (unsigned long)code + size; pc += count) {
255
        fprintf(out, "0x%08lx:  ", pc);
256
#ifdef __arm__
257
        /* since data are included in the code, it is better to
258
           display code data too */
259
        if (is_host) {
260
            fprintf(out, "%08x  ", (int)bfd_getl32((const bfd_byte *)pc));
261
        }
262
#endif
263
        count = print_insn(pc, &disasm_info);
264
        fprintf(out, "\n");
265
        if (count < 0)
266
            break;
267
    }
268
}
269

    
270
/* Look up symbol for debugging purpose.  Returns "" if unknown. */
271
const char *lookup_symbol(target_ulong orig_addr)
272
{
273
    unsigned int i;
274
    /* Hack, because we know this is x86. */
275
    Elf32_Sym *sym;
276
    struct syminfo *s;
277
    
278
    for (s = syminfos; s; s = s->next) {
279
        sym = s->disas_symtab;
280
        for (i = 0; i < s->disas_num_syms; i++) {
281
            if (sym[i].st_shndx == SHN_UNDEF
282
                || sym[i].st_shndx >= SHN_LORESERVE)
283
                continue;
284

    
285
            if (ELF_ST_TYPE(sym[i].st_info) != STT_FUNC)
286
                continue;
287

    
288
            if (orig_addr >= sym[i].st_value
289
                && orig_addr < sym[i].st_value + sym[i].st_size)
290
                return s->disas_strtab + sym[i].st_name;
291
        }
292
    }
293
    return "";
294
}
295

    
296
#if !defined(CONFIG_USER_ONLY)
297

    
298
void term_vprintf(const char *fmt, va_list ap);
299
void term_printf(const char *fmt, ...);
300

    
301
static int monitor_disas_is_physical;
302

    
303
static int
304
monitor_read_memory (memaddr, myaddr, length, info)
305
     bfd_vma memaddr;
306
     bfd_byte *myaddr;
307
     int length;
308
     struct disassemble_info *info;
309
{
310
    if (monitor_disas_is_physical) {
311
        cpu_physical_memory_rw(memaddr, myaddr, length, 0);
312
    } else {
313
        cpu_memory_rw_debug(cpu_single_env, memaddr,myaddr, length, 0);
314
    }
315
    return 0;
316
}
317

    
318
static int monitor_fprintf(FILE *stream, const char *fmt, ...)
319
{
320
    va_list ap;
321
    va_start(ap, fmt);
322
    term_vprintf(fmt, ap);
323
    va_end(ap);
324
    return 0;
325
}
326

    
327
void monitor_disas(target_ulong pc, int nb_insn, int is_physical, int flags)
328
{
329
    int count, i;
330
    struct disassemble_info disasm_info;
331
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
332

    
333
    INIT_DISASSEMBLE_INFO(disasm_info, NULL, monitor_fprintf);
334

    
335
    monitor_disas_is_physical = is_physical;
336
    disasm_info.read_memory_func = monitor_read_memory;
337

    
338
    disasm_info.buffer_vma = pc;
339

    
340
#ifdef TARGET_WORDS_BIGENDIAN
341
    disasm_info.endian = BFD_ENDIAN_BIG;
342
#else
343
    disasm_info.endian = BFD_ENDIAN_LITTLE;
344
#endif
345
#if defined(TARGET_I386)
346
    if (flags == 2)
347
        disasm_info.mach = bfd_mach_x86_64;
348
    else if (flags == 1) 
349
        disasm_info.mach = bfd_mach_i386_i8086;
350
    else
351
        disasm_info.mach = bfd_mach_i386_i386;
352
    print_insn = print_insn_i386;
353
#elif defined(TARGET_ARM)
354
    print_insn = print_insn_arm;
355
#elif defined(TARGET_SPARC)
356
    print_insn = print_insn_sparc;
357
#elif defined(TARGET_PPC)
358
    print_insn = print_insn_ppc;
359
#elif defined(TARGET_MIPS)
360
    print_insn = print_insn_big_mips;
361
#else
362
    term_printf("0x" TARGET_FMT_lx
363
                ": Asm output not supported on this arch\n", pc);
364
    return;
365
#endif
366

    
367
    for(i = 0; i < nb_insn; i++) {
368
        term_printf("0x" TARGET_FMT_lx ":  ", pc);
369
        count = print_insn(pc, &disasm_info);
370
        term_printf("\n");
371
        if (count < 0)
372
            break;
373
        pc += count;
374
    }
375
}
376
#endif