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. */ 42void 43legacy_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. */ 53void 54legacy_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 64int 65always_use_struct_convention (int gcc_p, struct type *value_type) 66{ 67 return 1; 68} 69 70 71int 72legacy_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 87int 88generic_return_value_on_stack_not (struct type *type) 89{ 90 return 0; 91} 92 93CORE_ADDR 94generic_skip_trampoline_code (CORE_ADDR pc) 95{ 96 return 0; 97} 98 99CORE_ADDR 100generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc) 101{ 102 return 0; 103} 104 105int 106generic_in_solib_call_trampoline (CORE_ADDR pc, char *name) 107{ 108 return 0; 109} 110 111int 112generic_in_solib_return_trampoline (CORE_ADDR pc, char *name) 113{ 114 return 0; 115} 116 117int 118generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc) 119{ 120 return 0; 121} 122 123#if defined (CALL_DUMMY) 124LONGEST legacy_call_dummy_words[] = CALL_DUMMY; 125#else 126LONGEST legacy_call_dummy_words[1]; 127#endif 128int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words); 129 130void 131generic_remote_translate_xfer_address (struct gdbarch *gdbarch, 132 struct regcache *regcache, 133 CORE_ADDR gdb_addr, int gdb_len, 134 CORE_ADDR * rem_addr, int *rem_len) 135{ 136 *rem_addr = gdb_addr; 137 *rem_len = gdb_len; 138} 139 140/* Helper functions for INNER_THAN */ 141 142int 143core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs) 144{ 145 return (lhs < rhs); 146} 147 148int 149core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs) 150{ 151 return (lhs > rhs); 152} 153 154 155/* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */ 156 157const struct floatformat * 158default_float_format (struct gdbarch *gdbarch) 159{ 160 int byte_order = gdbarch_byte_order (gdbarch); 161 switch (byte_order) 162 { 163 case BFD_ENDIAN_BIG: 164 return &floatformat_ieee_single_big; 165 case BFD_ENDIAN_LITTLE: 166 return &floatformat_ieee_single_little; 167 default: 168 internal_error (__FILE__, __LINE__, 169 "default_float_format: bad byte order"); 170 } 171} 172 173 174const struct floatformat * 175default_double_format (struct gdbarch *gdbarch) 176{ 177 int byte_order = gdbarch_byte_order (gdbarch); 178 switch (byte_order) 179 { 180 case BFD_ENDIAN_BIG: 181 return &floatformat_ieee_double_big; 182 case BFD_ENDIAN_LITTLE: 183 return &floatformat_ieee_double_little; 184 default: 185 internal_error (__FILE__, __LINE__, 186 "default_double_format: bad byte order"); 187 } 188} 189 190/* Misc helper functions for targets. */ 191 192CORE_ADDR 193core_addr_identity (CORE_ADDR addr) 194{ 195 return addr; 196} 197 198CORE_ADDR 199convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr, 200 struct target_ops *targ) 201{ 202 return addr; 203} 204 205int 206no_op_reg_to_regnum (int reg) 207{ 208 return reg; 209} 210 211CORE_ADDR 212deprecated_init_frame_pc_default (int fromleaf, struct frame_info *prev) 213{ 214 if (fromleaf && DEPRECATED_SAVED_PC_AFTER_CALL_P ()) 215 return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev)); 216 else if (get_next_frame (prev) != NULL) 217 return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev)); 218 else 219 return read_pc (); 220} 221 222void 223default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym) 224{ 225 return; 226} 227 228void 229default_coff_make_msymbol_special (int val, struct minimal_symbol *msym) 230{ 231 return; 232} 233 234int 235cannot_register_not (int regnum) 236{ 237 return 0; 238} 239 240/* Legacy version of target_virtual_frame_pointer(). Assumes that 241 there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or 242 raw. */ 243 244void 245legacy_virtual_frame_pointer (CORE_ADDR pc, 246 int *frame_regnum, 247 LONGEST *frame_offset) 248{ 249 /* FIXME: cagney/2002-09-13: This code is used when identifying the 250 frame pointer of the current PC. It is assuming that a single 251 register and an offset can determine this. I think it should 252 instead generate a byte code expression as that would work better 253 with things like Dwarf2's CFI. */ 254 if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS) 255 *frame_regnum = DEPRECATED_FP_REGNUM; 256 else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS) 257 *frame_regnum = SP_REGNUM; 258 else 259 /* Should this be an internal error? I guess so, it is reflecting 260 an architectural limitation in the current design. */ 261 internal_error (__FILE__, __LINE__, "No virtual frame pointer available"); 262 *frame_offset = 0; 263} 264 265/* Assume the world is sane, every register's virtual and real size 266 is identical. */ 267 268int 269generic_register_size (int regnum) 270{ 271 gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS); 272 if (gdbarch_register_type_p (current_gdbarch)) 273 return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum)); 274 else 275 /* FIXME: cagney/2003-03-01: Once all architectures implement 276 gdbarch_register_type(), this entire function can go away. It 277 is made obsolete by register_size(). */ 278 return TYPE_LENGTH (DEPRECATED_REGISTER_VIRTUAL_TYPE (regnum)); /* OK */ 279} 280 281/* Assume all registers are adjacent. */ 282 283int 284generic_register_byte (int regnum) 285{ 286 int byte; 287 int i; 288 gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS); 289 byte = 0; 290 for (i = 0; i < regnum; i++) 291 { 292 byte += generic_register_size (i); 293 } 294 return byte; 295} 296 297 298int 299legacy_pc_in_sigtramp (CORE_ADDR pc, char *name) 300{ 301#if !defined (IN_SIGTRAMP) 302 if (SIGTRAMP_START_P ()) 303 return (pc) >= SIGTRAMP_START (pc) && (pc) < SIGTRAMP_END (pc); 304 else 305 return name && strcmp ("_sigtramp", name) == 0; 306#else 307 return IN_SIGTRAMP (pc, name); 308#endif 309} 310 311int 312legacy_convert_register_p (int regnum, struct type *type) 313{ 314 return (DEPRECATED_REGISTER_CONVERTIBLE_P () 315 && DEPRECATED_REGISTER_CONVERTIBLE (regnum)); 316} 317 318void 319legacy_register_to_value (struct frame_info *frame, int regnum, 320 struct type *type, void *to) 321{ 322 char from[MAX_REGISTER_SIZE]; 323 get_frame_register (frame, regnum, from); 324 DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to); 325} 326 327void 328legacy_value_to_register (struct frame_info *frame, int regnum, 329 struct type *type, const void *tmp) 330{ 331 char to[MAX_REGISTER_SIZE]; 332 char *from = alloca (TYPE_LENGTH (type)); 333 memcpy (from, from, TYPE_LENGTH (type)); 334 DEPRECATED_REGISTER_CONVERT_TO_RAW (type, regnum, from, to); 335 put_frame_register (frame, regnum, to); 336} 337 338int 339default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type) 340{ 341 if (DEPRECATED_REG_STRUCT_HAS_ADDR_P () 342 && DEPRECATED_REG_STRUCT_HAS_ADDR (processing_gcc_compilation, type)) 343 { 344 CHECK_TYPEDEF (type); 345 346 return (TYPE_CODE (type) == TYPE_CODE_STRUCT 347 || TYPE_CODE (type) == TYPE_CODE_UNION 348 || TYPE_CODE (type) == TYPE_CODE_SET 349 || TYPE_CODE (type) == TYPE_CODE_BITSTRING); 350 } 351 352 return 0; 353} 354 355 356/* Functions to manipulate the endianness of the target. */ 357 358/* ``target_byte_order'' is only used when non- multi-arch. 359 Multi-arch targets obtain the current byte order using the 360 TARGET_BYTE_ORDER gdbarch method. 361 362 The choice of initial value is entirely arbitrary. During startup, 363 the function initialize_current_architecture() updates this value 364 based on default byte-order information extracted from BFD. */ 365static int target_byte_order = BFD_ENDIAN_BIG; 366static int target_byte_order_auto = 1; 367 368enum bfd_endian 369selected_byte_order (void) 370{ 371 if (target_byte_order_auto) 372 return BFD_ENDIAN_UNKNOWN; 373 else 374 return target_byte_order; 375} 376 377static const char endian_big[] = "big"; 378static const char endian_little[] = "little"; 379static const char endian_auto[] = "auto"; 380static const char *endian_enum[] = 381{ 382 endian_big, 383 endian_little, 384 endian_auto, 385 NULL, 386}; 387static const char *set_endian_string; 388 389/* Called by ``show endian''. */ 390 391static void 392show_endian (char *args, int from_tty) 393{ 394 if (target_byte_order_auto) 395 printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n", 396 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little")); 397 else 398 printf_unfiltered ("The target is assumed to be %s endian\n", 399 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little")); 400} 401 402static void 403set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c) 404{ 405 if (set_endian_string == endian_auto) 406 { 407 target_byte_order_auto = 1; 408 } 409 else if (set_endian_string == endian_little) 410 { 411 struct gdbarch_info info; 412 target_byte_order_auto = 0; 413 gdbarch_info_init (&info); 414 info.byte_order = BFD_ENDIAN_LITTLE; 415 if (! gdbarch_update_p (info)) 416 printf_unfiltered ("Little endian target not supported by GDB\n"); 417 } 418 else if (set_endian_string == endian_big) 419 { 420 struct gdbarch_info info; 421 target_byte_order_auto = 0; 422 gdbarch_info_init (&info); 423 info.byte_order = BFD_ENDIAN_BIG; 424 if (! gdbarch_update_p (info)) 425 printf_unfiltered ("Big endian target not supported by GDB\n"); 426 } 427 else 428 internal_error (__FILE__, __LINE__, 429 "set_endian: bad value"); 430 show_endian (NULL, from_tty); 431} 432 433/* Functions to manipulate the architecture of the target */ 434 435enum set_arch { set_arch_auto, set_arch_manual }; 436 437static int target_architecture_auto = 1; 438 439static const char *set_architecture_string; 440 441const char * 442selected_architecture_name (void) 443{ 444 if (target_architecture_auto) 445 return NULL; 446 else 447 return set_architecture_string; 448} 449 450/* Called if the user enters ``show architecture'' without an 451 argument. */ 452 453static void 454show_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 468static void 469set_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. */ 494int 495gdbarch_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/* Return the architecture for ABFD. If no suitable architecture 532 could be find, return NULL. */ 533 534struct gdbarch * 535gdbarch_from_bfd (bfd *abfd) 536{ 537 struct gdbarch *old_gdbarch = current_gdbarch; 538 struct gdbarch *new_gdbarch; 539 struct gdbarch_info info; 540 541 gdbarch_info_init (&info); 542 info.abfd = abfd; 543 return gdbarch_find_by_info (info); 544} 545 546/* Set the dynamic target-system-dependent parameters (architecture, 547 byte-order) using information found in the BFD */ 548 549void 550set_gdbarch_from_file (bfd *abfd) 551{ 552 struct gdbarch *gdbarch; 553 554 gdbarch = gdbarch_from_bfd (abfd); 555 if (gdbarch == NULL) 556 error ("Architecture of file not recognized.\n"); 557 deprecated_current_gdbarch_select_hack (gdbarch); 558} 559 560/* Initialize the current architecture. Update the ``set 561 architecture'' command so that it specifies a list of valid 562 architectures. */ 563 564#ifdef DEFAULT_BFD_ARCH 565extern const bfd_arch_info_type DEFAULT_BFD_ARCH; 566static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH; 567#else 568static const bfd_arch_info_type *default_bfd_arch; 569#endif 570 571#ifdef DEFAULT_BFD_VEC 572extern const bfd_target DEFAULT_BFD_VEC; 573static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC; 574#else 575static const bfd_target *default_bfd_vec; 576#endif 577 578void 579initialize_current_architecture (void) 580{ 581 const char **arches = gdbarch_printable_names (); 582 583 /* determine a default architecture and byte order. */ 584 struct gdbarch_info info; 585 gdbarch_info_init (&info); 586 587 /* Find a default architecture. */ 588 if (info.bfd_arch_info == NULL 589 && default_bfd_arch != NULL) 590 info.bfd_arch_info = default_bfd_arch; 591 if (info.bfd_arch_info == NULL) 592 { 593 /* Choose the architecture by taking the first one 594 alphabetically. */ 595 const char *chosen = arches[0]; 596 const char **arch; 597 for (arch = arches; *arch != NULL; arch++) 598 { 599 if (strcmp (*arch, chosen) < 0) 600 chosen = *arch; 601 } 602 if (chosen == NULL) 603 internal_error (__FILE__, __LINE__, 604 "initialize_current_architecture: No arch"); 605 info.bfd_arch_info = bfd_scan_arch (chosen); 606 if (info.bfd_arch_info == NULL) 607 internal_error (__FILE__, __LINE__, 608 "initialize_current_architecture: Arch not found"); 609 } 610 611 /* Take several guesses at a byte order. */ 612 if (info.byte_order == BFD_ENDIAN_UNKNOWN 613 && default_bfd_vec != NULL) 614 { 615 /* Extract BFD's default vector's byte order. */ 616 switch (default_bfd_vec->byteorder) 617 { 618 case BFD_ENDIAN_BIG: 619 info.byte_order = BFD_ENDIAN_BIG; 620 break; 621 case BFD_ENDIAN_LITTLE: 622 info.byte_order = BFD_ENDIAN_LITTLE; 623 break; 624 default: 625 break; 626 } 627 } 628 if (info.byte_order == BFD_ENDIAN_UNKNOWN) 629 { 630 /* look for ``*el-*'' in the target name. */ 631 const char *chp; 632 chp = strchr (target_name, '-'); 633 if (chp != NULL 634 && chp - 2 >= target_name 635 && strncmp (chp - 2, "el", 2) == 0) 636 info.byte_order = BFD_ENDIAN_LITTLE; 637 } 638 if (info.byte_order == BFD_ENDIAN_UNKNOWN) 639 { 640 /* Wire it to big-endian!!! */ 641 info.byte_order = BFD_ENDIAN_BIG; 642 } 643 644 if (! gdbarch_update_p (info)) 645 internal_error (__FILE__, __LINE__, 646 "initialize_current_architecture: Selection of initial architecture failed"); 647 648 /* Create the ``set architecture'' command appending ``auto'' to the 649 list of architectures. */ 650 { 651 struct cmd_list_element *c; 652 /* Append ``auto''. */ 653 int nr; 654 for (nr = 0; arches[nr] != NULL; nr++); 655 arches = xrealloc (arches, sizeof (char*) * (nr + 2)); 656 arches[nr + 0] = "auto"; 657 arches[nr + 1] = NULL; 658 /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead 659 of ``const char *''. We just happen to know that the casts are 660 safe. */ 661 c = add_set_enum_cmd ("architecture", class_support, 662 arches, &set_architecture_string, 663 "Set architecture of target.", 664 &setlist); 665 set_cmd_sfunc (c, set_architecture); 666 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist); 667 /* Don't use set_from_show - need to print both auto/manual and 668 current setting. */ 669 add_cmd ("architecture", class_support, show_architecture, 670 "Show the current target architecture", &showlist); 671 } 672} 673 674 675/* Initialize a gdbarch info to values that will be automatically 676 overridden. Note: Originally, this ``struct info'' was initialized 677 using memset(0). Unfortunately, that ran into problems, namely 678 BFD_ENDIAN_BIG is zero. An explicit initialization function that 679 can explicitly set each field to a well defined value is used. */ 680 681void 682gdbarch_info_init (struct gdbarch_info *info) 683{ 684 memset (info, 0, sizeof (struct gdbarch_info)); 685 info->byte_order = BFD_ENDIAN_UNKNOWN; 686 info->osabi = GDB_OSABI_UNINITIALIZED; 687} 688 689/* Similar to init, but this time fill in the blanks. Information is 690 obtained from the specified architecture, global "set ..." options, 691 and explicitly initialized INFO fields. */ 692 693void 694gdbarch_info_fill (struct gdbarch *gdbarch, struct gdbarch_info *info) 695{ 696 /* "(gdb) set architecture ...". */ 697 if (info->bfd_arch_info == NULL 698 && !target_architecture_auto 699 && gdbarch != NULL) 700 info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch); 701 if (info->bfd_arch_info == NULL 702 && info->abfd != NULL 703 && bfd_get_arch (info->abfd) != bfd_arch_unknown 704 && bfd_get_arch (info->abfd) != bfd_arch_obscure) 705 info->bfd_arch_info = bfd_get_arch_info (info->abfd); 706 if (info->bfd_arch_info == NULL 707 && gdbarch != NULL) 708 info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch); 709 710 /* "(gdb) set byte-order ...". */ 711 if (info->byte_order == BFD_ENDIAN_UNKNOWN 712 && !target_byte_order_auto 713 && gdbarch != NULL) 714 info->byte_order = gdbarch_byte_order (gdbarch); 715 /* From the INFO struct. */ 716 if (info->byte_order == BFD_ENDIAN_UNKNOWN 717 && info->abfd != NULL) 718 info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG 719 : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE 720 : BFD_ENDIAN_UNKNOWN); 721 /* From the current target. */ 722 if (info->byte_order == BFD_ENDIAN_UNKNOWN 723 && gdbarch != NULL) 724 info->byte_order = gdbarch_byte_order (gdbarch); 725 726 /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */ 727 if (info->osabi == GDB_OSABI_UNINITIALIZED) 728 info->osabi = gdbarch_lookup_osabi (info->abfd); 729 if (info->osabi == GDB_OSABI_UNINITIALIZED 730 && gdbarch != NULL) 731 info->osabi = gdbarch_osabi (gdbarch); 732 733 /* Must have at least filled in the architecture. */ 734 gdb_assert (info->bfd_arch_info != NULL); 735} 736 737/* */ 738 739extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */ 740 741void 742_initialize_gdbarch_utils (void) 743{ 744 struct cmd_list_element *c; 745 c = add_set_enum_cmd ("endian", class_support, 746 endian_enum, &set_endian_string, 747 "Set endianness of target.", 748 &setlist); 749 set_cmd_sfunc (c, set_endian); 750 /* Don't use set_from_show - need to print both auto/manual and 751 current setting. */ 752 add_cmd ("endian", class_support, show_endian, 753 "Show the current byte-order", &showlist); 754} 755