### 9.11 Target Conditionals

This section describes the macros and functions that you can use to define the target machine.

`CORE_ADDR gdbarch_addr_bits_remove (`gdbarch`,` addr`)`
  If a raw machine instruction address includes any bits that are not really part of the address, then this function is used to zero those bits in addr. This is only used for addresses of instructions, and even then not in all contexts.

  For example, the two low-order bits of the PC on the Hewlett-Packard PA 2.0 architecture contain the privilege level of the corresponding instruction. Since instructions must always be aligned on four-byte boundaries, the processor masks out these bits to generate the actual address of the instruction. `gdbarch_addr_bits_remove` would then for example look like that:

                arch_addr_bits_remove (CORE_ADDR addr)
                {
                  return (addr &= ~0x3);
                }

`int address_class_name_to_type_flags (`gdbarch`,` name`,` type_flags_ptr`)`
  If name is a valid address class qualifier name, set the `int` referenced by type_flags_ptr to the mask representing the qualifier and return 1. If name is not a valid address class qualifier name, return 0.

  The value for type_flags_ptr should be one of `TYPE_FLAG_ADDRESS_CLASS_1`, `TYPE_FLAG_ADDRESS_CLASS_2`, or possibly some combination of these values or'd together. See Address Classes.

`int address_class_name_to_type_flags_p (`gdbarch`)`
  Predicate which indicates whether `address_class_name_to_type_flags` has been defined.
`int gdbarch_address_class_type_flags (`gdbarch`,` byte_size`,` dwarf2_addr_class`)`
  Given a pointers byte size (as described by the debug information) and the possible `DW_AT_address_class` value, return the type flags used by gdb to represent this address class. The value returned should be one of `TYPE_FLAG_ADDRESS_CLASS_1`, `TYPE_FLAG_ADDRESS_CLASS_2`, or possibly some combination of these values or'd together. See Address Classes.
`int gdbarch_address_class_type_flags_p (`gdbarch`)`
  Predicate which indicates whether `gdbarch_address_class_type_flags_p` has been defined.
`const char *gdbarch_address_class_type_flags_to_name (`gdbarch`,` type_flags`)`
  Return the name of the address class qualifier associated with the type flags given by type_flags.
`int gdbarch_address_class_type_flags_to_name_p (`gdbarch`)`
  Predicate which indicates whether `gdbarch_address_class_type_flags_to_name` has been defined. See Address Classes.
`void gdbarch_address_to_pointer (`gdbarch`,` type`,` buf`,` addr`)`
  Store in buf a pointer of type type representing the address addr, in the appropriate format for the current architecture. This function may safely assume that type is either a pointer or a C`++` reference type. See Pointers Are Not Always Addresses.
`int gdbarch_believe_pcc_promotion (`gdbarch`)`
  Used to notify if the compiler promotes a `short` or `char` parameter to an `int`, but still reports the parameter as its original type, rather than the promoted type.
`BITS_BIG_ENDIAN`
  Define this if the numbering of bits in the targets does not match the endianness of the target byte order. A value of 1 means that the bits are numbered in a big-endian bit order, 0 means little-endian.
`BREAKPOINT`
  This is the character array initializer for the bit pattern to put into memory where a breakpoint is set. Although it's common to use a trap instruction for a breakpoint, it's not required; for instance, the bit pattern could be an invalid instruction. The breakpoint must be no longer than the shortest instruction of the architecture.

  `BREAKPOINT` has been deprecated in favor of `gdbarch_breakpoint_from_pc`.

`BIG_BREAKPOINT`
`LITTLE_BREAKPOINT`
  Similar to BREAKPOINT, but used for bi-endian targets.

  `BIG_BREAKPOINT` and `LITTLE_BREAKPOINT` have been deprecated in favor of `gdbarch_breakpoint_from_pc`.

`const gdb_byte *gdbarch_breakpoint_from_pc (`gdbarch`,` pcptr`,` lenptr`)`
  Use the program counter to determine the contents and size of a breakpoint instruction. It returns a pointer to a string of bytes that encode a breakpoint instruction, stores the length of the string to `*`lenptr, and adjusts the program counter (if necessary) to point to the actual memory location where the breakpoint should be inserted.

  Although it is common to use a trap instruction for a breakpoint, it's not required; for instance, the bit pattern could be an invalid instruction. The breakpoint must be no longer than the shortest instruction of the architecture.

  Replaces all the other BREAKPOINT macros.

`int gdbarch_memory_insert_breakpoint (`gdbarch`,` bp_tgt`)`
`gdbarch_memory_remove_breakpoint (`gdbarch`,` bp_tgt`)`
  Insert or remove memory based breakpoints. Reasonable defaults (`default_memory_insert_breakpoint` and `default_memory_remove_breakpoint` respectively) have been provided so that it is not necessary to set these for most architectures. Architectures which may want to set `gdbarch_memory_insert_breakpoint` and `gdbarch_memory_remove_breakpoint` will likely have instructions that are oddly sized or are not stored in a conventional manner.

  It may also be desirable (from an efficiency standpoint) to define custom breakpoint insertion and removal routines if `gdbarch_breakpoint_from_pc` needs to read the target's memory for some reason.

`CORE_ADDR gdbarch_adjust_breakpoint_address (`gdbarch`,` bpaddr`)`
  Given an address at which a breakpoint is desired, return a breakpoint address adjusted to account for architectural constraints on breakpoint placement. This method is not needed by most targets.

  The FR-V target (see `frv-tdep.c`) requires this method. The FR-V is a VLIW architecture in which a number of RISC-like instructions are grouped (packed) together into an aggregate instruction or instruction bundle. When the processor executes one of these bundles, the component instructions are executed in parallel.

  In the course of optimization, the compiler may group instructions from distinct source statements into the same bundle. The line number information associated with one of the latter statements will likely refer to some instruction other than the first one in the bundle. So, if the user attempts to place a breakpoint on one of these latter statements, gdb must be careful to not place the break instruction on any instruction other than the first one in the bundle. (Remember though that the instructions within a bundle execute in parallel, so the first instruction is the instruction at the lowest address and has nothing to do with execution order.)

  The FR-V's `gdbarch_adjust_breakpoint_address` method will adjust a breakpoint's address by scanning backwards for the beginning of the bundle, returning the address of the bundle.

  Since the adjustment of a breakpoint may significantly alter a user's expectation, gdb prints a warning when an adjusted breakpoint is initially set and each time that that breakpoint is hit.

`int gdbarch_call_dummy_location (`gdbarch`)`
  See the file `inferior.h`.

  This method has been replaced by `gdbarch_push_dummy_code` (see gdbarch_push_dummy_code).

`int gdbarch_cannot_fetch_register (`gdbarch`,` regum`)`
  This function should return nonzero if regno cannot be fetched from an inferior process. This is only relevant if `FETCH_INFERIOR_REGISTERS` is not defined.
`int gdbarch_cannot_store_register (`gdbarch`,` regnum`)`
  This function should return nonzero if regno should not be written to the target. This is often the case for program counters, status words, and other special registers. This function returns 0 as default so that gdb will assume that all registers may be written.
`int gdbarch_convert_register_p (`gdbarch`,` regnum`, struct type *`type`)`
  Return non-zero if register regnum represents data values of type type in a non-standard form. See Using Different Register and Memory Data Representations.
`CORE_ADDR gdbarch_decr_pc_after_break (`gdbarch`)`
  This function shall return the amount by which to decrement the PC after the program encounters a breakpoint. This is often the number of bytes in `BREAKPOINT`, though not always. For most targets this value will be 0.
`DISABLE_UNSETTABLE_BREAK (`addr`)`
  If defined, this should evaluate to 1 if addr is in a shared library in which breakpoints cannot be set and so should be disabled.
`void gdbarch_print_float_info (`gdbarch`,` file`,` frame`,` args`)`
  If defined, then the ``info float`' command will print information about the processor's floating point unit.
`void gdbarch_print_registers_info (`gdbarch`,` frame`,` regnum`,` all`)`
  If defined, pretty print the value of the register regnum for the specified frame. If the value of regnum is -1, pretty print either all registers (all is non zero) or a select subset of registers (all is zero).

  The default method prints one register per line, and if all is zero omits floating-point registers.

`int gdbarch_print_vector_info (`gdbarch`,` file`,` frame`,` args`)`
  If defined, then the ``info vector`' command will call this function to print information about the processor's vector unit.

  By default, the ``info vector`' command will print all vector registers (the register's type having the vector attribute).

`int gdbarch_dwarf_reg_to_regnum (`gdbarch`,` dwarf_regnr`)`
  Convert DWARF register number dwarf_regnr into gdb regnum. If not defined, no conversion will be performed.
`int gdbarch_dwarf2_reg_to_regnum (`gdbarch`,` dwarf2_regnr`)`
  Convert DWARF2 register number dwarf2_regnr into gdb regnum. If not defined, no conversion will be performed.
`int gdbarch_ecoff_reg_to_regnum (`gdbarch`,` ecoff_regnr`)`
  Convert ECOFF register number ecoff_regnr into gdb regnum. If not defined, no conversion will be performed.
`DEPRECATED_FP_REGNUM`
  If the virtual frame pointer is kept in a register, then define this macro to be the number (greater than or equal to zero) of that register.

  This should only need to be defined if `DEPRECATED_TARGET_READ_FP` is not defined.

`DEPRECATED_FRAMELESS_FUNCTION_INVOCATION(`fi`)`
  Define this to an expression that returns 1 if the function invocation represented by fi does not have a stack frame associated with it. Otherwise return 0.
`CORE_ADDR frame_align (`gdbarch`,` address`)`
  Define this to adjust address so that it meets the alignment requirements for the start of a new stack frame. A stack frame's alignment requirements are typically stronger than a target processors stack alignment requirements.

  This function is used to ensure that, when creating a dummy frame, both the initial stack pointer and (if needed) the address of the return value are correctly aligned.

  This function always adjusts the address in the direction of stack growth.

  By default, no frame based stack alignment is performed.

`int gdbarch_frame_red_zone_size (`gdbarch`)`
  The number of bytes, beyond the innermost-stack-address, reserved by the abi. A function is permitted to use this scratch area (instead of allocating extra stack space).

  When performing an inferior function call, to ensure that it does not modify this area, gdb adjusts the innermost-stack-address by gdbarch_frame_red_zone_size bytes before pushing parameters onto the stack.

  By default, zero bytes are allocated. The value must be aligned (see frame_align).

  The amd64 (nee x86-64) abi documentation refers to the red zone when describing this scratch area.

`DEPRECATED_FRAME_CHAIN(`frame`)`
  Given frame, return a pointer to the calling frame.
`DEPRECATED_FRAME_CHAIN_VALID(`chain`,` thisframe`)`
  Define this to be an expression that returns zero if the given frame is an outermost frame, with no caller, and nonzero otherwise. Most normal situations can be handled without defining this macro, including `NULL` chain pointers, dummy frames, and frames whose PC values are inside the startup file (e.g. `crt0.o`), inside `main`, or inside `_start`.
`DEPRECATED_FRAME_INIT_SAVED_REGS(`frame`)`
  See `frame.h`. Determines the address of all registers in the current stack frame storing each in `frame->saved_regs`. Space for `frame->saved_regs` shall be allocated by `DEPRECATED_FRAME_INIT_SAVED_REGS` using `frame_saved_regs_zalloc`.

  `FRAME_FIND_SAVED_REGS` is deprecated.

`int gdbarch_frame_num_args (`gdbarch`,` frame`)`
  For the frame described by frame return the number of arguments that are being passed. If the number of arguments is not known, return `-1`.
`DEPRECATED_FRAME_SAVED_PC(`frame`)`
  Given frame, return the pc saved there. This is the return address.

  This method is deprecated. See gdbarch_unwind_pc.

`CORE_ADDR gdbarch_unwind_pc (`next_frame`)`
  Return the instruction address, in next_frame's caller, at which execution will resume after next_frame returns. This is commonly referred to as the return address.

  The implementation, which must be frame agnostic (work with any frame), is typically no more than:

                ULONGEST pc;
                pc = frame_unwind_register_unsigned (next_frame, S390_PC_REGNUM);
                return gdbarch_addr_bits_remove (gdbarch, pc);

  See DEPRECATED_FRAME_SAVED_PC, which this method replaces.

`CORE_ADDR gdbarch_unwind_sp (`gdbarch`,` next_frame`)`
  Return the frame's inner most stack address. This is commonly referred to as the frame's stack pointer.

  The implementation, which must be frame agnostic (work with any frame), is typically no more than:

                ULONGEST sp;
                sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);
                return gdbarch_addr_bits_remove (gdbarch, sp);

  See TARGET_READ_SP, which this method replaces.

`FUNCTION_EPILOGUE_SIZE`
  For some COFF targets, the `x_sym.x_misc.x_fsize` field of the function end symbol is 0. For such targets, you must define `FUNCTION_EPILOGUE_SIZE` to expand into the standard size of a function's epilogue.
`DEPRECATED_FUNCTION_START_OFFSET`
  An integer, giving the offset in bytes from a function's address (as used in the values of symbols, function pointers, etc.), and the function's first genuine instruction.

  This is zero on almost all machines: the function's address is usually the address of its first instruction. However, on the VAX, for example, each function starts with two bytes containing a bitmask indicating which registers to save upon entry to the function. The VAX `call` instructions check this value, and save the appropriate registers automatically. Thus, since the offset from the function's address to its first instruction is two bytes, `DEPRECATED_FUNCTION_START_OFFSET` would be 2 on the VAX.

`GCC_COMPILED_FLAG_SYMBOL`
`GCC2_COMPILED_FLAG_SYMBOL`
  If defined, these are the names of the symbols that gdb will look for to detect that GCC compiled the file. The default symbols are `gcc_compiled.` and `gcc2_compiled.`, respectively. (Currently only defined for the Delta 68.)
`gdbarch_get_longjmp_target`
  For most machines, this is a target-dependent parameter. On the DECstation and the Iris, this is a native-dependent parameter, since the header file `setjmp.h` is needed to define it.

  This macro determines the target PC address that `longjmp` will jump to, assuming that we have just stopped at a `longjmp` breakpoint. It takes a `CORE_ADDR *` as argument, and stores the target PC value through this pointer. It examines the current state of the machine as needed.

`DEPRECATED_IBM6000_TARGET`
  Shows that we are configured for an IBM RS/6000 system. This conditional should be eliminated (FIXME) and replaced by feature-specific macros. It was introduced in a haste and we are repenting at leisure.
`I386_USE_GENERIC_WATCHPOINTS`
  An x86-based target can define this to use the generic x86 watchpoint support; see I386_USE_GENERIC_WATCHPOINTS.
`int gdbarch_inner_than (`gdbarch`,` lhs`,` rhs`)`
  Returns non-zero if stack address lhs is inner than (nearer to the stack top) stack address rhs. Let the function return `lhs < rhs` if the target's stack grows downward in memory, or `lhs > rsh` if the stack grows upward.
`gdbarch_in_function_epilogue_p (`gdbarch`,` addr`)`
  Returns non-zero if the given addr is in the epilogue of a function. The epilogue of a function is defined as the part of a function where the stack frame of the function already has been destroyed up to the final `return from function call' instruction.
`int gdbarch_in_solib_return_trampoline (`gdbarch`,` pc`,` name`)`
  Define this function to return nonzero if the program is stopped in the trampoline that returns from a shared library.
`IN_SOLIB_DYNSYM_RESOLVE_CODE (`pc`)`
  Define this to return nonzero if the program is stopped in the dynamic linker.
`SKIP_SOLIB_RESOLVER (`pc`)`
  Define this to evaluate to the (nonzero) address at which execution should continue to get past the dynamic linker's symbol resolution function. A zero value indicates that it is not important or necessary to set a breakpoint to get through the dynamic linker and that single stepping will suffice.
`CORE_ADDR gdbarch_integer_to_address (`gdbarch`,` type`,` buf`)`
  Define this when the architecture needs to handle non-pointer to address conversions specially. Converts that value to an address according to the current architectures conventions.

  Pragmatics: When the user copies a well defined expression from their source code and passes it, as a parameter, to gdb's `print` command, they should get the same value as would have been computed by the target program. Any deviation from this rule can cause major confusion and annoyance, and needs to be justified carefully. In other words, gdb doesn't really have the freedom to do these conversions in clever and useful ways. It has, however, been pointed out that users aren't complaining about how gdb casts integers to pointers; they are complaining that they can't take an address from a disassembly listing and give it to `x/i`. Adding an architecture method like `gdbarch_integer_to_address` certainly makes it possible for gdb to “get it right” in all circumstances.

  See Pointers Are Not Always Addresses.

`CORE_ADDR gdbarch_pointer_to_address (`gdbarch`,` type`,` buf`)`
  Assume that buf holds a pointer of type type, in the appropriate format for the current architecture. Return the byte address the pointer refers to. See Pointers Are Not Always Addresses.
`void gdbarch_register_to_value(`gdbarch`,` frame`,` regnum`,` type`,` fur`)`
  Convert the raw contents of register regnum into a value of type type. See Using Different Register and Memory Data Representations.
`register_reggroup_p (`gdbarch`,` regnum`,` reggroup`)`
  Return non-zero if register regnum is a member of the register group reggroup.

  By default, registers are grouped as follows:

  `float_reggroup`
    Any register with a valid name and a floating-point type.
  `vector_reggroup`
    Any register with a valid name and a vector type.
  `general_reggroup`
    Any register with a valid name and a type other than vector or floating-point. ``float_reggroup`'.
  `save_reggroup`
  `restore_reggroup`
  `all_reggroup`
    Any register with a valid name.
`DEPRECATED_REGISTER_VIRTUAL_SIZE (`reg`)`
  Return the virtual size of reg; defaults to the size of the register's virtual type. Return the virtual size of reg. See Raw and Virtual Register Representations.
`DEPRECATED_REGISTER_VIRTUAL_TYPE (`reg`)`
  Return the virtual type of reg. See Raw and Virtual Register Representations.
`struct type *register_type (`gdbarch`,` reg`)`
  If defined, return the type of register reg. This function supersedes `DEPRECATED_REGISTER_VIRTUAL_TYPE`. See Raw and Virtual Register Representations.
`REGISTER_CONVERT_TO_VIRTUAL(`reg`,` type`,` from`,` to`)`
  Convert the value of register reg from its raw form to its virtual form. See Raw and Virtual Register Representations.
`REGISTER_CONVERT_TO_RAW(`type`,` reg`,` from`,` to`)`
  Convert the value of register reg from its virtual form to its raw form. See Raw and Virtual Register Representations.
`const struct regset *regset_from_core_section (struct gdbarch *` gdbarch`, const char *` sect_name`, size_t` sect_size`)`
  Return the appropriate register set for a core file section with name sect_name and size sect_size.
`SOFTWARE_SINGLE_STEP_P()`
  Define this as 1 if the target does not have a hardware single-step mechanism. The macro `SOFTWARE_SINGLE_STEP` must also be defined.
`SOFTWARE_SINGLE_STEP(`signal`,` insert_breakpoints_p`)`
  A function that inserts or removes (depending on insert_breakpoints_p) breakpoints at each possible destinations of the next instruction. See `sparc-tdep.c` and `rs6000-tdep.c` for examples.
`set_gdbarch_sofun_address_maybe_missing (`gdbarch`,` set`)`
  Somebody clever observed that, the more actual addresses you have in the debug information, the more time the linker has to spend relocating them. So whenever there's some other way the debugger could find the address it needs, you should omit it from the debug info, to make linking faster.

  Calling `set_gdbarch_sofun_address_maybe_missing` with a non-zero argument set indicates that a particular set of hacks of this sort are in use, affecting `N_SO` and `N_FUN` entries in stabs-format debugging information. `N_SO` stabs mark the beginning and ending addresses of compilation units in the text segment. `N_FUN` stabs mark the starts and ends of functions.

  In this case, gdb assumes two things:

  - `N_FUN` stabs have an address of zero. Instead of using those addresses, you should find the address where the function starts by taking the function name from the stab, and then looking that up in the minsyms (the linker/assembler symbol table). In other words, the stab has the name, and the linker/assembler symbol table is the only place that carries the address.
  - `N_SO` stabs have an address of zero, too. You just look at the `N_FUN` stabs that appear before and after the `N_SO` stab, and guess the starting and ending addresses of the compilation unit from them.
`int gdbarch_pc_regnum (`gdbarch`)`
  If the program counter is kept in a register, then let this function return the number (greater than or equal to zero) of that register.

  This should only need to be defined if `gdbarch_read_pc` and `gdbarch_write_pc` are not defined.

`int gdbarch_stabs_argument_has_addr (`gdbarch`,` type`)`
  Define this function to return nonzero if a function argument of type type is passed by reference instead of value.
`PROCESS_LINENUMBER_HOOK`
  A hook defined for XCOFF reading.
`gdbarch_ps_regnum (`gdbarch
  If defined, this function returns the number of the processor status register. (This definition is only used in generic code when parsing "$ps".)
`CORE_ADDR gdbarch_push_dummy_call (`gdbarch`,` function`,` regcache`,` bp_addr`,` nargs`,` args`,` sp`,` struct_return`,` struct_addr`)`
  Define this to push the dummy frame's call to the inferior function onto the stack. In addition to pushing nargs, the code should push struct_addr (when struct_return is non-zero), and the return address (bp_addr).

  function is a pointer to a `struct value`; on architectures that use function descriptors, this contains the function descriptor value.

  Returns the updated top-of-stack pointer.

  This method replaces `DEPRECATED_PUSH_ARGUMENTS`.

`CORE_ADDR gdbarch_push_dummy_code (`gdbarch`,` sp`,` funaddr`,` using_gcc`,` args`,` nargs`,` value_type`,` real_pc`,` bp_addr`,` regcache`)`
  Given a stack based call dummy, push the instruction sequence (including space for a breakpoint) to which the called function should return.

  Set bp_addr to the address at which the breakpoint instruction should be inserted, real_pc to the resume address when starting the call sequence, and return the updated inner-most stack address.

  By default, the stack is grown sufficient to hold a frame-aligned (see frame_align) breakpoint, bp_addr is set to the address reserved for that breakpoint, and real_pc set to funaddr.

  This method replaces `gdbarch_call_dummy_location (`gdbarch`)` and `DEPRECATED_REGISTER_SIZE`.

`const char *gdbarch_register_name (`gdbarch`,` regnr`)`
  Return the name of register regnr as a string. May return `NULL` to indicate that regnr is not a valid register.
`SAVE_DUMMY_FRAME_TOS (`sp`)`
  Used in ``call_function_by_hand`' to notify the target dependent code of the top-of-stack value that will be passed to the inferior code. This is the value of the `SP` after both the dummy frame and space for parameters/results have been allocated on the stack. See gdbarch_unwind_dummy_id.
`int gdbarch_sdb_reg_to_regnum (`gdbarch`,` sdb_regnr`)`
  Use this function to convert sdb register sdb_regnr into gdb regnum. If not defined, no conversion will be done.
`enum return_value_convention gdbarch_return_value (struct gdbarch *`gdbarch`, struct type *`valtype`, struct regcache *`regcache`, void *`readbuf`, const void *`writebuf`)`
  Given a function with a return-value of type rettype, return which return-value convention that function would use.

  gdb currently recognizes two function return-value conventions: `RETURN_VALUE_REGISTER_CONVENTION` where the return value is found in registers; and `RETURN_VALUE_STRUCT_CONVENTION` where the return value is found in memory and the address of that memory location is passed in as the function's first parameter.

  If the register convention is being used, and writebuf is non-`NULL`, also copy the return-value in writebuf into regcache.

  If the register convention is being used, and readbuf is non-`NULL`, also copy the return value from regcache into readbuf (regcache contains a copy of the registers from the just returned function).

  Maintainer note: This method replaces separate predicate, extract, store methods. By having only one method, the logic needed to determine the return-value convention need only be implemented in one place. If gdb were written in an oo language, this method would instead return an object that knew how to perform the register return-value extract and store.

  Maintainer note: This method does not take a gcc_p parameter, and such a parameter should not be added. If an architecture that requires per-compiler or per-function information be identified, then the replacement of rettype with `struct value` function should be pursued.

  Maintainer note: The regcache parameter limits this methods to the inner most frame. While replacing regcache with a `struct frame_info` frame parameter would remove that limitation there has yet to be a demonstrated need for such a change.

`void gdbarch_skip_permanent_breakpoint (`gdbarch`,` regcache`)`
  Advance the inferior's PC past a permanent breakpoint. gdb normally steps over a breakpoint by removing it, stepping one instruction, and re-inserting the breakpoint. However, permanent breakpoints are hardwired into the inferior, and can't be removed, so this strategy doesn't work. Calling `gdbarch_skip_permanent_breakpoint` adjusts the processor's state so that execution will resume just after the breakpoint. This function does the right thing even when the breakpoint is in the delay slot of a branch or jump.
`CORE_ADDR gdbarch_skip_prologue (`gdbarch`,` ip`)`
  A function that returns the address of the “real” code beyond the function entry prologue found at ip.
`CORE_ADDR gdbarch_skip_trampoline_code (`gdbarch`,` frame`,` pc`)`
  If the target machine has trampoline code that sits between callers and the functions being called, then define this function to return a new PC that is at the start of the real function.
`int gdbarch_sp_regnum (`gdbarch`)`
  If the stack-pointer is kept in a register, then use this function to return the number (greater than or equal to zero) of that register, or -1 if there is no such register.
`int gdbarch_stab_reg_to_regnum (`gdbarch`,` stab_regnr`)`
  Use this function to convert stab register stab_regnr into gdb regnum. If not defined, no conversion will be done.
`SYMBOL_RELOADING_DEFAULT`
  The default value of the “symbol-reloading” variable. (Never defined in current sources.)
`TARGET_CHAR_BIT`
  Number of bits in a char; defaults to 8.
`int gdbarch_char_signed (`gdbarch`)`
  Non-zero if `char` is normally signed on this architecture; zero if it should be unsigned.

  The ISO C standard requires the compiler to treat `char` as equivalent to either `signed char` or `unsigned char`; any character in the standard execution set is supposed to be positive. Most compilers treat `char` as signed, but `char` is unsigned on the IBM S/390, RS6000, and PowerPC targets.

`int gdbarch_double_bit (`gdbarch`)`
  Number of bits in a double float; defaults to `8 * TARGET_CHAR_BIT`.
`int gdbarch_float_bit (`gdbarch`)`
  Number of bits in a float; defaults to `4 * TARGET_CHAR_BIT`.
`int gdbarch_int_bit (`gdbarch`)`
  Number of bits in an integer; defaults to `4 * TARGET_CHAR_BIT`.
`int gdbarch_long_bit (`gdbarch`)`
  Number of bits in a long integer; defaults to `4 * TARGET_CHAR_BIT`.
`int gdbarch_long_double_bit (`gdbarch`)`
  Number of bits in a long double float; defaults to `2 * gdbarch_double_bit (`gdbarch`)`.
`int gdbarch_long_long_bit (`gdbarch`)`
  Number of bits in a long long integer; defaults to `2 * gdbarch_long_bit (`gdbarch`)`.
`int gdbarch_ptr_bit (`gdbarch`)`
  Number of bits in a pointer; defaults to `gdbarch_int_bit (`gdbarch`)`.
`int gdbarch_short_bit (`gdbarch`)`
  Number of bits in a short integer; defaults to `2 * TARGET_CHAR_BIT`.
`CORE_ADDR gdbarch_read_pc (`gdbarch`,` regcache`)`
`gdbarch_write_pc (`gdbarch`,` regcache`,` val`)`
`TARGET_READ_SP`
`TARGET_READ_FP`
  These change the behavior of `gdbarch_read_pc`, `gdbarch_write_pc`, and `read_sp`. For most targets, these may be left undefined. gdb will call the read and write register functions with the relevant `_REGNUM` argument.

  These macros and functions are useful when a target keeps one of these registers in a hard to get at place; for example, part in a segment register and part in an ordinary register.

  See gdbarch_unwind_sp, which replaces `TARGET_READ_SP`.

`void gdbarch_virtual_frame_pointer (`gdbarch`,` pc`,` frame_regnum`,` frame_offset`)`
  Returns a `(register, offset)` pair representing the virtual frame pointer in use at the code address pc. If virtual frame pointers are not used, a default definition simply returns `DEPRECATED_FP_REGNUM`, with an offset of zero.
`TARGET_HAS_HARDWARE_WATCHPOINTS`
  If non-zero, the target has support for hardware-assisted watchpoints. See watchpoints, for more details and other related macros.
`int gdbarch_print_insn (`gdbarch`,` vma`,` info`)`
  This is the function used by gdb to print an assembly instruction. It prints the instruction at address vma in debugged memory and returns the length of the instruction, in bytes. If a target doesn't define its own printing routine, it defaults to an accessor function for the global pointer `deprecated_tm_print_insn`. This usually points to a function in the `opcodes` library (see Opcodes). info is a structure (of type `disassemble_info`) defined in `include/dis-asm.h` used to pass information to the instruction decoding routine.
`frame_id gdbarch_unwind_dummy_id (`gdbarch`,` frame`)`
  Given frame return a `struct frame_id` that uniquely identifies an inferior function call's dummy frame. The value returned must match the dummy frame stack value previously saved using `SAVE_DUMMY_FRAME_TOS`. See SAVE_DUMMY_FRAME_TOS.
`DEPRECATED_USE_STRUCT_CONVENTION (`gcc_p`,` type`)`
  If defined, this must be an expression that is nonzero if a value of the given type being returned from a function must have space allocated for it on the stack. gcc_p is true if the function being considered is known to have been compiled by GCC; this is helpful for systems where GCC is known to use different calling convention than other compilers.

  This method has been deprecated in favour of `gdbarch_return_value` (see gdbarch_return_value).

`void gdbarch_value_to_register (`gdbarch`,` frame`,` type`,` buf`)`
  Convert a value of type type into the raw contents of a register. See Using Different Register and Memory Data Representations.

Motorola M68K target conditionals.

`BPT_VECTOR`
  Define this to be the 4-bit location of the breakpoint trap vector. If not defined, it will default to `0xf`.
`REMOTE_BPT_VECTOR`
  Defaults to `1`.
`const char *gdbarch_name_of_malloc (`gdbarch`)`
  A string containing the name of the function to call in order to allocate some memory in the inferior. The default value is "malloc".