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