1# Dynamic architecture support for GDB, the GNU debugger. 2 3# Copyright (C) 1998-2023 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# How to add to gdbarch: 21# 22# There are four kinds of fields in gdbarch: 23# 24# * Info - you should never need this; it is only for things that are 25# copied directly from the gdbarch_info. 26# 27# * Value - a variable. 28# 29# * Function - a function pointer. 30# 31# * Method - a function pointer, but the function takes a gdbarch as 32# its first parameter. 33# 34# You construct a new one with a call to one of those functions. So, 35# for instance, you can use the function named "Value" to make a new 36# Value. 37# 38# All parameters are keyword-only. This is done to help catch typos. 39# 40# Some parameters are shared among all types (including Info): 41# 42# * "name" - required, the name of the field. 43# 44# * "type" - required, the type of the field. For functions and 45# methods, this is the return type. 46# 47# * "printer" - an expression to turn this field into a 'const char 48# *'. This is used for dumping. The string must live long enough to 49# be passed to printf. 50# 51# Value, Function, and Method share some more parameters. Some of 52# these work in conjunction in a somewhat complicated way, so they are 53# described in a separate sub-section below. 54# 55# * "comment" - a comment that's written to the .h file. Please 56# always use this. (It isn't currently a required option for 57# historical reasons.) 58# 59# * "predicate" - a boolean, if True then a _p predicate function will 60# be generated. The predicate will use the generic validation 61# function for the field. See below. 62# 63# * "predefault", "postdefault", and "invalid" - These are used for 64# the initialization and verification steps: 65# 66# A gdbarch is zero-initialized. Then, if a field has a pre-default, 67# the field is set to that value. After initialization is complete 68# (that is, after the tdep code has a chance to change the settings), 69# the post-initialization step is done. 70# 71# There is a generic algorithm to generate a "validation function" for 72# all fields. If the field has an "invalid" attribute with a string 73# value, then this string is the expression (note that a string-valued 74# "invalid" and "predicate" are mutually exclusive; and the case where 75# invalid is True means to ignore this field and instead use the 76# default checking that is about to be described). Otherwise, if 77# there is a "predefault", then the field is valid if it differs from 78# the predefault. Otherwise, the check is done against 0 (really NULL 79# for function pointers, but same idea). 80# 81# In post-initialization / validation, there are several cases. 82# 83# * If "invalid" is False, or if the field specifies "predicate", 84# validation is skipped. Otherwise, a validation step is emitted. 85# 86# * Otherwise, the validity is checked using the usual validation 87# function (see above). If the field is considered valid, nothing is 88# done. 89# 90# * Otherwise, the field's value is invalid. If there is a 91# "postdefault", then the field is assigned that value. 92# 93# * Otherwise, the gdbarch will fail validation and gdb will crash. 94# 95# Function and Method share: 96# 97# * "params" - required, a tuple of tuples. Each inner tuple is a 98# pair of the form (TYPE, NAME), where TYPE is the type of this 99# argument, and NAME is the name. Note that while the names could be 100# auto-generated, this approach lets the "comment" field refer to 101# arguments in a nicer way. It is also just nicer for users. 102# 103# * "param_checks" - optional, a list of strings. Each string is an 104# expression that is placed within a gdb_assert before the call is 105# made to the Function/Method implementation. Each expression is 106# something that should be true, and it is expected that the 107# expression will make use of the parameters named in 'params' (though 108# this is not required). 109# 110# * "result_checks" - optional, a list of strings. Each string is an 111# expression that is placed within a gdb_assert after the call to the 112# Function/Method implementation. Within each expression the variable 113# 'result' can be used to reference the result of the function/method 114# implementation. The 'result_checks' can only be used if the 'type' 115# of this Function/Method is not 'void'. 116 117Info( 118 type="const struct bfd_arch_info *", 119 name="bfd_arch_info", 120 printer="gdbarch_bfd_arch_info (gdbarch)->printable_name", 121) 122 123Info( 124 type="enum bfd_endian", 125 name="byte_order", 126) 127 128Info( 129 type="enum bfd_endian", 130 name="byte_order_for_code", 131) 132 133Info( 134 type="enum gdb_osabi", 135 name="osabi", 136) 137 138Info( 139 type="const struct target_desc *", 140 name="target_desc", 141 printer="host_address_to_string (gdbarch->target_desc)", 142) 143 144Value( 145 comment=""" 146Number of bits in a short or unsigned short for the target machine. 147""", 148 type="int", 149 name="short_bit", 150 predefault="2*TARGET_CHAR_BIT", 151 invalid=False, 152) 153 154int_bit = Value( 155 comment=""" 156Number of bits in an int or unsigned int for the target machine. 157""", 158 type="int", 159 name="int_bit", 160 predefault="4*TARGET_CHAR_BIT", 161 invalid=False, 162) 163 164long_bit = Value( 165 comment=""" 166Number of bits in a long or unsigned long for the target machine. 167""", 168 type="int", 169 name="long_bit", 170 predefault="4*TARGET_CHAR_BIT", 171 invalid=False, 172) 173 174Value( 175 comment=""" 176Number of bits in a long long or unsigned long long for the target 177machine. 178""", 179 type="int", 180 name="long_long_bit", 181 predefault="2*" + long_bit.predefault, 182 invalid=False, 183) 184 185Value( 186 comment=""" 187The ABI default bit-size and format for "bfloat16", "half", "float", "double", and 188"long double". These bit/format pairs should eventually be combined 189into a single object. For the moment, just initialize them as a pair. 190Each format describes both the big and little endian layouts (if 191useful). 192""", 193 type="int", 194 name="bfloat16_bit", 195 predefault="2*TARGET_CHAR_BIT", 196 invalid=False, 197) 198 199Value( 200 type="const struct floatformat **", 201 name="bfloat16_format", 202 postdefault="floatformats_bfloat16", 203 invalid=True, 204 printer="pformat (gdbarch, gdbarch->bfloat16_format)", 205) 206 207Value( 208 type="int", 209 name="half_bit", 210 predefault="2*TARGET_CHAR_BIT", 211 invalid=False, 212) 213 214Value( 215 type="const struct floatformat **", 216 name="half_format", 217 postdefault="floatformats_ieee_half", 218 invalid=True, 219 printer="pformat (gdbarch, gdbarch->half_format)", 220) 221 222Value( 223 type="int", 224 name="float_bit", 225 predefault="4*TARGET_CHAR_BIT", 226 invalid=False, 227) 228 229Value( 230 type="const struct floatformat **", 231 name="float_format", 232 postdefault="floatformats_ieee_single", 233 invalid=True, 234 printer="pformat (gdbarch, gdbarch->float_format)", 235) 236 237Value( 238 type="int", 239 name="double_bit", 240 predefault="8*TARGET_CHAR_BIT", 241 invalid=False, 242) 243 244Value( 245 type="const struct floatformat **", 246 name="double_format", 247 postdefault="floatformats_ieee_double", 248 invalid=True, 249 printer="pformat (gdbarch, gdbarch->double_format)", 250) 251 252Value( 253 type="int", 254 name="long_double_bit", 255 predefault="8*TARGET_CHAR_BIT", 256 invalid=False, 257) 258 259Value( 260 type="const struct floatformat **", 261 name="long_double_format", 262 postdefault="floatformats_ieee_double", 263 invalid=True, 264 printer="pformat (gdbarch, gdbarch->long_double_format)", 265) 266 267Value( 268 comment=""" 269The ABI default bit-size for "wchar_t". wchar_t is a built-in type 270starting with C++11. 271""", 272 type="int", 273 name="wchar_bit", 274 predefault="4*TARGET_CHAR_BIT", 275 invalid=False, 276) 277 278Value( 279 comment=""" 280One if `wchar_t' is signed, zero if unsigned. 281""", 282 type="int", 283 name="wchar_signed", 284 predefault="-1", 285 postdefault="1", 286 invalid=True, 287) 288 289Method( 290 comment=""" 291Returns the floating-point format to be used for values of length LENGTH. 292NAME, if non-NULL, is the type name, which may be used to distinguish 293different target formats of the same length. 294""", 295 type="const struct floatformat **", 296 name="floatformat_for_type", 297 params=[("const char *", "name"), ("int", "length")], 298 predefault="default_floatformat_for_type", 299 invalid=False, 300) 301 302Value( 303 comment=""" 304For most targets, a pointer on the target and its representation as an 305address in GDB have the same size and "look the same". For such a 306target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit 307/ addr_bit will be set from it. 308 309If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably 310also need to set gdbarch_dwarf2_addr_size, gdbarch_pointer_to_address and 311gdbarch_address_to_pointer as well. 312 313ptr_bit is the size of a pointer on the target 314""", 315 type="int", 316 name="ptr_bit", 317 predefault=int_bit.predefault, 318 invalid=False, 319) 320 321Value( 322 comment=""" 323addr_bit is the size of a target address as represented in gdb 324""", 325 type="int", 326 name="addr_bit", 327 predefault="0", 328 postdefault="gdbarch_ptr_bit (gdbarch)", 329 invalid=True, 330) 331 332Value( 333 comment=""" 334dwarf2_addr_size is the target address size as used in the Dwarf debug 335info. For .debug_frame FDEs, this is supposed to be the target address 336size from the associated CU header, and which is equivalent to the 337DWARF2_ADDR_SIZE as defined by the target specific GCC back-end. 338Unfortunately there is no good way to determine this value. Therefore 339dwarf2_addr_size simply defaults to the target pointer size. 340 341dwarf2_addr_size is not used for .eh_frame FDEs, which are generally 342defined using the target's pointer size so far. 343 344Note that dwarf2_addr_size only needs to be redefined by a target if the 345GCC back-end defines a DWARF2_ADDR_SIZE other than the target pointer size, 346and if Dwarf versions < 4 need to be supported. 347""", 348 type="int", 349 name="dwarf2_addr_size", 350 predefault="0", 351 postdefault="gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT", 352 invalid=True, 353) 354 355Value( 356 comment=""" 357One if `char' acts like `signed char', zero if `unsigned char'. 358""", 359 type="int", 360 name="char_signed", 361 predefault="-1", 362 postdefault="1", 363 invalid=True, 364) 365 366Function( 367 type="CORE_ADDR", 368 name="read_pc", 369 params=[("readable_regcache *", "regcache")], 370 predicate=True, 371 invalid=True, 372) 373 374Function( 375 type="void", 376 name="write_pc", 377 params=[("struct regcache *", "regcache"), ("CORE_ADDR", "val")], 378 predicate=True, 379 invalid=True, 380) 381 382Method( 383 comment=""" 384Function for getting target's idea of a frame pointer. FIXME: GDB's 385whole scheme for dealing with "frames" and "frame pointers" needs a 386serious shakedown. 387""", 388 type="void", 389 name="virtual_frame_pointer", 390 params=[ 391 ("CORE_ADDR", "pc"), 392 ("int *", "frame_regnum"), 393 ("LONGEST *", "frame_offset"), 394 ], 395 predefault="legacy_virtual_frame_pointer", 396 invalid=False, 397) 398 399Method( 400 type="enum register_status", 401 name="pseudo_register_read", 402 params=[ 403 ("readable_regcache *", "regcache"), 404 ("int", "cookednum"), 405 ("gdb_byte *", "buf"), 406 ], 407 predicate=True, 408 invalid=True, 409) 410 411Method( 412 comment=""" 413Read a register into a new struct value. If the register is wholly 414or partly unavailable, this should call mark_value_bytes_unavailable 415as appropriate. If this is defined, then pseudo_register_read will 416never be called. 417""", 418 type="struct value *", 419 name="pseudo_register_read_value", 420 params=[("readable_regcache *", "regcache"), ("int", "cookednum")], 421 predicate=True, 422 invalid=True, 423) 424 425Method( 426 type="void", 427 name="pseudo_register_write", 428 params=[ 429 ("struct regcache *", "regcache"), 430 ("int", "cookednum"), 431 ("const gdb_byte *", "buf"), 432 ], 433 predicate=True, 434 invalid=True, 435) 436 437Value( 438 type="int", 439 name="num_regs", 440 predefault="-1", 441 invalid=True, 442) 443 444Value( 445 comment=""" 446This macro gives the number of pseudo-registers that live in the 447register namespace but do not get fetched or stored on the target. 448These pseudo-registers may be aliases for other registers, 449combinations of other registers, or they may be computed by GDB. 450""", 451 type="int", 452 name="num_pseudo_regs", 453 predefault="0", 454 invalid=False, 455) 456 457Method( 458 comment=""" 459Assemble agent expression bytecode to collect pseudo-register REG. 460Return -1 if something goes wrong, 0 otherwise. 461""", 462 type="int", 463 name="ax_pseudo_register_collect", 464 params=[("struct agent_expr *", "ax"), ("int", "reg")], 465 predicate=True, 466 invalid=True, 467) 468 469Method( 470 comment=""" 471Assemble agent expression bytecode to push the value of pseudo-register 472REG on the interpreter stack. 473Return -1 if something goes wrong, 0 otherwise. 474""", 475 type="int", 476 name="ax_pseudo_register_push_stack", 477 params=[("struct agent_expr *", "ax"), ("int", "reg")], 478 predicate=True, 479 invalid=True, 480) 481 482Method( 483 comment=""" 484Some architectures can display additional information for specific 485signals. 486UIOUT is the output stream where the handler will place information. 487""", 488 type="void", 489 name="report_signal_info", 490 params=[("struct ui_out *", "uiout"), ("enum gdb_signal", "siggnal")], 491 predicate=True, 492 invalid=True, 493) 494 495Value( 496 comment=""" 497GDB's standard (or well known) register numbers. These can map onto 498a real register or a pseudo (computed) register or not be defined at 499all (-1). 500gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP. 501""", 502 type="int", 503 name="sp_regnum", 504 predefault="-1", 505 invalid=False, 506) 507 508Value( 509 type="int", 510 name="pc_regnum", 511 predefault="-1", 512 invalid=False, 513) 514 515Value( 516 type="int", 517 name="ps_regnum", 518 predefault="-1", 519 invalid=False, 520) 521 522Value( 523 type="int", 524 name="fp0_regnum", 525 predefault="-1", 526 invalid=False, 527) 528 529Method( 530 comment=""" 531Convert stab register number (from `r' declaration) to a gdb REGNUM. 532""", 533 type="int", 534 name="stab_reg_to_regnum", 535 params=[("int", "stab_regnr")], 536 predefault="no_op_reg_to_regnum", 537 invalid=False, 538) 539 540Method( 541 comment=""" 542Provide a default mapping from a ecoff register number to a gdb REGNUM. 543""", 544 type="int", 545 name="ecoff_reg_to_regnum", 546 params=[("int", "ecoff_regnr")], 547 predefault="no_op_reg_to_regnum", 548 invalid=False, 549) 550 551Method( 552 comment=""" 553Convert from an sdb register number to an internal gdb register number. 554""", 555 type="int", 556 name="sdb_reg_to_regnum", 557 params=[("int", "sdb_regnr")], 558 predefault="no_op_reg_to_regnum", 559 invalid=False, 560) 561 562Method( 563 comment=""" 564Provide a default mapping from a DWARF2 register number to a gdb REGNUM. 565Return -1 for bad REGNUM. Note: Several targets get this wrong. 566""", 567 type="int", 568 name="dwarf2_reg_to_regnum", 569 params=[("int", "dwarf2_regnr")], 570 predefault="no_op_reg_to_regnum", 571 invalid=False, 572) 573 574Method( 575 comment=""" 576Return the name of register REGNR for the specified architecture. 577REGNR can be any value greater than, or equal to zero, and less than 578'gdbarch_num_cooked_regs (GDBARCH)'. If REGNR is not supported for 579GDBARCH, then this function will return an empty string, this function 580should never return nullptr. 581""", 582 type="const char *", 583 name="register_name", 584 params=[("int", "regnr")], 585 param_checks=["regnr >= 0", "regnr < gdbarch_num_cooked_regs (gdbarch)"], 586 result_checks=["result != nullptr"], 587 predefault="0", 588 invalid=True, 589) 590 591Method( 592 comment=""" 593Return the type of a register specified by the architecture. Only 594the register cache should call this function directly; others should 595use "register_type". 596""", 597 type="struct type *", 598 name="register_type", 599 params=[("int", "reg_nr")], 600 invalid=True, 601) 602 603Method( 604 comment=""" 605Generate a dummy frame_id for THIS_FRAME assuming that the frame is 606a dummy frame. A dummy frame is created before an inferior call, 607the frame_id returned here must match the frame_id that was built 608for the inferior call. Usually this means the returned frame_id's 609stack address should match the address returned by 610gdbarch_push_dummy_call, and the returned frame_id's code address 611should match the address at which the breakpoint was set in the dummy 612frame. 613""", 614 type="struct frame_id", 615 name="dummy_id", 616 params=[("frame_info_ptr", "this_frame")], 617 predefault="default_dummy_id", 618 invalid=False, 619) 620 621Value( 622 comment=""" 623Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete 624deprecated_fp_regnum. 625""", 626 type="int", 627 name="deprecated_fp_regnum", 628 predefault="-1", 629 invalid=False, 630) 631 632Method( 633 type="CORE_ADDR", 634 name="push_dummy_call", 635 params=[ 636 ("struct value *", "function"), 637 ("struct regcache *", "regcache"), 638 ("CORE_ADDR", "bp_addr"), 639 ("int", "nargs"), 640 ("struct value **", "args"), 641 ("CORE_ADDR", "sp"), 642 ("function_call_return_method", "return_method"), 643 ("CORE_ADDR", "struct_addr"), 644 ], 645 predicate=True, 646 invalid=True, 647) 648 649Value( 650 type="enum call_dummy_location_type", 651 name="call_dummy_location", 652 predefault="AT_ENTRY_POINT", 653 invalid=False, 654) 655 656Method( 657 type="CORE_ADDR", 658 name="push_dummy_code", 659 params=[ 660 ("CORE_ADDR", "sp"), 661 ("CORE_ADDR", "funaddr"), 662 ("struct value **", "args"), 663 ("int", "nargs"), 664 ("struct type *", "value_type"), 665 ("CORE_ADDR *", "real_pc"), 666 ("CORE_ADDR *", "bp_addr"), 667 ("struct regcache *", "regcache"), 668 ], 669 predicate=True, 670 invalid=True, 671) 672 673Method( 674 comment=""" 675Return true if the code of FRAME is writable. 676""", 677 type="int", 678 name="code_of_frame_writable", 679 params=[("frame_info_ptr", "frame")], 680 predefault="default_code_of_frame_writable", 681 invalid=False, 682) 683 684Method( 685 type="void", 686 name="print_registers_info", 687 params=[ 688 ("struct ui_file *", "file"), 689 ("frame_info_ptr", "frame"), 690 ("int", "regnum"), 691 ("int", "all"), 692 ], 693 predefault="default_print_registers_info", 694 invalid=False, 695) 696 697Method( 698 type="void", 699 name="print_float_info", 700 params=[ 701 ("struct ui_file *", "file"), 702 ("frame_info_ptr", "frame"), 703 ("const char *", "args"), 704 ], 705 predefault="default_print_float_info", 706 invalid=False, 707) 708 709Method( 710 type="void", 711 name="print_vector_info", 712 params=[ 713 ("struct ui_file *", "file"), 714 ("frame_info_ptr", "frame"), 715 ("const char *", "args"), 716 ], 717 predicate=True, 718 invalid=True, 719) 720 721Method( 722 comment=""" 723MAP a GDB RAW register number onto a simulator register number. See 724also include/...-sim.h. 725""", 726 type="int", 727 name="register_sim_regno", 728 params=[("int", "reg_nr")], 729 predefault="legacy_register_sim_regno", 730 invalid=False, 731) 732 733Method( 734 type="int", 735 name="cannot_fetch_register", 736 params=[("int", "regnum")], 737 predefault="cannot_register_not", 738 invalid=False, 739) 740 741Method( 742 type="int", 743 name="cannot_store_register", 744 params=[("int", "regnum")], 745 predefault="cannot_register_not", 746 invalid=False, 747) 748 749Function( 750 comment=""" 751Determine the address where a longjmp will land and save this address 752in PC. Return nonzero on success. 753 754FRAME corresponds to the longjmp frame. 755""", 756 type="int", 757 name="get_longjmp_target", 758 params=[("frame_info_ptr", "frame"), ("CORE_ADDR *", "pc")], 759 predicate=True, 760 invalid=True, 761) 762 763Value( 764 type="int", 765 name="believe_pcc_promotion", 766 invalid=False, 767) 768 769Method( 770 type="int", 771 name="convert_register_p", 772 params=[("int", "regnum"), ("struct type *", "type")], 773 predefault="generic_convert_register_p", 774 invalid=False, 775) 776 777Function( 778 type="int", 779 name="register_to_value", 780 params=[ 781 ("frame_info_ptr", "frame"), 782 ("int", "regnum"), 783 ("struct type *", "type"), 784 ("gdb_byte *", "buf"), 785 ("int *", "optimizedp"), 786 ("int *", "unavailablep"), 787 ], 788 invalid=False, 789) 790 791Function( 792 type="void", 793 name="value_to_register", 794 params=[ 795 ("frame_info_ptr", "frame"), 796 ("int", "regnum"), 797 ("struct type *", "type"), 798 ("const gdb_byte *", "buf"), 799 ], 800 invalid=False, 801) 802 803Method( 804 comment=""" 805Construct a value representing the contents of register REGNUM in 806frame FRAME_ID, interpreted as type TYPE. The routine needs to 807allocate and return a struct value with all value attributes 808(but not the value contents) filled in. 809""", 810 type="struct value *", 811 name="value_from_register", 812 params=[ 813 ("struct type *", "type"), 814 ("int", "regnum"), 815 ("struct frame_id", "frame_id"), 816 ], 817 predefault="default_value_from_register", 818 invalid=False, 819) 820 821Method( 822 type="CORE_ADDR", 823 name="pointer_to_address", 824 params=[("struct type *", "type"), ("const gdb_byte *", "buf")], 825 predefault="unsigned_pointer_to_address", 826 invalid=False, 827) 828 829Method( 830 type="void", 831 name="address_to_pointer", 832 params=[("struct type *", "type"), ("gdb_byte *", "buf"), ("CORE_ADDR", "addr")], 833 predefault="unsigned_address_to_pointer", 834 invalid=False, 835) 836 837Method( 838 type="CORE_ADDR", 839 name="integer_to_address", 840 params=[("struct type *", "type"), ("const gdb_byte *", "buf")], 841 predicate=True, 842 invalid=True, 843) 844 845Method( 846 comment=""" 847Return the return-value convention that will be used by FUNCTION 848to return a value of type VALTYPE. FUNCTION may be NULL in which 849case the return convention is computed based only on VALTYPE. 850 851If READBUF is not NULL, extract the return value and save it in this buffer. 852 853If WRITEBUF is not NULL, it contains a return value which will be 854stored into the appropriate register. This can be used when we want 855to force the value returned by a function (see the "return" command 856for instance). 857""", 858 type="enum return_value_convention", 859 name="return_value", 860 params=[ 861 ("struct value *", "function"), 862 ("struct type *", "valtype"), 863 ("struct regcache *", "regcache"), 864 ("gdb_byte *", "readbuf"), 865 ("const gdb_byte *", "writebuf"), 866 ], 867 predicate=True, 868 invalid=True, 869) 870 871Function( 872 comment=""" 873Return the address at which the value being returned from 874the current function will be stored. This routine is only 875called if the current function uses the the "struct return 876convention". 877 878May return 0 when unable to determine that address.""", 879 type="CORE_ADDR", 880 name="get_return_buf_addr", 881 params=[("struct type *", "val_type"), ("frame_info_ptr", "cur_frame")], 882 predefault="default_get_return_buf_addr", 883 invalid=False, 884) 885 886Method( 887 comment=""" 888Return true if the return value of function is stored in the first hidden 889parameter. In theory, this feature should be language-dependent, specified 890by language and its ABI, such as C++. Unfortunately, compiler may 891implement it to a target-dependent feature. So that we need such hook here 892to be aware of this in GDB. 893""", 894 type="int", 895 name="return_in_first_hidden_param_p", 896 params=[("struct type *", "type")], 897 predefault="default_return_in_first_hidden_param_p", 898 invalid=False, 899) 900 901Method( 902 type="CORE_ADDR", 903 name="skip_prologue", 904 params=[("CORE_ADDR", "ip")], 905 predefault="0", 906 invalid=True, 907) 908 909Method( 910 type="CORE_ADDR", 911 name="skip_main_prologue", 912 params=[("CORE_ADDR", "ip")], 913 predicate=True, 914 invalid=True, 915) 916 917Method( 918 comment=""" 919On some platforms, a single function may provide multiple entry points, 920e.g. one that is used for function-pointer calls and a different one 921that is used for direct function calls. 922In order to ensure that breakpoints set on the function will trigger 923no matter via which entry point the function is entered, a platform 924may provide the skip_entrypoint callback. It is called with IP set 925to the main entry point of a function (as determined by the symbol table), 926and should return the address of the innermost entry point, where the 927actual breakpoint needs to be set. Note that skip_entrypoint is used 928by GDB common code even when debugging optimized code, where skip_prologue 929is not used. 930""", 931 type="CORE_ADDR", 932 name="skip_entrypoint", 933 params=[("CORE_ADDR", "ip")], 934 predicate=True, 935 invalid=True, 936) 937 938Function( 939 type="int", 940 name="inner_than", 941 params=[("CORE_ADDR", "lhs"), ("CORE_ADDR", "rhs")], 942 predefault="0", 943 invalid=True, 944) 945 946Method( 947 type="const gdb_byte *", 948 name="breakpoint_from_pc", 949 params=[("CORE_ADDR *", "pcptr"), ("int *", "lenptr")], 950 predefault="default_breakpoint_from_pc", 951 invalid=False, 952) 953 954Method( 955 comment=""" 956Return the breakpoint kind for this target based on *PCPTR. 957""", 958 type="int", 959 name="breakpoint_kind_from_pc", 960 params=[("CORE_ADDR *", "pcptr")], 961 predefault="0", 962 invalid=True, 963) 964 965Method( 966 comment=""" 967Return the software breakpoint from KIND. KIND can have target 968specific meaning like the Z0 kind parameter. 969SIZE is set to the software breakpoint's length in memory. 970""", 971 type="const gdb_byte *", 972 name="sw_breakpoint_from_kind", 973 params=[("int", "kind"), ("int *", "size")], 974 predefault="NULL", 975 invalid=False, 976) 977 978Method( 979 comment=""" 980Return the breakpoint kind for this target based on the current 981processor state (e.g. the current instruction mode on ARM) and the 982*PCPTR. In default, it is gdbarch->breakpoint_kind_from_pc. 983""", 984 type="int", 985 name="breakpoint_kind_from_current_state", 986 params=[("struct regcache *", "regcache"), ("CORE_ADDR *", "pcptr")], 987 predefault="default_breakpoint_kind_from_current_state", 988 invalid=False, 989) 990 991Method( 992 type="CORE_ADDR", 993 name="adjust_breakpoint_address", 994 params=[("CORE_ADDR", "bpaddr")], 995 predicate=True, 996 invalid=True, 997) 998 999Method( 1000 type="int", 1001 name="memory_insert_breakpoint", 1002 params=[("struct bp_target_info *", "bp_tgt")], 1003 predefault="default_memory_insert_breakpoint", 1004 invalid=False, 1005) 1006 1007Method( 1008 type="int", 1009 name="memory_remove_breakpoint", 1010 params=[("struct bp_target_info *", "bp_tgt")], 1011 predefault="default_memory_remove_breakpoint", 1012 invalid=False, 1013) 1014 1015Value( 1016 type="CORE_ADDR", 1017 name="decr_pc_after_break", 1018 invalid=False, 1019) 1020 1021Value( 1022 comment=""" 1023A function can be addressed by either it's "pointer" (possibly a 1024descriptor address) or "entry point" (first executable instruction). 1025The method "convert_from_func_ptr_addr" converting the former to the 1026latter. gdbarch_deprecated_function_start_offset is being used to implement 1027a simplified subset of that functionality - the function's address 1028corresponds to the "function pointer" and the function's start 1029corresponds to the "function entry point" - and hence is redundant. 1030""", 1031 type="CORE_ADDR", 1032 name="deprecated_function_start_offset", 1033 invalid=False, 1034) 1035 1036Method( 1037 comment=""" 1038Return the remote protocol register number associated with this 1039register. Normally the identity mapping. 1040""", 1041 type="int", 1042 name="remote_register_number", 1043 params=[("int", "regno")], 1044 predefault="default_remote_register_number", 1045 invalid=False, 1046) 1047 1048Function( 1049 comment=""" 1050Fetch the target specific address used to represent a load module. 1051""", 1052 type="CORE_ADDR", 1053 name="fetch_tls_load_module_address", 1054 params=[("struct objfile *", "objfile")], 1055 predicate=True, 1056 invalid=True, 1057) 1058 1059Method( 1060 comment=""" 1061Return the thread-local address at OFFSET in the thread-local 1062storage for the thread PTID and the shared library or executable 1063file given by LM_ADDR. If that block of thread-local storage hasn't 1064been allocated yet, this function may throw an error. LM_ADDR may 1065be zero for statically linked multithreaded inferiors. 1066""", 1067 type="CORE_ADDR", 1068 name="get_thread_local_address", 1069 params=[("ptid_t", "ptid"), ("CORE_ADDR", "lm_addr"), ("CORE_ADDR", "offset")], 1070 predicate=True, 1071 invalid=True, 1072) 1073 1074Value( 1075 type="CORE_ADDR", 1076 name="frame_args_skip", 1077 invalid=False, 1078) 1079 1080Method( 1081 type="CORE_ADDR", 1082 name="unwind_pc", 1083 params=[("frame_info_ptr", "next_frame")], 1084 predefault="default_unwind_pc", 1085 invalid=False, 1086) 1087 1088Method( 1089 type="CORE_ADDR", 1090 name="unwind_sp", 1091 params=[("frame_info_ptr", "next_frame")], 1092 predefault="default_unwind_sp", 1093 invalid=False, 1094) 1095 1096Function( 1097 comment=""" 1098DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame 1099frame-base. Enable frame-base before frame-unwind. 1100""", 1101 type="int", 1102 name="frame_num_args", 1103 params=[("frame_info_ptr", "frame")], 1104 predicate=True, 1105 invalid=True, 1106) 1107 1108Method( 1109 type="CORE_ADDR", 1110 name="frame_align", 1111 params=[("CORE_ADDR", "address")], 1112 predicate=True, 1113 invalid=True, 1114) 1115 1116Method( 1117 type="int", 1118 name="stabs_argument_has_addr", 1119 params=[("struct type *", "type")], 1120 predefault="default_stabs_argument_has_addr", 1121 invalid=False, 1122) 1123 1124Value( 1125 type="int", 1126 name="frame_red_zone_size", 1127 invalid=False, 1128) 1129 1130Method( 1131 type="CORE_ADDR", 1132 name="convert_from_func_ptr_addr", 1133 params=[("CORE_ADDR", "addr"), ("struct target_ops *", "targ")], 1134 predefault="convert_from_func_ptr_addr_identity", 1135 invalid=False, 1136) 1137 1138Method( 1139 comment=""" 1140On some machines there are bits in addresses which are not really 1141part of the address, but are used by the kernel, the hardware, etc. 1142for special purposes. gdbarch_addr_bits_remove takes out any such bits so 1143we get a "real" address such as one would find in a symbol table. 1144This is used only for addresses of instructions, and even then I'm 1145not sure it's used in all contexts. It exists to deal with there 1146being a few stray bits in the PC which would mislead us, not as some 1147sort of generic thing to handle alignment or segmentation (it's 1148possible it should be in TARGET_READ_PC instead). 1149""", 1150 type="CORE_ADDR", 1151 name="addr_bits_remove", 1152 params=[("CORE_ADDR", "addr")], 1153 predefault="core_addr_identity", 1154 invalid=False, 1155) 1156 1157Method( 1158 comment=""" 1159On some architectures, not all bits of a pointer are significant. 1160On AArch64, for example, the top bits of a pointer may carry a "tag", which 1161can be ignored by the kernel and the hardware. The "tag" can be regarded as 1162additional data associated with the pointer, but it is not part of the address. 1163 1164Given a pointer for the architecture, this hook removes all the 1165non-significant bits and sign-extends things as needed. It gets used to remove 1166non-address bits from data pointers (for example, removing the AArch64 MTE tag 1167bits from a pointer) and from code pointers (removing the AArch64 PAC signature 1168from a pointer containing the return address). 1169""", 1170 type="CORE_ADDR", 1171 name="remove_non_address_bits", 1172 params=[("CORE_ADDR", "pointer")], 1173 predefault="default_remove_non_address_bits", 1174 invalid=False, 1175) 1176 1177Method( 1178 comment=""" 1179Return a string representation of the memory tag TAG. 1180""", 1181 type="std::string", 1182 name="memtag_to_string", 1183 params=[("struct value *", "tag")], 1184 predefault="default_memtag_to_string", 1185 invalid=False, 1186) 1187 1188Method( 1189 comment=""" 1190Return true if ADDRESS contains a tag and false otherwise. ADDRESS 1191must be either a pointer or a reference type. 1192""", 1193 type="bool", 1194 name="tagged_address_p", 1195 params=[("struct value *", "address")], 1196 predefault="default_tagged_address_p", 1197 invalid=False, 1198) 1199 1200Method( 1201 comment=""" 1202Return true if the tag from ADDRESS matches the memory tag for that 1203particular address. Return false otherwise. 1204""", 1205 type="bool", 1206 name="memtag_matches_p", 1207 params=[("struct value *", "address")], 1208 predefault="default_memtag_matches_p", 1209 invalid=False, 1210) 1211 1212Method( 1213 comment=""" 1214Set the tags of type TAG_TYPE, for the memory address range 1215[ADDRESS, ADDRESS + LENGTH) to TAGS. 1216Return true if successful and false otherwise. 1217""", 1218 type="bool", 1219 name="set_memtags", 1220 params=[ 1221 ("struct value *", "address"), 1222 ("size_t", "length"), 1223 ("const gdb::byte_vector &", "tags"), 1224 ("memtag_type", "tag_type"), 1225 ], 1226 predefault="default_set_memtags", 1227 invalid=False, 1228) 1229 1230Method( 1231 comment=""" 1232Return the tag of type TAG_TYPE associated with the memory address ADDRESS, 1233assuming ADDRESS is tagged. 1234""", 1235 type="struct value *", 1236 name="get_memtag", 1237 params=[("struct value *", "address"), ("memtag_type", "tag_type")], 1238 predefault="default_get_memtag", 1239 invalid=False, 1240) 1241 1242Value( 1243 comment=""" 1244memtag_granule_size is the size of the allocation tag granule, for 1245architectures that support memory tagging. 1246This is 0 for architectures that do not support memory tagging. 1247For a non-zero value, this represents the number of bytes of memory per tag. 1248""", 1249 type="CORE_ADDR", 1250 name="memtag_granule_size", 1251 invalid=False, 1252) 1253 1254Function( 1255 comment=""" 1256FIXME/cagney/2001-01-18: This should be split in two. A target method that 1257indicates if the target needs software single step. An ISA method to 1258implement it. 1259 1260FIXME/cagney/2001-01-18: The logic is backwards. It should be asking if the 1261target can single step. If not, then implement single step using breakpoints. 1262 1263Return a vector of addresses on which the software single step 1264breakpoints should be inserted. NULL means software single step is 1265not used. 1266Multiple breakpoints may be inserted for some instructions such as 1267conditional branch. However, each implementation must always evaluate 1268the condition and only put the breakpoint at the branch destination if 1269the condition is true, so that we ensure forward progress when stepping 1270past a conditional branch to self. 1271""", 1272 type="std::vector<CORE_ADDR>", 1273 name="software_single_step", 1274 params=[("struct regcache *", "regcache")], 1275 predicate=True, 1276 invalid=True, 1277) 1278 1279Method( 1280 comment=""" 1281Return non-zero if the processor is executing a delay slot and a 1282further single-step is needed before the instruction finishes. 1283""", 1284 type="int", 1285 name="single_step_through_delay", 1286 params=[("frame_info_ptr", "frame")], 1287 predicate=True, 1288 invalid=True, 1289) 1290 1291Function( 1292 comment=""" 1293FIXME: cagney/2003-08-28: Need to find a better way of selecting the 1294disassembler. Perhaps objdump can handle it? 1295""", 1296 type="int", 1297 name="print_insn", 1298 params=[("bfd_vma", "vma"), ("struct disassemble_info *", "info")], 1299 predefault="default_print_insn", 1300 invalid=False, 1301) 1302 1303Function( 1304 type="CORE_ADDR", 1305 name="skip_trampoline_code", 1306 params=[("frame_info_ptr", "frame"), ("CORE_ADDR", "pc")], 1307 predefault="generic_skip_trampoline_code", 1308 invalid=False, 1309) 1310 1311Value( 1312 comment="Vtable of solib operations functions.", 1313 type="const struct target_so_ops *", 1314 name="so_ops", 1315 postdefault="&solib_target_so_ops", 1316 printer="host_address_to_string (gdbarch->so_ops)", 1317) 1318 1319Method( 1320 comment=""" 1321If in_solib_dynsym_resolve_code() returns true, and SKIP_SOLIB_RESOLVER 1322evaluates non-zero, this is the address where the debugger will place 1323a step-resume breakpoint to get us past the dynamic linker. 1324""", 1325 type="CORE_ADDR", 1326 name="skip_solib_resolver", 1327 params=[("CORE_ADDR", "pc")], 1328 predefault="generic_skip_solib_resolver", 1329 invalid=False, 1330) 1331 1332Method( 1333 comment=""" 1334Some systems also have trampoline code for returning from shared libs. 1335""", 1336 type="int", 1337 name="in_solib_return_trampoline", 1338 params=[("CORE_ADDR", "pc"), ("const char *", "name")], 1339 predefault="generic_in_solib_return_trampoline", 1340 invalid=False, 1341) 1342 1343Method( 1344 comment=""" 1345Return true if PC lies inside an indirect branch thunk. 1346""", 1347 type="bool", 1348 name="in_indirect_branch_thunk", 1349 params=[("CORE_ADDR", "pc")], 1350 predefault="default_in_indirect_branch_thunk", 1351 invalid=False, 1352) 1353 1354Method( 1355 comment=""" 1356A target might have problems with watchpoints as soon as the stack 1357frame of the current function has been destroyed. This mostly happens 1358as the first action in a function's epilogue. stack_frame_destroyed_p() 1359is defined to return a non-zero value if either the given addr is one 1360instruction after the stack destroying instruction up to the trailing 1361return instruction or if we can figure out that the stack frame has 1362already been invalidated regardless of the value of addr. Targets 1363which don't suffer from that problem could just let this functionality 1364untouched. 1365""", 1366 type="int", 1367 name="stack_frame_destroyed_p", 1368 params=[("CORE_ADDR", "addr")], 1369 predefault="generic_stack_frame_destroyed_p", 1370 invalid=False, 1371) 1372 1373Function( 1374 comment=""" 1375Process an ELF symbol in the minimal symbol table in a backend-specific 1376way. Normally this hook is supposed to do nothing, however if required, 1377then this hook can be used to apply tranformations to symbols that are 1378considered special in some way. For example the MIPS backend uses it 1379to interpret `st_other' information to mark compressed code symbols so 1380that they can be treated in the appropriate manner in the processing of 1381the main symbol table and DWARF-2 records. 1382""", 1383 type="void", 1384 name="elf_make_msymbol_special", 1385 params=[("asymbol *", "sym"), ("struct minimal_symbol *", "msym")], 1386 predicate=True, 1387 invalid=True, 1388) 1389 1390Function( 1391 type="void", 1392 name="coff_make_msymbol_special", 1393 params=[("int", "val"), ("struct minimal_symbol *", "msym")], 1394 predefault="default_coff_make_msymbol_special", 1395 invalid=False, 1396) 1397 1398Function( 1399 comment=""" 1400Process a symbol in the main symbol table in a backend-specific way. 1401Normally this hook is supposed to do nothing, however if required, 1402then this hook can be used to apply tranformations to symbols that 1403are considered special in some way. This is currently used by the 1404MIPS backend to make sure compressed code symbols have the ISA bit 1405set. This in turn is needed for symbol values seen in GDB to match 1406the values used at the runtime by the program itself, for function 1407and label references. 1408""", 1409 type="void", 1410 name="make_symbol_special", 1411 params=[("struct symbol *", "sym"), ("struct objfile *", "objfile")], 1412 predefault="default_make_symbol_special", 1413 invalid=False, 1414) 1415 1416Function( 1417 comment=""" 1418Adjust the address retrieved from a DWARF-2 record other than a line 1419entry in a backend-specific way. Normally this hook is supposed to 1420return the address passed unchanged, however if that is incorrect for 1421any reason, then this hook can be used to fix the address up in the 1422required manner. This is currently used by the MIPS backend to make 1423sure addresses in FDE, range records, etc. referring to compressed 1424code have the ISA bit set, matching line information and the symbol 1425table. 1426""", 1427 type="CORE_ADDR", 1428 name="adjust_dwarf2_addr", 1429 params=[("CORE_ADDR", "pc")], 1430 predefault="default_adjust_dwarf2_addr", 1431 invalid=False, 1432) 1433 1434Function( 1435 comment=""" 1436Adjust the address updated by a line entry in a backend-specific way. 1437Normally this hook is supposed to return the address passed unchanged, 1438however in the case of inconsistencies in these records, this hook can 1439be used to fix them up in the required manner. This is currently used 1440by the MIPS backend to make sure all line addresses in compressed code 1441are presented with the ISA bit set, which is not always the case. This 1442in turn ensures breakpoint addresses are correctly matched against the 1443stop PC. 1444""", 1445 type="CORE_ADDR", 1446 name="adjust_dwarf2_line", 1447 params=[("CORE_ADDR", "addr"), ("int", "rel")], 1448 predefault="default_adjust_dwarf2_line", 1449 invalid=False, 1450) 1451 1452Value( 1453 type="int", 1454 name="cannot_step_breakpoint", 1455 predefault="0", 1456 invalid=False, 1457) 1458 1459Value( 1460 comment=""" 1461See comment in target.h about continuable, steppable and 1462non-steppable watchpoints. 1463""", 1464 type="int", 1465 name="have_nonsteppable_watchpoint", 1466 predefault="0", 1467 invalid=False, 1468) 1469 1470Function( 1471 type="type_instance_flags", 1472 name="address_class_type_flags", 1473 params=[("int", "byte_size"), ("int", "dwarf2_addr_class")], 1474 predicate=True, 1475 invalid=True, 1476) 1477 1478Method( 1479 type="const char *", 1480 name="address_class_type_flags_to_name", 1481 params=[("type_instance_flags", "type_flags")], 1482 predicate=True, 1483 invalid=True, 1484) 1485 1486Method( 1487 comment=""" 1488Execute vendor-specific DWARF Call Frame Instruction. OP is the instruction. 1489FS are passed from the generic execute_cfa_program function. 1490""", 1491 type="bool", 1492 name="execute_dwarf_cfa_vendor_op", 1493 params=[("gdb_byte", "op"), ("struct dwarf2_frame_state *", "fs")], 1494 predefault="default_execute_dwarf_cfa_vendor_op", 1495 invalid=False, 1496) 1497 1498Method( 1499 comment=""" 1500Return the appropriate type_flags for the supplied address class. 1501This function should return true if the address class was recognized and 1502type_flags was set, false otherwise. 1503""", 1504 type="bool", 1505 name="address_class_name_to_type_flags", 1506 params=[("const char *", "name"), ("type_instance_flags *", "type_flags_ptr")], 1507 predicate=True, 1508 invalid=True, 1509) 1510 1511Method( 1512 comment=""" 1513Is a register in a group 1514""", 1515 type="int", 1516 name="register_reggroup_p", 1517 params=[("int", "regnum"), ("const struct reggroup *", "reggroup")], 1518 predefault="default_register_reggroup_p", 1519 invalid=False, 1520) 1521 1522Function( 1523 comment=""" 1524Fetch the pointer to the ith function argument. 1525""", 1526 type="CORE_ADDR", 1527 name="fetch_pointer_argument", 1528 params=[ 1529 ("frame_info_ptr", "frame"), 1530 ("int", "argi"), 1531 ("struct type *", "type"), 1532 ], 1533 predicate=True, 1534 invalid=True, 1535) 1536 1537Method( 1538 comment=""" 1539Iterate over all supported register notes in a core file. For each 1540supported register note section, the iterator must call CB and pass 1541CB_DATA unchanged. If REGCACHE is not NULL, the iterator can limit 1542the supported register note sections based on the current register 1543values. Otherwise it should enumerate all supported register note 1544sections. 1545""", 1546 type="void", 1547 name="iterate_over_regset_sections", 1548 params=[ 1549 ("iterate_over_regset_sections_cb *", "cb"), 1550 ("void *", "cb_data"), 1551 ("const struct regcache *", "regcache"), 1552 ], 1553 predicate=True, 1554 invalid=True, 1555) 1556 1557Method( 1558 comment=""" 1559Create core file notes 1560""", 1561 type="gdb::unique_xmalloc_ptr<char>", 1562 name="make_corefile_notes", 1563 params=[("bfd *", "obfd"), ("int *", "note_size")], 1564 predicate=True, 1565 invalid=True, 1566) 1567 1568Method( 1569 comment=""" 1570Find core file memory regions 1571""", 1572 type="int", 1573 name="find_memory_regions", 1574 params=[("find_memory_region_ftype", "func"), ("void *", "data")], 1575 predicate=True, 1576 invalid=True, 1577) 1578 1579Method( 1580 comment=""" 1581Given a bfd OBFD, segment ADDRESS and SIZE, create a memory tag section to be dumped to a core file 1582""", 1583 type="asection *", 1584 name="create_memtag_section", 1585 params=[("bfd *", "obfd"), ("CORE_ADDR", "address"), ("size_t", "size")], 1586 predicate=True, 1587 invalid=True, 1588) 1589 1590Method( 1591 comment=""" 1592Given a memory tag section OSEC, fill OSEC's contents with the appropriate tag data 1593""", 1594 type="bool", 1595 name="fill_memtag_section", 1596 params=[("asection *", "osec")], 1597 predicate=True, 1598 invalid=True, 1599) 1600 1601Method( 1602 comment=""" 1603Decode a memory tag SECTION and return the tags of type TYPE contained in 1604the memory range [ADDRESS, ADDRESS + LENGTH). 1605If no tags were found, return an empty vector. 1606""", 1607 type="gdb::byte_vector", 1608 name="decode_memtag_section", 1609 params=[ 1610 ("bfd_section *", "section"), 1611 ("int", "type"), 1612 ("CORE_ADDR", "address"), 1613 ("size_t", "length"), 1614 ], 1615 predicate=True, 1616 invalid=True, 1617) 1618 1619Method( 1620 comment=""" 1621Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from 1622core file into buffer READBUF with length LEN. Return the number of bytes read 1623(zero indicates failure). 1624failed, otherwise, return the red length of READBUF. 1625""", 1626 type="ULONGEST", 1627 name="core_xfer_shared_libraries", 1628 params=[("gdb_byte *", "readbuf"), ("ULONGEST", "offset"), ("ULONGEST", "len")], 1629 predicate=True, 1630 invalid=True, 1631) 1632 1633Method( 1634 comment=""" 1635Read offset OFFSET of TARGET_OBJECT_LIBRARIES_AIX formatted shared 1636libraries list from core file into buffer READBUF with length LEN. 1637Return the number of bytes read (zero indicates failure). 1638""", 1639 type="ULONGEST", 1640 name="core_xfer_shared_libraries_aix", 1641 params=[("gdb_byte *", "readbuf"), ("ULONGEST", "offset"), ("ULONGEST", "len")], 1642 predicate=True, 1643 invalid=True, 1644) 1645 1646Method( 1647 comment=""" 1648How the core target converts a PTID from a core file to a string. 1649""", 1650 type="std::string", 1651 name="core_pid_to_str", 1652 params=[("ptid_t", "ptid")], 1653 predicate=True, 1654 invalid=True, 1655) 1656 1657Method( 1658 comment=""" 1659How the core target extracts the name of a thread from a core file. 1660""", 1661 type="const char *", 1662 name="core_thread_name", 1663 params=[("struct thread_info *", "thr")], 1664 predicate=True, 1665 invalid=True, 1666) 1667 1668Method( 1669 comment=""" 1670Read offset OFFSET of TARGET_OBJECT_SIGNAL_INFO signal information 1671from core file into buffer READBUF with length LEN. Return the number 1672of bytes read (zero indicates EOF, a negative value indicates failure). 1673""", 1674 type="LONGEST", 1675 name="core_xfer_siginfo", 1676 params=[("gdb_byte *", "readbuf"), ("ULONGEST", "offset"), ("ULONGEST", "len")], 1677 predicate=True, 1678 invalid=True, 1679) 1680 1681Value( 1682 comment=""" 1683BFD target to use when generating a core file. 1684""", 1685 type="const char *", 1686 name="gcore_bfd_target", 1687 predicate=True, 1688 predefault="0", 1689 invalid=True, 1690 printer="pstring (gdbarch->gcore_bfd_target)", 1691) 1692 1693Value( 1694 comment=""" 1695If the elements of C++ vtables are in-place function descriptors rather 1696than normal function pointers (which may point to code or a descriptor), 1697set this to one. 1698""", 1699 type="int", 1700 name="vtable_function_descriptors", 1701 predefault="0", 1702 invalid=False, 1703) 1704 1705Value( 1706 comment=""" 1707Set if the least significant bit of the delta is used instead of the least 1708significant bit of the pfn for pointers to virtual member functions. 1709""", 1710 type="int", 1711 name="vbit_in_delta", 1712 predefault="0", 1713 invalid=False, 1714) 1715 1716Function( 1717 comment=""" 1718Advance PC to next instruction in order to skip a permanent breakpoint. 1719""", 1720 type="void", 1721 name="skip_permanent_breakpoint", 1722 params=[("struct regcache *", "regcache")], 1723 predefault="default_skip_permanent_breakpoint", 1724 invalid=False, 1725) 1726 1727Value( 1728 comment=""" 1729The maximum length of an instruction on this architecture in bytes. 1730""", 1731 type="ULONGEST", 1732 name="max_insn_length", 1733 predicate=True, 1734 predefault="0", 1735 invalid=True, 1736) 1737 1738Method( 1739 comment=""" 1740Copy the instruction at FROM to TO, and make any adjustments 1741necessary to single-step it at that address. 1742 1743REGS holds the state the thread's registers will have before 1744executing the copied instruction; the PC in REGS will refer to FROM, 1745not the copy at TO. The caller should update it to point at TO later. 1746 1747Return a pointer to data of the architecture's choice to be passed 1748to gdbarch_displaced_step_fixup. 1749 1750For a general explanation of displaced stepping and how GDB uses it, 1751see the comments in infrun.c. 1752 1753The TO area is only guaranteed to have space for 1754gdbarch_max_insn_length (arch) bytes, so this function must not 1755write more bytes than that to that area. 1756 1757If you do not provide this function, GDB assumes that the 1758architecture does not support displaced stepping. 1759 1760If the instruction cannot execute out of line, return NULL. The 1761core falls back to stepping past the instruction in-line instead in 1762that case. 1763""", 1764 type="displaced_step_copy_insn_closure_up", 1765 name="displaced_step_copy_insn", 1766 params=[("CORE_ADDR", "from"), ("CORE_ADDR", "to"), ("struct regcache *", "regs")], 1767 predicate=True, 1768 invalid=True, 1769) 1770 1771Method( 1772 comment=""" 1773Return true if GDB should use hardware single-stepping to execute a displaced 1774step instruction. If false, GDB will simply restart execution at the 1775displaced instruction location, and it is up to the target to ensure GDB will 1776receive control again (e.g. by placing a software breakpoint instruction into 1777the displaced instruction buffer). 1778 1779The default implementation returns false on all targets that provide a 1780gdbarch_software_single_step routine, and true otherwise. 1781""", 1782 type="bool", 1783 name="displaced_step_hw_singlestep", 1784 params=[], 1785 predefault="default_displaced_step_hw_singlestep", 1786 invalid=False, 1787) 1788 1789Method( 1790 comment=""" 1791Fix up the state resulting from successfully single-stepping a 1792displaced instruction, to give the result we would have gotten from 1793stepping the instruction in its original location. 1794 1795REGS is the register state resulting from single-stepping the 1796displaced instruction. 1797 1798CLOSURE is the result from the matching call to 1799gdbarch_displaced_step_copy_insn. 1800 1801If you provide gdbarch_displaced_step_copy_insn.but not this 1802function, then GDB assumes that no fixup is needed after 1803single-stepping the instruction. 1804 1805For a general explanation of displaced stepping and how GDB uses it, 1806see the comments in infrun.c. 1807""", 1808 type="void", 1809 name="displaced_step_fixup", 1810 params=[ 1811 ("struct displaced_step_copy_insn_closure *", "closure"), 1812 ("CORE_ADDR", "from"), 1813 ("CORE_ADDR", "to"), 1814 ("struct regcache *", "regs"), 1815 ], 1816 predicate=True, 1817 predefault="NULL", 1818 invalid=True, 1819) 1820 1821Method( 1822 comment=""" 1823Prepare THREAD for it to displaced step the instruction at its current PC. 1824 1825Throw an exception if any unexpected error happens. 1826""", 1827 type="displaced_step_prepare_status", 1828 name="displaced_step_prepare", 1829 params=[("thread_info *", "thread"), ("CORE_ADDR &", "displaced_pc")], 1830 predicate=True, 1831 invalid=True, 1832) 1833 1834Method( 1835 comment=""" 1836Clean up after a displaced step of THREAD. 1837""", 1838 type="displaced_step_finish_status", 1839 name="displaced_step_finish", 1840 params=[("thread_info *", "thread"), ("gdb_signal", "sig")], 1841 predefault="NULL", 1842 invalid="(! gdbarch->displaced_step_finish) != (! gdbarch->displaced_step_prepare)", 1843) 1844 1845Function( 1846 comment=""" 1847Return the closure associated to the displaced step buffer that is at ADDR. 1848""", 1849 type="const displaced_step_copy_insn_closure *", 1850 name="displaced_step_copy_insn_closure_by_addr", 1851 params=[("inferior *", "inf"), ("CORE_ADDR", "addr")], 1852 predicate=True, 1853 invalid=True, 1854) 1855 1856Function( 1857 comment=""" 1858PARENT_INF has forked and CHILD_PTID is the ptid of the child. Restore the 1859contents of all displaced step buffers in the child's address space. 1860""", 1861 type="void", 1862 name="displaced_step_restore_all_in_ptid", 1863 params=[("inferior *", "parent_inf"), ("ptid_t", "child_ptid")], 1864 invalid=False, 1865) 1866 1867Method( 1868 comment=""" 1869Relocate an instruction to execute at a different address. OLDLOC 1870is the address in the inferior memory where the instruction to 1871relocate is currently at. On input, TO points to the destination 1872where we want the instruction to be copied (and possibly adjusted) 1873to. On output, it points to one past the end of the resulting 1874instruction(s). The effect of executing the instruction at TO shall 1875be the same as if executing it at FROM. For example, call 1876instructions that implicitly push the return address on the stack 1877should be adjusted to return to the instruction after OLDLOC; 1878relative branches, and other PC-relative instructions need the 1879offset adjusted; etc. 1880""", 1881 type="void", 1882 name="relocate_instruction", 1883 params=[("CORE_ADDR *", "to"), ("CORE_ADDR", "from")], 1884 predicate=True, 1885 predefault="NULL", 1886 invalid=True, 1887) 1888 1889Function( 1890 comment=""" 1891Refresh overlay mapped state for section OSECT. 1892""", 1893 type="void", 1894 name="overlay_update", 1895 params=[("struct obj_section *", "osect")], 1896 predicate=True, 1897 invalid=True, 1898) 1899 1900Method( 1901 type="const struct target_desc *", 1902 name="core_read_description", 1903 params=[("struct target_ops *", "target"), ("bfd *", "abfd")], 1904 predicate=True, 1905 invalid=True, 1906) 1907 1908Value( 1909 comment=""" 1910Set if the address in N_SO or N_FUN stabs may be zero. 1911""", 1912 type="int", 1913 name="sofun_address_maybe_missing", 1914 predefault="0", 1915 invalid=False, 1916) 1917 1918Method( 1919 comment=""" 1920Parse the instruction at ADDR storing in the record execution log 1921the registers REGCACHE and memory ranges that will be affected when 1922the instruction executes, along with their current values. 1923Return -1 if something goes wrong, 0 otherwise. 1924""", 1925 type="int", 1926 name="process_record", 1927 params=[("struct regcache *", "regcache"), ("CORE_ADDR", "addr")], 1928 predicate=True, 1929 invalid=True, 1930) 1931 1932Method( 1933 comment=""" 1934Save process state after a signal. 1935Return -1 if something goes wrong, 0 otherwise. 1936""", 1937 type="int", 1938 name="process_record_signal", 1939 params=[("struct regcache *", "regcache"), ("enum gdb_signal", "signal")], 1940 predicate=True, 1941 invalid=True, 1942) 1943 1944Method( 1945 comment=""" 1946Signal translation: translate inferior's signal (target's) number 1947into GDB's representation. The implementation of this method must 1948be host independent. IOW, don't rely on symbols of the NAT_FILE 1949header (the nm-*.h files), the host <signal.h> header, or similar 1950headers. This is mainly used when cross-debugging core files --- 1951"Live" targets hide the translation behind the target interface 1952(target_wait, target_resume, etc.). 1953""", 1954 type="enum gdb_signal", 1955 name="gdb_signal_from_target", 1956 params=[("int", "signo")], 1957 predicate=True, 1958 invalid=True, 1959) 1960 1961Method( 1962 comment=""" 1963Signal translation: translate the GDB's internal signal number into 1964the inferior's signal (target's) representation. The implementation 1965of this method must be host independent. IOW, don't rely on symbols 1966of the NAT_FILE header (the nm-*.h files), the host <signal.h> 1967header, or similar headers. 1968Return the target signal number if found, or -1 if the GDB internal 1969signal number is invalid. 1970""", 1971 type="int", 1972 name="gdb_signal_to_target", 1973 params=[("enum gdb_signal", "signal")], 1974 predicate=True, 1975 invalid=True, 1976) 1977 1978Method( 1979 comment=""" 1980Extra signal info inspection. 1981 1982Return a type suitable to inspect extra signal information. 1983""", 1984 type="struct type *", 1985 name="get_siginfo_type", 1986 params=[], 1987 predicate=True, 1988 invalid=True, 1989) 1990 1991Method( 1992 comment=""" 1993Record architecture-specific information from the symbol table. 1994""", 1995 type="void", 1996 name="record_special_symbol", 1997 params=[("struct objfile *", "objfile"), ("asymbol *", "sym")], 1998 predicate=True, 1999 invalid=True, 2000) 2001 2002Method( 2003 comment=""" 2004Function for the 'catch syscall' feature. 2005Get architecture-specific system calls information from registers. 2006""", 2007 type="LONGEST", 2008 name="get_syscall_number", 2009 params=[("thread_info *", "thread")], 2010 predicate=True, 2011 invalid=True, 2012) 2013 2014Value( 2015 comment=""" 2016The filename of the XML syscall for this architecture. 2017""", 2018 type="const char *", 2019 name="xml_syscall_file", 2020 predefault="0", 2021 invalid=False, 2022 printer="pstring (gdbarch->xml_syscall_file)", 2023) 2024 2025Value( 2026 comment=""" 2027Information about system calls from this architecture 2028""", 2029 type="struct syscalls_info *", 2030 name="syscalls_info", 2031 predefault="0", 2032 invalid=False, 2033 printer="host_address_to_string (gdbarch->syscalls_info)", 2034) 2035 2036Value( 2037 comment=""" 2038SystemTap related fields and functions. 2039A NULL-terminated array of prefixes used to mark an integer constant 2040on the architecture's assembly. 2041For example, on x86 integer constants are written as: 2042 2043$10 ;; integer constant 10 2044 2045in this case, this prefix would be the character `$'. 2046""", 2047 type="const char *const *", 2048 name="stap_integer_prefixes", 2049 predefault="0", 2050 invalid=False, 2051 printer="pstring_list (gdbarch->stap_integer_prefixes)", 2052) 2053 2054Value( 2055 comment=""" 2056A NULL-terminated array of suffixes used to mark an integer constant 2057on the architecture's assembly. 2058""", 2059 type="const char *const *", 2060 name="stap_integer_suffixes", 2061 predefault="0", 2062 invalid=False, 2063 printer="pstring_list (gdbarch->stap_integer_suffixes)", 2064) 2065 2066Value( 2067 comment=""" 2068A NULL-terminated array of prefixes used to mark a register name on 2069the architecture's assembly. 2070For example, on x86 the register name is written as: 2071 2072%eax ;; register eax 2073 2074in this case, this prefix would be the character `%'. 2075""", 2076 type="const char *const *", 2077 name="stap_register_prefixes", 2078 predefault="0", 2079 invalid=False, 2080 printer="pstring_list (gdbarch->stap_register_prefixes)", 2081) 2082 2083Value( 2084 comment=""" 2085A NULL-terminated array of suffixes used to mark a register name on 2086the architecture's assembly. 2087""", 2088 type="const char *const *", 2089 name="stap_register_suffixes", 2090 predefault="0", 2091 invalid=False, 2092 printer="pstring_list (gdbarch->stap_register_suffixes)", 2093) 2094 2095Value( 2096 comment=""" 2097A NULL-terminated array of prefixes used to mark a register 2098indirection on the architecture's assembly. 2099For example, on x86 the register indirection is written as: 2100 2101(%eax) ;; indirecting eax 2102 2103in this case, this prefix would be the charater `('. 2104 2105Please note that we use the indirection prefix also for register 2106displacement, e.g., `4(%eax)' on x86. 2107""", 2108 type="const char *const *", 2109 name="stap_register_indirection_prefixes", 2110 predefault="0", 2111 invalid=False, 2112 printer="pstring_list (gdbarch->stap_register_indirection_prefixes)", 2113) 2114 2115Value( 2116 comment=""" 2117A NULL-terminated array of suffixes used to mark a register 2118indirection on the architecture's assembly. 2119For example, on x86 the register indirection is written as: 2120 2121(%eax) ;; indirecting eax 2122 2123in this case, this prefix would be the charater `)'. 2124 2125Please note that we use the indirection suffix also for register 2126displacement, e.g., `4(%eax)' on x86. 2127""", 2128 type="const char *const *", 2129 name="stap_register_indirection_suffixes", 2130 predefault="0", 2131 invalid=False, 2132 printer="pstring_list (gdbarch->stap_register_indirection_suffixes)", 2133) 2134 2135Value( 2136 comment=""" 2137Prefix(es) used to name a register using GDB's nomenclature. 2138 2139For example, on PPC a register is represented by a number in the assembly 2140language (e.g., `10' is the 10th general-purpose register). However, 2141inside GDB this same register has an `r' appended to its name, so the 10th 2142register would be represented as `r10' internally. 2143""", 2144 type="const char *", 2145 name="stap_gdb_register_prefix", 2146 predefault="0", 2147 invalid=False, 2148 printer="pstring (gdbarch->stap_gdb_register_prefix)", 2149) 2150 2151Value( 2152 comment=""" 2153Suffix used to name a register using GDB's nomenclature. 2154""", 2155 type="const char *", 2156 name="stap_gdb_register_suffix", 2157 predefault="0", 2158 invalid=False, 2159 printer="pstring (gdbarch->stap_gdb_register_suffix)", 2160) 2161 2162Method( 2163 comment=""" 2164Check if S is a single operand. 2165 2166Single operands can be: 2167- Literal integers, e.g. `$10' on x86 2168- Register access, e.g. `%eax' on x86 2169- Register indirection, e.g. `(%eax)' on x86 2170- Register displacement, e.g. `4(%eax)' on x86 2171 2172This function should check for these patterns on the string 2173and return 1 if some were found, or zero otherwise. Please try to match 2174as much info as you can from the string, i.e., if you have to match 2175something like `(%', do not match just the `('. 2176""", 2177 type="int", 2178 name="stap_is_single_operand", 2179 params=[("const char *", "s")], 2180 predicate=True, 2181 invalid=True, 2182) 2183 2184Method( 2185 comment=""" 2186Function used to handle a "special case" in the parser. 2187 2188A "special case" is considered to be an unknown token, i.e., a token 2189that the parser does not know how to parse. A good example of special 2190case would be ARM's register displacement syntax: 2191 2192[R0, #4] ;; displacing R0 by 4 2193 2194Since the parser assumes that a register displacement is of the form: 2195 2196<number> <indirection_prefix> <register_name> <indirection_suffix> 2197 2198it means that it will not be able to recognize and parse this odd syntax. 2199Therefore, we should add a special case function that will handle this token. 2200 2201This function should generate the proper expression form of the expression 2202using GDB's internal expression mechanism (e.g., `write_exp_elt_opcode' 2203and so on). It should also return 1 if the parsing was successful, or zero 2204if the token was not recognized as a special token (in this case, returning 2205zero means that the special parser is deferring the parsing to the generic 2206parser), and should advance the buffer pointer (p->arg). 2207""", 2208 type="expr::operation_up", 2209 name="stap_parse_special_token", 2210 params=[("struct stap_parse_info *", "p")], 2211 predicate=True, 2212 invalid=True, 2213) 2214 2215Method( 2216 comment=""" 2217Perform arch-dependent adjustments to a register name. 2218 2219In very specific situations, it may be necessary for the register 2220name present in a SystemTap probe's argument to be handled in a 2221special way. For example, on i386, GCC may over-optimize the 2222register allocation and use smaller registers than necessary. In 2223such cases, the client that is reading and evaluating the SystemTap 2224probe (ourselves) will need to actually fetch values from the wider 2225version of the register in question. 2226 2227To illustrate the example, consider the following probe argument 2228(i386): 2229 22304@%ax 2231 2232This argument says that its value can be found at the %ax register, 2233which is a 16-bit register. However, the argument's prefix says 2234that its type is "uint32_t", which is 32-bit in size. Therefore, in 2235this case, GDB should actually fetch the probe's value from register 2236%eax, not %ax. In this scenario, this function would actually 2237replace the register name from %ax to %eax. 2238 2239The rationale for this can be found at PR breakpoints/24541. 2240""", 2241 type="std::string", 2242 name="stap_adjust_register", 2243 params=[ 2244 ("struct stap_parse_info *", "p"), 2245 ("const std::string &", "regname"), 2246 ("int", "regnum"), 2247 ], 2248 predicate=True, 2249 invalid=True, 2250) 2251 2252Method( 2253 comment=""" 2254DTrace related functions. 2255The expression to compute the NARTGth+1 argument to a DTrace USDT probe. 2256NARG must be >= 0. 2257""", 2258 type="expr::operation_up", 2259 name="dtrace_parse_probe_argument", 2260 params=[("int", "narg")], 2261 predicate=True, 2262 invalid=True, 2263) 2264 2265Method( 2266 comment=""" 2267True if the given ADDR does not contain the instruction sequence 2268corresponding to a disabled DTrace is-enabled probe. 2269""", 2270 type="int", 2271 name="dtrace_probe_is_enabled", 2272 params=[("CORE_ADDR", "addr")], 2273 predicate=True, 2274 invalid=True, 2275) 2276 2277Method( 2278 comment=""" 2279Enable a DTrace is-enabled probe at ADDR. 2280""", 2281 type="void", 2282 name="dtrace_enable_probe", 2283 params=[("CORE_ADDR", "addr")], 2284 predicate=True, 2285 invalid=True, 2286) 2287 2288Method( 2289 comment=""" 2290Disable a DTrace is-enabled probe at ADDR. 2291""", 2292 type="void", 2293 name="dtrace_disable_probe", 2294 params=[("CORE_ADDR", "addr")], 2295 predicate=True, 2296 invalid=True, 2297) 2298 2299Value( 2300 comment=""" 2301True if the list of shared libraries is one and only for all 2302processes, as opposed to a list of shared libraries per inferior. 2303This usually means that all processes, although may or may not share 2304an address space, will see the same set of symbols at the same 2305addresses. 2306""", 2307 type="int", 2308 name="has_global_solist", 2309 predefault="0", 2310 invalid=False, 2311) 2312 2313Value( 2314 comment=""" 2315On some targets, even though each inferior has its own private 2316address space, the debug interface takes care of making breakpoints 2317visible to all address spaces automatically. For such cases, 2318this property should be set to true. 2319""", 2320 type="int", 2321 name="has_global_breakpoints", 2322 predefault="0", 2323 invalid=False, 2324) 2325 2326Method( 2327 comment=""" 2328True if inferiors share an address space (e.g., uClinux). 2329""", 2330 type="int", 2331 name="has_shared_address_space", 2332 params=[], 2333 predefault="default_has_shared_address_space", 2334 invalid=False, 2335) 2336 2337Method( 2338 comment=""" 2339True if a fast tracepoint can be set at an address. 2340""", 2341 type="int", 2342 name="fast_tracepoint_valid_at", 2343 params=[("CORE_ADDR", "addr"), ("std::string *", "msg")], 2344 predefault="default_fast_tracepoint_valid_at", 2345 invalid=False, 2346) 2347 2348Method( 2349 comment=""" 2350Guess register state based on tracepoint location. Used for tracepoints 2351where no registers have been collected, but there's only one location, 2352allowing us to guess the PC value, and perhaps some other registers. 2353On entry, regcache has all registers marked as unavailable. 2354""", 2355 type="void", 2356 name="guess_tracepoint_registers", 2357 params=[("struct regcache *", "regcache"), ("CORE_ADDR", "addr")], 2358 predefault="default_guess_tracepoint_registers", 2359 invalid=False, 2360) 2361 2362Function( 2363 comment=""" 2364Return the "auto" target charset. 2365""", 2366 type="const char *", 2367 name="auto_charset", 2368 params=[], 2369 predefault="default_auto_charset", 2370 invalid=False, 2371) 2372 2373Function( 2374 comment=""" 2375Return the "auto" target wide charset. 2376""", 2377 type="const char *", 2378 name="auto_wide_charset", 2379 params=[], 2380 predefault="default_auto_wide_charset", 2381 invalid=False, 2382) 2383 2384Value( 2385 comment=""" 2386If non-empty, this is a file extension that will be opened in place 2387of the file extension reported by the shared library list. 2388 2389This is most useful for toolchains that use a post-linker tool, 2390where the names of the files run on the target differ in extension 2391compared to the names of the files GDB should load for debug info. 2392""", 2393 type="const char *", 2394 name="solib_symbols_extension", 2395 invalid=False, 2396 printer="pstring (gdbarch->solib_symbols_extension)", 2397) 2398 2399Value( 2400 comment=""" 2401If true, the target OS has DOS-based file system semantics. That 2402is, absolute paths include a drive name, and the backslash is 2403considered a directory separator. 2404""", 2405 type="int", 2406 name="has_dos_based_file_system", 2407 predefault="0", 2408 invalid=False, 2409) 2410 2411Method( 2412 comment=""" 2413Generate bytecodes to collect the return address in a frame. 2414Since the bytecodes run on the target, possibly with GDB not even 2415connected, the full unwinding machinery is not available, and 2416typically this function will issue bytecodes for one or more likely 2417places that the return address may be found. 2418""", 2419 type="void", 2420 name="gen_return_address", 2421 params=[ 2422 ("struct agent_expr *", "ax"), 2423 ("struct axs_value *", "value"), 2424 ("CORE_ADDR", "scope"), 2425 ], 2426 predefault="default_gen_return_address", 2427 invalid=False, 2428) 2429 2430Method( 2431 comment=""" 2432Implement the "info proc" command. 2433""", 2434 type="void", 2435 name="info_proc", 2436 params=[("const char *", "args"), ("enum info_proc_what", "what")], 2437 predicate=True, 2438 invalid=True, 2439) 2440 2441Method( 2442 comment=""" 2443Implement the "info proc" command for core files. Noe that there 2444are two "info_proc"-like methods on gdbarch -- one for core files, 2445one for live targets. 2446""", 2447 type="void", 2448 name="core_info_proc", 2449 params=[("const char *", "args"), ("enum info_proc_what", "what")], 2450 predicate=True, 2451 invalid=True, 2452) 2453 2454Method( 2455 comment=""" 2456Iterate over all objfiles in the order that makes the most sense 2457for the architecture to make global symbol searches. 2458 2459CB is a callback function passed an objfile to be searched. The iteration stops 2460if this function returns nonzero. 2461 2462If not NULL, CURRENT_OBJFILE corresponds to the objfile being 2463inspected when the symbol search was requested. 2464""", 2465 type="void", 2466 name="iterate_over_objfiles_in_search_order", 2467 params=[ 2468 ("iterate_over_objfiles_in_search_order_cb_ftype", "cb"), 2469 ("struct objfile *", "current_objfile"), 2470 ], 2471 predefault="default_iterate_over_objfiles_in_search_order", 2472 invalid=False, 2473) 2474 2475Value( 2476 comment=""" 2477Ravenscar arch-dependent ops. 2478""", 2479 type="struct ravenscar_arch_ops *", 2480 name="ravenscar_ops", 2481 predefault="NULL", 2482 invalid=False, 2483 printer="host_address_to_string (gdbarch->ravenscar_ops)", 2484) 2485 2486Method( 2487 comment=""" 2488Return non-zero if the instruction at ADDR is a call; zero otherwise. 2489""", 2490 type="int", 2491 name="insn_is_call", 2492 params=[("CORE_ADDR", "addr")], 2493 predefault="default_insn_is_call", 2494 invalid=False, 2495) 2496 2497Method( 2498 comment=""" 2499Return non-zero if the instruction at ADDR is a return; zero otherwise. 2500""", 2501 type="int", 2502 name="insn_is_ret", 2503 params=[("CORE_ADDR", "addr")], 2504 predefault="default_insn_is_ret", 2505 invalid=False, 2506) 2507 2508Method( 2509 comment=""" 2510Return non-zero if the instruction at ADDR is a jump; zero otherwise. 2511""", 2512 type="int", 2513 name="insn_is_jump", 2514 params=[("CORE_ADDR", "addr")], 2515 predefault="default_insn_is_jump", 2516 invalid=False, 2517) 2518 2519Method( 2520 comment=""" 2521Return true if there's a program/permanent breakpoint planted in 2522memory at ADDRESS, return false otherwise. 2523""", 2524 type="bool", 2525 name="program_breakpoint_here_p", 2526 params=[("CORE_ADDR", "address")], 2527 predefault="default_program_breakpoint_here_p", 2528 invalid=False, 2529) 2530 2531Method( 2532 comment=""" 2533Read one auxv entry from *READPTR, not reading locations >= ENDPTR. 2534Return 0 if *READPTR is already at the end of the buffer. 2535Return -1 if there is insufficient buffer for a whole entry. 2536Return 1 if an entry was read into *TYPEP and *VALP. 2537""", 2538 type="int", 2539 name="auxv_parse", 2540 params=[ 2541 ("const gdb_byte **", "readptr"), 2542 ("const gdb_byte *", "endptr"), 2543 ("CORE_ADDR *", "typep"), 2544 ("CORE_ADDR *", "valp"), 2545 ], 2546 predicate=True, 2547 invalid=True, 2548) 2549 2550Method( 2551 comment=""" 2552Print the description of a single auxv entry described by TYPE and VAL 2553to FILE. 2554""", 2555 type="void", 2556 name="print_auxv_entry", 2557 params=[("struct ui_file *", "file"), ("CORE_ADDR", "type"), ("CORE_ADDR", "val")], 2558 predefault="default_print_auxv_entry", 2559 invalid=False, 2560) 2561 2562Method( 2563 comment=""" 2564Find the address range of the current inferior's vsyscall/vDSO, and 2565write it to *RANGE. If the vsyscall's length can't be determined, a 2566range with zero length is returned. Returns true if the vsyscall is 2567found, false otherwise. 2568""", 2569 type="int", 2570 name="vsyscall_range", 2571 params=[("struct mem_range *", "range")], 2572 predefault="default_vsyscall_range", 2573 invalid=False, 2574) 2575 2576Function( 2577 comment=""" 2578Allocate SIZE bytes of PROT protected page aligned memory in inferior. 2579PROT has GDB_MMAP_PROT_* bitmask format. 2580Throw an error if it is not possible. Returned address is always valid. 2581""", 2582 type="CORE_ADDR", 2583 name="infcall_mmap", 2584 params=[("CORE_ADDR", "size"), ("unsigned", "prot")], 2585 predefault="default_infcall_mmap", 2586 invalid=False, 2587) 2588 2589Function( 2590 comment=""" 2591Deallocate SIZE bytes of memory at ADDR in inferior from gdbarch_infcall_mmap. 2592Print a warning if it is not possible. 2593""", 2594 type="void", 2595 name="infcall_munmap", 2596 params=[("CORE_ADDR", "addr"), ("CORE_ADDR", "size")], 2597 predefault="default_infcall_munmap", 2598 invalid=False, 2599) 2600 2601Method( 2602 comment=""" 2603Return string (caller has to use xfree for it) with options for GCC 2604to produce code for this target, typically "-m64", "-m32" or "-m31". 2605These options are put before CU's DW_AT_producer compilation options so that 2606they can override it. 2607""", 2608 type="std::string", 2609 name="gcc_target_options", 2610 params=[], 2611 predefault="default_gcc_target_options", 2612 invalid=False, 2613) 2614 2615Method( 2616 comment=""" 2617Return a regular expression that matches names used by this 2618architecture in GNU configury triplets. The result is statically 2619allocated and must not be freed. The default implementation simply 2620returns the BFD architecture name, which is correct in nearly every 2621case. 2622""", 2623 type="const char *", 2624 name="gnu_triplet_regexp", 2625 params=[], 2626 predefault="default_gnu_triplet_regexp", 2627 invalid=False, 2628) 2629 2630Method( 2631 comment=""" 2632Return the size in 8-bit bytes of an addressable memory unit on this 2633architecture. This corresponds to the number of 8-bit bytes associated to 2634each address in memory. 2635""", 2636 type="int", 2637 name="addressable_memory_unit_size", 2638 params=[], 2639 predefault="default_addressable_memory_unit_size", 2640 invalid=False, 2641) 2642 2643Value( 2644 comment=""" 2645Functions for allowing a target to modify its disassembler options. 2646""", 2647 type="const char *", 2648 name="disassembler_options_implicit", 2649 predefault="0", 2650 invalid=False, 2651 printer="pstring (gdbarch->disassembler_options_implicit)", 2652) 2653 2654Value( 2655 type="char **", 2656 name="disassembler_options", 2657 predefault="0", 2658 invalid=False, 2659 printer="pstring_ptr (gdbarch->disassembler_options)", 2660) 2661 2662Value( 2663 type="const disasm_options_and_args_t *", 2664 name="valid_disassembler_options", 2665 predefault="0", 2666 invalid=False, 2667 printer="host_address_to_string (gdbarch->valid_disassembler_options)", 2668) 2669 2670Method( 2671 comment=""" 2672Type alignment override method. Return the architecture specific 2673alignment required for TYPE. If there is no special handling 2674required for TYPE then return the value 0, GDB will then apply the 2675default rules as laid out in gdbtypes.c:type_align. 2676""", 2677 type="ULONGEST", 2678 name="type_align", 2679 params=[("struct type *", "type")], 2680 predefault="default_type_align", 2681 invalid=False, 2682) 2683 2684Function( 2685 comment=""" 2686Return a string containing any flags for the given PC in the given FRAME. 2687""", 2688 type="std::string", 2689 name="get_pc_address_flags", 2690 params=[("frame_info_ptr", "frame"), ("CORE_ADDR", "pc")], 2691 predefault="default_get_pc_address_flags", 2692 invalid=False, 2693) 2694 2695Method( 2696 comment=""" 2697Read core file mappings 2698""", 2699 type="void", 2700 name="read_core_file_mappings", 2701 params=[ 2702 ("struct bfd *", "cbfd"), 2703 ("read_core_file_mappings_pre_loop_ftype", "pre_loop_cb"), 2704 ("read_core_file_mappings_loop_ftype", "loop_cb"), 2705 ], 2706 predefault="default_read_core_file_mappings", 2707 invalid=False, 2708) 2709