Statistics
| Branch: | Revision:

root / disas.c @ 48024e4a

History | View | Annotate | Download (10 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
#ifdef TARGET_PPC64
183
    disasm_info.mach = bfd_mach_ppc64;
184
#else
185
    disasm_info.mach = bfd_mach_ppc;
186
#endif
187
    print_insn = print_insn_ppc;
188
#elif defined(TARGET_MIPS)
189
    print_insn = print_insn_big_mips;
190
#elif defined(TARGET_M68K)
191
    print_insn = print_insn_m68k;
192
#else
193
    fprintf(out, "0x" TARGET_FMT_lx
194
            ": Asm output not supported on this arch\n", code);
195
    return;
196
#endif
197

    
198
    for (pc = code; pc < code + size; pc += count) {
199
        fprintf(out, "0x" TARGET_FMT_lx ":  ", pc);
200
        count = print_insn(pc, &disasm_info);
201
#if 0
202
        {
203
            int i;
204
            uint8_t b;
205
            fprintf(out, " {");
206
            for(i = 0; i < count; i++) {
207
                target_read_memory(pc + i, &b, 1, &disasm_info);
208
                fprintf(out, " %02x", b);
209
            }
210
            fprintf(out, " }");
211
        }
212
#endif
213
        fprintf(out, "\n");
214
        if (count < 0)
215
            break;
216
    }
217
}
218

    
219
/* Disassemble this for me please... (debugging). */
220
void disas(FILE *out, void *code, unsigned long size)
221
{
222
    unsigned long pc;
223
    int count;
224
    struct disassemble_info disasm_info;
225
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
226

    
227
    INIT_DISASSEMBLE_INFO(disasm_info, out, fprintf);
228

    
229
    disasm_info.buffer = code;
230
    disasm_info.buffer_vma = (unsigned long)code;
231
    disasm_info.buffer_length = size;
232

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

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

    
295
            if (ELF_ST_TYPE(sym[i].st_info) != STT_FUNC)
296
                continue;
297

    
298
            addr = sym[i].st_value;
299
#ifdef TARGET_ARM
300
            /* The bottom address bit marks a Thumb symbol.  */
301
            addr &= ~(target_ulong)1;
302
#endif
303
            if (orig_addr >= addr
304
                && orig_addr < addr + sym[i].st_size)
305
                return s->disas_strtab + sym[i].st_name;
306
        }
307
    }
308
    return "";
309
}
310

    
311
#if !defined(CONFIG_USER_ONLY)
312

    
313
void term_vprintf(const char *fmt, va_list ap);
314
void term_printf(const char *fmt, ...);
315

    
316
static int monitor_disas_is_physical;
317

    
318
static int
319
monitor_read_memory (memaddr, myaddr, length, info)
320
     bfd_vma memaddr;
321
     bfd_byte *myaddr;
322
     int length;
323
     struct disassemble_info *info;
324
{
325
    if (monitor_disas_is_physical) {
326
        cpu_physical_memory_rw(memaddr, myaddr, length, 0);
327
    } else {
328
        cpu_memory_rw_debug(cpu_single_env, memaddr,myaddr, length, 0);
329
    }
330
    return 0;
331
}
332

    
333
static int monitor_fprintf(FILE *stream, const char *fmt, ...)
334
{
335
    va_list ap;
336
    va_start(ap, fmt);
337
    term_vprintf(fmt, ap);
338
    va_end(ap);
339
    return 0;
340
}
341

    
342
void monitor_disas(target_ulong pc, int nb_insn, int is_physical, int flags)
343
{
344
    int count, i;
345
    struct disassemble_info disasm_info;
346
    int (*print_insn)(bfd_vma pc, disassemble_info *info);
347

    
348
    INIT_DISASSEMBLE_INFO(disasm_info, NULL, monitor_fprintf);
349

    
350
    monitor_disas_is_physical = is_physical;
351
    disasm_info.read_memory_func = monitor_read_memory;
352

    
353
    disasm_info.buffer_vma = pc;
354

    
355
#ifdef TARGET_WORDS_BIGENDIAN
356
    disasm_info.endian = BFD_ENDIAN_BIG;
357
#else
358
    disasm_info.endian = BFD_ENDIAN_LITTLE;
359
#endif
360
#if defined(TARGET_I386)
361
    if (flags == 2)
362
        disasm_info.mach = bfd_mach_x86_64;
363
    else if (flags == 1) 
364
        disasm_info.mach = bfd_mach_i386_i8086;
365
    else
366
        disasm_info.mach = bfd_mach_i386_i386;
367
    print_insn = print_insn_i386;
368
#elif defined(TARGET_ARM)
369
    print_insn = print_insn_arm;
370
#elif defined(TARGET_SPARC)
371
    print_insn = print_insn_sparc;
372
#elif defined(TARGET_PPC)
373
#ifdef TARGET_PPC64
374
    disasm_info.mach = bfd_mach_ppc64;
375
#else
376
    disasm_info.mach = bfd_mach_ppc;
377
#endif
378
    print_insn = print_insn_ppc;
379
#elif defined(TARGET_MIPS)
380
    print_insn = print_insn_big_mips;
381
#elif defined(TARGET_M68K)
382
    print_insn = print_insn_m68k;
383
#else
384
    term_printf("0x" TARGET_FMT_lx
385
                ": Asm output not supported on this arch\n", pc);
386
    return;
387
#endif
388

    
389
    for(i = 0; i < nb_insn; i++) {
390
        term_printf("0x" TARGET_FMT_lx ":  ", pc);
391
        count = print_insn(pc, &disasm_info);
392
        term_printf("\n");
393
        if (count < 0)
394
            break;
395
        pc += count;
396
    }
397
}
398
#endif