12116Sjkh/* Dynamic architecture support for GDB, the GNU debugger. 22116Sjkh 32116Sjkh Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, 42116Sjkh Inc. 52116Sjkh 62116Sjkh This file is part of GDB. 72116Sjkh 82116Sjkh This program is free software; you can redistribute it and/or modify 92116Sjkh it under the terms of the GNU General Public License as published by 102116Sjkh the Free Software Foundation; either version 2 of the License, or 112116Sjkh (at your option) any later version. 122116Sjkh 132116Sjkh This program is distributed in the hope that it will be useful, 142116Sjkh but WITHOUT ANY WARRANTY; without even the implied warranty of 152116Sjkh MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 162116Sjkh GNU General Public License for more details. 172116Sjkh 182116Sjkh You should have received a copy of the GNU General Public License 192116Sjkh along with this program; if not, write to the Free Software 202116Sjkh Foundation, Inc., 59 Temple Place - Suite 330, 212116Sjkh Boston, MA 02111-1307, USA. */ 222116Sjkh 232116Sjkh#include "defs.h" 242116Sjkh 252116Sjkh#include "arch-utils.h" 262116Sjkh#include "buildsym.h" 272116Sjkh#include "gdbcmd.h" 282116Sjkh#include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */ 292116Sjkh#include "gdb_string.h" 302116Sjkh#include "regcache.h" 312116Sjkh#include "gdb_assert.h" 322116Sjkh#include "sim-regno.h" 332116Sjkh 342116Sjkh#include "osabi.h" 352116Sjkh 3623577Sbde#include "version.h" 37213337Sdim 382116Sjkh#include "floatformat.h" 39141280Sdas 402116Sjkh/* Implementation of extract return value that grubs around in the 412116Sjkh register cache. */ 422116Sjkhvoid 432116Sjkhlegacy_extract_return_value (struct type *type, struct regcache *regcache, 442116Sjkh void *valbuf) 452116Sjkh{ 4661335Sbde char *registers = deprecated_grub_regcache_for_registers (regcache); 472116Sjkh bfd_byte *buf = valbuf; 48192760Sattilio DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */ 49217108Skib} 50217108Skib 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