gdb/arch-utils.c

   1 /* Dynamic architecture support for GDB, the GNU debugger.
   2
   3    Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
   4    Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24
  25 #include "arch-utils.h"
  26 #include "gdbcmd.h"
  27 #include "inferior.h"           /* enum CALL_DUMMY_LOCATION et.al. */
  28 #include "gdb_string.h"
  29 #include "regcache.h"
  30 #include "gdb_assert.h"
  31 #include "sim-regno.h"
  32
  33 #include "version.h"
  34
  35 #include "floatformat.h"
  36
  37 /* Implementation of extract return value that grubs around in the
  38    register cache.  */
  39 void
  40 legacy_extract_return_value (struct type *type, struct regcache *regcache,
  41                              void *valbuf)
  42 {
  43   char *registers = deprecated_grub_regcache_for_registers (regcache);
  44   bfd_byte *buf = valbuf;
  45   DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */
  46 }
  47
  48 /* Implementation of store return value that grubs the register cache.
  49    Takes a local copy of the buffer to avoid const problems.  */
  50 void
  51 legacy_store_return_value (struct type *type, struct regcache *regcache,
  52                            const void *buf)
  53 {
  54   bfd_byte *b = alloca (TYPE_LENGTH (type));
  55   gdb_assert (regcache == current_regcache);
  56   memcpy (b, buf, TYPE_LENGTH (type));
  57   DEPRECATED_STORE_RETURN_VALUE (type, b);
  58 }
  59
  60
  61 int
  62 always_use_struct_convention (int gcc_p, struct type *value_type)
  63 {
  64   return 1;
  65 }
  66
  67
  68 int
  69 legacy_register_sim_regno (int regnum)
  70 {
  71   /* Only makes sense to supply raw registers.  */
  72   gdb_assert (regnum >= 0 && regnum < NUM_REGS);
  73   /* NOTE: cagney/2002-05-13: The old code did it this way and it is
  74      suspected that some GDB/SIM combinations may rely on this
  75      behavour.  The default should be one2one_register_sim_regno
  76      (below).  */
  77   if (REGISTER_NAME (regnum) != NULL
  78       && REGISTER_NAME (regnum)[0] != '\0')
  79     return regnum;
  80   else
  81     return LEGACY_SIM_REGNO_IGNORE;
  82 }
  83
  84 int
  85 generic_frameless_function_invocation_not (struct frame_info *fi)
  86 {
  87   return 0;
  88 }
  89
  90 int
  91 generic_return_value_on_stack_not (struct type *type)
  92 {
  93   return 0;
  94 }
  95
  96 CORE_ADDR
  97 generic_skip_trampoline_code (CORE_ADDR pc)
  98 {
  99   return 0;
 100 }
 101
 102 int
 103 generic_in_solib_call_trampoline (CORE_ADDR pc, char *name)
 104 {
 105   return 0;
 106 }
 107
 108 int
 109 generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
 110 {
 111   return 0;
 112 }
 113
 114 int
 115 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 116 {
 117   return 0;
 118 }
 119
 120 #if defined (CALL_DUMMY)
 121 LONGEST legacy_call_dummy_words[] = CALL_DUMMY;
 122 #else
 123 LONGEST legacy_call_dummy_words[1];
 124 #endif
 125 int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words);
 126
 127 void
 128 generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
 129                                        struct regcache *regcache,
 130                                        CORE_ADDR gdb_addr, int gdb_len,
 131                                        CORE_ADDR * rem_addr, int *rem_len)
 132 {
 133   *rem_addr = gdb_addr;
 134   *rem_len = gdb_len;
 135 }
 136
 137 int
 138 generic_prologue_frameless_p (CORE_ADDR ip)
 139 {
 140   return ip == SKIP_PROLOGUE (ip);
 141 }
 142
 143 /* Helper functions for INNER_THAN */
 144
 145 int
 146 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
 147 {
 148   return (lhs < rhs);
 149 }
 150
 151 int
 152 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
 153 {
 154   return (lhs > rhs);
 155 }
 156
 157
 158 /* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
 159
 160 const struct floatformat *
 161 default_float_format (struct gdbarch *gdbarch)
 162 {
 163   int byte_order = gdbarch_byte_order (gdbarch);
 164   switch (byte_order)
 165     {
 166     case BFD_ENDIAN_BIG:
 167       return &floatformat_ieee_single_big;
 168     case BFD_ENDIAN_LITTLE:
 169       return &floatformat_ieee_single_little;
 170     default:
 171       internal_error (__FILE__, __LINE__,
 172                       "default_float_format: bad byte order");
 173     }
 174 }
 175
 176
 177 const struct floatformat *
 178 default_double_format (struct gdbarch *gdbarch)
 179 {
 180   int byte_order = gdbarch_byte_order (gdbarch);
 181   switch (byte_order)
 182     {
 183     case BFD_ENDIAN_BIG:
 184       return &floatformat_ieee_double_big;
 185     case BFD_ENDIAN_LITTLE:
 186       return &floatformat_ieee_double_little;
 187     default:
 188       internal_error (__FILE__, __LINE__,
 189                       "default_double_format: bad byte order");
 190     }
 191 }
 192
 193 /* Misc helper functions for targets. */
 194
 195 int
 196 deprecated_register_convertible_not (int num)
 197 {
 198   return 0;
 199 }
 200
 201
 202 /* Under some ABI's that specify the `struct convention' for returning
 203    structures by value, by the time we've returned from the function,
 204    the return value is sitting there in the caller's buffer, but GDB
 205    has no way to find the address of that buffer.
 206
 207    On such architectures, use this function as your
 208    extract_struct_value_address method.  When asked to a struct
 209    returned by value in this fashion, GDB will print a nice error
 210    message, instead of garbage.  */
 211 CORE_ADDR
 212 generic_cannot_extract_struct_value_address (char *dummy)
 213 {
 214   return 0;
 215 }
 216
 217 CORE_ADDR
 218 core_addr_identity (CORE_ADDR addr)
 219 {
 220   return addr;
 221 }
 222
 223 int
 224 no_op_reg_to_regnum (int reg)
 225 {
 226   return reg;
 227 }
 228
 229 CORE_ADDR
 230 init_frame_pc_noop (int fromleaf, struct frame_info *prev)
 231 {
 232   /* Do nothing, implies return the same PC value.  */
 233   return get_frame_pc (prev);
 234 }
 235
 236 CORE_ADDR
 237 init_frame_pc_default (int fromleaf, struct frame_info *prev)
 238 {
 239   if (fromleaf && DEPRECATED_SAVED_PC_AFTER_CALL_P ())
 240     return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev));
 241   else if (get_next_frame (prev) != NULL)
 242     return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev));
 243   else
 244     return read_pc ();
 245 }
 246
 247 void
 248 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 249 {
 250   return;
 251 }
 252
 253 void
 254 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
 255 {
 256   return;
 257 }
 258
 259 int
 260 cannot_register_not (int regnum)
 261 {
 262   return 0;
 263 }
 264
 265 /* Legacy version of target_virtual_frame_pointer().  Assumes that
 266    there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
 267    raw.  */
 268
 269 void
 270 legacy_virtual_frame_pointer (CORE_ADDR pc,
 271                               int *frame_regnum,
 272                               LONGEST *frame_offset)
 273 {
 274   /* FIXME: cagney/2002-09-13: This code is used when identifying the
 275      frame pointer of the current PC.  It is assuming that a single
 276      register and an offset can determine this.  I think it should
 277      instead generate a byte code expression as that would work better
 278      with things like Dwarf2's CFI.  */
 279   if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
 280     *frame_regnum = DEPRECATED_FP_REGNUM;
 281   else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
 282     *frame_regnum = SP_REGNUM;
 283   else
 284     /* Should this be an internal error?  I guess so, it is reflecting
 285        an architectural limitation in the current design.  */
 286     internal_error (__FILE__, __LINE__, "No virtual frame pointer available");
 287   *frame_offset = 0;
 288 }
 289
 290 /* Assume the world is sane, every register's virtual and real size
 291    is identical.  */
 292
 293 int
 294 generic_register_size (int regnum)
 295 {
 296   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 297   if (gdbarch_register_type_p (current_gdbarch))
 298     return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum));
 299   else
 300     /* FIXME: cagney/2003-03-01: Once all architectures implement
 301        gdbarch_register_type(), this entire function can go away.  It
 302        is made obsolete by register_size().  */
 303     return TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum)); /* OK */
 304 }
 305
 306 /* Assume all registers are adjacent.  */
 307
 308 int
 309 generic_register_byte (int regnum)
 310 {
 311   int byte;
 312   int i;
 313   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 314   byte = 0;
 315   for (i = 0; i < regnum; i++)
 316     {
 317       byte += generic_register_size (i);
 318     }
 319   return byte;
 320 }
 321
 322 \f
 323 int
 324 legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
 325 {
 326 #if !defined (IN_SIGTRAMP)
 327   if (SIGTRAMP_START_P ())
 328     return (pc) >= SIGTRAMP_START (pc) && (pc) < SIGTRAMP_END (pc);
 329   else
 330     return name && strcmp ("_sigtramp", name) == 0;
 331 #else
 332   return IN_SIGTRAMP (pc, name);
 333 #endif
 334 }
 335
 336 int
 337 legacy_convert_register_p (int regnum, struct type *type)
 338 {
 339   return DEPRECATED_REGISTER_CONVERTIBLE (regnum);
 340 }
 341
 342 void
 343 legacy_register_to_value (struct frame_info *frame, int regnum,
 344                           struct type *type, void *to)
 345 {
 346   char from[MAX_REGISTER_SIZE];
 347   frame_read_register (frame, regnum, from);
 348   DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to);
 349 }
 350
 351 void
 352 legacy_value_to_register (struct frame_info *frame, int regnum,
 353                           struct type *type, const void *tmp)
 354 {
 355   char to[MAX_REGISTER_SIZE];
 356   char *from = alloca (TYPE_LENGTH (type));
 357   memcpy (from, from, TYPE_LENGTH (type));
 358   DEPRECATED_REGISTER_CONVERT_TO_RAW (type, regnum, from, to);
 359   put_frame_register (frame, regnum, to);
 360 }
 361
 362 \f
 363 /* Functions to manipulate the endianness of the target.  */
 364
 365 /* ``target_byte_order'' is only used when non- multi-arch.
 366    Multi-arch targets obtain the current byte order using the
 367    TARGET_BYTE_ORDER gdbarch method.
 368
 369    The choice of initial value is entirely arbitrary.  During startup,
 370    the function initialize_current_architecture() updates this value
 371    based on default byte-order information extracted from BFD.  */
 372 int target_byte_order = BFD_ENDIAN_BIG;
 373 int target_byte_order_auto = 1;
 374
 375 static const char endian_big[] = "big";
 376 static const char endian_little[] = "little";
 377 static const char endian_auto[] = "auto";
 378 static const char *endian_enum[] =
 379 {
 380   endian_big,
 381   endian_little,
 382   endian_auto,
 383   NULL,
 384 };
 385 static const char *set_endian_string;
 386
 387 /* Called by ``show endian''.  */
 388
 389 static void
 390 show_endian (char *args, int from_tty)
 391 {
 392   if (TARGET_BYTE_ORDER_AUTO)
 393     printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
 394                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 395   else
 396     printf_unfiltered ("The target is assumed to be %s endian\n",
 397                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 398 }
 399
 400 static void
 401 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
 402 {
 403   if (set_endian_string == endian_auto)
 404     {
 405       target_byte_order_auto = 1;
 406     }
 407   else if (set_endian_string == endian_little)
 408     {
 409       struct gdbarch_info info;
 410       target_byte_order_auto = 0;
 411       gdbarch_info_init (&info);
 412       info.byte_order = BFD_ENDIAN_LITTLE;
 413       if (! gdbarch_update_p (info))
 414         printf_unfiltered ("Little endian target not supported by GDB\n");
 415     }
 416   else if (set_endian_string == endian_big)
 417     {
 418       struct gdbarch_info info;
 419       target_byte_order_auto = 0;
 420       gdbarch_info_init (&info);
 421       info.byte_order = BFD_ENDIAN_BIG;
 422       if (! gdbarch_update_p (info))
 423         printf_unfiltered ("Big endian target not supported by GDB\n");
 424     }
 425   else
 426     internal_error (__FILE__, __LINE__,
 427                     "set_endian: bad value");
 428   show_endian (NULL, from_tty);
 429 }
 430
 431 /* Functions to manipulate the architecture of the target */
 432
 433 enum set_arch { set_arch_auto, set_arch_manual };
 434
 435 int target_architecture_auto = 1;
 436
 437 const char *set_architecture_string;
 438
 439 /* Called if the user enters ``show architecture'' without an
 440    argument. */
 441
 442 static void
 443 show_architecture (char *args, int from_tty)
 444 {
 445   const char *arch;
 446   arch = TARGET_ARCHITECTURE->printable_name;
 447   if (target_architecture_auto)
 448     printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
 449   else
 450     printf_filtered ("The target architecture is assumed to be %s\n", arch);
 451 }
 452
 453
 454 /* Called if the user enters ``set architecture'' with or without an
 455    argument. */
 456
 457 static void
 458 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
 459 {
 460   if (strcmp (set_architecture_string, "auto") == 0)
 461     {
 462       target_architecture_auto = 1;
 463     }
 464   else
 465     {
 466       struct gdbarch_info info;
 467       gdbarch_info_init (&info);
 468       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 469       if (info.bfd_arch_info == NULL)
 470         internal_error (__FILE__, __LINE__,
 471                         "set_architecture: bfd_scan_arch failed");
 472       if (gdbarch_update_p (info))
 473         target_architecture_auto = 0;
 474       else
 475         printf_unfiltered ("Architecture `%s' not recognized.\n",
 476                            set_architecture_string);
 477     }
 478   show_architecture (NULL, from_tty);
 479 }
 480
 481 /* Set the dynamic target-system-dependent parameters (architecture,
 482    byte-order) using information found in the BFD */
 483
 484 void
 485 set_gdbarch_from_file (bfd *abfd)
 486 {
 487   struct gdbarch_info info;
 488   gdbarch_info_init (&info);
 489   info.abfd = abfd;
 490   if (! gdbarch_update_p (info))
 491     error ("Architecture of file not recognized.\n");
 492 }
 493
 494 /* Initialize the current architecture.  Update the ``set
 495    architecture'' command so that it specifies a list of valid
 496    architectures.  */
 497
 498 #ifdef DEFAULT_BFD_ARCH
 499 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 500 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 501 #else
 502 static const bfd_arch_info_type *default_bfd_arch;
 503 #endif
 504
 505 #ifdef DEFAULT_BFD_VEC
 506 extern const bfd_target DEFAULT_BFD_VEC;
 507 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 508 #else
 509 static const bfd_target *default_bfd_vec;
 510 #endif
 511
 512 void
 513 initialize_current_architecture (void)
 514 {
 515   const char **arches = gdbarch_printable_names ();
 516
 517   /* determine a default architecture and byte order. */
 518   struct gdbarch_info info;
 519   gdbarch_info_init (&info);
 520
 521   /* Find a default architecture. */
 522   if (info.bfd_arch_info == NULL
 523       && default_bfd_arch != NULL)
 524     info.bfd_arch_info = default_bfd_arch;
 525   if (info.bfd_arch_info == NULL)
 526     {
 527       /* Choose the architecture by taking the first one
 528          alphabetically. */
 529       const char *chosen = arches[0];
 530       const char **arch;
 531       for (arch = arches; *arch != NULL; arch++)
 532         {
 533           if (strcmp (*arch, chosen) < 0)
 534             chosen = *arch;
 535         }
 536       if (chosen == NULL)
 537         internal_error (__FILE__, __LINE__,
 538                         "initialize_current_architecture: No arch");
 539       info.bfd_arch_info = bfd_scan_arch (chosen);
 540       if (info.bfd_arch_info == NULL)
 541         internal_error (__FILE__, __LINE__,
 542                         "initialize_current_architecture: Arch not found");
 543     }
 544
 545   /* Take several guesses at a byte order.  */
 546   if (info.byte_order == BFD_ENDIAN_UNKNOWN
 547       && default_bfd_vec != NULL)
 548     {
 549       /* Extract BFD's default vector's byte order. */
 550       switch (default_bfd_vec->byteorder)
 551         {
 552         case BFD_ENDIAN_BIG:
 553           info.byte_order = BFD_ENDIAN_BIG;
 554           break;
 555         case BFD_ENDIAN_LITTLE:
 556           info.byte_order = BFD_ENDIAN_LITTLE;
 557           break;
 558         default:
 559           break;
 560         }
 561     }
 562   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 563     {
 564       /* look for ``*el-*'' in the target name. */
 565       const char *chp;
 566       chp = strchr (target_name, '-');
 567       if (chp != NULL
 568           && chp - 2 >= target_name
 569           && strncmp (chp - 2, "el", 2) == 0)
 570         info.byte_order = BFD_ENDIAN_LITTLE;
 571     }
 572   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 573     {
 574       /* Wire it to big-endian!!! */
 575       info.byte_order = BFD_ENDIAN_BIG;
 576     }
 577
 578   if (! gdbarch_update_p (info))
 579     internal_error (__FILE__, __LINE__,
 580                     "initialize_current_architecture: Selection of initial architecture failed");
 581
 582   /* Create the ``set architecture'' command appending ``auto'' to the
 583      list of architectures. */
 584   {
 585     struct cmd_list_element *c;
 586     /* Append ``auto''. */
 587     int nr;
 588     for (nr = 0; arches[nr] != NULL; nr++);
 589     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 590     arches[nr + 0] = "auto";
 591     arches[nr + 1] = NULL;
 592     /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
 593        of ``const char *''.  We just happen to know that the casts are
 594        safe. */
 595     c = add_set_enum_cmd ("architecture", class_support,
 596                           arches, &set_architecture_string,
 597                           "Set architecture of target.",
 598                           &setlist);
 599     set_cmd_sfunc (c, set_architecture);
 600     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 601     /* Don't use set_from_show - need to print both auto/manual and
 602        current setting. */
 603     add_cmd ("architecture", class_support, show_architecture,
 604              "Show the current target architecture", &showlist);
 605   }
 606 }
 607
 608
 609 /* Initialize a gdbarch info to values that will be automatically
 610    overridden.  Note: Originally, this ``struct info'' was initialized
 611    using memset(0).  Unfortunatly, that ran into problems, namely
 612    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 613    can explicitly set each field to a well defined value is used.  */
 614
 615 void
 616 gdbarch_info_init (struct gdbarch_info *info)
 617 {
 618   memset (info, 0, sizeof (struct gdbarch_info));
 619   info->byte_order = BFD_ENDIAN_UNKNOWN;
 620   info->osabi = GDB_OSABI_UNINITIALIZED;
 621 }
 622
 623 /* */
 624
 625 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
 626
 627 void
 628 _initialize_gdbarch_utils (void)
 629 {
 630   struct cmd_list_element *c;
 631   c = add_set_enum_cmd ("endian", class_support,
 632                         endian_enum, &set_endian_string,
 633                         "Set endianness of target.",
 634                         &setlist);
 635   set_cmd_sfunc (c, set_endian);
 636   /* Don't use set_from_show - need to print both auto/manual and
 637      current setting. */
 638   add_cmd ("endian", class_support, show_endian,
 639            "Show the current byte-order", &showlist);
 640 }