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