disas.c

   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 unsigned int disas_num_syms;
  13 void *disas_symtab;
  14 const char *disas_strtab;
  15
  16 /* Get LENGTH bytes from info's buffer, at target address memaddr.
  17    Transfer them to myaddr.  */
  18 int
  19 buffer_read_memory (memaddr, myaddr, length, info)
  20      bfd_vma memaddr;
  21      bfd_byte *myaddr;
  22      int length;
  23      struct disassemble_info *info;
  24 {
  25     if (memaddr < info->buffer_vma
  26         || memaddr + length > info->buffer_vma + info->buffer_length)
  27         /* Out of bounds.  Use EIO because GDB uses it.  */
  28         return EIO;
  29     memcpy (myaddr, info->buffer + (memaddr - info->buffer_vma), length);
  30     return 0;
  31 }
  32
  33 #if !defined(CONFIG_USER_ONLY)
  34 /* Get LENGTH bytes from info's buffer, at target address memaddr.
  35    Transfer them to myaddr.  */
  36 static int
  37 target_read_memory (memaddr, myaddr, length, info)
  38      bfd_vma memaddr;
  39      bfd_byte *myaddr;
  40      int length;
  41      struct disassemble_info *info;
  42 {
  43     int i;
  44     for(i = 0; i < length; i++) {
  45         myaddr[i] = ldub_code((void *)((long)memaddr + i));
  46     }
  47     return 0;
  48 }
  49 #endif
  50
  51 /* Print an error message.  We can assume that this is in response to
  52    an error return from buffer_read_memory.  */
  53 void
  54 perror_memory (status, memaddr, info)
  55      int status;
  56      bfd_vma memaddr;
  57      struct disassemble_info *info;
  58 {
  59   if (status != EIO)
  60     /* Can't happen.  */
  61     (*info->fprintf_func) (info->stream, "Unknown error %d\n", status);
  62   else
  63     /* Actually, address between memaddr and memaddr + len was
  64        out of bounds.  */
  65     (*info->fprintf_func) (info->stream,
  66                            "Address 0x%llx is out of bounds.\n", memaddr);
  67 }
  68
  69 /* This could be in a separate file, to save miniscule amounts of space
  70    in statically linked executables.  */
  71
  72 /* Just print the address is hex.  This is included for completeness even
  73    though both GDB and objdump provide their own (to print symbolic
  74    addresses).  */
  75
  76 void
  77 generic_print_address (addr, info)
  78      bfd_vma addr;
  79      struct disassemble_info *info;
  80 {
  81   (*info->fprintf_func) (info->stream, "0x%llx", addr);
  82 }
  83
  84 /* Just return the given address.  */
  85
  86 int
  87 generic_symbol_at_address (addr, info)
  88      bfd_vma addr;
  89      struct disassemble_info * info;
  90 {
  91   return 1;
  92 }
  93
  94 bfd_vma bfd_getl32 (const bfd_byte *addr)
  95 {
  96   unsigned long v;
  97
  98   v = (unsigned long) addr[0];
  99   v |= (unsigned long) addr[1] << 8;
 100   v |= (unsigned long) addr[2] << 16;
 101   v |= (unsigned long) addr[3] << 24;
 102   return (bfd_vma) v;
 103 }
 104
 105 bfd_vma bfd_getb32 (const bfd_byte *addr)
 106 {
 107   unsigned long v;
 108
 109   v = (unsigned long) addr[0] << 24;
 110   v |= (unsigned long) addr[1] << 16;
 111   v |= (unsigned long) addr[2] << 8;
 112   v |= (unsigned long) addr[3];
 113   return (bfd_vma) v;
 114 }
 115
 116 /* Disassemble this for me please... (debugging). 'flags' is only used
 117    for i386: non zero means 16 bit code */
 118 void disas(FILE *out, void *code, unsigned long size, int is_host, int flags)
 119 {
 120     uint8_t *pc;
 121     int count;
 122     struct disassemble_info disasm_info;
 123     int (*print_insn)(bfd_vma pc, disassemble_info *info);
 124
 125     INIT_DISASSEMBLE_INFO(disasm_info, out, fprintf);
 126
 127 #if !defined(CONFIG_USER_ONLY)
 128     if (!is_host) {
 129         disasm_info.read_memory_func = target_read_memory;
 130     }
 131 #endif
 132
 133     disasm_info.buffer = code;
 134     disasm_info.buffer_vma = (unsigned long)code;
 135     disasm_info.buffer_length = size;
 136
 137     if (is_host) {
 138 #ifdef WORDS_BIGENDIAN
 139         disasm_info.endian = BFD_ENDIAN_BIG;
 140 #else
 141         disasm_info.endian = BFD_ENDIAN_LITTLE;
 142 #endif
 143 #if defined(__i386__)
 144         disasm_info.mach = bfd_mach_i386_i386;
 145         print_insn = print_insn_i386;
 146 #elif defined(__x86_64__)
 147         disasm_info.mach = bfd_mach_x86_64;
 148         print_insn = print_insn_i386;
 149 #elif defined(__powerpc__)
 150         print_insn = print_insn_ppc;
 151 #elif defined(__alpha__)
 152         print_insn = print_insn_alpha;
 153 #elif defined(__sparc__)
 154         print_insn = print_insn_sparc;
 155 #elif defined(__arm__)
 156         print_insn = print_insn_arm;
 157 #else
 158         fprintf(out, "Asm output not supported on this arch\n");
 159         return;
 160 #endif
 161     } else {
 162 #ifdef TARGET_WORDS_BIGENDIAN
 163         disasm_info.endian = BFD_ENDIAN_BIG;
 164 #else
 165         disasm_info.endian = BFD_ENDIAN_LITTLE;
 166 #endif
 167 #if defined(TARGET_I386)
 168         if (!flags)
 169             disasm_info.mach = bfd_mach_i386_i386;
 170         else
 171             disasm_info.mach = bfd_mach_i386_i8086;
 172         print_insn = print_insn_i386;
 173 #elif defined(TARGET_ARM)
 174         print_insn = print_insn_arm;
 175 #elif defined(TARGET_SPARC)
 176         print_insn = print_insn_sparc;
 177 #elif defined(TARGET_PPC)
 178         print_insn = print_insn_ppc;
 179 #else
 180         fprintf(out, "Asm output not supported on this arch\n");
 181         return;
 182 #endif
 183     }
 184
 185     for (pc = code; pc < (uint8_t *)code + size; pc += count) {
 186         fprintf(out, "0x%08lx:  ", (long)pc);
 187 #ifdef __arm__
 188         /* since data are included in the code, it is better to
 189            display code data too */
 190         if (is_host) {
 191             fprintf(out, "%08x  ", (int)bfd_getl32((const bfd_byte *)pc));
 192         }
 193 #endif
 194         count = print_insn((unsigned long)pc, &disasm_info);
 195         fprintf(out, "\n");
 196         if (count < 0)
 197             break;
 198     }
 199 }
 200
 201 /* Look up symbol for debugging purpose.  Returns "" if unknown. */
 202 const char *lookup_symbol(void *orig_addr)
 203 {
 204     unsigned int i;
 205     /* Hack, because we know this is x86. */
 206     Elf32_Sym *sym = disas_symtab;
 207
 208     for (i = 0; i < disas_num_syms; i++) {
 209         if (sym[i].st_shndx == SHN_UNDEF
 210             || sym[i].st_shndx >= SHN_LORESERVE)
 211             continue;
 212
 213         if (ELF_ST_TYPE(sym[i].st_info) != STT_FUNC)
 214             continue;
 215
 216         if ((long)orig_addr >= sym[i].st_value
 217             && (long)orig_addr < sym[i].st_value + sym[i].st_size)
 218             return disas_strtab + sym[i].st_name;
 219     }
 220     return "";
 221 }
 222
 223 #if !defined(CONFIG_USER_ONLY)
 224
 225 static int monitor_disas_is_physical;
 226
 227 static int
 228 monitor_read_memory (memaddr, myaddr, length, info)
 229      bfd_vma memaddr;
 230      bfd_byte *myaddr;
 231      int length;
 232      struct disassemble_info *info;
 233 {
 234     if (monitor_disas_is_physical) {
 235         cpu_physical_memory_rw(memaddr, myaddr, length, 0);
 236     } else {
 237         cpu_memory_rw_debug(cpu_single_env, memaddr,myaddr, length, 0);
 238     }
 239     return 0;
 240 }
 241
 242 void monitor_disas(target_ulong pc, int nb_insn, int is_physical, int flags)
 243 {
 244     FILE *out;
 245     int count, i;
 246     struct disassemble_info disasm_info;
 247     int (*print_insn)(bfd_vma pc, disassemble_info *info);
 248
 249     out = stdout;
 250
 251     INIT_DISASSEMBLE_INFO(disasm_info, out, fprintf);
 252
 253     monitor_disas_is_physical = is_physical;
 254     disasm_info.read_memory_func = monitor_read_memory;
 255
 256     disasm_info.buffer_vma = pc;
 257
 258 #ifdef TARGET_WORDS_BIGENDIAN
 259     disasm_info.endian = BFD_ENDIAN_BIG;
 260 #else
 261     disasm_info.endian = BFD_ENDIAN_LITTLE;
 262 #endif
 263 #if defined(TARGET_I386)
 264     if (!flags)
 265         disasm_info.mach = bfd_mach_i386_i386;
 266     else
 267         disasm_info.mach = bfd_mach_i386_i8086;
 268     print_insn = print_insn_i386;
 269 #elif defined(TARGET_ARM)
 270     print_insn = print_insn_arm;
 271 #elif defined(TARGET_SPARC)
 272     print_insn = print_insn_sparc;
 273 #elif defined(TARGET_PPC)
 274     print_insn = print_insn_ppc;
 275 #else
 276     fprintf(out, "Asm output not supported on this arch\n");
 277     return;
 278 #endif
 279
 280     for(i = 0; i < nb_insn; i++) {
 281         fprintf(out, "0x%08lx:  ", (unsigned long)pc);
 282         count = print_insn(pc, &disasm_info);
 283         fprintf(out, "\n");
 284         if (count < 0)
 285             break;
 286         pc += count;
 287     }
 288 }
 289 #endif