1 /* Dynamic architecture support for GDB, the GNU debugger. 2 3 Copyright (C) 1998-2012 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 22 #include "arch-utils.h" 23 #include "buildsym.h" 24 #include "gdbcmd.h" 25 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et al. */ 26 #include "gdb_string.h" 27 #include "regcache.h" 28 #include "gdb_assert.h" 29 #include "sim-regno.h" 30 #include "gdbcore.h" 31 #include "osabi.h" 32 #include "target-descriptions.h" 33 #include "objfiles.h" 34 35 #include "version.h" 36 37 #include "floatformat.h" 38 39 40 struct displaced_step_closure * 41 simple_displaced_step_copy_insn (struct gdbarch *gdbarch, 42 CORE_ADDR from, CORE_ADDR to, 43 struct regcache *regs) 44 { 45 size_t len = gdbarch_max_insn_length (gdbarch); 46 gdb_byte *buf = xmalloc (len); 47 48 read_memory (from, buf, len); 49 write_memory (to, buf, len); 50 51 if (debug_displaced) 52 { 53 fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ", 54 paddress (gdbarch, from), paddress (gdbarch, to)); 55 displaced_step_dump_bytes (gdb_stdlog, buf, len); 56 } 57 58 return (struct displaced_step_closure *) buf; 59 } 60 61 62 void 63 simple_displaced_step_free_closure (struct gdbarch *gdbarch, 64 struct displaced_step_closure *closure) 65 { 66 xfree (closure); 67 } 68 69 int 70 default_displaced_step_hw_singlestep (struct gdbarch *gdbarch, 71 struct displaced_step_closure *closure) 72 { 73 return !gdbarch_software_single_step_p (gdbarch); 74 } 75 76 CORE_ADDR 77 displaced_step_at_entry_point (struct gdbarch *gdbarch) 78 { 79 CORE_ADDR addr; 80 int bp_len; 81 82 addr = entry_point_address (); 83 84 /* Inferior calls also use the entry point as a breakpoint location. 85 We don't want displaced stepping to interfere with those 86 breakpoints, so leave space. */ 87 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len); 88 addr += bp_len * 2; 89 90 return addr; 91 } 92 93 int 94 legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum) 95 { 96 /* Only makes sense to supply raw registers. */ 97 gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)); 98 /* NOTE: cagney/2002-05-13: The old code did it this way and it is 99 suspected that some GDB/SIM combinations may rely on this 100 behavour. The default should be one2one_register_sim_regno 101 (below). */ 102 if (gdbarch_register_name (gdbarch, regnum) != NULL 103 && gdbarch_register_name (gdbarch, regnum)[0] != '\0') 104 return regnum; 105 else 106 return LEGACY_SIM_REGNO_IGNORE; 107 } 108 109 CORE_ADDR 110 generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) 111 { 112 return 0; 113 } 114 115 CORE_ADDR 116 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc) 117 { 118 return 0; 119 } 120 121 int 122 generic_in_solib_return_trampoline (struct gdbarch *gdbarch, 123 CORE_ADDR pc, char *name) 124 { 125 return 0; 126 } 127 128 int 129 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc) 130 { 131 return 0; 132 } 133 134 /* Helper functions for gdbarch_inner_than */ 135 136 int 137 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs) 138 { 139 return (lhs < rhs); 140 } 141 142 int 143 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs) 144 { 145 return (lhs > rhs); 146 } 147 148 /* Misc helper functions for targets. */ 149 150 CORE_ADDR 151 core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr) 152 { 153 return addr; 154 } 155 156 CORE_ADDR 157 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr, 158 struct target_ops *targ) 159 { 160 return addr; 161 } 162 163 int 164 no_op_reg_to_regnum (struct gdbarch *gdbarch, int reg) 165 { 166 return reg; 167 } 168 169 void 170 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym) 171 { 172 return; 173 } 174 175 void 176 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym) 177 { 178 return; 179 } 180 181 int 182 cannot_register_not (struct gdbarch *gdbarch, int regnum) 183 { 184 return 0; 185 } 186 187 /* Legacy version of target_virtual_frame_pointer(). Assumes that 188 there is an gdbarch_deprecated_fp_regnum and that it is the same, 189 cooked or raw. */ 190 191 void 192 legacy_virtual_frame_pointer (struct gdbarch *gdbarch, 193 CORE_ADDR pc, 194 int *frame_regnum, 195 LONGEST *frame_offset) 196 { 197 /* FIXME: cagney/2002-09-13: This code is used when identifying the 198 frame pointer of the current PC. It is assuming that a single 199 register and an offset can determine this. I think it should 200 instead generate a byte code expression as that would work better 201 with things like Dwarf2's CFI. */ 202 if (gdbarch_deprecated_fp_regnum (gdbarch) >= 0 203 && gdbarch_deprecated_fp_regnum (gdbarch) 204 < gdbarch_num_regs (gdbarch)) 205 *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch); 206 else if (gdbarch_sp_regnum (gdbarch) >= 0 207 && gdbarch_sp_regnum (gdbarch) 208 < gdbarch_num_regs (gdbarch)) 209 *frame_regnum = gdbarch_sp_regnum (gdbarch); 210 else 211 /* Should this be an internal error? I guess so, it is reflecting 212 an architectural limitation in the current design. */ 213 internal_error (__FILE__, __LINE__, 214 _("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 377 target description whether it accepts SELECTED as compatible 378 anyway. */ 379 if (tdesc_compatible_p (target_desc, selected)) 380 return from_target; 381 382 warning (_("Selected architecture %s is not compatible " 383 "with reported target architecture %s"), 384 selected->printable_name, from_target->printable_name); 385 return selected; 386 } 387 388 if (compat1 == NULL) 389 return compat2; 390 if (compat2 == NULL) 391 return compat1; 392 if (compat1 == compat2) 393 return compat1; 394 395 /* If the two didn't match, but one of them was a default 396 architecture, assume the more specific one is correct. This 397 handles the case where an executable or target description just 398 says "mips", but the other knows which MIPS variant. */ 399 if (compat1->the_default) 400 return compat2; 401 if (compat2->the_default) 402 return compat1; 403 404 /* We have no idea which one is better. This is a bug, but not 405 a critical problem; warn the user. */ 406 warning (_("Selected architecture %s is ambiguous with " 407 "reported target architecture %s"), 408 selected->printable_name, from_target->printable_name); 409 return selected; 410 } 411 412 /* Functions to manipulate the architecture of the target. */ 413 414 enum set_arch { set_arch_auto, set_arch_manual }; 415 416 static const struct bfd_arch_info *target_architecture_user; 417 418 static const char *set_architecture_string; 419 420 const char * 421 selected_architecture_name (void) 422 { 423 if (target_architecture_user == NULL) 424 return NULL; 425 else 426 return set_architecture_string; 427 } 428 429 /* Called if the user enters ``show architecture'' without an 430 argument. */ 431 432 static void 433 show_architecture (struct ui_file *file, int from_tty, 434 struct cmd_list_element *c, const char *value) 435 { 436 if (target_architecture_user == NULL) 437 fprintf_filtered (file, _("The target architecture is set " 438 "automatically (currently %s)\n"), 439 gdbarch_bfd_arch_info (get_current_arch ())->printable_name); 440 else 441 fprintf_filtered (file, _("The target architecture is assumed to be %s\n"), 442 set_architecture_string); 443 } 444 445 446 /* Called if the user enters ``set architecture'' with or without an 447 argument. */ 448 449 static void 450 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c) 451 { 452 struct gdbarch_info info; 453 454 gdbarch_info_init (&info); 455 456 if (strcmp (set_architecture_string, "auto") == 0) 457 { 458 target_architecture_user = NULL; 459 if (!gdbarch_update_p (info)) 460 internal_error (__FILE__, __LINE__, 461 _("could not select an architecture automatically")); 462 } 463 else 464 { 465 info.bfd_arch_info = bfd_scan_arch (set_architecture_string); 466 if (info.bfd_arch_info == NULL) 467 internal_error (__FILE__, __LINE__, 468 _("set_architecture: bfd_scan_arch failed")); 469 if (gdbarch_update_p (info)) 470 target_architecture_user = info.bfd_arch_info; 471 else 472 printf_unfiltered (_("Architecture `%s' not recognized.\n"), 473 set_architecture_string); 474 } 475 show_architecture (gdb_stdout, from_tty, NULL, NULL); 476 } 477 478 /* Try to select a global architecture that matches "info". Return 479 non-zero if the attempt succeds. */ 480 int 481 gdbarch_update_p (struct gdbarch_info info) 482 { 483 struct gdbarch *new_gdbarch; 484 485 /* Check for the current file. */ 486 if (info.abfd == NULL) 487 info.abfd = exec_bfd; 488 if (info.abfd == NULL) 489 info.abfd = core_bfd; 490 491 /* Check for the current target description. */ 492 if (info.target_desc == NULL) 493 info.target_desc = target_current_description (); 494 495 new_gdbarch = gdbarch_find_by_info (info); 496 497 /* If there no architecture by that name, reject the request. */ 498 if (new_gdbarch == NULL) 499 { 500 if (gdbarch_debug) 501 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " 502 "Architecture not found\n"); 503 return 0; 504 } 505 506 /* If it is the same old architecture, accept the request (but don't 507 swap anything). */ 508 if (new_gdbarch == target_gdbarch) 509 { 510 if (gdbarch_debug) 511 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " 512 "Architecture %s (%s) unchanged\n", 513 host_address_to_string (new_gdbarch), 514 gdbarch_bfd_arch_info (new_gdbarch)->printable_name); 515 return 1; 516 } 517 518 /* It's a new architecture, swap it in. */ 519 if (gdbarch_debug) 520 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " 521 "New architecture %s (%s) selected\n", 522 host_address_to_string (new_gdbarch), 523 gdbarch_bfd_arch_info (new_gdbarch)->printable_name); 524 deprecated_target_gdbarch_select_hack (new_gdbarch); 525 526 return 1; 527 } 528 529 /* Return the architecture for ABFD. If no suitable architecture 530 could be find, return NULL. */ 531 532 struct gdbarch * 533 gdbarch_from_bfd (bfd *abfd) 534 { 535 struct gdbarch_info info; 536 gdbarch_info_init (&info); 537 538 info.abfd = abfd; 539 return gdbarch_find_by_info (info); 540 } 541 542 /* Set the dynamic target-system-dependent parameters (architecture, 543 byte-order) using information found in the BFD */ 544 545 void 546 set_gdbarch_from_file (bfd *abfd) 547 { 548 struct gdbarch_info info; 549 struct gdbarch *gdbarch; 550 551 gdbarch_info_init (&info); 552 info.abfd = abfd; 553 info.target_desc = target_current_description (); 554 gdbarch = gdbarch_find_by_info (info); 555 556 if (gdbarch == NULL) 557 error (_("Architecture of file not recognized.")); 558 deprecated_target_gdbarch_select_hack (gdbarch); 559 } 560 561 /* Initialize the current architecture. Update the ``set 562 architecture'' command so that it specifies a list of valid 563 architectures. */ 564 565 #ifdef DEFAULT_BFD_ARCH 566 extern const bfd_arch_info_type DEFAULT_BFD_ARCH; 567 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH; 568 #else 569 static const bfd_arch_info_type *default_bfd_arch; 570 #endif 571 572 #ifdef DEFAULT_BFD_VEC 573 extern const bfd_target DEFAULT_BFD_VEC; 574 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC; 575 #else 576 static const bfd_target *default_bfd_vec; 577 #endif 578 579 static int default_byte_order = BFD_ENDIAN_UNKNOWN; 580 581 void 582 initialize_current_architecture (void) 583 { 584 const char **arches = gdbarch_printable_names (); 585 struct gdbarch_info info; 586 587 /* determine a default architecture and byte order. */ 588 gdbarch_info_init (&info); 589 590 /* Find a default architecture. */ 591 if (default_bfd_arch == 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 default_bfd_arch = bfd_scan_arch (chosen); 606 if (default_bfd_arch == NULL) 607 internal_error (__FILE__, __LINE__, 608 _("initialize_current_architecture: Arch not found")); 609 } 610 611 info.bfd_arch_info = default_bfd_arch; 612 613 /* Take several guesses at a byte order. */ 614 if (default_byte_order == BFD_ENDIAN_UNKNOWN 615 && default_bfd_vec != NULL) 616 { 617 /* Extract BFD's default vector's byte order. */ 618 switch (default_bfd_vec->byteorder) 619 { 620 case BFD_ENDIAN_BIG: 621 default_byte_order = BFD_ENDIAN_BIG; 622 break; 623 case BFD_ENDIAN_LITTLE: 624 default_byte_order = BFD_ENDIAN_LITTLE; 625 break; 626 default: 627 break; 628 } 629 } 630 if (default_byte_order == BFD_ENDIAN_UNKNOWN) 631 { 632 /* look for ``*el-*'' in the target name. */ 633 const char *chp; 634 chp = strchr (target_name, '-'); 635 if (chp != NULL 636 && chp - 2 >= target_name 637 && strncmp (chp - 2, "el", 2) == 0) 638 default_byte_order = BFD_ENDIAN_LITTLE; 639 } 640 if (default_byte_order == BFD_ENDIAN_UNKNOWN) 641 { 642 /* Wire it to big-endian!!! */ 643 default_byte_order = BFD_ENDIAN_BIG; 644 } 645 646 info.byte_order = default_byte_order; 647 info.byte_order_for_code = info.byte_order; 648 649 if (! gdbarch_update_p (info)) 650 internal_error (__FILE__, __LINE__, 651 _("initialize_current_architecture: Selection of " 652 "initial architecture failed")); 653 654 /* Create the ``set architecture'' command appending ``auto'' to the 655 list of architectures. */ 656 { 657 /* Append ``auto''. */ 658 int nr; 659 for (nr = 0; arches[nr] != NULL; nr++); 660 arches = xrealloc (arches, sizeof (char*) * (nr + 2)); 661 arches[nr + 0] = "auto"; 662 arches[nr + 1] = NULL; 663 add_setshow_enum_cmd ("architecture", class_support, 664 arches, &set_architecture_string, 665 _("Set architecture of target."), 666 _("Show architecture of target."), NULL, 667 set_architecture, show_architecture, 668 &setlist, &showlist); 669 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist); 670 } 671 } 672 673 674 /* Initialize a gdbarch info to values that will be automatically 675 overridden. Note: Originally, this ``struct info'' was initialized 676 using memset(0). Unfortunately, that ran into problems, namely 677 BFD_ENDIAN_BIG is zero. An explicit initialization function that 678 can explicitly set each field to a well defined value is used. */ 679 680 void 681 gdbarch_info_init (struct gdbarch_info *info) 682 { 683 memset (info, 0, sizeof (struct gdbarch_info)); 684 info->byte_order = BFD_ENDIAN_UNKNOWN; 685 info->byte_order_for_code = info->byte_order; 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 global "set ..." options and explicitly 691 initialized INFO fields. */ 692 693 void 694 gdbarch_info_fill (struct gdbarch_info *info) 695 { 696 /* "(gdb) set architecture ...". */ 697 if (info->bfd_arch_info == NULL 698 && target_architecture_user) 699 info->bfd_arch_info = target_architecture_user; 700 /* From the file. */ 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 /* From the target. */ 707 if (info->target_desc != NULL) 708 info->bfd_arch_info = choose_architecture_for_target 709 (info->target_desc, info->bfd_arch_info); 710 /* From the default. */ 711 if (info->bfd_arch_info == NULL) 712 info->bfd_arch_info = default_bfd_arch; 713 714 /* "(gdb) set byte-order ...". */ 715 if (info->byte_order == BFD_ENDIAN_UNKNOWN 716 && target_byte_order_user != BFD_ENDIAN_UNKNOWN) 717 info->byte_order = target_byte_order_user; 718 /* From the INFO struct. */ 719 if (info->byte_order == BFD_ENDIAN_UNKNOWN 720 && info->abfd != NULL) 721 info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG 722 : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE 723 : BFD_ENDIAN_UNKNOWN); 724 /* From the default. */ 725 if (info->byte_order == BFD_ENDIAN_UNKNOWN) 726 info->byte_order = default_byte_order; 727 info->byte_order_for_code = info->byte_order; 728 729 /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */ 730 /* From the manual override, or from file. */ 731 if (info->osabi == GDB_OSABI_UNINITIALIZED) 732 info->osabi = gdbarch_lookup_osabi (info->abfd); 733 /* From the target. */ 734 if (info->osabi == GDB_OSABI_UNKNOWN && info->target_desc != NULL) 735 info->osabi = tdesc_osabi (info->target_desc); 736 /* From the configured default. */ 737 #ifdef GDB_OSABI_DEFAULT 738 if (info->osabi == GDB_OSABI_UNKNOWN) 739 info->osabi = GDB_OSABI_DEFAULT; 740 #endif 741 742 /* Must have at least filled in the architecture. */ 743 gdb_assert (info->bfd_arch_info != NULL); 744 } 745 746 /* Return "current" architecture. If the target is running, this is 747 the architecture of the selected frame. Otherwise, the "current" 748 architecture defaults to the target architecture. 749 750 This function should normally be called solely by the command 751 interpreter routines to determine the architecture to execute a 752 command in. */ 753 struct gdbarch * 754 get_current_arch (void) 755 { 756 if (has_stack_frames ()) 757 return get_frame_arch (get_selected_frame (NULL)); 758 else 759 return target_gdbarch; 760 } 761 762 int 763 default_has_shared_address_space (struct gdbarch *gdbarch) 764 { 765 /* Simply say no. In most unix-like targets each inferior/process 766 has its own address space. */ 767 return 0; 768 } 769 770 int 771 default_fast_tracepoint_valid_at (struct gdbarch *gdbarch, 772 CORE_ADDR addr, int *isize, char **msg) 773 { 774 /* We don't know if maybe the target has some way to do fast 775 tracepoints that doesn't need gdbarch, so always say yes. */ 776 if (msg) 777 *msg = NULL; 778 return 1; 779 } 780 781 void 782 default_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, 783 int *kindptr) 784 { 785 gdbarch_breakpoint_from_pc (gdbarch, pcptr, kindptr); 786 } 787 788 void 789 default_gen_return_address (struct gdbarch *gdbarch, 790 struct agent_expr *ax, struct axs_value *value, 791 CORE_ADDR scope) 792 { 793 error (_("This architecture has no method to collect a return address.")); 794 } 795 796 /* */ 797 798 /* -Wmissing-prototypes */ 799 extern initialize_file_ftype _initialize_gdbarch_utils; 800 801 void 802 _initialize_gdbarch_utils (void) 803 { 804 add_setshow_enum_cmd ("endian", class_support, 805 endian_enum, &set_endian_string, 806 _("Set endianness of target."), 807 _("Show endianness of target."), 808 NULL, set_endian, show_endian, 809 &setlist, &showlist); 810 } 811