gdb/gdbarch.c

   1 /* Semi-dynamic architecture support for GDB, the GNU debugger.
   2    Copyright 1998, Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "defs.h"
  21
  22 /* Just include everything in sight so that the every old definition
  23    of macro is visible. */
  24 #include "gdb_string.h"
  25 #include <ctype.h>
  26 #include "symtab.h"
  27 #include "frame.h"
  28 #include "inferior.h"
  29 #include "breakpoint.h"
  30 #include "wait.h"
  31 #include "gdbcore.h"
  32 #include "gdbcmd.h"
  33 #include "target.h"
  34 #include "gdbthread.h"
  35 #include "annotate.h"
  36 #include "symfile.h"            /* for overlay functions */
  37 #include "symcat.h"
  38
  39
  40 /* Non-zero if we want to trace architecture code.  */
  41
  42 #ifndef GDBARCH_DEBUG
  43 #define GDBARCH_DEBUG 0
  44 #endif
  45 int gdbarch_debug = GDBARCH_DEBUG;
  46
  47
  48 /* Functions to manipulate the endianness of the target.  */
  49
  50 #ifdef TARGET_BYTE_ORDER_SELECTABLE
  51 /* compat - Catch old targets that expect a selectable byte-order to
  52    default to BIG_ENDIAN */
  53 #ifndef TARGET_BYTE_ORDER_DEFAULT
  54 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
  55 #endif
  56 #endif
  57 #if !TARGET_BYTE_ORDER_SELECTABLE_P
  58 #ifndef TARGET_BYTE_ORDER_DEFAULT
  59 /* compat - Catch old non byte-order selectable targets that do not
  60    define TARGET_BYTE_ORDER_DEFAULT and instead expect
  61    TARGET_BYTE_ORDER to be used as the default.  For targets that
  62    defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
  63    below will get a strange compiler warning. */
  64 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
  65 #endif
  66 #endif
  67 #ifndef TARGET_BYTE_ORDER_DEFAULT
  68 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
  69 #endif
  70 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
  71 int target_byte_order_auto = 1;
  72
  73 /* Chain containing the \"set endian\" commands.  */
  74 static struct cmd_list_element *endianlist = NULL;
  75
  76 /* Called by ``show endian''.  */
  77 static void show_endian PARAMS ((char *, int));
  78 static void
  79 show_endian (args, from_tty)
  80      char *args;
  81      int from_tty;
  82 {
  83   char *msg =
  84     (TARGET_BYTE_ORDER_AUTO
  85      ? "The target endianness is set automatically (currently %s endian)\n"
  86      : "The target is assumed to be %s endian\n");
  87   printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
  88 }
  89
  90 /* Called if the user enters ``set endian'' without an argument.  */
  91 static void set_endian PARAMS ((char *, int));
  92 static void
  93 set_endian (args, from_tty)
  94      char *args;
  95      int from_tty;
  96 {
  97   printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
  98   show_endian (args, from_tty);
  99 }
 100
 101 /* Called by ``set endian big''.  */
 102 static void set_endian_big PARAMS ((char *, int));
 103 static void
 104 set_endian_big (args, from_tty)
 105      char *args;
 106      int from_tty;
 107 {
 108   if (TARGET_BYTE_ORDER_SELECTABLE_P)
 109     {
 110       target_byte_order = BIG_ENDIAN;
 111       target_byte_order_auto = 0;
 112     }
 113   else
 114     {
 115       printf_unfiltered ("Byte order is not selectable.");
 116       show_endian (args, from_tty);
 117     }
 118 }
 119
 120 /* Called by ``set endian little''.  */
 121 static void set_endian_little PARAMS ((char *, int));
 122 static void
 123 set_endian_little (args, from_tty)
 124      char *args;
 125      int from_tty;
 126 {
 127   if (TARGET_BYTE_ORDER_SELECTABLE_P)
 128     {
 129       target_byte_order = LITTLE_ENDIAN;
 130       target_byte_order_auto = 0;
 131     }
 132   else
 133     {
 134       printf_unfiltered ("Byte order is not selectable.");
 135       show_endian (args, from_tty);
 136     }
 137 }
 138
 139 /* Called by ``set endian auto''.  */
 140 static void set_endian_auto PARAMS ((char *, int));
 141 static void
 142 set_endian_auto (args, from_tty)
 143      char *args;
 144      int from_tty;
 145 {
 146   if (TARGET_BYTE_ORDER_SELECTABLE_P)
 147     {
 148       target_byte_order_auto = 1;
 149     }
 150   else
 151     {
 152       printf_unfiltered ("Byte order is not selectable.");
 153       show_endian (args, from_tty);
 154     }
 155 }
 156
 157 /* Set the endianness from a BFD.  */
 158 static void set_endian_from_file PARAMS ((bfd *));
 159 static void
 160 set_endian_from_file (abfd)
 161      bfd *abfd;
 162 {
 163   if (TARGET_BYTE_ORDER_SELECTABLE_P)
 164     {
 165       int want;
 166
 167       if (bfd_big_endian (abfd))
 168         want = BIG_ENDIAN;
 169       else
 170         want = LITTLE_ENDIAN;
 171       if (TARGET_BYTE_ORDER_AUTO)
 172         target_byte_order = want;
 173       else if (TARGET_BYTE_ORDER != want)
 174         warning ("%s endian file does not match %s endian target.",
 175                  want == BIG_ENDIAN ? "big" : "little",
 176                  TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
 177     }
 178   else
 179     {
 180       if (bfd_big_endian (abfd)
 181           ? TARGET_BYTE_ORDER != BIG_ENDIAN
 182           : TARGET_BYTE_ORDER == BIG_ENDIAN)
 183         warning ("%s endian file does not match %s endian target.",
 184                  bfd_big_endian (abfd) ? "big" : "little",
 185                  TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
 186     }
 187 }
 188
 189
 190
 191 /* Functions to manipulate the architecture of the target */
 192
 193 int target_architecture_auto = 1;
 194 extern const struct bfd_arch_info bfd_default_arch_struct;
 195 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
 196 int (*target_architecture_hook) PARAMS ((const struct bfd_arch_info *ap));
 197
 198 /* Do the real work of changing the current architecture */
 199 enum set_arch { set_arch_auto, set_arch_manual };
 200 static void
 201 set_arch (arch, type)
 202      const struct bfd_arch_info *arch;
 203      enum set_arch type;
 204 {
 205   /* FIXME: Should be performing the more basic check that the binary
 206      is compatible with GDB. */
 207   /* Check with the target that the architecture is valid. */
 208   int arch_valid = (target_architecture_hook != NULL
 209                     && !target_architecture_hook (arch));
 210   switch (type)
 211     {
 212     case set_arch_auto:
 213       if (!arch_valid)
 214         warning ("Target may not support %s architecture",
 215                  arch->printable_name);
 216       target_architecture = arch;
 217       break;
 218     case set_arch_manual:
 219       if (!arch_valid)
 220         {
 221           printf_unfiltered ("Target does not support `%s' architecture.\n",
 222                              arch->printable_name);
 223         }
 224       else
 225         {
 226           target_architecture_auto = 0;
 227           target_architecture = arch;
 228         }
 229       break;
 230     }
 231 }
 232
 233 /* Called if the user enters ``show architecture'' without an argument. */
 234 static void show_architecture PARAMS ((char *, int));
 235 static void
 236 show_architecture (args, from_tty)
 237      char *args;
 238      int from_tty;
 239 {
 240   const char *arch;
 241   arch = TARGET_ARCHITECTURE->printable_name;
 242   if (target_architecture_auto)
 243     printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
 244   else
 245     printf_filtered ("The target architecture is assumed to be %s\n", arch);
 246 }
 247
 248 /* Called if the user enters ``set architecture'' with or without an
 249    argument. */
 250 static void set_architecture PARAMS ((char *, int));
 251 static void
 252 set_architecture (args, from_tty)
 253      char *args;
 254      int from_tty;
 255 {
 256   if (args == NULL)
 257     {
 258       printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
 259     }
 260   else if (strcmp (args, "auto") == 0)
 261     {
 262       target_architecture_auto = 1;
 263     }
 264   else
 265     {
 266       const struct bfd_arch_info *arch = bfd_scan_arch (args);
 267       if (arch != NULL)
 268         set_arch (arch, set_arch_manual);
 269       else
 270         printf_unfiltered ("Architecture `%s' not reconized.\n", args);
 271     }
 272 }
 273
 274 /* Called if the user enters ``info architecture'' without an argument. */
 275 static void info_architecture PARAMS ((char *, int));
 276 static void
 277 info_architecture (args, from_tty)
 278      char *args;
 279      int from_tty;
 280 {
 281   enum bfd_architecture a;
 282   printf_filtered ("Available architectures are:\n");
 283   for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
 284     {
 285       const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
 286       if (ap != NULL)
 287         {
 288           do
 289             {
 290               printf_filtered (" %s", ap->printable_name);
 291               ap = ap->next;
 292             }
 293           while (ap != NULL);
 294           printf_filtered ("\n");
 295         }
 296     }
 297 }
 298
 299 /* Set the architecture from arch/machine */
 300 void
 301 set_architecture_from_arch_mach (arch, mach)
 302      enum bfd_architecture arch;
 303      unsigned long mach;
 304 {
 305   const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
 306   if (wanted != NULL)
 307     set_arch (wanted, set_arch_manual);
 308   else
 309     fatal ("hardwired architecture/machine not reconized");
 310 }
 311
 312 /* Set the architecture from a BFD */
 313 static void set_architecture_from_file PARAMS ((bfd *));
 314 static void
 315 set_architecture_from_file (abfd)
 316      bfd *abfd;
 317 {
 318   const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
 319   if (target_architecture_auto)
 320     {
 321       set_arch (wanted, set_arch_auto);
 322     }
 323   else if (wanted != target_architecture)
 324     {
 325       warning ("%s architecture file may be incompatible with %s target.",
 326                wanted->printable_name,
 327                target_architecture->printable_name);
 328     }
 329 }
 330
 331
 332
 333 /* Disassembler */
 334
 335 /* Pointer to the target-dependent disassembly function.  */
 336 int (*tm_print_insn) PARAMS ((bfd_vma, disassemble_info *));
 337 disassemble_info tm_print_insn_info;
 338
 339
 340
 341 /* Set the dynamic target-system-dependant parameters (architecture,
 342    byte-order) using information found in the BFD */
 343
 344 void
 345 set_gdbarch_from_file (abfd)
 346      bfd *abfd;
 347 {
 348   set_architecture_from_file (abfd);
 349   set_endian_from_file (abfd);
 350 }
 351
 352
 353 #if defined (CALL_DUMMY)
 354 /* FIXME - this should go away */
 355 LONGEST call_dummy_words[] = CALL_DUMMY;
 356 int sizeof_call_dummy_words = sizeof (call_dummy_words);
 357 #endif
 358
 359
 360 extern void _initialize_gdbarch PARAMS ((void));
 361 void
 362 _initialize_gdbarch ()
 363 {
 364   add_prefix_cmd ("endian", class_support, set_endian,
 365                   "Set endianness of target.",
 366                   &endianlist, "set endian ", 0, &setlist);
 367   add_cmd ("big", class_support, set_endian_big,
 368            "Set target as being big endian.", &endianlist);
 369   add_cmd ("little", class_support, set_endian_little,
 370            "Set target as being little endian.", &endianlist);
 371   add_cmd ("auto", class_support, set_endian_auto,
 372            "Select target endianness automatically.", &endianlist);
 373   add_cmd ("endian", class_support, show_endian,
 374            "Show endianness of target.", &showlist);
 375
 376   add_cmd ("architecture", class_support, set_architecture,
 377            "Set architecture of target.", &setlist);
 378   add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 379   add_cmd ("architecture", class_support, show_architecture,
 380            "Show architecture of target.", &showlist);
 381   add_cmd ("architecture", class_support, info_architecture,
 382            "List supported target architectures", &infolist);
 383
 384   INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
 385   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
 386   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
 387   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
 388   tm_print_insn_info.print_address_func = dis_asm_print_address;
 389
 390   add_show_from_set (add_set_cmd ("archdebug",
 391                                   class_maintenance,
 392                                   var_zinteger,
 393                                   (char *)&gdbarch_debug,
 394                                   "Set architecture debugging.\n\
 395 When non-zero, architecture debugging is enabled.", &setlist),
 396                      &showlist);
 397 }