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 "osabi.h"
  35
  36 #include "version.h"
  37
  38 #include "floatformat.h"
  39
  40 /* Implementation of extract return value that grubs around in the
  41    register cache.  */
  42 void
  43 legacy_extract_return_value (struct type *type, struct regcache *regcache,
  44                              void *valbuf)
  45 {
  46   char *registers = deprecated_grub_regcache_for_registers (regcache);
  47   bfd_byte *buf = valbuf;
  48   DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */
  49 }
  50
  51 /* Implementation of store return value that grubs the register cache.
  52    Takes a local copy of the buffer to avoid const problems.  */
  53 void
  54 legacy_store_return_value (struct type *type, struct regcache *regcache,
  55                            const void *buf)
  56 {
  57   bfd_byte *b = alloca (TYPE_LENGTH (type));
  58   gdb_assert (regcache == current_regcache);
  59   memcpy (b, buf, TYPE_LENGTH (type));
  60   DEPRECATED_STORE_RETURN_VALUE (type, b);
  61 }
  62
  63
  64 int
  65 always_use_struct_convention (int gcc_p, struct type *value_type)
  66 {
  67   return 1;
  68 }
  69
  70
  71 int
  72 legacy_register_sim_regno (int regnum)
  73 {
  74   /* Only makes sense to supply raw registers.  */
  75   gdb_assert (regnum >= 0 && regnum < NUM_REGS);
  76   /* NOTE: cagney/2002-05-13: The old code did it this way and it is
  77      suspected that some GDB/SIM combinations may rely on this
  78      behavour.  The default should be one2one_register_sim_regno
  79      (below).  */
  80   if (REGISTER_NAME (regnum) != NULL
  81       && REGISTER_NAME (regnum)[0] != '\0')
  82     return regnum;
  83   else
  84     return LEGACY_SIM_REGNO_IGNORE;
  85 }
  86
  87 int
  88 generic_frameless_function_invocation_not (struct frame_info *fi)
  89 {
  90   return 0;
  91 }
  92
  93 int
  94 generic_return_value_on_stack_not (struct type *type)
  95 {
  96   return 0;
  97 }
  98
  99 CORE_ADDR
 100 generic_skip_trampoline_code (CORE_ADDR pc)
 101 {
 102   return 0;
 103 }
 104
 105 CORE_ADDR
 106 generic_skip_solib_resolver (CORE_ADDR pc)
 107 {
 108   return 0;
 109 }
 110
 111 int
 112 generic_in_solib_call_trampoline (CORE_ADDR pc, char *name)
 113 {
 114   return 0;
 115 }
 116
 117 int
 118 generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
 119 {
 120   return 0;
 121 }
 122
 123 int
 124 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 125 {
 126   return 0;
 127 }
 128
 129 #if defined (CALL_DUMMY)
 130 LONGEST legacy_call_dummy_words[] = CALL_DUMMY;
 131 #else
 132 LONGEST legacy_call_dummy_words[1];
 133 #endif
 134 int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words);
 135
 136 void
 137 generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
 138                                        struct regcache *regcache,
 139                                        CORE_ADDR gdb_addr, int gdb_len,
 140                                        CORE_ADDR * rem_addr, int *rem_len)
 141 {
 142   *rem_addr = gdb_addr;
 143   *rem_len = gdb_len;
 144 }
 145
 146 int
 147 generic_prologue_frameless_p (CORE_ADDR ip)
 148 {
 149   return ip == SKIP_PROLOGUE (ip);
 150 }
 151
 152 /* Helper functions for INNER_THAN */
 153
 154 int
 155 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
 156 {
 157   return (lhs < rhs);
 158 }
 159
 160 int
 161 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
 162 {
 163   return (lhs > rhs);
 164 }
 165
 166
 167 /* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
 168
 169 const struct floatformat *
 170 default_float_format (struct gdbarch *gdbarch)
 171 {
 172   int byte_order = gdbarch_byte_order (gdbarch);
 173   switch (byte_order)
 174     {
 175     case BFD_ENDIAN_BIG:
 176       return &floatformat_ieee_single_big;
 177     case BFD_ENDIAN_LITTLE:
 178       return &floatformat_ieee_single_little;
 179     default:
 180       internal_error (__FILE__, __LINE__,
 181                       "default_float_format: bad byte order");
 182     }
 183 }
 184
 185
 186 const struct floatformat *
 187 default_double_format (struct gdbarch *gdbarch)
 188 {
 189   int byte_order = gdbarch_byte_order (gdbarch);
 190   switch (byte_order)
 191     {
 192     case BFD_ENDIAN_BIG:
 193       return &floatformat_ieee_double_big;
 194     case BFD_ENDIAN_LITTLE:
 195       return &floatformat_ieee_double_little;
 196     default:
 197       internal_error (__FILE__, __LINE__,
 198                       "default_double_format: bad byte order");
 199     }
 200 }
 201
 202 /* Misc helper functions for targets. */
 203
 204 int
 205 deprecated_register_convertible_not (int num)
 206 {
 207   return 0;
 208 }
 209
 210
 211 CORE_ADDR
 212 core_addr_identity (CORE_ADDR addr)
 213 {
 214   return addr;
 215 }
 216
 217 CORE_ADDR
 218 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
 219                                      struct target_ops *targ)
 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 deprecated_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 (DEPRECATED_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   get_frame_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 /* Try to select a global architecture that matches "info".  Return
 493    non-zero if the attempt succeds.  */
 494 int
 495 gdbarch_update_p (struct gdbarch_info info)
 496 {
 497   struct gdbarch *new_gdbarch = gdbarch_find_by_info (info);
 498
 499   /* If there no architecture by that name, reject the request.  */
 500   if (new_gdbarch == NULL)
 501     {
 502       if (gdbarch_debug)
 503         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 504                             "Architecture not found\n");
 505       return 0;
 506     }
 507
 508   /* If it is the same old architecture, accept the request (but don't
 509      swap anything).  */
 510   if (new_gdbarch == current_gdbarch)
 511     {
 512       if (gdbarch_debug)
 513         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 514                             "Architecture 0x%08lx (%s) unchanged\n",
 515                             (long) new_gdbarch,
 516                             gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 517       return 1;
 518     }
 519
 520   /* It's a new architecture, swap it in.  */
 521   if (gdbarch_debug)
 522     fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 523                         "New architecture 0x%08lx (%s) selected\n",
 524                         (long) new_gdbarch,
 525                         gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 526   deprecated_current_gdbarch_select_hack (new_gdbarch);
 527
 528   return 1;
 529 }
 530
 531 /* FIXME: kettenis/20031124: Of the functions that follow, only
 532    gdbarch_from_bfd is supposed to survive.  The others will
 533    dissappear since in the future GDB will (hopefully) be truly
 534    multi-arch.  However, for now we're still stuck with the concept of
 535    a single active architecture.  */
 536
 537 /* Make GDBARCH the currently selected architecture.  */
 538
 539 static void
 540 deprecated_select_gdbarch_hack (struct gdbarch *gdbarch)
 541 {
 542   struct gdbarch_info info;
 543
 544   /* FIXME: kettenis/20031024: The only way to select a specific
 545      architecture is to clone its `struct gdbarch_info', and update
 546      according to that copy.  This is gross, but significant work will
 547      need to be done before we can take a more sane approach.  */
 548   gdbarch_info_init (&info);
 549   info.bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
 550   info.byte_order = gdbarch_byte_order (gdbarch);
 551   info.osabi = gdbarch_osabi (gdbarch);
 552   gdbarch_update_p (info);
 553   gdb_assert (gdbarch == current_gdbarch);
 554 }
 555
 556 /* Return the architecture for ABFD.  If no suitable architecture
 557    could be find, return NULL.  */
 558
 559 struct gdbarch *
 560 gdbarch_from_bfd (bfd *abfd)
 561 {
 562   struct gdbarch *old_gdbarch = current_gdbarch;
 563   struct gdbarch *new_gdbarch;
 564   struct gdbarch_info info;
 565
 566   /* FIXME: kettenis/20031024: The only way to find the architecture
 567      for a certain BFD is by doing an architecture update.  This
 568      activates the architecture, so we need to reactivate the old
 569      architecture.  This is gross, but significant work will need to
 570      be done before we can take a more sane approach.  */
 571   gdbarch_info_init (&info);
 572   info.abfd = abfd;
 573   if (! gdbarch_update_p (info))
 574     return NULL;
 575
 576   new_gdbarch = current_gdbarch;
 577   deprecated_select_gdbarch_hack (old_gdbarch);
 578   return new_gdbarch;
 579 }
 580
 581 /* Set the dynamic target-system-dependent parameters (architecture,
 582    byte-order) using information found in the BFD */
 583
 584 void
 585 set_gdbarch_from_file (bfd *abfd)
 586 {
 587   struct gdbarch *gdbarch;
 588
 589   gdbarch = gdbarch_from_bfd (abfd);
 590   if (gdbarch == NULL)
 591     error ("Architecture of file not recognized.\n");
 592   deprecated_select_gdbarch_hack (gdbarch);
 593 }
 594
 595 /* Initialize the current architecture.  Update the ``set
 596    architecture'' command so that it specifies a list of valid
 597    architectures.  */
 598
 599 #ifdef DEFAULT_BFD_ARCH
 600 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 601 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 602 #else
 603 static const bfd_arch_info_type *default_bfd_arch;
 604 #endif
 605
 606 #ifdef DEFAULT_BFD_VEC
 607 extern const bfd_target DEFAULT_BFD_VEC;
 608 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 609 #else
 610 static const bfd_target *default_bfd_vec;
 611 #endif
 612
 613 void
 614 initialize_current_architecture (void)
 615 {
 616   const char **arches = gdbarch_printable_names ();
 617
 618   /* determine a default architecture and byte order. */
 619   struct gdbarch_info info;
 620   gdbarch_info_init (&info);
 621
 622   /* Find a default architecture. */
 623   if (info.bfd_arch_info == NULL
 624       && default_bfd_arch != NULL)
 625     info.bfd_arch_info = default_bfd_arch;
 626   if (info.bfd_arch_info == NULL)
 627     {
 628       /* Choose the architecture by taking the first one
 629          alphabetically. */
 630       const char *chosen = arches[0];
 631       const char **arch;
 632       for (arch = arches; *arch != NULL; arch++)
 633         {
 634           if (strcmp (*arch, chosen) < 0)
 635             chosen = *arch;
 636         }
 637       if (chosen == NULL)
 638         internal_error (__FILE__, __LINE__,
 639                         "initialize_current_architecture: No arch");
 640       info.bfd_arch_info = bfd_scan_arch (chosen);
 641       if (info.bfd_arch_info == NULL)
 642         internal_error (__FILE__, __LINE__,
 643                         "initialize_current_architecture: Arch not found");
 644     }
 645
 646   /* Take several guesses at a byte order.  */
 647   if (info.byte_order == BFD_ENDIAN_UNKNOWN
 648       && default_bfd_vec != NULL)
 649     {
 650       /* Extract BFD's default vector's byte order. */
 651       switch (default_bfd_vec->byteorder)
 652         {
 653         case BFD_ENDIAN_BIG:
 654           info.byte_order = BFD_ENDIAN_BIG;
 655           break;
 656         case BFD_ENDIAN_LITTLE:
 657           info.byte_order = BFD_ENDIAN_LITTLE;
 658           break;
 659         default:
 660           break;
 661         }
 662     }
 663   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 664     {
 665       /* look for ``*el-*'' in the target name. */
 666       const char *chp;
 667       chp = strchr (target_name, '-');
 668       if (chp != NULL
 669           && chp - 2 >= target_name
 670           && strncmp (chp - 2, "el", 2) == 0)
 671         info.byte_order = BFD_ENDIAN_LITTLE;
 672     }
 673   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 674     {
 675       /* Wire it to big-endian!!! */
 676       info.byte_order = BFD_ENDIAN_BIG;
 677     }
 678
 679   if (! gdbarch_update_p (info))
 680     internal_error (__FILE__, __LINE__,
 681                     "initialize_current_architecture: Selection of initial architecture failed");
 682
 683   /* Create the ``set architecture'' command appending ``auto'' to the
 684      list of architectures. */
 685   {
 686     struct cmd_list_element *c;
 687     /* Append ``auto''. */
 688     int nr;
 689     for (nr = 0; arches[nr] != NULL; nr++);
 690     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 691     arches[nr + 0] = "auto";
 692     arches[nr + 1] = NULL;
 693     /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
 694        of ``const char *''.  We just happen to know that the casts are
 695        safe. */
 696     c = add_set_enum_cmd ("architecture", class_support,
 697                           arches, &set_architecture_string,
 698                           "Set architecture of target.",
 699                           &setlist);
 700     set_cmd_sfunc (c, set_architecture);
 701     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 702     /* Don't use set_from_show - need to print both auto/manual and
 703        current setting. */
 704     add_cmd ("architecture", class_support, show_architecture,
 705              "Show the current target architecture", &showlist);
 706   }
 707 }
 708
 709
 710 /* Initialize a gdbarch info to values that will be automatically
 711    overridden.  Note: Originally, this ``struct info'' was initialized
 712    using memset(0).  Unfortunately, that ran into problems, namely
 713    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 714    can explicitly set each field to a well defined value is used.  */
 715
 716 void
 717 gdbarch_info_init (struct gdbarch_info *info)
 718 {
 719   memset (info, 0, sizeof (struct gdbarch_info));
 720   info->byte_order = BFD_ENDIAN_UNKNOWN;
 721   info->osabi = GDB_OSABI_UNINITIALIZED;
 722 }
 723
 724 /* Similar it init, but this time fill in the blanks.  Information is
 725    obtained from the specified architecture, global "set ..." options,
 726    and explicitly initialized INFO fields.  */
 727
 728 void
 729 gdbarch_info_fill (struct gdbarch *gdbarch, struct gdbarch_info *info)
 730 {
 731   /* "(gdb) set architecture ...".  */
 732   if (info->bfd_arch_info == NULL
 733       && !target_architecture_auto
 734       && gdbarch != NULL)
 735     info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
 736   if (info->bfd_arch_info == NULL
 737       && info->abfd != NULL
 738       && bfd_get_arch (info->abfd) != bfd_arch_unknown
 739       && bfd_get_arch (info->abfd) != bfd_arch_obscure)
 740     info->bfd_arch_info = bfd_get_arch_info (info->abfd);
 741   if (info->bfd_arch_info == NULL
 742       && gdbarch != NULL)
 743     info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
 744
 745   /* "(gdb) set byte-order ...".  */
 746   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 747       && !target_byte_order_auto
 748       && gdbarch != NULL)
 749     info->byte_order = gdbarch_byte_order (gdbarch);
 750   /* From the INFO struct.  */
 751   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 752       && info->abfd != NULL)
 753     info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
 754                        : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
 755                        : BFD_ENDIAN_UNKNOWN);
 756   /* From the current target.  */
 757   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 758       && gdbarch != NULL)
 759     info->byte_order = gdbarch_byte_order (gdbarch);
 760
 761   /* "(gdb) set osabi ...".  Handled by gdbarch_lookup_osabi.  */
 762   if (info->osabi == GDB_OSABI_UNINITIALIZED)
 763     info->osabi = gdbarch_lookup_osabi (info->abfd);
 764   if (info->osabi == GDB_OSABI_UNINITIALIZED
 765       && gdbarch != NULL)
 766     info->osabi = gdbarch_osabi (gdbarch);
 767
 768   /* Must have at least filled in the architecture.  */
 769   gdb_assert (info->bfd_arch_info != NULL);
 770 }
 771
 772 /* */
 773
 774 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
 775
 776 void
 777 _initialize_gdbarch_utils (void)
 778 {
 779   struct cmd_list_element *c;
 780   c = add_set_enum_cmd ("endian", class_support,
 781                         endian_enum, &set_endian_string,
 782                         "Set endianness of target.",
 783                         &setlist);
 784   set_cmd_sfunc (c, set_endian);
 785   /* Don't use set_from_show - need to print both auto/manual and
 786      current setting. */
 787   add_cmd ("endian", class_support, show_endian,
 788            "Show the current byte-order", &showlist);
 789 }