-#!/usr/local/bin/bash -u
+#!/bin/sh -u
# Architecture commands for GDB, the GNU debugger.
# Copyright 1998-2000 Free Software Foundation, Inc.
compare_new ()
{
file=$1
- if ! test -r ${file}
+ if test ! -r ${file}
then
echo "${file} missing? cp new-${file} ${file}" 1>&2
elif diff -c ${file} new-${file}
do_read ()
{
- if eval read $read
- then
- test "${staticdefault}" || staticdefault=0
- # NOT YET: Breaks BELIEVE_PCC_PROMOTION and confuses non-
- # multi-arch defaults.
- # test "${predefault}" || predefault=0
- test "${fmt}" || fmt="%ld"
- test "${print}" || print="(long) ${macro}"
- case "${invalid_p}" in
- 0 ) valid_p=1 ;;
- "" )
- if [ "${predefault}" ]
- then
- #invalid_p="gdbarch->${function} == ${predefault}"
- valid_p="gdbarch->${function} != ${predefault}"
- else
- #invalid_p="gdbarch->${function} == 0"
- valid_p="gdbarch->${function} != 0"
- fi
- ;;
- * ) valid_p="!(${invalid_p})"
- esac
-
- # PREDEFAULT is a valid fallback definition of MEMBER when
- # multi-arch is not enabled. This ensures that the default
- # value, when multi-arch is the same as the default value when
- # not multi-arch. POSTDEFAULT is always a valid definition of
- # MEMBER as this again ensures consistency.
- if [ "${postdefault}" != "" ]
+ comment=""
+ class=""
+ while read line
+ do
+ if test "${line}" = ""
then
- fallbackdefault="${postdefault}"
- elif [ "${predefault}" != "" ]
+ continue
+ elif test "${line}" = "#" -a "${comment}" = ""
then
- fallbackdefault="${predefault}"
+ continue
+ elif expr "${line}" : "#" > /dev/null
+ then
+ comment="${comment}
+${line}"
else
- fallbackdefault=""
+
+ # The semantics of IFS varies between different SH's. Some
+ # treat ``::' as three fields while some treat it as just too.
+ # Work around this by eliminating ``::'' ....
+ line="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`"
+
+ OFS="${IFS}" ; IFS="[:]"
+ eval read ${read} <<EOF
+${line}
+EOF
+ IFS="${OFS}"
+
+ # .... and then going back through each field and strip out those
+ # that ended up with just that space character.
+ for r in ${read}
+ do
+ if eval test \"\${${r}}\" = \"\ \"
+ then
+ eval ${r}=""
+ fi
+ done
+
+ test "${staticdefault}" || staticdefault=0
+ # NOT YET: Breaks BELIEVE_PCC_PROMOTION and confuses non-
+ # multi-arch defaults.
+ # test "${predefault}" || predefault=0
+ test "${fmt}" || fmt="%ld"
+ test "${print}" || print="(long) ${macro}"
+ case "${invalid_p}" in
+ 0 ) valid_p=1 ;;
+ "" )
+ if [ "${predefault}" ]
+ then
+ #invalid_p="gdbarch->${function} == ${predefault}"
+ valid_p="gdbarch->${function} != ${predefault}"
+ else
+ #invalid_p="gdbarch->${function} == 0"
+ valid_p="gdbarch->${function} != 0"
+ fi
+ ;;
+ * ) valid_p="!(${invalid_p})"
+ esac
+
+ # PREDEFAULT is a valid fallback definition of MEMBER when
+ # multi-arch is not enabled. This ensures that the
+ # default value, when multi-arch is the same as the
+ # default value when not multi-arch. POSTDEFAULT is
+ # always a valid definition of MEMBER as this again
+ # ensures consistency.
+
+ if [ "${postdefault}" != "" ]
+ then
+ fallbackdefault="${postdefault}"
+ elif [ "${predefault}" != "" ]
+ then
+ fallbackdefault="${predefault}"
+ else
+ fallbackdefault=""
+ fi
+
+ #NOT YET: See gdbarch.log for basic verification of
+ # database
+
+ break
fi
- #NOT YET:
- # See gdbarch.log for basic verification of database
- :
+ done
+ if [ "${class}" ]
+ then
+ true
else
false
fi
esac
done
-IFS=:
function_list ()
{
# See below (DOCO) for description of each field
- cat <<EOF |
+ cat <<EOF
i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct::::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
#
i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN
+# Number of bits in a char or unsigned char for the target machine.
+# Just like CHAR_BIT in <limits.h> but describes the target machine.
+# v::TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
+#
+# Number of bits in a short or unsigned short for the target machine.
+v::TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):2*TARGET_CHAR_BIT::0
+# Number of bits in an int or unsigned int for the target machine.
+v::TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):4*TARGET_CHAR_BIT::0
+# Number of bits in a long or unsigned long for the target machine.
+v::TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):4*TARGET_CHAR_BIT::0
+# Number of bits in a long long or unsigned long long for the target
+# machine.
+v::TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):2*TARGET_LONG_BIT::0
+# Number of bits in a float for the target machine.
+v::TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):4*TARGET_CHAR_BIT::0
+# Number of bits in a double for the target machine.
+v::TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):8*TARGET_CHAR_BIT::0
+# Number of bits in a long double for the target machine.
+v::TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):2*TARGET_DOUBLE_BIT::0
+# For most targets, a pointer on the target and its representation as an
+# address in GDB have the same size and "look the same". For such a
+# target, you need only set TARGET_PTR_BIT / ptr_bit and TARGET_ADDR_BIT
+# / addr_bit will be set from it.
+#
+# If TARGET_PTR_BIT and TARGET_ADDR_BIT are different, you'll probably
+# also need to set POINTER_TO_ADDRESS and ADDRESS_TO_POINTER as well.
#
-v:1:TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0
-v:1:TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):0
-#v:1:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):0
-v:1:TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):0
-v:1:TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):0
-v:1:TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):0
-v:1:TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):0
-v:1:TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):0
-v:1:TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):0
-v:1:TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):0
-v:1:IEEE_FLOAT:int:ieee_float::::0:0::0:::
+# ptr_bit is the size of a pointer on the target
+v::TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):TARGET_INT_BIT::0
+# addr_bit is the size of a target address as represented in gdb
+v::TARGET_ADDR_BIT:int:addr_bit::::8 * sizeof (void*):0:TARGET_PTR_BIT:
+# Number of bits in a BFD_VMA for the target object file format.
+v::TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0
#
-f:1:TARGET_READ_PC:CORE_ADDR:read_pc:int pid:pid::0:0
-f:1:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, int pid:val, pid::0:0
-f:1:TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:0
-f:1:TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:0
-f:1:TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:0
-f:1:TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:0
+v::IEEE_FLOAT:int:ieee_float::::0:0::0:::
+#
+f::TARGET_READ_PC:CORE_ADDR:read_pc:int pid:pid::0:generic_target_read_pc::0
+f::TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, int pid:val, pid::0:generic_target_write_pc::0
+f::TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:generic_target_read_fp::0
+f::TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:generic_target_write_fp::0
+f::TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:generic_target_read_sp::0
+f::TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:generic_target_write_sp::0
#
v:2:NUM_REGS:int:num_regs::::0:-1
+# This macro gives the number of pseudo-registers that live in the
+# register namespace but do not get fetched or stored on the target.
+# These pseudo-registers may be aliases for other registers,
+# combinations of other registers, or they may be computed by GDB.
+v:2:NUM_PSEUDO_REGS:int:num_pseudo_regs::::0:0::0:::
v:2:SP_REGNUM:int:sp_regnum::::0:-1
v:2:FP_REGNUM:int:fp_regnum::::0:-1
v:2:PC_REGNUM:int:pc_regnum::::0:-1
f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
+f:2:DO_REGISTERS_INFO:void:do_registers_info:int reg_nr, int fpregs:reg_nr, fpregs:::do_registers_info::0
+# MAP a GDB RAW register number onto a simulator register number. See
+# also include/...-sim.h.
+f:2:REGISTER_SIM_REGNO:int:register_sim_regno:int reg_nr:reg_nr:::default_register_sim_regno::0
#
v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
f:2:CALL_DUMMY_ADDRESS:CORE_ADDR:call_dummy_address:void:::0:0::gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0
v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1:::0x%08lx
-v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1:::0x%08lx
+v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1:::0x%08lx::CALL_DUMMY_BREAKPOINT_OFFSET_P
v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1:::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
f:2:PC_IN_CALL_DUMMY:int:pc_in_call_dummy:CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address:pc, sp, frame_address::0:0
f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not::0
f:2:REGISTER_CONVERT_TO_VIRTUAL:void:register_convert_to_virtual:int regnum, struct type *type, char *from, char *to:regnum, type, from, to:::0::0
f:2:REGISTER_CONVERT_TO_RAW:void:register_convert_to_raw:struct type *type, int regnum, char *from, char *to:type, regnum, from, to:::0::0
+# This function is called when the value of a pseudo-register needs to
+# be updated. Typically it will be defined on a per-architecture
+# basis.
+f:2:FETCH_PSEUDO_REGISTER:void:fetch_pseudo_register:int regnum:regnum:::0::0
+# This function is called when the value of a pseudo-register needs to
+# be set or stored. Typically it will be defined on a
+# per-architecture basis.
+f:2:STORE_PSEUDO_REGISTER:void:store_pseudo_register:int regnum:regnum:::0::0
#
f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, void *buf:type, buf:::unsigned_pointer_to_address::0
f:2:ADDRESS_TO_POINTER:void:address_to_pointer:struct type *type, void *buf, CORE_ADDR addr:type, buf, addr:::unsigned_address_to_pointer::0
f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
#
F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
+v:1:EXTRA_STACK_ALIGNMENT_NEEDED:int:extra_stack_alignment_needed::::0:1::0:::
F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
F:2:SAVE_DUMMY_FRAME_TOS:void:save_dummy_frame_tos:CORE_ADDR sp:sp::0:0
#
v:2:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (gdbarch)
v:2:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (gdbarch)
v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::&floatformat_unknown
+f:2:CONVERT_FROM_FUNC_PTR_ADDR:CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr:addr:::default_convert_from_func_ptr_addr::0
EOF
- grep -v '^#'
}
#
# The .log file
#
exec > new-gdbarch.log
-function_list | while do_read # eval read $read
+function_list | while do_read
do
cat <<EOF
${class} ${macro}(${actual})
${returntype} ${function} ($formal)${attrib}
- level=${level}
- staticdefault=${staticdefault}
- predefault=${predefault}
- postdefault=${postdefault}
- fallbackdefault=${fallbackdefault}
- invalid_p=${invalid_p}
- valid_p=${valid_p}
- fmt=${fmt}
- print=${print}
- print_p=${print_p}
- description=${description}
EOF
+ for r in ${read}
+ do
+ eval echo \"\ \ \ \ ${r}=\${${r}}\"
+ done
+# #fallbackdefault=${fallbackdefault}
+# #valid_p=${valid_p}
+#EOF
if class_is_predicate_p && fallback_default_p
then
- echo "Error: predicate function can not have a non- multi-arch default" 1>&2
+ echo "Error: predicate function ${macro} can not have a non- multi-arch default" 1>&2
kill $$
exit 1
fi
kill $$
exit 1
fi
+ echo ""
done
exec 1>&2
/* This file was created with the aid of \`\`gdbarch.sh''.
- The bourn shell script \`\`gdbarch.sh'' creates the files
+ The Bourne shell script \`\`gdbarch.sh'' creates the files
\`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
against the existing \`\`gdbarch.[hc]''. Any differences found
being reported.
If editing this file, please also run gdbarch.sh and merge any
- changes into that script. Conversely, when makeing sweeping changes
+ changes into that script. Conversely, when making sweeping changes
to this file, modifying gdbarch.sh and using its output may prove
easier. */
struct value;
-#ifndef GDB_MULTI_ARCH
-#define GDB_MULTI_ARCH 0
-#endif
-
extern struct gdbarch *current_gdbarch;
-/* See gdb/doc/gdbint.texi for a discussion of the GDB_MULTI_ARCH
- macro */
-
-
/* If any of the following are defined, the target wasn't correctly
converted. */
EOF
# function typedef's
-echo ""
-echo ""
-echo "/* The following are pre-initialized by GDBARCH. */"
-function_list | while do_read # eval read $read
+printf "\n"
+printf "\n"
+printf "/* The following are pre-initialized by GDBARCH. */\n"
+function_list | while do_read
do
if class_is_info_p
then
- echo ""
- echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
- echo "/* set_gdbarch_${function}() - not applicable - pre-initialized. */"
- echo "#if GDB_MULTI_ARCH"
- echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
- echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
- echo "#endif"
- echo "#endif"
+ printf "\n"
+ printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
+ printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
+ printf "#if GDB_MULTI_ARCH\n"
+ printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
+ printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
+ printf "#endif\n"
+ printf "#endif\n"
fi
done
# function typedef's
-echo ""
-echo ""
-echo "/* The following are initialized by the target dependant code. */"
-function_list | while do_read # eval read $read
+printf "\n"
+printf "\n"
+printf "/* The following are initialized by the target dependent code. */\n"
+function_list | while do_read
do
+ if [ "${comment}" ]
+ then
+ echo "${comment}" | sed \
+ -e '2 s,#,/*,' \
+ -e '3,$ s,#, ,' \
+ -e '$ s,$, */,'
+ fi
if class_is_predicate_p
then
- echo ""
- echo "#if defined (${macro})"
- echo "/* Legacy for systems yet to multi-arch ${macro} */"
-# echo "#if (GDB_MULTI_ARCH <= 2) && defined (${macro})"
- echo "#define ${macro}_P() (1)"
- echo "#endif"
- echo ""
- echo "/* Default predicate for non- multi-arch targets. */"
- echo "#if (GDB_MULTI_ARCH == 0) && !defined (${macro}_P)"
- echo "#define ${macro}_P() (0)"
- echo "#endif"
- echo ""
- echo "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);"
- echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro}_P)"
- echo "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))"
- echo "#endif"
+ printf "\n"
+ printf "#if defined (${macro})\n"
+ printf "/* Legacy for systems yet to multi-arch ${macro} */\n"
+# printf "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
+ printf "#define ${macro}_P() (1)\n"
+ printf "#endif\n"
+ printf "\n"
+ printf "/* Default predicate for non- multi-arch targets. */\n"
+ printf "#if (!GDB_MULTI_ARCH) && !defined (${macro}_P)\n"
+ printf "#define ${macro}_P() (0)\n"
+ printf "#endif\n"
+ printf "\n"
+ printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
+ printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro}_P)\n"
+ printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n"
+ printf "#endif\n"
fi
if class_is_variable_p
then
if fallback_default_p || class_is_predicate_p
then
- echo ""
- echo "/* Default (value) for non- multi-arch platforms. */"
- echo "#if (GDB_MULTI_ARCH == 0) && !defined (${macro})"
+ printf "\n"
+ printf "/* Default (value) for non- multi-arch platforms. */\n"
+ printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
echo "#define ${macro} (${fallbackdefault})" \
| sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
- echo "#endif"
+ printf "#endif\n"
fi
- echo ""
- echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
- echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});"
- echo "#if GDB_MULTI_ARCH"
- echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
- echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
- echo "#endif"
- echo "#endif"
+ printf "\n"
+ printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
+ printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
+ printf "#if GDB_MULTI_ARCH\n"
+ printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
+ printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
+ printf "#endif\n"
+ printf "#endif\n"
fi
if class_is_function_p
then
if fallback_default_p || class_is_predicate_p
then
- echo ""
- echo "/* Default (function) for non- multi-arch platforms. */"
- echo "#if (GDB_MULTI_ARCH == 0) && !defined (${macro})"
+ printf "\n"
+ printf "/* Default (function) for non- multi-arch platforms. */\n"
+ printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
if [ "${fallbackdefault}" = "0" ]
then
- echo "#define ${macro}(${actual}) (internal_error (\"${macro}\"), 0)"
+ printf "#define ${macro}(${actual}) (internal_error (\"${macro}\"), 0)\n"
else
# FIXME: Should be passing current_gdbarch through!
echo "#define ${macro}(${actual}) (${fallbackdefault} (${actual}))" \
| sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
fi
- echo "#endif"
+ printf "#endif\n"
fi
- echo ""
- echo "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});"
+ printf "\n"
+ printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
if [ "${formal}" = "void" ]
then
- echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
+ printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
else
- echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});"
+ printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
fi
- echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});"
- echo "#if GDB_MULTI_ARCH"
- echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
+ printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
+ printf "#if GDB_MULTI_ARCH\n"
+ printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
if [ "${actual}" = "" ]
then
- echo "#define ${macro}() (gdbarch_${function} (current_gdbarch))"
+ printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
elif [ "${actual}" = "-" ]
then
- echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
+ printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
else
- echo "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
+ printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n"
fi
- echo "#endif"
- echo "#endif"
+ printf "#endif\n"
+ printf "#endif\n"
fi
done
The mechanisms below ensures that there is only a loose connection
between the set-architecture command and the various GDB
- components. Each component can independantly register their need
+ components. Each component can independently register their need
to maintain architecture specific data with gdbarch.
Pragmatics:
The more traditional mega-struct containing architecture specific
data for all the various GDB components was also considered. Since
- GDB is built from a variable number of (fairly independant)
+ GDB is built from a variable number of (fairly independent)
components it was determined that the global aproach was not
applicable. */
that the INFO.BYTE_ORDER is non-zero.
The INIT function shall return any of: NULL - indicating that it
- doesn't reconize the selected architecture; an existing \`\`struct
+ doesn't recognize the selected architecture; an existing \`\`struct
gdbarch'' from the ARCHES list - indicating that the new
architecture is just a synonym for an earlier architecture (see
gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
architecture manipulation commands.
The INFO parameter shall be fully initialized (\`\`memset (&INFO,
- sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
- called. gdbarch_update() shall initialize any \`\`default'' fields
- using information obtained from the previous architecture or
+ sizeof (info), 0)'' set relevant fields) before gdbarch_update_p()
+ is called. gdbarch_update_p() shall initialize any \`\`default''
+ fields using information obtained from the previous architecture or
INFO.ABFD (if specified) before calling the corresponding
- architectures INIT function. */
+ architectures INIT function.
+
+ Returns non-zero if the update succeeds */
-extern int gdbarch_update (struct gdbarch_info info);
+extern int gdbarch_update_p (struct gdbarch_info info);
-/* The target-system-dependant byte order is dynamic */
+/* The target-system-dependent byte order is dynamic */
/* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
is selectable at runtime. The user can use the \`\`set endian''
-/* The target-system-dependant BFD architecture is dynamic */
+/* The target-system-dependent BFD architecture is dynamic */
extern int target_architecture_auto;
#ifndef TARGET_ARCHITECTURE_AUTO
#endif
-/* The target-system-dependant disassembler is semi-dynamic */
+/* The target-system-dependent disassembler is semi-dynamic */
#include "dis-asm.h" /* Get defs for disassemble_info */
#endif
-/* Set the dynamic target-system-dependant parameters (architecture,
+/* Set the dynamic target-system-dependent parameters (architecture,
byte-order, ...) using information found in the BFD */
extern void set_gdbarch_from_file (bfd *);
EOF
# gdbarch open the gdbarch object
-echo ""
-echo "/* Maintain the struct gdbarch object */"
-echo ""
-echo "struct gdbarch"
-echo "{"
-echo " /* basic architectural information */"
-function_list | while do_read # eval read $read
+printf "\n"
+printf "/* Maintain the struct gdbarch object */\n"
+printf "\n"
+printf "struct gdbarch\n"
+printf "{\n"
+printf " /* basic architectural information */\n"
+function_list | while do_read
do
if class_is_info_p
then
- echo " ${returntype} ${function};"
+ printf " ${returntype} ${function};\n"
fi
done
-echo ""
-echo " /* target specific vector. */"
-echo " struct gdbarch_tdep *tdep;"
-echo " gdbarch_dump_tdep_ftype *dump_tdep;"
-echo ""
-echo " /* per-architecture data-pointers */"
-echo " int nr_data;"
-echo " void **data;"
-echo ""
-echo " /* per-architecture swap-regions */"
-echo " struct gdbarch_swap *swap;"
-echo ""
+printf "\n"
+printf " /* target specific vector. */\n"
+printf " struct gdbarch_tdep *tdep;\n"
+printf " gdbarch_dump_tdep_ftype *dump_tdep;\n"
+printf "\n"
+printf " /* per-architecture data-pointers */\n"
+printf " int nr_data;\n"
+printf " void **data;\n"
+printf "\n"
+printf " /* per-architecture swap-regions */\n"
+printf " struct gdbarch_swap *swap;\n"
+printf "\n"
cat <<EOF
/* Multi-arch values.
verify_gdbarch(): Confirm that the target updated the field
correctly.
- gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
+ gdbarch_dump(): Add a fprintf_unfiltered call so that the new
field is dumped out
\`\`startup_gdbarch()'': Append an initial value to the static
*/
EOF
-function_list | while do_read # eval read $read
+function_list | while do_read
do
if class_is_variable_p
then
- echo " ${returntype} ${function};"
+ printf " ${returntype} ${function};\n"
elif class_is_function_p
then
- echo " gdbarch_${function}_ftype *${function}${attrib};"
+ printf " gdbarch_${function}_ftype *${function}${attrib};\n"
fi
done
-echo "};"
+printf "};\n"
# A pre-initialized vector
-echo ""
-echo ""
+printf "\n"
+printf "\n"
cat <<EOF
/* The default architecture uses host values (for want of a better
choice). */
EOF
-echo ""
-echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
-echo ""
-echo "struct gdbarch startup_gdbarch ="
-echo "{"
-echo " /* basic architecture information */"
+printf "\n"
+printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
+printf "\n"
+printf "struct gdbarch startup_gdbarch =\n"
+printf "{\n"
+printf " /* basic architecture information */\n"
function_list | while do_read
do
if class_is_info_p
then
- echo " ${staticdefault},"
+ printf " ${staticdefault},\n"
fi
done
cat <<EOF
0, NULL, NULL,
/* Multi-arch values */
EOF
-function_list | while do_read # eval read $read
+function_list | while do_read
do
if class_is_function_p || class_is_variable_p
then
- echo " ${staticdefault},"
+ printf " ${staticdefault},\n"
fi
done
cat <<EOF
EOF
# Create a new gdbarch struct
-echo ""
-echo ""
+printf "\n"
+printf "\n"
cat <<EOF
-/* Create a new \`\`struct gdbarch'' based in information provided by
+/* Create a new \`\`struct gdbarch'' based on information provided by
\`\`struct gdbarch_info''. */
EOF
-echo ""
+printf "\n"
cat <<EOF
struct gdbarch *
gdbarch_alloc (const struct gdbarch_info *info,
gdbarch->tdep = tdep;
EOF
-echo ""
-function_list | while do_read # eval read $read
+printf "\n"
+function_list | while do_read
do
if class_is_info_p
then
- echo " gdbarch->${function} = info->${function};"
+ printf " gdbarch->${function} = info->${function};\n"
fi
done
-echo ""
-echo " /* Force the explicit initialization of these. */"
-function_list | while do_read # eval read $read
+printf "\n"
+printf " /* Force the explicit initialization of these. */\n"
+function_list | while do_read
do
if class_is_function_p || class_is_variable_p
then
if [ "${predefault}" != "" -a "${predefault}" != "0" ]
then
- echo " gdbarch->${function} = ${predefault};"
+ printf " gdbarch->${function} = ${predefault};\n"
fi
fi
done
EOF
# Free a gdbarch struct.
-echo ""
-echo ""
+printf "\n"
+printf "\n"
cat <<EOF
/* Free a gdbarch struct. This should never happen in normal
operation --- once you've created a gdbarch, you keep it around.
EOF
# verify a new architecture
-echo ""
-echo ""
-echo "/* Ensure that all values in a GDBARCH are reasonable. */"
-echo ""
+printf "\n"
+printf "\n"
+printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
+printf "\n"
cat <<EOF
static void
verify_gdbarch (struct gdbarch *gdbarch)
{
/* Only perform sanity checks on a multi-arch target. */
- if (GDB_MULTI_ARCH <= 0)
+ if (!GDB_MULTI_ARCH)
return;
/* fundamental */
if (gdbarch->byte_order == 0)
internal_error ("verify_gdbarch: bfd_arch_info unset");
/* Check those that need to be defined for the given multi-arch level. */
EOF
-function_list | while do_read # eval read $read
+function_list | while do_read
do
if class_is_function_p || class_is_variable_p
then
if [ "${invalid_p}" = "0" ]
then
- echo " /* Skip verify of ${function}, invalid_p == 0 */"
+ printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
elif class_is_predicate_p
then
- echo " /* Skip verify of ${function}, has predicate */"
+ printf " /* Skip verify of ${function}, has predicate */\n"
# FIXME: See do_read for potential simplification
elif [ "${invalid_p}" -a "${postdefault}" ]
then
- echo " if (${invalid_p})"
- echo " gdbarch->${function} = ${postdefault};"
+ printf " if (${invalid_p})\n"
+ printf " gdbarch->${function} = ${postdefault};\n"
elif [ "${predefault}" -a "${postdefault}" ]
then
- echo " if (gdbarch->${function} == ${predefault})"
- echo " gdbarch->${function} = ${postdefault};"
+ printf " if (gdbarch->${function} == ${predefault})\n"
+ printf " gdbarch->${function} = ${postdefault};\n"
elif [ "${postdefault}" ]
then
- echo " if (gdbarch->${function} == 0)"
- echo " gdbarch->${function} = ${postdefault};"
+ printf " if (gdbarch->${function} == 0)\n"
+ printf " gdbarch->${function} = ${postdefault};\n"
elif [ "${invalid_p}" ]
then
- echo " if ((GDB_MULTI_ARCH >= ${level})"
- echo " && (${invalid_p}))"
- echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
+ printf " if ((GDB_MULTI_ARCH >= ${level})\n"
+ printf " && (${invalid_p}))\n"
+ printf " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");\n"
elif [ "${predefault}" ]
then
- echo " if ((GDB_MULTI_ARCH >= ${level})"
- echo " && (gdbarch->${function} == ${predefault}))"
- echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
+ printf " if ((GDB_MULTI_ARCH >= ${level})\n"
+ printf " && (gdbarch->${function} == ${predefault}))\n"
+ printf " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");\n"
fi
fi
done
EOF
# dump the structure
-echo ""
-echo ""
+printf "\n"
+printf "\n"
cat <<EOF
/* Print out the details of the current architecture. */
EOF
function_list | while do_read
do
- if [ ${returntype} == "void" ]
+ if [ "${returntype}" = "void" ]
then
- echo "#if defined (${macro}) && GDB_MULTI_ARCH"
- echo " /* Macro might contain \`[{}]' when not multi-arch */"
+ printf "#if defined (${macro}) && GDB_MULTI_ARCH\n"
+ printf " /* Macro might contain \`[{}]' when not multi-arch */\n"
else
- echo "#ifdef ${macro}"
+ printf "#ifdef ${macro}\n"
fi
if class_is_function_p
then
- echo " fprintf_unfiltered (file,"
- echo " \"gdbarch_dump: %s # %s\\n\","
- echo " \"${macro}(${actual})\","
- echo " XSTRING (${macro} (${actual})));"
+ printf " fprintf_unfiltered (file,\n"
+ printf " \"gdbarch_dump: %%s # %%s\\\\n\",\n"
+ printf " \"${macro}(${actual})\",\n"
+ printf " XSTRING (${macro} (${actual})));\n"
else
- echo " fprintf_unfiltered (file,"
- echo " \"gdbarch_dump: ${macro} # %s\\n\","
- echo " XSTRING (${macro}));"
+ printf " fprintf_unfiltered (file,\n"
+ printf " \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
+ printf " XSTRING (${macro}));\n"
fi
- echo "#endif"
+ printf "#endif\n"
done
function_list | while do_read
do
- echo "#ifdef ${macro}"
+ printf "#ifdef ${macro}\n"
if [ "${print_p}" = "()" ]
then
- echo " gdbarch_dump_${function} (current_gdbarch);"
+ printf " gdbarch_dump_${function} (current_gdbarch);\n"
elif [ "${print_p}" = "0" ]
then
- echo " /* skip print of ${macro}, print_p == 0. */"
+ printf " /* skip print of ${macro}, print_p == 0. */\n"
elif [ "${print_p}" ]
then
- echo " if (${print_p})"
- echo " fprintf_unfiltered (file,"
- echo " \"gdbarch_dump: ${macro} = ${fmt}\\n\","
- echo " ${print});"
+ printf " if (${print_p})\n"
+ printf " fprintf_unfiltered (file,\n"
+ printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
+ printf " ${print});\n"
elif class_is_function_p
then
- echo " if (GDB_MULTI_ARCH)"
- echo " fprintf_unfiltered (file,"
- echo " \"gdbarch_dump: ${macro} = 0x%08lx\\n\","
- echo " (long) current_gdbarch->${function}"
- echo " /*${macro} ()*/);"
+ printf " if (GDB_MULTI_ARCH)\n"
+ printf " fprintf_unfiltered (file,\n"
+ printf " \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
+ printf " (long) current_gdbarch->${function}\n"
+ printf " /*${macro} ()*/);\n"
else
- echo " fprintf_unfiltered (file,"
- echo " \"gdbarch_dump: ${macro} = ${fmt}\\n\","
- echo " ${print});"
+ printf " fprintf_unfiltered (file,\n"
+ printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
+ printf " ${print});\n"
fi
- echo "#endif"
+ printf "#endif\n"
done
cat <<EOF
if (current_gdbarch->dump_tdep != NULL)
# GET/SET
-echo ""
+printf "\n"
cat <<EOF
struct gdbarch_tdep *
gdbarch_tdep (struct gdbarch *gdbarch)
{
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
return gdbarch->tdep;
}
EOF
-echo ""
-function_list | while do_read # eval read $read
+printf "\n"
+function_list | while do_read
do
if class_is_predicate_p
then
- echo ""
- echo "int"
- echo "gdbarch_${function}_p (struct gdbarch *gdbarch)"
- echo "{"
+ printf "\n"
+ printf "int\n"
+ printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
+ printf "{\n"
if [ "${valid_p}" ]
then
- echo " return ${valid_p};"
+ printf " return ${valid_p};\n"
else
- echo "#error \"gdbarch_${function}_p: not defined\""
+ printf "#error \"gdbarch_${function}_p: not defined\"\n"
fi
- echo "}"
+ printf "}\n"
fi
if class_is_function_p
then
- echo ""
- echo "${returntype}"
+ printf "\n"
+ printf "${returntype}\n"
if [ "${formal}" = "void" ]
then
- echo "gdbarch_${function} (struct gdbarch *gdbarch)"
+ printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
else
- echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
+ printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
fi
- echo "{"
- echo " if (gdbarch->${function} == 0)"
- echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
- echo " if (gdbarch_debug >= 2)"
- echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
+ printf "{\n"
+ printf " if (gdbarch->${function} == 0)\n"
+ printf " internal_error (\"gdbarch: gdbarch_${function} invalid\");\n"
+ printf " if (gdbarch_debug >= 2)\n"
+ printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
test "${actual}" = "-" && actual=""
if [ "${returntype}" = "void" ]
then
- echo " gdbarch->${function} (${actual});"
+ printf " gdbarch->${function} (${actual});\n"
else
- echo " return gdbarch->${function} (${actual});"
+ printf " return gdbarch->${function} (${actual});\n"
fi
- echo "}"
- echo ""
- echo "void"
- echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
- echo " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})"
- echo "{"
- echo " gdbarch->${function} = ${function};"
- echo "}"
+ printf "}\n"
+ printf "\n"
+ printf "void\n"
+ printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
+ printf " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})\n"
+ printf "{\n"
+ printf " gdbarch->${function} = ${function};\n"
+ printf "}\n"
elif class_is_variable_p
then
- echo ""
- echo "${returntype}"
- echo "gdbarch_${function} (struct gdbarch *gdbarch)"
- echo "{"
+ printf "\n"
+ printf "${returntype}\n"
+ printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
+ printf "{\n"
if [ "${invalid_p}" = "0" ]
then
- echo " /* Skip verify of ${function}, invalid_p == 0 */"
+ printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
elif [ "${invalid_p}" ]
then
- echo " if (${invalid_p})"
- echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
+ printf " if (${invalid_p})\n"
+ printf " internal_error (\"gdbarch: gdbarch_${function} invalid\");\n"
elif [ "${predefault}" ]
then
- echo " if (gdbarch->${function} == ${predefault})"
- echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
+ printf " if (gdbarch->${function} == ${predefault})\n"
+ printf " internal_error (\"gdbarch: gdbarch_${function} invalid\");\n"
fi
- echo " if (gdbarch_debug >= 2)"
- echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
- echo " return gdbarch->${function};"
- echo "}"
- echo ""
- echo "void"
- echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
- echo " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})"
- echo "{"
- echo " gdbarch->${function} = ${function};"
- echo "}"
+ printf " if (gdbarch_debug >= 2)\n"
+ printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
+ printf " return gdbarch->${function};\n"
+ printf "}\n"
+ printf "\n"
+ printf "void\n"
+ printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
+ printf " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})\n"
+ printf "{\n"
+ printf " gdbarch->${function} = ${function};\n"
+ printf "}\n"
elif class_is_info_p
then
- echo ""
- echo "${returntype}"
- echo "gdbarch_${function} (struct gdbarch *gdbarch)"
- echo "{"
- echo " if (gdbarch_debug >= 2)"
- echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
- echo " return gdbarch->${function};"
- echo "}"
+ printf "\n"
+ printf "${returntype}\n"
+ printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
+ printf "{\n"
+ printf " if (gdbarch_debug >= 2)\n"
+ printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
+ printf " return gdbarch->${function};\n"
+ printf "}\n"
fi
done
data-pointer. */
void *
-gdbarch_data (data)
- struct gdbarch_data *data;
+gdbarch_data (struct gdbarch_data *data)
{
if (data->index >= current_gdbarch->nr_data)
internal_error ("gdbarch_data: request for non-existant data.");
-/* Keep a registrary of swaped data required by GDB modules. */
+/* Keep a registrary of swapped data required by GDB modules. */
struct gdbarch_swap
{
{
struct gdbarch_registration **curr;
const struct bfd_arch_info *bfd_arch_info;
- /* Check that BFD reconizes this architecture */
+ /* Check that BFD recognizes this architecture */
bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
if (bfd_arch_info == NULL)
{
failed. */
int
-gdbarch_update (struct gdbarch_info info)
+gdbarch_update_p (struct gdbarch_info info)
{
struct gdbarch *new_gdbarch;
struct gdbarch_list **list;
if (rego == NULL)
{
if (gdbarch_debug)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
return 0;
}
if (gdbarch_debug)
{
fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: info.bfd_architecture %d (%s)\n",
+ "gdbarch_update: info.bfd_architecture %d (%s)\\n",
info.bfd_architecture,
bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: info.bfd_arch_info %s\n",
+ "gdbarch_update: info.bfd_arch_info %s\\n",
(info.bfd_arch_info != NULL
? info.bfd_arch_info->printable_name
: "(null)"));
fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: info.byte_order %d (%s)\n",
+ "gdbarch_update: info.byte_order %d (%s)\\n",
info.byte_order,
(info.byte_order == BIG_ENDIAN ? "big"
: info.byte_order == LITTLE_ENDIAN ? "little"
: "default"));
fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: info.abfd 0x%lx\n",
+ "gdbarch_update: info.abfd 0x%lx\\n",
(long) info.abfd);
fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: info.tdep_info 0x%lx\n",
+ "gdbarch_update: info.tdep_info 0x%lx\\n",
(long) info.tdep_info);
}
if (new_gdbarch == NULL)
{
if (gdbarch_debug)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
return 0;
}
if (current_gdbarch == new_gdbarch)
{
if (gdbarch_debug)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
(long) new_gdbarch,
new_gdbarch->bfd_arch_info->printable_name);
return 1;
{
if (gdbarch_debug)
fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
+ "gdbarch_update: Previous architecture 0x%08lx (%s) selected\\n",
(long) new_gdbarch,
new_gdbarch->bfd_arch_info->printable_name);
current_gdbarch = new_gdbarch;
if (gdbarch_debug)
{
fprintf_unfiltered (gdb_stdlog,
- "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
+ "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
(long) new_gdbarch,
new_gdbarch->bfd_arch_info->printable_name);
}
extern void _initialize_gdbarch (void);
void
-_initialize_gdbarch ()
+_initialize_gdbarch (void)
{
struct cmd_list_element *c;
class_maintenance,
var_zinteger,
(char *)&gdbarch_debug,
- "Set architecture debugging.\n\\
+ "Set architecture debugging.\\n\\
When non-zero, architecture debugging is enabled.", &setdebuglist),
&showdebuglist);
c = add_set_cmd ("archdebug",
class_maintenance,
var_zinteger,
(char *)&gdbarch_debug,
- "Set architecture debugging.\n\\
+ "Set architecture debugging.\\n\\
When non-zero, architecture debugging is enabled.", &setlist);
deprecate_cmd (c, "set debug arch");
projects / deliverable / binutils-gdb.git / blobdiff