1#!/bin/sh -u 2 3# Architecture commands for GDB, the GNU debugger. 4# 5# Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 6# Free Software Foundation, Inc. 7# 8# This file is part of GDB. 9# 10# This program is free software; you can redistribute it and/or modify 11# it under the terms of the GNU General Public License as published by 12# the Free Software Foundation; either version 3 of the License, or 13# (at your option) any later version. 14# 15# This program is distributed in the hope that it will be useful, 16# but WITHOUT ANY WARRANTY; without even the implied warranty of 17# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18# GNU General Public License for more details. 19# 20# You should have received a copy of the GNU General Public License 21# along with this program. If not, see <http://www.gnu.org/licenses/>. 22 23# Make certain that the script is not running in an internationalized 24# environment. 25LANG=c ; export LANG 26LC_ALL=c ; export LC_ALL 27 28 29compare_new () 30{ 31 file=$1 32 if test ! -r ${file} 33 then 34 echo "${file} missing? cp new-${file} ${file}" 1>&2 35 elif diff -u ${file} new-${file} 36 then 37 echo "${file} unchanged" 1>&2 38 else 39 echo "${file} has changed? cp new-${file} ${file}" 1>&2 40 fi 41} 42 43 44# Format of the input table 45read="class macro returntype function formal actual staticdefault predefault postdefault invalid_p print garbage_at_eol" 46 47do_read () 48{ 49 comment="" 50 class="" 51 while read line 52 do 53 if test "${line}" = "" 54 then 55 continue 56 elif test "${line}" = "#" -a "${comment}" = "" 57 then 58 continue 59 elif expr "${line}" : "#" > /dev/null 60 then 61 comment="${comment} 62${line}" 63 else 64 65 # The semantics of IFS varies between different SH's. Some 66 # treat ``::' as three fields while some treat it as just too. 67 # Work around this by eliminating ``::'' .... 68 line="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`" 69 70 OFS="${IFS}" ; IFS="[:]" 71 eval read ${read} <<EOF 72${line} 73EOF 74 IFS="${OFS}" 75 76 if test -n "${garbage_at_eol}" 77 then 78 echo "Garbage at end-of-line in ${line}" 1>&2 79 kill $$ 80 exit 1 81 fi 82 83 # .... and then going back through each field and strip out those 84 # that ended up with just that space character. 85 for r in ${read} 86 do 87 if eval test \"\${${r}}\" = \"\ \" 88 then 89 eval ${r}="" 90 fi 91 done 92 93 FUNCTION=`echo ${function} | tr '[a-z]' '[A-Z]'` 94 if test "x${macro}" = "x=" 95 then 96 # Provide a UCASE version of function (for when there isn't MACRO) 97 macro="${FUNCTION}" 98 elif test "${macro}" = "${FUNCTION}" 99 then 100 echo "${function}: Specify = for macro field" 1>&2 101 kill $$ 102 exit 1 103 fi 104 105 # Check that macro definition wasn't supplied for multi-arch 106 case "${class}" in 107 [mM] ) 108 if test "${macro}" != "" 109 then 110 echo "Error: Function ${function} multi-arch yet macro ${macro} supplied" 1>&2 111 kill $$ 112 exit 1 113 fi 114 esac 115 116 case "${class}" in 117 m ) staticdefault="${predefault}" ;; 118 M ) staticdefault="0" ;; 119 * ) test "${staticdefault}" || staticdefault=0 ;; 120 esac 121 122 case "${class}" in 123 F | V | M ) 124 case "${invalid_p}" in 125 "" ) 126 if test -n "${predefault}" 127 then 128 #invalid_p="gdbarch->${function} == ${predefault}" 129 predicate="gdbarch->${function} != ${predefault}" 130 elif class_is_variable_p 131 then 132 predicate="gdbarch->${function} != 0" 133 elif class_is_function_p 134 then 135 predicate="gdbarch->${function} != NULL" 136 fi 137 ;; 138 * ) 139 echo "Predicate function ${function} with invalid_p." 1>&2 140 kill $$ 141 exit 1 142 ;; 143 esac 144 esac 145 146 # PREDEFAULT is a valid fallback definition of MEMBER when 147 # multi-arch is not enabled. This ensures that the 148 # default value, when multi-arch is the same as the 149 # default value when not multi-arch. POSTDEFAULT is 150 # always a valid definition of MEMBER as this again 151 # ensures consistency. 152 153 if [ -n "${postdefault}" ] 154 then 155 fallbackdefault="${postdefault}" 156 elif [ -n "${predefault}" ] 157 then 158 fallbackdefault="${predefault}" 159 else 160 fallbackdefault="0" 161 fi 162 163 #NOT YET: See gdbarch.log for basic verification of 164 # database 165 166 break 167 fi 168 done 169 if [ -n "${class}" ] 170 then 171 true 172 else 173 false 174 fi 175} 176 177 178fallback_default_p () 179{ 180 [ -n "${postdefault}" -a "x${invalid_p}" != "x0" ] \ 181 || [ -n "${predefault}" -a "x${invalid_p}" = "x0" ] 182} 183 184class_is_variable_p () 185{ 186 case "${class}" in 187 *v* | *V* ) true ;; 188 * ) false ;; 189 esac 190} 191 192class_is_function_p () 193{ 194 case "${class}" in 195 *f* | *F* | *m* | *M* ) true ;; 196 * ) false ;; 197 esac 198} 199 200class_is_multiarch_p () 201{ 202 case "${class}" in 203 *m* | *M* ) true ;; 204 * ) false ;; 205 esac 206} 207 208class_is_predicate_p () 209{ 210 case "${class}" in 211 *F* | *V* | *M* ) true ;; 212 * ) false ;; 213 esac 214} 215 216class_is_info_p () 217{ 218 case "${class}" in 219 *i* ) true ;; 220 * ) false ;; 221 esac 222} 223 224 225# dump out/verify the doco 226for field in ${read} 227do 228 case ${field} in 229 230 class ) : ;; 231 232 # # -> line disable 233 # f -> function 234 # hiding a function 235 # F -> function + predicate 236 # hiding a function + predicate to test function validity 237 # v -> variable 238 # hiding a variable 239 # V -> variable + predicate 240 # hiding a variable + predicate to test variables validity 241 # i -> set from info 242 # hiding something from the ``struct info'' object 243 # m -> multi-arch function 244 # hiding a multi-arch function (parameterised with the architecture) 245 # M -> multi-arch function + predicate 246 # hiding a multi-arch function + predicate to test function validity 247 248 macro ) : ;; 249 250 # The name of the legacy C macro by which this method can be 251 # accessed. If empty, no macro is defined. If "=", a macro 252 # formed from the upper-case function name is used. 253 254 returntype ) : ;; 255 256 # For functions, the return type; for variables, the data type 257 258 function ) : ;; 259 260 # For functions, the member function name; for variables, the 261 # variable name. Member function names are always prefixed with 262 # ``gdbarch_'' for name-space purity. 263 264 formal ) : ;; 265 266 # The formal argument list. It is assumed that the formal 267 # argument list includes the actual name of each list element. 268 # A function with no arguments shall have ``void'' as the 269 # formal argument list. 270 271 actual ) : ;; 272 273 # The list of actual arguments. The arguments specified shall 274 # match the FORMAL list given above. Functions with out 275 # arguments leave this blank. 276 277 staticdefault ) : ;; 278 279 # To help with the GDB startup a static gdbarch object is 280 # created. STATICDEFAULT is the value to insert into that 281 # static gdbarch object. Since this a static object only 282 # simple expressions can be used. 283 284 # If STATICDEFAULT is empty, zero is used. 285 286 predefault ) : ;; 287 288 # An initial value to assign to MEMBER of the freshly 289 # malloc()ed gdbarch object. After initialization, the 290 # freshly malloc()ed object is passed to the target 291 # architecture code for further updates. 292 293 # If PREDEFAULT is empty, zero is used. 294 295 # A non-empty PREDEFAULT, an empty POSTDEFAULT and a zero 296 # INVALID_P are specified, PREDEFAULT will be used as the 297 # default for the non- multi-arch target. 298 299 # A zero PREDEFAULT function will force the fallback to call 300 # internal_error(). 301 302 # Variable declarations can refer to ``gdbarch'' which will 303 # contain the current architecture. Care should be taken. 304 305 postdefault ) : ;; 306 307 # A value to assign to MEMBER of the new gdbarch object should 308 # the target architecture code fail to change the PREDEFAULT 309 # value. 310 311 # If POSTDEFAULT is empty, no post update is performed. 312 313 # If both INVALID_P and POSTDEFAULT are non-empty then 314 # INVALID_P will be used to determine if MEMBER should be 315 # changed to POSTDEFAULT. 316 317 # If a non-empty POSTDEFAULT and a zero INVALID_P are 318 # specified, POSTDEFAULT will be used as the default for the 319 # non- multi-arch target (regardless of the value of 320 # PREDEFAULT). 321 322 # You cannot specify both a zero INVALID_P and a POSTDEFAULT. 323 324 # Variable declarations can refer to ``current_gdbarch'' which 325 # will contain the current architecture. Care should be 326 # taken. 327 328 invalid_p ) : ;; 329 330 # A predicate equation that validates MEMBER. Non-zero is 331 # returned if the code creating the new architecture failed to 332 # initialize MEMBER or the initialized the member is invalid. 333 # If POSTDEFAULT is non-empty then MEMBER will be updated to 334 # that value. If POSTDEFAULT is empty then internal_error() 335 # is called. 336 337 # If INVALID_P is empty, a check that MEMBER is no longer 338 # equal to PREDEFAULT is used. 339 340 # The expression ``0'' disables the INVALID_P check making 341 # PREDEFAULT a legitimate value. 342 343 # See also PREDEFAULT and POSTDEFAULT. 344 345 print ) : ;; 346 347 # An optional expression that convers MEMBER to a value 348 # suitable for formatting using %s. 349 350 # If PRINT is empty, paddr_nz (for CORE_ADDR) or paddr_d 351 # (anything else) is used. 352 353 garbage_at_eol ) : ;; 354 355 # Catches stray fields. 356 357 *) 358 echo "Bad field ${field}" 359 exit 1;; 360 esac 361done 362 363 364function_list () 365{ 366 # See below (DOCO) for description of each field 367 cat <<EOF 368i::const struct bfd_arch_info *:bfd_arch_info:::&bfd_default_arch_struct::::gdbarch_bfd_arch_info (current_gdbarch)->printable_name 369# 370i::int:byte_order:::BFD_ENDIAN_BIG 371# 372i::enum gdb_osabi:osabi:::GDB_OSABI_UNKNOWN 373# 374i::const struct target_desc *:target_desc:::::::paddr_d ((long) current_gdbarch->target_desc) 375# Number of bits in a char or unsigned char for the target machine. 376# Just like CHAR_BIT in <limits.h> but describes the target machine. 377# v:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0: 378# 379# Number of bits in a short or unsigned short for the target machine. 380v::int:short_bit:::8 * sizeof (short):2*TARGET_CHAR_BIT::0 381# Number of bits in an int or unsigned int for the target machine. 382v::int:int_bit:::8 * sizeof (int):4*TARGET_CHAR_BIT::0 383# Number of bits in a long or unsigned long for the target machine. 384v::int:long_bit:::8 * sizeof (long):4*TARGET_CHAR_BIT::0 385# Number of bits in a long long or unsigned long long for the target 386# machine. 387v::int:long_long_bit:::8 * sizeof (LONGEST):2*current_gdbarch->long_bit::0 388 389# The ABI default bit-size and format for "float", "double", and "long 390# double". These bit/format pairs should eventually be combined into 391# a single object. For the moment, just initialize them as a pair. 392# Each format describes both the big and little endian layouts (if 393# useful). 394 395v::int:float_bit:::8 * sizeof (float):4*TARGET_CHAR_BIT::0 396v::const struct floatformat **:float_format:::::floatformats_ieee_single::pformat (current_gdbarch->float_format) 397v::int:double_bit:::8 * sizeof (double):8*TARGET_CHAR_BIT::0 398v::const struct floatformat **:double_format:::::floatformats_ieee_double::pformat (current_gdbarch->double_format) 399v::int:long_double_bit:::8 * sizeof (long double):8*TARGET_CHAR_BIT::0 400v::const struct floatformat **:long_double_format:::::floatformats_ieee_double::pformat (current_gdbarch->long_double_format) 401 402# For most targets, a pointer on the target and its representation as an 403# address in GDB have the same size and "look the same". For such a 404# target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit 405# / addr_bit will be set from it. 406# 407# If gdbarch_ptr_bit and gdbarch_addr_bit are different, you'll probably 408# also need to set gdbarch_pointer_to_address and gdbarch_address_to_pointer 409# as well. 410# 411# ptr_bit is the size of a pointer on the target 412v::int:ptr_bit:::8 * sizeof (void*):current_gdbarch->int_bit::0 413# addr_bit is the size of a target address as represented in gdb 414v::int:addr_bit:::8 * sizeof (void*):0:gdbarch_ptr_bit (current_gdbarch): 415# 416# One if \`char' acts like \`signed char', zero if \`unsigned char'. 417v::int:char_signed:::1:-1:1 418# 419F::CORE_ADDR:read_pc:struct regcache *regcache:regcache 420F::void:write_pc:struct regcache *regcache, CORE_ADDR val:regcache, val 421# Function for getting target's idea of a frame pointer. FIXME: GDB's 422# whole scheme for dealing with "frames" and "frame pointers" needs a 423# serious shakedown. 424f::void:virtual_frame_pointer:CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset:pc, frame_regnum, frame_offset:0:legacy_virtual_frame_pointer::0 425# 426M::void:pseudo_register_read:struct regcache *regcache, int cookednum, gdb_byte *buf:regcache, cookednum, buf 427M::void:pseudo_register_write:struct regcache *regcache, int cookednum, const gdb_byte *buf:regcache, cookednum, buf 428# 429v::int:num_regs:::0:-1 430# This macro gives the number of pseudo-registers that live in the 431# register namespace but do not get fetched or stored on the target. 432# These pseudo-registers may be aliases for other registers, 433# combinations of other registers, or they may be computed by GDB. 434v::int:num_pseudo_regs:::0:0::0 435 436# GDB's standard (or well known) register numbers. These can map onto 437# a real register or a pseudo (computed) register or not be defined at 438# all (-1). 439# gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP. 440v::int:sp_regnum:::-1:-1::0 441v::int:pc_regnum:::-1:-1::0 442v::int:ps_regnum:::-1:-1::0 443v::int:fp0_regnum:::0:-1::0 444# Convert stab register number (from \`r\' declaration) to a gdb REGNUM. 445f::int:stab_reg_to_regnum:int stab_regnr:stab_regnr::no_op_reg_to_regnum::0 446# Provide a default mapping from a ecoff register number to a gdb REGNUM. 447f::int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr::no_op_reg_to_regnum::0 448# Provide a default mapping from a DWARF register number to a gdb REGNUM. 449f::int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr::no_op_reg_to_regnum::0 450# Convert from an sdb register number to an internal gdb register number. 451f::int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr::no_op_reg_to_regnum::0 452f::int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr::no_op_reg_to_regnum::0 453f::const char *:register_name:int regnr:regnr 454 455# Return the type of a register specified by the architecture. Only 456# the register cache should call this function directly; others should 457# use "register_type". 458M::struct type *:register_type:int reg_nr:reg_nr 459 460# See gdbint.texinfo, and PUSH_DUMMY_CALL. 461M::struct frame_id:unwind_dummy_id:struct frame_info *info:info 462# Implement UNWIND_DUMMY_ID and PUSH_DUMMY_CALL, then delete 463# deprecated_fp_regnum. 464v::int:deprecated_fp_regnum:::-1:-1::0 465 466# See gdbint.texinfo. See infcall.c. 467M::CORE_ADDR:push_dummy_call:struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr 468v::int:call_dummy_location::::AT_ENTRY_POINT::0 469M::CORE_ADDR:push_dummy_code:CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache:sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr, regcache 470 471m::void:print_registers_info:struct ui_file *file, struct frame_info *frame, int regnum, int all:file, frame, regnum, all::default_print_registers_info::0 472M::void:print_float_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args 473M::void:print_vector_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args 474# MAP a GDB RAW register number onto a simulator register number. See 475# also include/...-sim.h. 476f::int:register_sim_regno:int reg_nr:reg_nr::legacy_register_sim_regno::0 477f::int:cannot_fetch_register:int regnum:regnum::cannot_register_not::0 478f::int:cannot_store_register:int regnum:regnum::cannot_register_not::0 479# setjmp/longjmp support. 480F::int:get_longjmp_target:struct frame_info *frame, CORE_ADDR *pc:frame, pc 481# 482v::int:believe_pcc_promotion::::::: 483# 484f::int:convert_register_p:int regnum, struct type *type:regnum, type:0:generic_convert_register_p::0 485f::void:register_to_value:struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf:frame, regnum, type, buf:0 486f::void:value_to_register:struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf:frame, regnum, type, buf:0 487# Construct a value representing the contents of register REGNUM in 488# frame FRAME, interpreted as type TYPE. The routine needs to 489# allocate and return a struct value with all value attributes 490# (but not the value contents) filled in. 491f::struct value *:value_from_register:struct type *type, int regnum, struct frame_info *frame:type, regnum, frame::default_value_from_register::0 492# 493f::CORE_ADDR:pointer_to_address:struct type *type, const gdb_byte *buf:type, buf::unsigned_pointer_to_address::0 494f::void:address_to_pointer:struct type *type, gdb_byte *buf, CORE_ADDR addr:type, buf, addr::unsigned_address_to_pointer::0 495M::CORE_ADDR:integer_to_address:struct type *type, const gdb_byte *buf:type, buf 496 497# It has been suggested that this, well actually its predecessor, 498# should take the type/value of the function to be called and not the 499# return type. This is left as an exercise for the reader. 500 501# NOTE: cagney/2004-06-13: The function stack.c:return_command uses 502# the predicate with default hack to avoid calling store_return_value 503# (via legacy_return_value), when a small struct is involved. 504 505M::enum return_value_convention:return_value:struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf:valtype, regcache, readbuf, writebuf::legacy_return_value 506 507# The deprecated methods extract_return_value, store_return_value, 508# DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS and 509# deprecated_use_struct_convention have all been folded into 510# RETURN_VALUE. 511 512f::void:extract_return_value:struct type *type, struct regcache *regcache, gdb_byte *valbuf:type, regcache, valbuf:0 513f::void:store_return_value:struct type *type, struct regcache *regcache, const gdb_byte *valbuf:type, regcache, valbuf:0 514f::int:deprecated_use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type::generic_use_struct_convention::0 515 516f::CORE_ADDR:skip_prologue:CORE_ADDR ip:ip:0:0 517f::int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs:0:0 518f::const gdb_byte *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr::0: 519M::CORE_ADDR:adjust_breakpoint_address:CORE_ADDR bpaddr:bpaddr 520f::int:memory_insert_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_insert_breakpoint::0 521f::int:memory_remove_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_remove_breakpoint::0 522v::CORE_ADDR:decr_pc_after_break:::0:::0 523 524# A function can be addressed by either it's "pointer" (possibly a 525# descriptor address) or "entry point" (first executable instruction). 526# The method "convert_from_func_ptr_addr" converting the former to the 527# latter. gdbarch_deprecated_function_start_offset is being used to implement 528# a simplified subset of that functionality - the function's address 529# corresponds to the "function pointer" and the function's start 530# corresponds to the "function entry point" - and hence is redundant. 531 532v::CORE_ADDR:deprecated_function_start_offset:::0:::0 533 534# Return the remote protocol register number associated with this 535# register. Normally the identity mapping. 536m::int:remote_register_number:int regno:regno::default_remote_register_number::0 537 538# Fetch the target specific address used to represent a load module. 539F::CORE_ADDR:fetch_tls_load_module_address:struct objfile *objfile:objfile 540# 541v::CORE_ADDR:frame_args_skip:::0:::0 542M::CORE_ADDR:unwind_pc:struct frame_info *next_frame:next_frame 543M::CORE_ADDR:unwind_sp:struct frame_info *next_frame:next_frame 544# DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame 545# frame-base. Enable frame-base before frame-unwind. 546F::int:frame_num_args:struct frame_info *frame:frame 547# 548M::CORE_ADDR:frame_align:CORE_ADDR address:address 549# deprecated_reg_struct_has_addr has been replaced by 550# stabs_argument_has_addr. 551F::int:deprecated_reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type 552m::int:stabs_argument_has_addr:struct type *type:type::default_stabs_argument_has_addr::0 553v::int:frame_red_zone_size 554# 555m::CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr, struct target_ops *targ:addr, targ::convert_from_func_ptr_addr_identity::0 556# On some machines there are bits in addresses which are not really 557# part of the address, but are used by the kernel, the hardware, etc. 558# for special purposes. gdbarch_addr_bits_remove takes out any such bits so 559# we get a "real" address such as one would find in a symbol table. 560# This is used only for addresses of instructions, and even then I'm 561# not sure it's used in all contexts. It exists to deal with there 562# being a few stray bits in the PC which would mislead us, not as some 563# sort of generic thing to handle alignment or segmentation (it's 564# possible it should be in TARGET_READ_PC instead). 565f::CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr::core_addr_identity::0 566# It is not at all clear why gdbarch_smash_text_address is not folded into 567# gdbarch_addr_bits_remove. 568f::CORE_ADDR:smash_text_address:CORE_ADDR addr:addr::core_addr_identity::0 569 570# FIXME/cagney/2001-01-18: This should be split in two. A target method that 571# indicates if the target needs software single step. An ISA method to 572# implement it. 573# 574# FIXME/cagney/2001-01-18: This should be replaced with something that inserts 575# breakpoints using the breakpoint system instead of blatting memory directly 576# (as with rs6000). 577# 578# FIXME/cagney/2001-01-18: The logic is backwards. It should be asking if the 579# target can single step. If not, then implement single step using breakpoints. 580# 581# A return value of 1 means that the software_single_step breakpoints 582# were inserted; 0 means they were not. 583F::int:software_single_step:struct frame_info *frame:frame 584 585# Return non-zero if the processor is executing a delay slot and a 586# further single-step is needed before the instruction finishes. 587M::int:single_step_through_delay:struct frame_info *frame:frame 588# FIXME: cagney/2003-08-28: Need to find a better way of selecting the 589# disassembler. Perhaps objdump can handle it? 590f::int:print_insn:bfd_vma vma, struct disassemble_info *info:vma, info::0: 591f::CORE_ADDR:skip_trampoline_code:struct frame_info *frame, CORE_ADDR pc:frame, pc::generic_skip_trampoline_code::0 592 593 594# If IN_SOLIB_DYNSYM_RESOLVE_CODE returns true, and SKIP_SOLIB_RESOLVER 595# evaluates non-zero, this is the address where the debugger will place 596# a step-resume breakpoint to get us past the dynamic linker. 597m::CORE_ADDR:skip_solib_resolver:CORE_ADDR pc:pc::generic_skip_solib_resolver::0 598# Some systems also have trampoline code for returning from shared libs. 599f::int:in_solib_return_trampoline:CORE_ADDR pc, char *name:pc, name::generic_in_solib_return_trampoline::0 600 601# A target might have problems with watchpoints as soon as the stack 602# frame of the current function has been destroyed. This mostly happens 603# as the first action in a funtion's epilogue. in_function_epilogue_p() 604# is defined to return a non-zero value if either the given addr is one 605# instruction after the stack destroying instruction up to the trailing 606# return instruction or if we can figure out that the stack frame has 607# already been invalidated regardless of the value of addr. Targets 608# which don't suffer from that problem could just let this functionality 609# untouched. 610m::int:in_function_epilogue_p:CORE_ADDR addr:addr:0:generic_in_function_epilogue_p::0 611# Given a vector of command-line arguments, return a newly allocated 612# string which, when passed to the create_inferior function, will be 613# parsed (on Unix systems, by the shell) to yield the same vector. 614# This function should call error() if the argument vector is not 615# representable for this target or if this target does not support 616# command-line arguments. 617# ARGC is the number of elements in the vector. 618# ARGV is an array of strings, one per argument. 619m::char *:construct_inferior_arguments:int argc, char **argv:argc, argv::construct_inferior_arguments::0 620f::void:elf_make_msymbol_special:asymbol *sym, struct minimal_symbol *msym:sym, msym::default_elf_make_msymbol_special::0 621f::void:coff_make_msymbol_special:int val, struct minimal_symbol *msym:val, msym::default_coff_make_msymbol_special::0 622v::const char *:name_of_malloc:::"malloc":"malloc"::0:current_gdbarch->name_of_malloc 623v::int:cannot_step_breakpoint:::0:0::0 624v::int:have_nonsteppable_watchpoint:::0:0::0 625F::int:address_class_type_flags:int byte_size, int dwarf2_addr_class:byte_size, dwarf2_addr_class 626M::const char *:address_class_type_flags_to_name:int type_flags:type_flags 627M::int:address_class_name_to_type_flags:const char *name, int *type_flags_ptr:name, type_flags_ptr 628# Is a register in a group 629m::int:register_reggroup_p:int regnum, struct reggroup *reggroup:regnum, reggroup::default_register_reggroup_p::0 630# Fetch the pointer to the ith function argument. 631F::CORE_ADDR:fetch_pointer_argument:struct frame_info *frame, int argi, struct type *type:frame, argi, type 632 633# Return the appropriate register set for a core file section with 634# name SECT_NAME and size SECT_SIZE. 635M::const struct regset *:regset_from_core_section:const char *sect_name, size_t sect_size:sect_name, sect_size 636 637# Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from 638# core file into buffer READBUF with length LEN. 639M::LONGEST:core_xfer_shared_libraries:gdb_byte *readbuf, ULONGEST offset, LONGEST len:readbuf, offset, len 640 641# If the elements of C++ vtables are in-place function descriptors rather 642# than normal function pointers (which may point to code or a descriptor), 643# set this to one. 644v::int:vtable_function_descriptors:::0:0::0 645 646# Set if the least significant bit of the delta is used instead of the least 647# significant bit of the pfn for pointers to virtual member functions. 648v::int:vbit_in_delta:::0:0::0 649 650# Advance PC to next instruction in order to skip a permanent breakpoint. 651F::void:skip_permanent_breakpoint:struct regcache *regcache:regcache 652 653# Refresh overlay mapped state for section OSECT. 654F::void:overlay_update:struct obj_section *osect:osect 655EOF 656} 657 658# 659# The .log file 660# 661exec > new-gdbarch.log 662function_list | while do_read 663do 664 cat <<EOF 665${class} ${returntype} ${function} ($formal) 666EOF 667 for r in ${read} 668 do 669 eval echo \"\ \ \ \ ${r}=\${${r}}\" 670 done 671 if class_is_predicate_p && fallback_default_p 672 then 673 echo "Error: predicate function ${function} can not have a non- multi-arch default" 1>&2 674 kill $$ 675 exit 1 676 fi 677 if [ "x${invalid_p}" = "x0" -a -n "${postdefault}" ] 678 then 679 echo "Error: postdefault is useless when invalid_p=0" 1>&2 680 kill $$ 681 exit 1 682 fi 683 if class_is_multiarch_p 684 then 685 if class_is_predicate_p ; then : 686 elif test "x${predefault}" = "x" 687 then 688 echo "Error: pure multi-arch function ${function} must have a predefault" 1>&2 689 kill $$ 690 exit 1 691 fi 692 fi 693 echo "" 694done 695 696exec 1>&2 697compare_new gdbarch.log 698 699 700copyright () 701{ 702cat <<EOF 703/* *INDENT-OFF* */ /* THIS FILE IS GENERATED */ 704 705/* Dynamic architecture support for GDB, the GNU debugger. 706 707 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 708 Free Software Foundation, Inc. 709 710 This file is part of GDB. 711 712 This program is free software; you can redistribute it and/or modify 713 it under the terms of the GNU General Public License as published by 714 the Free Software Foundation; either version 3 of the License, or 715 (at your option) any later version. 716 717 This program is distributed in the hope that it will be useful, 718 but WITHOUT ANY WARRANTY; without even the implied warranty of 719 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 720 GNU General Public License for more details. 721 722 You should have received a copy of the GNU General Public License 723 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 724 725/* This file was created with the aid of \`\`gdbarch.sh''. 726 727 The Bourne shell script \`\`gdbarch.sh'' creates the files 728 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them 729 against the existing \`\`gdbarch.[hc]''. Any differences found 730 being reported. 731 732 If editing this file, please also run gdbarch.sh and merge any 733 changes into that script. Conversely, when making sweeping changes 734 to this file, modifying gdbarch.sh and using its output may prove 735 easier. */ 736 737EOF 738} 739 740# 741# The .h file 742# 743 744exec > new-gdbarch.h 745copyright 746cat <<EOF 747#ifndef GDBARCH_H 748#define GDBARCH_H 749 750struct floatformat; 751struct ui_file; 752struct frame_info; 753struct value; 754struct objfile; 755struct obj_section; 756struct minimal_symbol; 757struct regcache; 758struct reggroup; 759struct regset; 760struct disassemble_info; 761struct target_ops; 762struct obstack; 763struct bp_target_info; 764struct target_desc; 765 766extern struct gdbarch *current_gdbarch; 767EOF 768 769# function typedef's 770printf "\n" 771printf "\n" 772printf "/* The following are pre-initialized by GDBARCH. */\n" 773function_list | while do_read 774do 775 if class_is_info_p 776 then 777 printf "\n" 778 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n" 779 printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n" 780 if test -n "${macro}" 781 then 782 printf "#if !defined (GDB_TM_FILE) && defined (${macro})\n" 783 printf "#error \"Non multi-arch definition of ${macro}\"\n" 784 printf "#endif\n" 785 printf "#if !defined (${macro})\n" 786 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n" 787 printf "#endif\n" 788 fi 789 fi 790done 791 792# function typedef's 793printf "\n" 794printf "\n" 795printf "/* The following are initialized by the target dependent code. */\n" 796function_list | while do_read 797do 798 if [ -n "${comment}" ] 799 then 800 echo "${comment}" | sed \ 801 -e '2 s,#,/*,' \ 802 -e '3,$ s,#, ,' \ 803 -e '$ s,$, */,' 804 fi 805 806 if class_is_predicate_p 807 then 808 if test -n "${macro}" 809 then 810 printf "\n" 811 printf "#if defined (${macro})\n" 812 printf "/* Legacy for systems yet to multi-arch ${macro} */\n" 813 printf "#if !defined (${macro}_P)\n" 814 printf "#define ${macro}_P() (1)\n" 815 printf "#endif\n" 816 printf "#endif\n" 817 fi 818 printf "\n" 819 printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n" 820 if test -n "${macro}" 821 then 822 printf "#if !defined (GDB_TM_FILE) && defined (${macro}_P)\n" 823 printf "#error \"Non multi-arch definition of ${macro}\"\n" 824 printf "#endif\n" 825 printf "#if !defined (${macro}_P)\n" 826 printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n" 827 printf "#endif\n" 828 fi 829 fi 830 if class_is_variable_p 831 then 832 printf "\n" 833 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n" 834 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n" 835 if test -n "${macro}" 836 then 837 printf "#if !defined (GDB_TM_FILE) && defined (${macro})\n" 838 printf "#error \"Non multi-arch definition of ${macro}\"\n" 839 printf "#endif\n" 840 printf "#if !defined (${macro})\n" 841 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n" 842 printf "#endif\n" 843 fi 844 fi 845 if class_is_function_p 846 then 847 printf "\n" 848 if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p 849 then 850 printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch);\n" 851 elif class_is_multiarch_p 852 then 853 printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch, ${formal});\n" 854 else 855 printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n" 856 fi 857 if [ "x${formal}" = "xvoid" ] 858 then 859 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n" 860 else 861 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n" 862 fi 863 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n" 864 if test -n "${macro}" 865 then 866 printf "#if !defined (GDB_TM_FILE) && defined (${macro})\n" 867 printf "#error \"Non multi-arch definition of ${macro}\"\n" 868 printf "#endif\n" 869 if [ "x${actual}" = "x" ] 870 then 871 d="#define ${macro}() (gdbarch_${function} (current_gdbarch))" 872 elif [ "x${actual}" = "x-" ] 873 then 874 d="#define ${macro} (gdbarch_${function} (current_gdbarch))" 875 else 876 d="#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))" 877 fi 878 printf "#if !defined (${macro})\n" 879 if [ "x${actual}" = "x" ] 880 then 881 printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n" 882 elif [ "x${actual}" = "x-" ] 883 then 884 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n" 885 else 886 printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n" 887 fi 888 printf "#endif\n" 889 fi 890 fi 891done 892 893# close it off 894cat <<EOF 895 896extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch); 897 898 899/* Mechanism for co-ordinating the selection of a specific 900 architecture. 901 902 GDB targets (*-tdep.c) can register an interest in a specific 903 architecture. Other GDB components can register a need to maintain 904 per-architecture data. 905 906 The mechanisms below ensures that there is only a loose connection 907 between the set-architecture command and the various GDB 908 components. Each component can independently register their need 909 to maintain architecture specific data with gdbarch. 910 911 Pragmatics: 912 913 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It 914 didn't scale. 915 916 The more traditional mega-struct containing architecture specific 917 data for all the various GDB components was also considered. Since 918 GDB is built from a variable number of (fairly independent) 919 components it was determined that the global aproach was not 920 applicable. */ 921 922 923/* Register a new architectural family with GDB. 924 925 Register support for the specified ARCHITECTURE with GDB. When 926 gdbarch determines that the specified architecture has been 927 selected, the corresponding INIT function is called. 928 929 -- 930 931 The INIT function takes two parameters: INFO which contains the 932 information available to gdbarch about the (possibly new) 933 architecture; ARCHES which is a list of the previously created 934 \`\`struct gdbarch'' for this architecture. 935 936 The INFO parameter is, as far as possible, be pre-initialized with 937 information obtained from INFO.ABFD or the global defaults. 938 939 The ARCHES parameter is a linked list (sorted most recently used) 940 of all the previously created architures for this architecture 941 family. The (possibly NULL) ARCHES->gdbarch can used to access 942 values from the previously selected architecture for this 943 architecture family. The global \`\`current_gdbarch'' shall not be 944 used. 945 946 The INIT function shall return any of: NULL - indicating that it 947 doesn't recognize the selected architecture; an existing \`\`struct 948 gdbarch'' from the ARCHES list - indicating that the new 949 architecture is just a synonym for an earlier architecture (see 950 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch'' 951 - that describes the selected architecture (see gdbarch_alloc()). 952 953 The DUMP_TDEP function shall print out all target specific values. 954 Care should be taken to ensure that the function works in both the 955 multi-arch and non- multi-arch cases. */ 956 957struct gdbarch_list 958{ 959 struct gdbarch *gdbarch; 960 struct gdbarch_list *next; 961}; 962 963struct gdbarch_info 964{ 965 /* Use default: NULL (ZERO). */ 966 const struct bfd_arch_info *bfd_arch_info; 967 968 /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO). */ 969 int byte_order; 970 971 /* Use default: NULL (ZERO). */ 972 bfd *abfd; 973 974 /* Use default: NULL (ZERO). */ 975 struct gdbarch_tdep_info *tdep_info; 976 977 /* Use default: GDB_OSABI_UNINITIALIZED (-1). */ 978 enum gdb_osabi osabi; 979 980 /* Use default: NULL (ZERO). */ 981 const struct target_desc *target_desc; 982}; 983 984typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches); 985typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file); 986 987/* DEPRECATED - use gdbarch_register() */ 988extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *); 989 990extern void gdbarch_register (enum bfd_architecture architecture, 991 gdbarch_init_ftype *, 992 gdbarch_dump_tdep_ftype *); 993 994 995/* Return a freshly allocated, NULL terminated, array of the valid 996 architecture names. Since architectures are registered during the 997 _initialize phase this function only returns useful information 998 once initialization has been completed. */ 999 1000extern const char **gdbarch_printable_names (void); 1001 1002 1003/* Helper function. Search the list of ARCHES for a GDBARCH that 1004 matches the information provided by INFO. */ 1005 1006extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info); 1007 1008 1009/* Helper function. Create a preliminary \`\`struct gdbarch''. Perform 1010 basic initialization using values obtained from the INFO and TDEP 1011 parameters. set_gdbarch_*() functions are called to complete the 1012 initialization of the object. */ 1013 1014extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep); 1015 1016 1017/* Helper function. Free a partially-constructed \`\`struct gdbarch''. 1018 It is assumed that the caller freeds the \`\`struct 1019 gdbarch_tdep''. */ 1020 1021extern void gdbarch_free (struct gdbarch *); 1022 1023 1024/* Helper function. Allocate memory from the \`\`struct gdbarch'' 1025 obstack. The memory is freed when the corresponding architecture 1026 is also freed. */ 1027 1028extern void *gdbarch_obstack_zalloc (struct gdbarch *gdbarch, long size); 1029#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), (NR) * sizeof (TYPE))) 1030#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), sizeof (TYPE))) 1031 1032 1033/* Helper function. Force an update of the current architecture. 1034 1035 The actual architecture selected is determined by INFO, \`\`(gdb) set 1036 architecture'' et.al., the existing architecture and BFD's default 1037 architecture. INFO should be initialized to zero and then selected 1038 fields should be updated. 1039 1040 Returns non-zero if the update succeeds */ 1041 1042extern int gdbarch_update_p (struct gdbarch_info info); 1043 1044 1045/* Helper function. Find an architecture matching info. 1046 1047 INFO should be initialized using gdbarch_info_init, relevant fields 1048 set, and then finished using gdbarch_info_fill. 1049 1050 Returns the corresponding architecture, or NULL if no matching 1051 architecture was found. "current_gdbarch" is not updated. */ 1052 1053extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info); 1054 1055 1056/* Helper function. Set the global "current_gdbarch" to "gdbarch". 1057 1058 FIXME: kettenis/20031124: Of the functions that follow, only 1059 gdbarch_from_bfd is supposed to survive. The others will 1060 dissappear since in the future GDB will (hopefully) be truly 1061 multi-arch. However, for now we're still stuck with the concept of 1062 a single active architecture. */ 1063 1064extern void deprecated_current_gdbarch_select_hack (struct gdbarch *gdbarch); 1065 1066 1067/* Register per-architecture data-pointer. 1068 1069 Reserve space for a per-architecture data-pointer. An identifier 1070 for the reserved data-pointer is returned. That identifer should 1071 be saved in a local static variable. 1072 1073 Memory for the per-architecture data shall be allocated using 1074 gdbarch_obstack_zalloc. That memory will be deleted when the 1075 corresponding architecture object is deleted. 1076 1077 When a previously created architecture is re-selected, the 1078 per-architecture data-pointer for that previous architecture is 1079 restored. INIT() is not re-called. 1080 1081 Multiple registrarants for any architecture are allowed (and 1082 strongly encouraged). */ 1083 1084struct gdbarch_data; 1085 1086typedef void *(gdbarch_data_pre_init_ftype) (struct obstack *obstack); 1087extern struct gdbarch_data *gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *init); 1088typedef void *(gdbarch_data_post_init_ftype) (struct gdbarch *gdbarch); 1089extern struct gdbarch_data *gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *init); 1090extern void deprecated_set_gdbarch_data (struct gdbarch *gdbarch, 1091 struct gdbarch_data *data, 1092 void *pointer); 1093 1094extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *); 1095 1096 1097/* Set the dynamic target-system-dependent parameters (architecture, 1098 byte-order, ...) using information found in the BFD */ 1099 1100extern void set_gdbarch_from_file (bfd *); 1101 1102 1103/* Initialize the current architecture to the "first" one we find on 1104 our list. */ 1105 1106extern void initialize_current_architecture (void); 1107 1108/* gdbarch trace variable */ 1109extern int gdbarch_debug; 1110 1111extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file); 1112 1113#endif 1114EOF 1115exec 1>&2 1116#../move-if-change new-gdbarch.h gdbarch.h 1117compare_new gdbarch.h 1118 1119 1120# 1121# C file 1122# 1123 1124exec > new-gdbarch.c 1125copyright 1126cat <<EOF 1127 1128#include "defs.h" 1129#include "arch-utils.h" 1130 1131#include "gdbcmd.h" 1132#include "inferior.h" 1133#include "symcat.h" 1134 1135#include "floatformat.h" 1136 1137#include "gdb_assert.h" 1138#include "gdb_string.h" 1139#include "gdb-events.h" 1140#include "reggroups.h" 1141#include "osabi.h" 1142#include "gdb_obstack.h" 1143 1144/* Static function declarations */ 1145 1146static void alloc_gdbarch_data (struct gdbarch *); 1147 1148/* Non-zero if we want to trace architecture code. */ 1149 1150#ifndef GDBARCH_DEBUG 1151#define GDBARCH_DEBUG 0 1152#endif 1153int gdbarch_debug = GDBARCH_DEBUG; 1154static void 1155show_gdbarch_debug (struct ui_file *file, int from_tty, 1156 struct cmd_list_element *c, const char *value) 1157{ 1158 fprintf_filtered (file, _("Architecture debugging is %s.\\n"), value); 1159} 1160 1161static const char * 1162pformat (const struct floatformat **format) 1163{ 1164 if (format == NULL) 1165 return "(null)"; 1166 else 1167 /* Just print out one of them - this is only for diagnostics. */ 1168 return format[0]->name; 1169} 1170 1171EOF 1172 1173# gdbarch open the gdbarch object 1174printf "\n" 1175printf "/* Maintain the struct gdbarch object */\n" 1176printf "\n" 1177printf "struct gdbarch\n" 1178printf "{\n" 1179printf " /* Has this architecture been fully initialized? */\n" 1180printf " int initialized_p;\n" 1181printf "\n" 1182printf " /* An obstack bound to the lifetime of the architecture. */\n" 1183printf " struct obstack *obstack;\n" 1184printf "\n" 1185printf " /* basic architectural information */\n" 1186function_list | while do_read 1187do 1188 if class_is_info_p 1189 then 1190 printf " ${returntype} ${function};\n" 1191 fi 1192done 1193printf "\n" 1194printf " /* target specific vector. */\n" 1195printf " struct gdbarch_tdep *tdep;\n" 1196printf " gdbarch_dump_tdep_ftype *dump_tdep;\n" 1197printf "\n" 1198printf " /* per-architecture data-pointers */\n" 1199printf " unsigned nr_data;\n" 1200printf " void **data;\n" 1201printf "\n" 1202printf " /* per-architecture swap-regions */\n" 1203printf " struct gdbarch_swap *swap;\n" 1204printf "\n" 1205cat <<EOF 1206 /* Multi-arch values. 1207 1208 When extending this structure you must: 1209 1210 Add the field below. 1211 1212 Declare set/get functions and define the corresponding 1213 macro in gdbarch.h. 1214 1215 gdbarch_alloc(): If zero/NULL is not a suitable default, 1216 initialize the new field. 1217 1218 verify_gdbarch(): Confirm that the target updated the field 1219 correctly. 1220 1221 gdbarch_dump(): Add a fprintf_unfiltered call so that the new 1222 field is dumped out 1223 1224 \`\`startup_gdbarch()'': Append an initial value to the static 1225 variable (base values on the host's c-type system). 1226 1227 get_gdbarch(): Implement the set/get functions (probably using 1228 the macro's as shortcuts). 1229 1230 */ 1231 1232EOF 1233function_list | while do_read 1234do 1235 if class_is_variable_p 1236 then 1237 printf " ${returntype} ${function};\n" 1238 elif class_is_function_p 1239 then 1240 printf " gdbarch_${function}_ftype *${function};\n" 1241 fi 1242done 1243printf "};\n" 1244 1245# A pre-initialized vector 1246printf "\n" 1247printf "\n" 1248cat <<EOF 1249/* The default architecture uses host values (for want of a better 1250 choice). */ 1251EOF 1252printf "\n" 1253printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n" 1254printf "\n" 1255printf "struct gdbarch startup_gdbarch =\n" 1256printf "{\n" 1257printf " 1, /* Always initialized. */\n" 1258printf " NULL, /* The obstack. */\n" 1259printf " /* basic architecture information */\n" 1260function_list | while do_read 1261do 1262 if class_is_info_p 1263 then 1264 printf " ${staticdefault}, /* ${function} */\n" 1265 fi 1266done 1267cat <<EOF 1268 /* target specific vector and its dump routine */ 1269 NULL, NULL, 1270 /*per-architecture data-pointers and swap regions */ 1271 0, NULL, NULL, 1272 /* Multi-arch values */ 1273EOF 1274function_list | while do_read 1275do 1276 if class_is_function_p || class_is_variable_p 1277 then 1278 printf " ${staticdefault}, /* ${function} */\n" 1279 fi 1280done 1281cat <<EOF 1282 /* startup_gdbarch() */ 1283}; 1284 1285struct gdbarch *current_gdbarch = &startup_gdbarch; 1286EOF 1287 1288# Create a new gdbarch struct 1289cat <<EOF 1290 1291/* Create a new \`\`struct gdbarch'' based on information provided by 1292 \`\`struct gdbarch_info''. */ 1293EOF 1294printf "\n" 1295cat <<EOF 1296struct gdbarch * 1297gdbarch_alloc (const struct gdbarch_info *info, 1298 struct gdbarch_tdep *tdep) 1299{ 1300 /* NOTE: The new architecture variable is named \`\`current_gdbarch'' 1301 so that macros such as TARGET_ARCHITECTURE, when expanded, refer to 1302 the current local architecture and not the previous global 1303 architecture. This ensures that the new architectures initial 1304 values are not influenced by the previous architecture. Once 1305 everything is parameterised with gdbarch, this will go away. */ 1306 struct gdbarch *current_gdbarch; 1307 1308 /* Create an obstack for allocating all the per-architecture memory, 1309 then use that to allocate the architecture vector. */ 1310 struct obstack *obstack = XMALLOC (struct obstack); 1311 obstack_init (obstack); 1312 current_gdbarch = obstack_alloc (obstack, sizeof (*current_gdbarch)); 1313 memset (current_gdbarch, 0, sizeof (*current_gdbarch)); 1314 current_gdbarch->obstack = obstack; 1315 1316 alloc_gdbarch_data (current_gdbarch); 1317 1318 current_gdbarch->tdep = tdep; 1319EOF 1320printf "\n" 1321function_list | while do_read 1322do 1323 if class_is_info_p 1324 then 1325 printf " current_gdbarch->${function} = info->${function};\n" 1326 fi 1327done 1328printf "\n" 1329printf " /* Force the explicit initialization of these. */\n" 1330function_list | while do_read 1331do 1332 if class_is_function_p || class_is_variable_p 1333 then 1334 if [ -n "${predefault}" -a "x${predefault}" != "x0" ] 1335 then 1336 printf " current_gdbarch->${function} = ${predefault};\n" 1337 fi 1338 fi 1339done 1340cat <<EOF 1341 /* gdbarch_alloc() */ 1342 1343 return current_gdbarch; 1344} 1345EOF 1346 1347# Free a gdbarch struct. 1348printf "\n" 1349printf "\n" 1350cat <<EOF 1351/* Allocate extra space using the per-architecture obstack. */ 1352 1353void * 1354gdbarch_obstack_zalloc (struct gdbarch *arch, long size) 1355{ 1356 void *data = obstack_alloc (arch->obstack, size); 1357 memset (data, 0, size); 1358 return data; 1359} 1360 1361 1362/* Free a gdbarch struct. This should never happen in normal 1363 operation --- once you've created a gdbarch, you keep it around. 1364 However, if an architecture's init function encounters an error 1365 building the structure, it may need to clean up a partially 1366 constructed gdbarch. */ 1367 1368void 1369gdbarch_free (struct gdbarch *arch) 1370{ 1371 struct obstack *obstack; 1372 gdb_assert (arch != NULL); 1373 gdb_assert (!arch->initialized_p); 1374 obstack = arch->obstack; 1375 obstack_free (obstack, 0); /* Includes the ARCH. */ 1376 xfree (obstack); 1377} 1378EOF 1379 1380# verify a new architecture 1381cat <<EOF 1382 1383 1384/* Ensure that all values in a GDBARCH are reasonable. */ 1385 1386/* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it 1387 just happens to match the global variable \`\`current_gdbarch''. That 1388 way macros refering to that variable get the local and not the global 1389 version - ulgh. Once everything is parameterised with gdbarch, this 1390 will go away. */ 1391 1392static void 1393verify_gdbarch (struct gdbarch *current_gdbarch) 1394{ 1395 struct ui_file *log; 1396 struct cleanup *cleanups; 1397 long dummy; 1398 char *buf; 1399 log = mem_fileopen (); 1400 cleanups = make_cleanup_ui_file_delete (log); 1401 /* fundamental */ 1402 if (current_gdbarch->byte_order == BFD_ENDIAN_UNKNOWN) 1403 fprintf_unfiltered (log, "\n\tbyte-order"); 1404 if (current_gdbarch->bfd_arch_info == NULL) 1405 fprintf_unfiltered (log, "\n\tbfd_arch_info"); 1406 /* Check those that need to be defined for the given multi-arch level. */ 1407EOF 1408function_list | while do_read 1409do 1410 if class_is_function_p || class_is_variable_p 1411 then 1412 if [ "x${invalid_p}" = "x0" ] 1413 then 1414 printf " /* Skip verify of ${function}, invalid_p == 0 */\n" 1415 elif class_is_predicate_p 1416 then 1417 printf " /* Skip verify of ${function}, has predicate */\n" 1418 # FIXME: See do_read for potential simplification 1419 elif [ -n "${invalid_p}" -a -n "${postdefault}" ] 1420 then 1421 printf " if (${invalid_p})\n" 1422 printf " current_gdbarch->${function} = ${postdefault};\n" 1423 elif [ -n "${predefault}" -a -n "${postdefault}" ] 1424 then 1425 printf " if (current_gdbarch->${function} == ${predefault})\n" 1426 printf " current_gdbarch->${function} = ${postdefault};\n" 1427 elif [ -n "${postdefault}" ] 1428 then 1429 printf " if (current_gdbarch->${function} == 0)\n" 1430 printf " current_gdbarch->${function} = ${postdefault};\n" 1431 elif [ -n "${invalid_p}" ] 1432 then 1433 printf " if (${invalid_p})\n" 1434 printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n" 1435 elif [ -n "${predefault}" ] 1436 then 1437 printf " if (current_gdbarch->${function} == ${predefault})\n" 1438 printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n" 1439 fi 1440 fi 1441done 1442cat <<EOF 1443 buf = ui_file_xstrdup (log, &dummy); 1444 make_cleanup (xfree, buf); 1445 if (strlen (buf) > 0) 1446 internal_error (__FILE__, __LINE__, 1447 _("verify_gdbarch: the following are invalid ...%s"), 1448 buf); 1449 do_cleanups (cleanups); 1450} 1451EOF 1452 1453# dump the structure 1454printf "\n" 1455printf "\n" 1456cat <<EOF 1457/* Print out the details of the current architecture. */ 1458 1459/* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it 1460 just happens to match the global variable \`\`current_gdbarch''. That 1461 way macros refering to that variable get the local and not the global 1462 version - ulgh. Once everything is parameterised with gdbarch, this 1463 will go away. */ 1464 1465void 1466gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file) 1467{ 1468 const char *gdb_xm_file = "<not-defined>"; 1469 const char *gdb_nm_file = "<not-defined>"; 1470 const char *gdb_tm_file = "<not-defined>"; 1471#if defined (GDB_XM_FILE) 1472 gdb_xm_file = GDB_XM_FILE; 1473#endif 1474 fprintf_unfiltered (file, 1475 "gdbarch_dump: GDB_XM_FILE = %s\\n", 1476 gdb_xm_file); 1477#if defined (GDB_NM_FILE) 1478 gdb_nm_file = GDB_NM_FILE; 1479#endif 1480 fprintf_unfiltered (file, 1481 "gdbarch_dump: GDB_NM_FILE = %s\\n", 1482 gdb_nm_file); 1483#if defined (GDB_TM_FILE) 1484 gdb_tm_file = GDB_TM_FILE; 1485#endif 1486 fprintf_unfiltered (file, 1487 "gdbarch_dump: GDB_TM_FILE = %s\\n", 1488 gdb_tm_file); 1489EOF 1490function_list | sort -t: -k 4 | while do_read 1491do 1492 # First the predicate 1493 if class_is_predicate_p 1494 then 1495 if test -n "${macro}" 1496 then 1497 printf "#ifdef ${macro}_P\n" 1498 printf " fprintf_unfiltered (file,\n" 1499 printf " \"gdbarch_dump: %%s # %%s\\\\n\",\n" 1500 printf " \"${macro}_P()\",\n" 1501 printf " XSTRING (${macro}_P ()));\n" 1502 printf "#endif\n" 1503 fi 1504 printf " fprintf_unfiltered (file,\n" 1505 printf " \"gdbarch_dump: gdbarch_${function}_p() = %%d\\\\n\",\n" 1506 printf " gdbarch_${function}_p (current_gdbarch));\n" 1507 fi 1508 # Print the macro definition. 1509 if test -n "${macro}" 1510 then 1511 printf "#ifdef ${macro}\n" 1512 if class_is_function_p 1513 then 1514 printf " fprintf_unfiltered (file,\n" 1515 printf " \"gdbarch_dump: %%s # %%s\\\\n\",\n" 1516 printf " \"${macro}(${actual})\",\n" 1517 printf " XSTRING (${macro} (${actual})));\n" 1518 else 1519 printf " fprintf_unfiltered (file,\n" 1520 printf " \"gdbarch_dump: ${macro} # %%s\\\\n\",\n" 1521 printf " XSTRING (${macro}));\n" 1522 fi 1523 printf "#endif\n" 1524 fi 1525 # Print the corresponding value. 1526 if class_is_function_p 1527 then 1528 printf " fprintf_unfiltered (file,\n" 1529 printf " \"gdbarch_dump: ${function} = <0x%%lx>\\\\n\",\n" 1530 printf " (long) current_gdbarch->${function});\n" 1531 else 1532 # It is a variable 1533 case "${print}:${returntype}" in 1534 :CORE_ADDR ) 1535 fmt="0x%s" 1536 print="paddr_nz (current_gdbarch->${function})" 1537 ;; 1538 :* ) 1539 fmt="%s" 1540 print="paddr_d (current_gdbarch->${function})" 1541 ;; 1542 * ) 1543 fmt="%s" 1544 ;; 1545 esac 1546 printf " fprintf_unfiltered (file,\n" 1547 printf " \"gdbarch_dump: ${function} = %s\\\\n\",\n" "${fmt}" 1548 printf " ${print});\n" 1549 fi 1550done 1551cat <<EOF 1552 if (current_gdbarch->dump_tdep != NULL) 1553 current_gdbarch->dump_tdep (current_gdbarch, file); 1554} 1555EOF 1556 1557 1558# GET/SET 1559printf "\n" 1560cat <<EOF 1561struct gdbarch_tdep * 1562gdbarch_tdep (struct gdbarch *gdbarch) 1563{ 1564 if (gdbarch_debug >= 2) 1565 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n"); 1566 return gdbarch->tdep; 1567} 1568EOF 1569printf "\n" 1570function_list | while do_read 1571do 1572 if class_is_predicate_p 1573 then 1574 printf "\n" 1575 printf "int\n" 1576 printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n" 1577 printf "{\n" 1578 printf " gdb_assert (gdbarch != NULL);\n" 1579 printf " return ${predicate};\n" 1580 printf "}\n" 1581 fi 1582 if class_is_function_p 1583 then 1584 printf "\n" 1585 printf "${returntype}\n" 1586 if [ "x${formal}" = "xvoid" ] 1587 then 1588 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n" 1589 else 1590 printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n" 1591 fi 1592 printf "{\n" 1593 printf " gdb_assert (gdbarch != NULL);\n" 1594 printf " gdb_assert (gdbarch->${function} != NULL);\n" 1595 if class_is_predicate_p && test -n "${predefault}" 1596 then 1597 # Allow a call to a function with a predicate. 1598 printf " /* Do not check predicate: ${predicate}, allow call. */\n" 1599 fi 1600 printf " if (gdbarch_debug >= 2)\n" 1601 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n" 1602 if [ "x${actual}" = "x-" -o "x${actual}" = "x" ] 1603 then 1604 if class_is_multiarch_p 1605 then 1606 params="gdbarch" 1607 else 1608 params="" 1609 fi 1610 else 1611 if class_is_multiarch_p 1612 then 1613 params="gdbarch, ${actual}" 1614 else 1615 params="${actual}" 1616 fi 1617 fi 1618 if [ "x${returntype}" = "xvoid" ] 1619 then 1620 printf " gdbarch->${function} (${params});\n" 1621 else 1622 printf " return gdbarch->${function} (${params});\n" 1623 fi 1624 printf "}\n" 1625 printf "\n" 1626 printf "void\n" 1627 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n" 1628 printf " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})\n" 1629 printf "{\n" 1630 printf " gdbarch->${function} = ${function};\n" 1631 printf "}\n" 1632 elif class_is_variable_p 1633 then 1634 printf "\n" 1635 printf "${returntype}\n" 1636 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n" 1637 printf "{\n" 1638 printf " gdb_assert (gdbarch != NULL);\n" 1639 if [ "x${invalid_p}" = "x0" ] 1640 then 1641 printf " /* Skip verify of ${function}, invalid_p == 0 */\n" 1642 elif [ -n "${invalid_p}" ] 1643 then 1644 printf " /* Check variable is valid. */\n" 1645 printf " gdb_assert (!(${invalid_p}));\n" 1646 elif [ -n "${predefault}" ] 1647 then 1648 printf " /* Check variable changed from pre-default. */\n" 1649 printf " gdb_assert (gdbarch->${function} != ${predefault});\n" 1650 fi 1651 printf " if (gdbarch_debug >= 2)\n" 1652 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n" 1653 printf " return gdbarch->${function};\n" 1654 printf "}\n" 1655 printf "\n" 1656 printf "void\n" 1657 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n" 1658 printf " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})\n" 1659 printf "{\n" 1660 printf " gdbarch->${function} = ${function};\n" 1661 printf "}\n" 1662 elif class_is_info_p 1663 then 1664 printf "\n" 1665 printf "${returntype}\n" 1666 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n" 1667 printf "{\n" 1668 printf " gdb_assert (gdbarch != NULL);\n" 1669 printf " if (gdbarch_debug >= 2)\n" 1670 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n" 1671 printf " return gdbarch->${function};\n" 1672 printf "}\n" 1673 fi 1674done 1675 1676# All the trailing guff 1677cat <<EOF 1678 1679 1680/* Keep a registry of per-architecture data-pointers required by GDB 1681 modules. */ 1682 1683struct gdbarch_data 1684{ 1685 unsigned index; 1686 int init_p; 1687 gdbarch_data_pre_init_ftype *pre_init; 1688 gdbarch_data_post_init_ftype *post_init; 1689}; 1690 1691struct gdbarch_data_registration 1692{ 1693 struct gdbarch_data *data; 1694 struct gdbarch_data_registration *next; 1695}; 1696 1697struct gdbarch_data_registry 1698{ 1699 unsigned nr; 1700 struct gdbarch_data_registration *registrations; 1701}; 1702 1703struct gdbarch_data_registry gdbarch_data_registry = 1704{ 1705 0, NULL, 1706}; 1707 1708static struct gdbarch_data * 1709gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init, 1710 gdbarch_data_post_init_ftype *post_init) 1711{ 1712 struct gdbarch_data_registration **curr; 1713 /* Append the new registraration. */ 1714 for (curr = &gdbarch_data_registry.registrations; 1715 (*curr) != NULL; 1716 curr = &(*curr)->next); 1717 (*curr) = XMALLOC (struct gdbarch_data_registration); 1718 (*curr)->next = NULL; 1719 (*curr)->data = XMALLOC (struct gdbarch_data); 1720 (*curr)->data->index = gdbarch_data_registry.nr++; 1721 (*curr)->data->pre_init = pre_init; 1722 (*curr)->data->post_init = post_init; 1723 (*curr)->data->init_p = 1; 1724 return (*curr)->data; 1725} 1726 1727struct gdbarch_data * 1728gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init) 1729{ 1730 return gdbarch_data_register (pre_init, NULL); 1731} 1732 1733struct gdbarch_data * 1734gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init) 1735{ 1736 return gdbarch_data_register (NULL, post_init); 1737} 1738 1739/* Create/delete the gdbarch data vector. */ 1740 1741static void 1742alloc_gdbarch_data (struct gdbarch *gdbarch) 1743{ 1744 gdb_assert (gdbarch->data == NULL); 1745 gdbarch->nr_data = gdbarch_data_registry.nr; 1746 gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *); 1747} 1748 1749/* Initialize the current value of the specified per-architecture 1750 data-pointer. */ 1751 1752void 1753deprecated_set_gdbarch_data (struct gdbarch *gdbarch, 1754 struct gdbarch_data *data, 1755 void *pointer) 1756{ 1757 gdb_assert (data->index < gdbarch->nr_data); 1758 gdb_assert (gdbarch->data[data->index] == NULL); 1759 gdb_assert (data->pre_init == NULL); 1760 gdbarch->data[data->index] = pointer; 1761} 1762 1763/* Return the current value of the specified per-architecture 1764 data-pointer. */ 1765 1766void * 1767gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data) 1768{ 1769 gdb_assert (data->index < gdbarch->nr_data); 1770 if (gdbarch->data[data->index] == NULL) 1771 { 1772 /* The data-pointer isn't initialized, call init() to get a 1773 value. */ 1774 if (data->pre_init != NULL) 1775 /* Mid architecture creation: pass just the obstack, and not 1776 the entire architecture, as that way it isn't possible for 1777 pre-init code to refer to undefined architecture 1778 fields. */ 1779 gdbarch->data[data->index] = data->pre_init (gdbarch->obstack); 1780 else if (gdbarch->initialized_p 1781 && data->post_init != NULL) 1782 /* Post architecture creation: pass the entire architecture 1783 (as all fields are valid), but be careful to also detect 1784 recursive references. */ 1785 { 1786 gdb_assert (data->init_p); 1787 data->init_p = 0; 1788 gdbarch->data[data->index] = data->post_init (gdbarch); 1789 data->init_p = 1; 1790 } 1791 else 1792 /* The architecture initialization hasn't completed - punt - 1793 hope that the caller knows what they are doing. Once 1794 deprecated_set_gdbarch_data has been initialized, this can be 1795 changed to an internal error. */ 1796 return NULL; 1797 gdb_assert (gdbarch->data[data->index] != NULL); 1798 } 1799 return gdbarch->data[data->index]; 1800} 1801 1802 1803/* Keep a registry of the architectures known by GDB. */ 1804 1805struct gdbarch_registration 1806{ 1807 enum bfd_architecture bfd_architecture; 1808 gdbarch_init_ftype *init; 1809 gdbarch_dump_tdep_ftype *dump_tdep; 1810 struct gdbarch_list *arches; 1811 struct gdbarch_registration *next; 1812}; 1813 1814static struct gdbarch_registration *gdbarch_registry = NULL; 1815 1816static void 1817append_name (const char ***buf, int *nr, const char *name) 1818{ 1819 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1)); 1820 (*buf)[*nr] = name; 1821 *nr += 1; 1822} 1823 1824const char ** 1825gdbarch_printable_names (void) 1826{ 1827 /* Accumulate a list of names based on the registed list of 1828 architectures. */ 1829 enum bfd_architecture a; 1830 int nr_arches = 0; 1831 const char **arches = NULL; 1832 struct gdbarch_registration *rego; 1833 for (rego = gdbarch_registry; 1834 rego != NULL; 1835 rego = rego->next) 1836 { 1837 const struct bfd_arch_info *ap; 1838 ap = bfd_lookup_arch (rego->bfd_architecture, 0); 1839 if (ap == NULL) 1840 internal_error (__FILE__, __LINE__, 1841 _("gdbarch_architecture_names: multi-arch unknown")); 1842 do 1843 { 1844 append_name (&arches, &nr_arches, ap->printable_name); 1845 ap = ap->next; 1846 } 1847 while (ap != NULL); 1848 } 1849 append_name (&arches, &nr_arches, NULL); 1850 return arches; 1851} 1852 1853 1854void 1855gdbarch_register (enum bfd_architecture bfd_architecture, 1856 gdbarch_init_ftype *init, 1857 gdbarch_dump_tdep_ftype *dump_tdep) 1858{ 1859 struct gdbarch_registration **curr; 1860 const struct bfd_arch_info *bfd_arch_info; 1861 /* Check that BFD recognizes this architecture */ 1862 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0); 1863 if (bfd_arch_info == NULL) 1864 { 1865 internal_error (__FILE__, __LINE__, 1866 _("gdbarch: Attempt to register unknown architecture (%d)"), 1867 bfd_architecture); 1868 } 1869 /* Check that we haven't seen this architecture before */ 1870 for (curr = &gdbarch_registry; 1871 (*curr) != NULL; 1872 curr = &(*curr)->next) 1873 { 1874 if (bfd_architecture == (*curr)->bfd_architecture) 1875 internal_error (__FILE__, __LINE__, 1876 _("gdbarch: Duplicate registraration of architecture (%s)"), 1877 bfd_arch_info->printable_name); 1878 } 1879 /* log it */ 1880 if (gdbarch_debug) 1881 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n", 1882 bfd_arch_info->printable_name, 1883 (long) init); 1884 /* Append it */ 1885 (*curr) = XMALLOC (struct gdbarch_registration); 1886 (*curr)->bfd_architecture = bfd_architecture; 1887 (*curr)->init = init; 1888 (*curr)->dump_tdep = dump_tdep; 1889 (*curr)->arches = NULL; 1890 (*curr)->next = NULL; 1891} 1892 1893void 1894register_gdbarch_init (enum bfd_architecture bfd_architecture, 1895 gdbarch_init_ftype *init) 1896{ 1897 gdbarch_register (bfd_architecture, init, NULL); 1898} 1899 1900 1901/* Look for an architecture using gdbarch_info. */ 1902 1903struct gdbarch_list * 1904gdbarch_list_lookup_by_info (struct gdbarch_list *arches, 1905 const struct gdbarch_info *info) 1906{ 1907 for (; arches != NULL; arches = arches->next) 1908 { 1909 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info) 1910 continue; 1911 if (info->byte_order != arches->gdbarch->byte_order) 1912 continue; 1913 if (info->osabi != arches->gdbarch->osabi) 1914 continue; 1915 if (info->target_desc != arches->gdbarch->target_desc) 1916 continue; 1917 return arches; 1918 } 1919 return NULL; 1920} 1921 1922 1923/* Find an architecture that matches the specified INFO. Create a new 1924 architecture if needed. Return that new architecture. Assumes 1925 that there is no current architecture. */ 1926 1927static struct gdbarch * 1928find_arch_by_info (struct gdbarch_info info) 1929{ 1930 struct gdbarch *new_gdbarch; 1931 struct gdbarch_registration *rego; 1932 1933 /* The existing architecture has been swapped out - all this code 1934 works from a clean slate. */ 1935 gdb_assert (current_gdbarch == NULL); 1936 1937 /* Fill in missing parts of the INFO struct using a number of 1938 sources: "set ..."; INFOabfd supplied; and the global 1939 defaults. */ 1940 gdbarch_info_fill (&info); 1941 1942 /* Must have found some sort of architecture. */ 1943 gdb_assert (info.bfd_arch_info != NULL); 1944 1945 if (gdbarch_debug) 1946 { 1947 fprintf_unfiltered (gdb_stdlog, 1948 "find_arch_by_info: info.bfd_arch_info %s\n", 1949 (info.bfd_arch_info != NULL 1950 ? info.bfd_arch_info->printable_name 1951 : "(null)")); 1952 fprintf_unfiltered (gdb_stdlog, 1953 "find_arch_by_info: info.byte_order %d (%s)\n", 1954 info.byte_order, 1955 (info.byte_order == BFD_ENDIAN_BIG ? "big" 1956 : info.byte_order == BFD_ENDIAN_LITTLE ? "little" 1957 : "default")); 1958 fprintf_unfiltered (gdb_stdlog, 1959 "find_arch_by_info: info.osabi %d (%s)\n", 1960 info.osabi, gdbarch_osabi_name (info.osabi)); 1961 fprintf_unfiltered (gdb_stdlog, 1962 "find_arch_by_info: info.abfd 0x%lx\n", 1963 (long) info.abfd); 1964 fprintf_unfiltered (gdb_stdlog, 1965 "find_arch_by_info: info.tdep_info 0x%lx\n", 1966 (long) info.tdep_info); 1967 } 1968 1969 /* Find the tdep code that knows about this architecture. */ 1970 for (rego = gdbarch_registry; 1971 rego != NULL; 1972 rego = rego->next) 1973 if (rego->bfd_architecture == info.bfd_arch_info->arch) 1974 break; 1975 if (rego == NULL) 1976 { 1977 if (gdbarch_debug) 1978 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: " 1979 "No matching architecture\n"); 1980 return 0; 1981 } 1982 1983 /* Ask the tdep code for an architecture that matches "info". */ 1984 new_gdbarch = rego->init (info, rego->arches); 1985 1986 /* Did the tdep code like it? No. Reject the change and revert to 1987 the old architecture. */ 1988 if (new_gdbarch == NULL) 1989 { 1990 if (gdbarch_debug) 1991 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: " 1992 "Target rejected architecture\n"); 1993 return NULL; 1994 } 1995 1996 /* Is this a pre-existing architecture (as determined by already 1997 being initialized)? Move it to the front of the architecture 1998 list (keeping the list sorted Most Recently Used). */ 1999 if (new_gdbarch->initialized_p) 2000 { 2001 struct gdbarch_list **list; 2002 struct gdbarch_list *this; 2003 if (gdbarch_debug) 2004 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: " 2005 "Previous architecture 0x%08lx (%s) selected\n", 2006 (long) new_gdbarch, 2007 new_gdbarch->bfd_arch_info->printable_name); 2008 /* Find the existing arch in the list. */ 2009 for (list = ®o->arches; 2010 (*list) != NULL && (*list)->gdbarch != new_gdbarch; 2011 list = &(*list)->next); 2012 /* It had better be in the list of architectures. */ 2013 gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch); 2014 /* Unlink THIS. */ 2015 this = (*list); 2016 (*list) = this->next; 2017 /* Insert THIS at the front. */ 2018 this->next = rego->arches; 2019 rego->arches = this; 2020 /* Return it. */ 2021 return new_gdbarch; 2022 } 2023 2024 /* It's a new architecture. */ 2025 if (gdbarch_debug) 2026 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: " 2027 "New architecture 0x%08lx (%s) selected\n", 2028 (long) new_gdbarch, 2029 new_gdbarch->bfd_arch_info->printable_name); 2030 2031 /* Insert the new architecture into the front of the architecture 2032 list (keep the list sorted Most Recently Used). */ 2033 { 2034 struct gdbarch_list *this = XMALLOC (struct gdbarch_list); 2035 this->next = rego->arches; 2036 this->gdbarch = new_gdbarch; 2037 rego->arches = this; 2038 } 2039 2040 /* Check that the newly installed architecture is valid. Plug in 2041 any post init values. */ 2042 new_gdbarch->dump_tdep = rego->dump_tdep; 2043 verify_gdbarch (new_gdbarch); 2044 new_gdbarch->initialized_p = 1; 2045 2046 if (gdbarch_debug) 2047 gdbarch_dump (new_gdbarch, gdb_stdlog); 2048 2049 return new_gdbarch; 2050} 2051 2052struct gdbarch * 2053gdbarch_find_by_info (struct gdbarch_info info) 2054{ 2055 struct gdbarch *new_gdbarch; 2056 2057 /* Save the previously selected architecture, setting the global to 2058 NULL. This stops things like gdbarch->init() trying to use the 2059 previous architecture's configuration. The previous architecture 2060 may not even be of the same architecture family. The most recent 2061 architecture of the same family is found at the head of the 2062 rego->arches list. */ 2063 struct gdbarch *old_gdbarch = current_gdbarch; 2064 current_gdbarch = NULL; 2065 2066 /* Find the specified architecture. */ 2067 new_gdbarch = find_arch_by_info (info); 2068 2069 /* Restore the existing architecture. */ 2070 gdb_assert (current_gdbarch == NULL); 2071 current_gdbarch = old_gdbarch; 2072 2073 return new_gdbarch; 2074} 2075 2076/* Make the specified architecture current. */ 2077 2078void 2079deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch) 2080{ 2081 gdb_assert (new_gdbarch != NULL); 2082 gdb_assert (current_gdbarch != NULL); 2083 gdb_assert (new_gdbarch->initialized_p); 2084 current_gdbarch = new_gdbarch; 2085 architecture_changed_event (); 2086 reinit_frame_cache (); 2087} 2088 2089extern void _initialize_gdbarch (void); 2090 2091void 2092_initialize_gdbarch (void) 2093{ 2094 struct cmd_list_element *c; 2095 2096 add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\\ 2097Set architecture debugging."), _("\\ 2098Show architecture debugging."), _("\\ 2099When non-zero, architecture debugging is enabled."), 2100 NULL, 2101 show_gdbarch_debug, 2102 &setdebuglist, &showdebuglist); 2103} 2104EOF 2105 2106# close things off 2107exec 1>&2 2108#../move-if-change new-gdbarch.c gdbarch.c 2109compare_new gdbarch.c 2110