1 /* Dynamic architecture support for GDB, the GNU debugger. 2 3 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 4 2008, 2009 Free Software Foundation, 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 3 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, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 23 #include "arch-utils.h" 24 #include "buildsym.h" 25 #include "gdbcmd.h" 26 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */ 27 #include "gdb_string.h" 28 #include "regcache.h" 29 #include "gdb_assert.h" 30 #include "sim-regno.h" 31 #include "gdbcore.h" 32 #include "osabi.h" 33 #include "target-descriptions.h" 34 #include "objfiles.h" 35 36 #include "version.h" 37 38 #include "floatformat.h" 39 40 41 struct displaced_step_closure * 42 simple_displaced_step_copy_insn (struct gdbarch *gdbarch, 43 CORE_ADDR from, CORE_ADDR to, 44 struct regcache *regs) 45 { 46 size_t len = gdbarch_max_insn_length (gdbarch); 47 gdb_byte *buf = xmalloc (len); 48 49 read_memory (from, buf, len); 50 write_memory (to, buf, len); 51 52 if (debug_displaced) 53 { 54 fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ", 55 paddress (gdbarch, from), paddress (gdbarch, to)); 56 displaced_step_dump_bytes (gdb_stdlog, buf, len); 57 } 58 59 return (struct displaced_step_closure *) buf; 60 } 61 62 63 void 64 simple_displaced_step_free_closure (struct gdbarch *gdbarch, 65 struct displaced_step_closure *closure) 66 { 67 xfree (closure); 68 } 69 70 int 71 default_displaced_step_hw_singlestep (struct gdbarch *gdbarch, 72 struct displaced_step_closure *closure) 73 { 74 return !gdbarch_software_single_step_p (gdbarch); 75 } 76 77 CORE_ADDR 78 displaced_step_at_entry_point (struct gdbarch *gdbarch) 79 { 80 CORE_ADDR addr; 81 int bp_len; 82 83 addr = entry_point_address (); 84 85 /* Inferior calls also use the entry point as a breakpoint location. 86 We don't want displaced stepping to interfere with those 87 breakpoints, so leave space. */ 88 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len); 89 addr += bp_len * 2; 90 91 return addr; 92 } 93 94 int 95 legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum) 96 { 97 /* Only makes sense to supply raw registers. */ 98 gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)); 99 /* NOTE: cagney/2002-05-13: The old code did it this way and it is 100 suspected that some GDB/SIM combinations may rely on this 101 behavour. The default should be one2one_register_sim_regno 102 (below). */ 103 if (gdbarch_register_name (gdbarch, regnum) != NULL 104 && gdbarch_register_name (gdbarch, regnum)[0] != '\0') 105 return regnum; 106 else 107 return LEGACY_SIM_REGNO_IGNORE; 108 } 109 110 CORE_ADDR 111 generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) 112 { 113 return 0; 114 } 115 116 CORE_ADDR 117 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc) 118 { 119 return 0; 120 } 121 122 int 123 generic_in_solib_return_trampoline (struct gdbarch *gdbarch, 124 CORE_ADDR pc, char *name) 125 { 126 return 0; 127 } 128 129 int 130 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc) 131 { 132 return 0; 133 } 134 135 /* Helper functions for gdbarch_inner_than */ 136 137 int 138 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs) 139 { 140 return (lhs < rhs); 141 } 142 143 int 144 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs) 145 { 146 return (lhs > rhs); 147 } 148 149 /* Misc helper functions for targets. */ 150 151 CORE_ADDR 152 core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr) 153 { 154 return addr; 155 } 156 157 CORE_ADDR 158 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr, 159 struct target_ops *targ) 160 { 161 return addr; 162 } 163 164 int 165 no_op_reg_to_regnum (struct gdbarch *gdbarch, int reg) 166 { 167 return reg; 168 } 169 170 void 171 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym) 172 { 173 return; 174 } 175 176 void 177 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym) 178 { 179 return; 180 } 181 182 int 183 cannot_register_not (struct gdbarch *gdbarch, int regnum) 184 { 185 return 0; 186 } 187 188 /* Legacy version of target_virtual_frame_pointer(). Assumes that 189 there is an gdbarch_deprecated_fp_regnum and that it is the same, cooked or 190 raw. */ 191 192 void 193 legacy_virtual_frame_pointer (struct gdbarch *gdbarch, 194 CORE_ADDR pc, 195 int *frame_regnum, 196 LONGEST *frame_offset) 197 { 198 /* FIXME: cagney/2002-09-13: This code is used when identifying the 199 frame pointer of the current PC. It is assuming that a single 200 register and an offset can determine this. I think it should 201 instead generate a byte code expression as that would work better 202 with things like Dwarf2's CFI. */ 203 if (gdbarch_deprecated_fp_regnum (gdbarch) >= 0 204 && gdbarch_deprecated_fp_regnum (gdbarch) 205 < gdbarch_num_regs (gdbarch)) 206 *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch); 207 else if (gdbarch_sp_regnum (gdbarch) >= 0 208 && gdbarch_sp_regnum (gdbarch) 209 < gdbarch_num_regs (gdbarch)) 210 *frame_regnum = gdbarch_sp_regnum (gdbarch); 211 else 212 /* Should this be an internal error? I guess so, it is reflecting 213 an architectural limitation in the current design. */ 214 internal_error (__FILE__, __LINE__, _("No virtual frame pointer available")); 215 *frame_offset = 0; 216 } 217 218 219 int 220 generic_convert_register_p (struct gdbarch *gdbarch, int regnum, 221 struct type *type) 222 { 223 return 0; 224 } 225 226 int 227 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type) 228 { 229 return 0; 230 } 231 232 int 233 generic_instruction_nullified (struct gdbarch *gdbarch, 234 struct regcache *regcache) 235 { 236 return 0; 237 } 238 239 int 240 default_remote_register_number (struct gdbarch *gdbarch, 241 int regno) 242 { 243 return regno; 244 } 245 246 247 /* Functions to manipulate the endianness of the target. */ 248 249 static int target_byte_order_user = BFD_ENDIAN_UNKNOWN; 250 251 static const char endian_big[] = "big"; 252 static const char endian_little[] = "little"; 253 static const char endian_auto[] = "auto"; 254 static const char *endian_enum[] = 255 { 256 endian_big, 257 endian_little, 258 endian_auto, 259 NULL, 260 }; 261 static const char *set_endian_string; 262 263 enum bfd_endian 264 selected_byte_order (void) 265 { 266 return target_byte_order_user; 267 } 268 269 /* Called by ``show endian''. */ 270 271 static void 272 show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c, 273 const char *value) 274 { 275 if (target_byte_order_user == BFD_ENDIAN_UNKNOWN) 276 if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG) 277 fprintf_unfiltered (file, _("The target endianness is set automatically " 278 "(currently big endian)\n")); 279 else 280 fprintf_unfiltered (file, _("The target endianness is set automatically " 281 "(currently little endian)\n")); 282 else 283 if (target_byte_order_user == BFD_ENDIAN_BIG) 284 fprintf_unfiltered (file, 285 _("The target is assumed to be big endian\n")); 286 else 287 fprintf_unfiltered (file, 288 _("The target is assumed to be little endian\n")); 289 } 290 291 static void 292 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c) 293 { 294 struct gdbarch_info info; 295 296 gdbarch_info_init (&info); 297 298 if (set_endian_string == endian_auto) 299 { 300 target_byte_order_user = BFD_ENDIAN_UNKNOWN; 301 if (! gdbarch_update_p (info)) 302 internal_error (__FILE__, __LINE__, 303 _("set_endian: architecture update failed")); 304 } 305 else if (set_endian_string == endian_little) 306 { 307 info.byte_order = BFD_ENDIAN_LITTLE; 308 if (! gdbarch_update_p (info)) 309 printf_unfiltered (_("Little endian target not supported by GDB\n")); 310 else 311 target_byte_order_user = BFD_ENDIAN_LITTLE; 312 } 313 else if (set_endian_string == endian_big) 314 { 315 info.byte_order = BFD_ENDIAN_BIG; 316 if (! gdbarch_update_p (info)) 317 printf_unfiltered (_("Big endian target not supported by GDB\n")); 318 else 319 target_byte_order_user = BFD_ENDIAN_BIG; 320 } 321 else 322 internal_error (__FILE__, __LINE__, 323 _("set_endian: bad value")); 324 325 show_endian (gdb_stdout, from_tty, NULL, NULL); 326 } 327 328 /* Given SELECTED, a currently selected BFD architecture, and 329 TARGET_DESC, the current target description, return what 330 architecture to use. 331 332 SELECTED may be NULL, in which case we return the architecture 333 associated with TARGET_DESC. If SELECTED specifies a variant 334 of the architecture associtated with TARGET_DESC, return the 335 more specific of the two. 336 337 If SELECTED is a different architecture, but it is accepted as 338 compatible by the target, we can use the target architecture. 339 340 If SELECTED is obviously incompatible, warn the user. */ 341 342 static const struct bfd_arch_info * 343 choose_architecture_for_target (const struct target_desc *target_desc, 344 const struct bfd_arch_info *selected) 345 { 346 const struct bfd_arch_info *from_target = tdesc_architecture (target_desc); 347 const struct bfd_arch_info *compat1, *compat2; 348 349 if (selected == NULL) 350 return from_target; 351 352 if (from_target == NULL) 353 return selected; 354 355 /* struct bfd_arch_info objects are singletons: that is, there's 356 supposed to be exactly one instance for a given machine. So you 357 can tell whether two are equivalent by comparing pointers. */ 358 if (from_target == selected) 359 return selected; 360 361 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are 362 incompatible. But if they are compatible, it returns the 'more 363 featureful' of the two arches. That is, if A can run code 364 written for B, but B can't run code written for A, then it'll 365 return A. 366 367 Some targets (e.g. MIPS as of 2006-12-04) don't fully 368 implement this, instead always returning NULL or the first 369 argument. We detect that case by checking both directions. */ 370 371 compat1 = selected->compatible (selected, from_target); 372 compat2 = from_target->compatible (from_target, selected); 373 374 if (compat1 == NULL && compat2 == NULL) 375 { 376 /* BFD considers the architectures incompatible. Check our target 377 description whether it accepts SELECTED as compatible anyway. */ 378 if (tdesc_compatible_p (target_desc, selected)) 379 return from_target; 380 381 warning (_("Selected architecture %s is not compatible " 382 "with reported target architecture %s"), 383 selected->printable_name, from_target->printable_name); 384 return selected; 385 } 386 387 if (compat1 == NULL) 388 return compat2; 389 if (compat2 == NULL) 390 return compat1; 391 if (compat1 == compat2) 392 return compat1; 393 394 /* If the two didn't match, but one of them was a default architecture, 395 assume the more specific one is correct. This handles the case 396 where an executable or target description just says "mips", but 397 the other knows which MIPS variant. */ 398 if (compat1->the_default) 399 return compat2; 400 if (compat2->the_default) 401 return compat1; 402 403 /* We have no idea which one is better. This is a bug, but not 404 a critical problem; warn the user. */ 405 warning (_("Selected architecture %s is ambiguous with " 406 "reported target architecture %s"), 407 selected->printable_name, from_target->printable_name); 408 return selected; 409 } 410 411 /* Functions to manipulate the architecture of the target */ 412 413 enum set_arch { set_arch_auto, set_arch_manual }; 414 415 static const struct bfd_arch_info *target_architecture_user; 416 417 static const char *set_architecture_string; 418 419 const char * 420 selected_architecture_name (void) 421 { 422 if (target_architecture_user == NULL) 423 return NULL; 424 else 425 return set_architecture_string; 426 } 427 428 /* Called if the user enters ``show architecture'' without an 429 argument. */ 430 431 static void 432 show_architecture (struct ui_file *file, int from_tty, 433 struct cmd_list_element *c, const char *value) 434 { 435 if (target_architecture_user == NULL) 436 fprintf_filtered (file, _("\ 437 The target architecture is set automatically (currently %s)\n"), 438 gdbarch_bfd_arch_info (get_current_arch ())->printable_name); 439 else 440 fprintf_filtered (file, _("\ 441 The target architecture is assumed to be %s\n"), set_architecture_string); 442 } 443 444 445 /* Called if the user enters ``set architecture'' with or without an 446 argument. */ 447 448 static void 449 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c) 450 { 451 struct gdbarch_info info; 452 453 gdbarch_info_init (&info); 454 455 if (strcmp (set_architecture_string, "auto") == 0) 456 { 457 target_architecture_user = NULL; 458 if (!gdbarch_update_p (info)) 459 internal_error (__FILE__, __LINE__, 460 _("could not select an architecture automatically")); 461 } 462 else 463 { 464 info.bfd_arch_info = bfd_scan_arch (set_architecture_string); 465 if (info.bfd_arch_info == NULL) 466 internal_error (__FILE__, __LINE__, 467 _("set_architecture: bfd_scan_arch failed")); 468 if (gdbarch_update_p (info)) 469 target_architecture_user = info.bfd_arch_info; 470 else 471 printf_unfiltered (_("Architecture `%s' not recognized.\n"), 472 set_architecture_string); 473 } 474 show_architecture (gdb_stdout, from_tty, NULL, NULL); 475 } 476 477 /* Try to select a global architecture that matches "info". Return 478 non-zero if the attempt succeds. */ 479 int 480 gdbarch_update_p (struct gdbarch_info info) 481 { 482 struct gdbarch *new_gdbarch; 483 484 /* Check for the current file. */ 485 if (info.abfd == NULL) 486 info.abfd = exec_bfd; 487 if (info.abfd == NULL) 488 info.abfd = core_bfd; 489 490 /* Check for the current target description. */ 491 if (info.target_desc == NULL) 492 info.target_desc = target_current_description (); 493 494 new_gdbarch = gdbarch_find_by_info (info); 495 496 /* If there no architecture by that name, reject the request. */ 497 if (new_gdbarch == NULL) 498 { 499 if (gdbarch_debug) 500 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " 501 "Architecture not found\n"); 502 return 0; 503 } 504 505 /* If it is the same old architecture, accept the request (but don't 506 swap anything). */ 507 if (new_gdbarch == target_gdbarch) 508 { 509 if (gdbarch_debug) 510 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " 511 "Architecture %s (%s) unchanged\n", 512 host_address_to_string (new_gdbarch), 513 gdbarch_bfd_arch_info (new_gdbarch)->printable_name); 514 return 1; 515 } 516 517 /* It's a new architecture, swap it in. */ 518 if (gdbarch_debug) 519 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " 520 "New architecture %s (%s) selected\n", 521 host_address_to_string (new_gdbarch), 522 gdbarch_bfd_arch_info (new_gdbarch)->printable_name); 523 deprecated_target_gdbarch_select_hack (new_gdbarch); 524 525 return 1; 526 } 527 528 /* Return the architecture for ABFD. If no suitable architecture 529 could be find, return NULL. */ 530 531 struct gdbarch * 532 gdbarch_from_bfd (bfd *abfd) 533 { 534 struct gdbarch_info info; 535 gdbarch_info_init (&info); 536 info.abfd = abfd; 537 return gdbarch_find_by_info (info); 538 } 539 540 /* Set the dynamic target-system-dependent parameters (architecture, 541 byte-order) using information found in the BFD */ 542 543 void 544 set_gdbarch_from_file (bfd *abfd) 545 { 546 struct gdbarch_info info; 547 struct gdbarch *gdbarch; 548 549 gdbarch_info_init (&info); 550 info.abfd = abfd; 551 info.target_desc = target_current_description (); 552 gdbarch = gdbarch_find_by_info (info); 553 554 if (gdbarch == NULL) 555 error (_("Architecture of file not recognized.")); 556 deprecated_target_gdbarch_select_hack (gdbarch); 557 } 558 559 /* Initialize the current architecture. Update the ``set 560 architecture'' command so that it specifies a list of valid 561 architectures. */ 562 563 #ifdef DEFAULT_BFD_ARCH 564 extern const bfd_arch_info_type DEFAULT_BFD_ARCH; 565 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH; 566 #else 567 static const bfd_arch_info_type *default_bfd_arch; 568 #endif 569 570 #ifdef DEFAULT_BFD_VEC 571 extern const bfd_target DEFAULT_BFD_VEC; 572 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC; 573 #else 574 static const bfd_target *default_bfd_vec; 575 #endif 576 577 static int default_byte_order = BFD_ENDIAN_UNKNOWN; 578 579 void 580 initialize_current_architecture (void) 581 { 582 const char **arches = gdbarch_printable_names (); 583 584 /* determine a default architecture and byte order. */ 585 struct gdbarch_info info; 586 gdbarch_info_init (&info); 587 588 /* Find a default architecture. */ 589 if (default_bfd_arch == NULL) 590 { 591 /* Choose the architecture by taking the first one 592 alphabetically. */ 593 const char *chosen = arches[0]; 594 const char **arch; 595 for (arch = arches; *arch != NULL; arch++) 596 { 597 if (strcmp (*arch, chosen) < 0) 598 chosen = *arch; 599 } 600 if (chosen == NULL) 601 internal_error (__FILE__, __LINE__, 602 _("initialize_current_architecture: No arch")); 603 default_bfd_arch = bfd_scan_arch (chosen); 604 if (default_bfd_arch == NULL) 605 internal_error (__FILE__, __LINE__, 606 _("initialize_current_architecture: Arch not found")); 607 } 608 609 info.bfd_arch_info = default_bfd_arch; 610 611 /* Take several guesses at a byte order. */ 612 if (default_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 default_byte_order = BFD_ENDIAN_BIG; 620 break; 621 case BFD_ENDIAN_LITTLE: 622 default_byte_order = BFD_ENDIAN_LITTLE; 623 break; 624 default: 625 break; 626 } 627 } 628 if (default_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 default_byte_order = BFD_ENDIAN_LITTLE; 637 } 638 if (default_byte_order == BFD_ENDIAN_UNKNOWN) 639 { 640 /* Wire it to big-endian!!! */ 641 default_byte_order = BFD_ENDIAN_BIG; 642 } 643 644 info.byte_order = default_byte_order; 645 info.byte_order_for_code = info.byte_order; 646 647 if (! gdbarch_update_p (info)) 648 internal_error (__FILE__, __LINE__, 649 _("initialize_current_architecture: Selection of " 650 "initial architecture failed")); 651 652 /* Create the ``set architecture'' command appending ``auto'' to the 653 list of architectures. */ 654 { 655 struct cmd_list_element *c; 656 /* Append ``auto''. */ 657 int nr; 658 for (nr = 0; arches[nr] != NULL; nr++); 659 arches = xrealloc (arches, sizeof (char*) * (nr + 2)); 660 arches[nr + 0] = "auto"; 661 arches[nr + 1] = NULL; 662 add_setshow_enum_cmd ("architecture", class_support, 663 arches, &set_architecture_string, _("\ 664 Set architecture of target."), _("\ 665 Show architecture of target."), NULL, 666 set_architecture, show_architecture, 667 &setlist, &showlist); 668 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist); 669 } 670 } 671 672 673 /* Initialize a gdbarch info to values that will be automatically 674 overridden. Note: Originally, this ``struct info'' was initialized 675 using memset(0). Unfortunately, that ran into problems, namely 676 BFD_ENDIAN_BIG is zero. An explicit initialization function that 677 can explicitly set each field to a well defined value is used. */ 678 679 void 680 gdbarch_info_init (struct gdbarch_info *info) 681 { 682 memset (info, 0, sizeof (struct gdbarch_info)); 683 info->byte_order = BFD_ENDIAN_UNKNOWN; 684 info->byte_order_for_code = info->byte_order; 685 info->osabi = GDB_OSABI_UNINITIALIZED; 686 } 687 688 /* Similar to init, but this time fill in the blanks. Information is 689 obtained from the global "set ..." options and explicitly 690 initialized INFO fields. */ 691 692 void 693 gdbarch_info_fill (struct gdbarch_info *info) 694 { 695 /* "(gdb) set architecture ...". */ 696 if (info->bfd_arch_info == NULL 697 && target_architecture_user) 698 info->bfd_arch_info = target_architecture_user; 699 /* From the file. */ 700 if (info->bfd_arch_info == NULL 701 && info->abfd != NULL 702 && bfd_get_arch (info->abfd) != bfd_arch_unknown 703 && bfd_get_arch (info->abfd) != bfd_arch_obscure) 704 info->bfd_arch_info = bfd_get_arch_info (info->abfd); 705 /* From the target. */ 706 if (info->target_desc != NULL) 707 info->bfd_arch_info = choose_architecture_for_target 708 (info->target_desc, info->bfd_arch_info); 709 /* From the default. */ 710 if (info->bfd_arch_info == NULL) 711 info->bfd_arch_info = default_bfd_arch; 712 713 /* "(gdb) set byte-order ...". */ 714 if (info->byte_order == BFD_ENDIAN_UNKNOWN 715 && target_byte_order_user != BFD_ENDIAN_UNKNOWN) 716 info->byte_order = target_byte_order_user; 717 /* From the INFO struct. */ 718 if (info->byte_order == BFD_ENDIAN_UNKNOWN 719 && info->abfd != NULL) 720 info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG 721 : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE 722 : BFD_ENDIAN_UNKNOWN); 723 /* From the default. */ 724 if (info->byte_order == BFD_ENDIAN_UNKNOWN) 725 info->byte_order = default_byte_order; 726 info->byte_order_for_code = info->byte_order; 727 728 /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */ 729 /* From the manual override, or from file. */ 730 if (info->osabi == GDB_OSABI_UNINITIALIZED) 731 info->osabi = gdbarch_lookup_osabi (info->abfd); 732 /* From the target. */ 733 if (info->osabi == GDB_OSABI_UNKNOWN && info->target_desc != NULL) 734 info->osabi = tdesc_osabi (info->target_desc); 735 /* From the configured default. */ 736 #ifdef GDB_OSABI_DEFAULT 737 if (info->osabi == GDB_OSABI_UNKNOWN) 738 info->osabi = GDB_OSABI_DEFAULT; 739 #endif 740 741 /* Must have at least filled in the architecture. */ 742 gdb_assert (info->bfd_arch_info != NULL); 743 } 744 745 /* Return "current" architecture. If the target is running, this is the 746 architecture of the selected frame. Otherwise, the "current" architecture 747 defaults to the target architecture. 748 749 This function should normally be called solely by the command interpreter 750 routines to determine the architecture to execute a command in. */ 751 struct gdbarch * 752 get_current_arch (void) 753 { 754 if (has_stack_frames ()) 755 return get_frame_arch (get_selected_frame (NULL)); 756 else 757 return target_gdbarch; 758 } 759 760 /* */ 761 762 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */ 763 764 void 765 _initialize_gdbarch_utils (void) 766 { 767 struct cmd_list_element *c; 768 add_setshow_enum_cmd ("endian", class_support, 769 endian_enum, &set_endian_string, _("\ 770 Set endianness of target."), _("\ 771 Show endianness of target."), NULL, 772 set_endian, show_endian, 773 &setlist, &showlist); 774 } 775