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 int
 225 no_op_reg_to_regnum (int reg)
 226 {
 227   return reg;
 228 }
 229
 230 CORE_ADDR
 231 init_frame_pc_default (int fromleaf, struct frame_info *prev)
 232 {
 233   if (fromleaf && DEPRECATED_SAVED_PC_AFTER_CALL_P ())
 234     return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev));
 235   else if (get_next_frame (prev) != NULL)
 236     return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev));
 237   else
 238     return read_pc ();
 239 }
 240
 241 void
 242 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 243 {
 244   return;
 245 }
 246
 247 void
 248 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
 249 {
 250   return;
 251 }
 252
 253 int
 254 cannot_register_not (int regnum)
 255 {
 256   return 0;
 257 }
 258
 259 /* Legacy version of target_virtual_frame_pointer().  Assumes that
 260    there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
 261    raw.  */
 262
 263 void
 264 legacy_virtual_frame_pointer (CORE_ADDR pc,
 265                               int *frame_regnum,
 266                               LONGEST *frame_offset)
 267 {
 268   /* FIXME: cagney/2002-09-13: This code is used when identifying the
 269      frame pointer of the current PC.  It is assuming that a single
 270      register and an offset can determine this.  I think it should
 271      instead generate a byte code expression as that would work better
 272      with things like Dwarf2's CFI.  */
 273   if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
 274     *frame_regnum = DEPRECATED_FP_REGNUM;
 275   else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
 276     *frame_regnum = SP_REGNUM;
 277   else
 278     /* Should this be an internal error?  I guess so, it is reflecting
 279        an architectural limitation in the current design.  */
 280     internal_error (__FILE__, __LINE__, "No virtual frame pointer available");
 281   *frame_offset = 0;
 282 }
 283
 284 /* Assume the world is sane, every register's virtual and real size
 285    is identical.  */
 286
 287 int
 288 generic_register_size (int regnum)
 289 {
 290   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 291   if (gdbarch_register_type_p (current_gdbarch))
 292     return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum));
 293   else
 294     /* FIXME: cagney/2003-03-01: Once all architectures implement
 295        gdbarch_register_type(), this entire function can go away.  It
 296        is made obsolete by register_size().  */
 297     return TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum)); /* OK */
 298 }
 299
 300 /* Assume all registers are adjacent.  */
 301
 302 int
 303 generic_register_byte (int regnum)
 304 {
 305   int byte;
 306   int i;
 307   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 308   byte = 0;
 309   for (i = 0; i < regnum; i++)
 310     {
 311       byte += generic_register_size (i);
 312     }
 313   return byte;
 314 }
 315
 316 \f
 317 int
 318 legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
 319 {
 320 #if !defined (IN_SIGTRAMP)
 321   if (SIGTRAMP_START_P ())
 322     return (pc) >= SIGTRAMP_START (pc) && (pc) < SIGTRAMP_END (pc);
 323   else
 324     return name && strcmp ("_sigtramp", name) == 0;
 325 #else
 326   return IN_SIGTRAMP (pc, name);
 327 #endif
 328 }
 329
 330 int
 331 legacy_convert_register_p (int regnum, struct type *type)
 332 {
 333   return DEPRECATED_REGISTER_CONVERTIBLE (regnum);
 334 }
 335
 336 void
 337 legacy_register_to_value (struct frame_info *frame, int regnum,
 338                           struct type *type, void *to)
 339 {
 340   char from[MAX_REGISTER_SIZE];
 341   frame_read_register (frame, regnum, from);
 342   DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to);
 343 }
 344
 345 void
 346 legacy_value_to_register (struct frame_info *frame, int regnum,
 347                           struct type *type, const void *tmp)
 348 {
 349   char to[MAX_REGISTER_SIZE];
 350   char *from = alloca (TYPE_LENGTH (type));
 351   memcpy (from, from, TYPE_LENGTH (type));
 352   DEPRECATED_REGISTER_CONVERT_TO_RAW (type, regnum, from, to);
 353   put_frame_register (frame, regnum, to);
 354 }
 355
 356 int
 357 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
 358 {
 359   if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()
 360       && DEPRECATED_REG_STRUCT_HAS_ADDR (processing_gcc_compilation, type))
 361     {
 362       CHECK_TYPEDEF (type);
 363
 364       return (TYPE_CODE (type) == TYPE_CODE_STRUCT
 365               || TYPE_CODE (type) == TYPE_CODE_UNION
 366               || TYPE_CODE (type) == TYPE_CODE_SET
 367               || TYPE_CODE (type) == TYPE_CODE_BITSTRING);
 368     }
 369
 370   return 0;
 371 }
 372
 373 \f
 374 /* Functions to manipulate the endianness of the target.  */
 375
 376 /* ``target_byte_order'' is only used when non- multi-arch.
 377    Multi-arch targets obtain the current byte order using the
 378    TARGET_BYTE_ORDER gdbarch method.
 379
 380    The choice of initial value is entirely arbitrary.  During startup,
 381    the function initialize_current_architecture() updates this value
 382    based on default byte-order information extracted from BFD.  */
 383 int target_byte_order = BFD_ENDIAN_BIG;
 384 int target_byte_order_auto = 1;
 385
 386 static const char endian_big[] = "big";
 387 static const char endian_little[] = "little";
 388 static const char endian_auto[] = "auto";
 389 static const char *endian_enum[] =
 390 {
 391   endian_big,
 392   endian_little,
 393   endian_auto,
 394   NULL,
 395 };
 396 static const char *set_endian_string;
 397
 398 /* Called by ``show endian''.  */
 399
 400 static void
 401 show_endian (char *args, int from_tty)
 402 {
 403   if (TARGET_BYTE_ORDER_AUTO)
 404     printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
 405                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 406   else
 407     printf_unfiltered ("The target is assumed to be %s endian\n",
 408                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 409 }
 410
 411 static void
 412 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
 413 {
 414   if (set_endian_string == endian_auto)
 415     {
 416       target_byte_order_auto = 1;
 417     }
 418   else if (set_endian_string == endian_little)
 419     {
 420       struct gdbarch_info info;
 421       target_byte_order_auto = 0;
 422       gdbarch_info_init (&info);
 423       info.byte_order = BFD_ENDIAN_LITTLE;
 424       if (! gdbarch_update_p (info))
 425         printf_unfiltered ("Little endian target not supported by GDB\n");
 426     }
 427   else if (set_endian_string == endian_big)
 428     {
 429       struct gdbarch_info info;
 430       target_byte_order_auto = 0;
 431       gdbarch_info_init (&info);
 432       info.byte_order = BFD_ENDIAN_BIG;
 433       if (! gdbarch_update_p (info))
 434         printf_unfiltered ("Big endian target not supported by GDB\n");
 435     }
 436   else
 437     internal_error (__FILE__, __LINE__,
 438                     "set_endian: bad value");
 439   show_endian (NULL, from_tty);
 440 }
 441
 442 /* Functions to manipulate the architecture of the target */
 443
 444 enum set_arch { set_arch_auto, set_arch_manual };
 445
 446 int target_architecture_auto = 1;
 447
 448 const char *set_architecture_string;
 449
 450 /* Called if the user enters ``show architecture'' without an
 451    argument. */
 452
 453 static void
 454 show_architecture (char *args, int from_tty)
 455 {
 456   const char *arch;
 457   arch = TARGET_ARCHITECTURE->printable_name;
 458   if (target_architecture_auto)
 459     printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
 460   else
 461     printf_filtered ("The target architecture is assumed to be %s\n", arch);
 462 }
 463
 464
 465 /* Called if the user enters ``set architecture'' with or without an
 466    argument. */
 467
 468 static void
 469 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
 470 {
 471   if (strcmp (set_architecture_string, "auto") == 0)
 472     {
 473       target_architecture_auto = 1;
 474     }
 475   else
 476     {
 477       struct gdbarch_info info;
 478       gdbarch_info_init (&info);
 479       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 480       if (info.bfd_arch_info == NULL)
 481         internal_error (__FILE__, __LINE__,
 482                         "set_architecture: bfd_scan_arch failed");
 483       if (gdbarch_update_p (info))
 484         target_architecture_auto = 0;
 485       else
 486         printf_unfiltered ("Architecture `%s' not recognized.\n",
 487                            set_architecture_string);
 488     }
 489   show_architecture (NULL, from_tty);
 490 }
 491
 492 /* Set the dynamic target-system-dependent parameters (architecture,
 493    byte-order) using information found in the BFD */
 494
 495 void
 496 set_gdbarch_from_file (bfd *abfd)
 497 {
 498   struct gdbarch_info info;
 499   gdbarch_info_init (&info);
 500   info.abfd = abfd;
 501   if (! gdbarch_update_p (info))
 502     error ("Architecture of file not recognized.\n");
 503 }
 504
 505 /* Initialize the current architecture.  Update the ``set
 506    architecture'' command so that it specifies a list of valid
 507    architectures.  */
 508
 509 #ifdef DEFAULT_BFD_ARCH
 510 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 511 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 512 #else
 513 static const bfd_arch_info_type *default_bfd_arch;
 514 #endif
 515
 516 #ifdef DEFAULT_BFD_VEC
 517 extern const bfd_target DEFAULT_BFD_VEC;
 518 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 519 #else
 520 static const bfd_target *default_bfd_vec;
 521 #endif
 522
 523 void
 524 initialize_current_architecture (void)
 525 {
 526   const char **arches = gdbarch_printable_names ();
 527
 528   /* determine a default architecture and byte order. */
 529   struct gdbarch_info info;
 530   gdbarch_info_init (&info);
 531
 532   /* Find a default architecture. */
 533   if (info.bfd_arch_info == NULL
 534       && default_bfd_arch != NULL)
 535     info.bfd_arch_info = default_bfd_arch;
 536   if (info.bfd_arch_info == NULL)
 537     {
 538       /* Choose the architecture by taking the first one
 539          alphabetically. */
 540       const char *chosen = arches[0];
 541       const char **arch;
 542       for (arch = arches; *arch != NULL; arch++)
 543         {
 544           if (strcmp (*arch, chosen) < 0)
 545             chosen = *arch;
 546         }
 547       if (chosen == NULL)
 548         internal_error (__FILE__, __LINE__,
 549                         "initialize_current_architecture: No arch");
 550       info.bfd_arch_info = bfd_scan_arch (chosen);
 551       if (info.bfd_arch_info == NULL)
 552         internal_error (__FILE__, __LINE__,
 553                         "initialize_current_architecture: Arch not found");
 554     }
 555
 556   /* Take several guesses at a byte order.  */
 557   if (info.byte_order == BFD_ENDIAN_UNKNOWN
 558       && default_bfd_vec != NULL)
 559     {
 560       /* Extract BFD's default vector's byte order. */
 561       switch (default_bfd_vec->byteorder)
 562         {
 563         case BFD_ENDIAN_BIG:
 564           info.byte_order = BFD_ENDIAN_BIG;
 565           break;
 566         case BFD_ENDIAN_LITTLE:
 567           info.byte_order = BFD_ENDIAN_LITTLE;
 568           break;
 569         default:
 570           break;
 571         }
 572     }
 573   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 574     {
 575       /* look for ``*el-*'' in the target name. */
 576       const char *chp;
 577       chp = strchr (target_name, '-');
 578       if (chp != NULL
 579           && chp - 2 >= target_name
 580           && strncmp (chp - 2, "el", 2) == 0)
 581         info.byte_order = BFD_ENDIAN_LITTLE;
 582     }
 583   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 584     {
 585       /* Wire it to big-endian!!! */
 586       info.byte_order = BFD_ENDIAN_BIG;
 587     }
 588
 589   if (! gdbarch_update_p (info))
 590     internal_error (__FILE__, __LINE__,
 591                     "initialize_current_architecture: Selection of initial architecture failed");
 592
 593   /* Create the ``set architecture'' command appending ``auto'' to the
 594      list of architectures. */
 595   {
 596     struct cmd_list_element *c;
 597     /* Append ``auto''. */
 598     int nr;
 599     for (nr = 0; arches[nr] != NULL; nr++);
 600     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 601     arches[nr + 0] = "auto";
 602     arches[nr + 1] = NULL;
 603     /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
 604        of ``const char *''.  We just happen to know that the casts are
 605        safe. */
 606     c = add_set_enum_cmd ("architecture", class_support,
 607                           arches, &set_architecture_string,
 608                           "Set architecture of target.",
 609                           &setlist);
 610     set_cmd_sfunc (c, set_architecture);
 611     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 612     /* Don't use set_from_show - need to print both auto/manual and
 613        current setting. */
 614     add_cmd ("architecture", class_support, show_architecture,
 615              "Show the current target architecture", &showlist);
 616   }
 617 }
 618
 619
 620 /* Initialize a gdbarch info to values that will be automatically
 621    overridden.  Note: Originally, this ``struct info'' was initialized
 622    using memset(0).  Unfortunatly, that ran into problems, namely
 623    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 624    can explicitly set each field to a well defined value is used.  */
 625
 626 void
 627 gdbarch_info_init (struct gdbarch_info *info)
 628 {
 629   memset (info, 0, sizeof (struct gdbarch_info));
 630   info->byte_order = BFD_ENDIAN_UNKNOWN;
 631   info->osabi = GDB_OSABI_UNINITIALIZED;
 632 }
 633
 634 /* */
 635
 636 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
 637
 638 void
 639 _initialize_gdbarch_utils (void)
 640 {
 641   struct cmd_list_element *c;
 642   c = add_set_enum_cmd ("endian", class_support,
 643                         endian_enum, &set_endian_string,
 644                         "Set endianness of target.",
 645                         &setlist);
 646   set_cmd_sfunc (c, set_endian);
 647   /* Don't use set_from_show - need to print both auto/manual and
 648      current setting. */
 649   add_cmd ("endian", class_support, show_endian,
 650            "Show the current byte-order", &showlist);
 651 }