fi
done
- test "${staticdefault}" || staticdefault=0
+ case "${class}" in
+ m ) staticdefault="${predefault}" ;;
+ M ) staticdefault="0" ;;
+ * ) test "${staticdefault}" || staticdefault=0 ;;
+ esac
# NOT YET: Breaks BELIEVE_PCC_PROMOTION and confuses non-
# multi-arch defaults.
# test "${predefault}" || predefault=0
+
+ # come up with a format, use a few guesses for variables
+ case ":${class}:${fmt}:${print}:" in
+ :[vV]::: )
+ if [ "${returntype}" = int ]
+ then
+ fmt="%d"
+ print="${macro}"
+ elif [ "${returntype}" = long ]
+ then
+ fmt="%ld"
+ print="${macro}"
+ fi
+ ;;
+ esac
test "${fmt}" || fmt="%ld"
test "${print}" || print="(long) ${macro}"
+
case "${invalid_p}" in
0 ) valid_p=1 ;;
"" )
then
fallbackdefault="${predefault}"
else
- fallbackdefault=""
+ fallbackdefault="0"
fi
#NOT YET: See gdbarch.log for basic verification of
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
+i:2:TARGET_BYTE_ORDER:int:byte_order::::BFD_ENDIAN_BIG
# 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 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
#
+# One if \`char' acts like \`signed char', zero if \`unsigned char'.
+v::TARGET_CHAR_SIGNED:int:char_signed::::1:-1:1::::
+#
v::IEEE_FLOAT:int:ieee_float::::0:0::0:::
#
f::TARGET_READ_PC:CORE_ADDR:read_pc:ptid_t ptid:ptid::0:generic_target_read_pc::0
v:2:REGISTER_SIZE:int:register_size::::0:-1
v:2:REGISTER_BYTES:int:register_bytes::::0:-1
f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
-f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
+f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::generic_register_raw_size:0
v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
-f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
+f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::generic_register_virtual_size: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
f:2:CANNOT_STORE_REGISTER:int:cannot_store_register:int regnum:regnum:::cannot_register_not::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
+v:1: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::CALL_DUMMY_BREAKPOINT_OFFSET_P
+v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1::gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -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: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
v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0:0x%08lx
# 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
+F:2:FETCH_PSEUDO_REGISTER:void:fetch_pseudo_register:int regnum:regnum:
# 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:STORE_PSEUDO_REGISTER:void:store_pseudo_register:int regnum:regnum:
#
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:INTEGER_TO_ADDRESS:CORE_ADDR:integer_to_address:struct type *type, void *buf:type, buf
#
f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0
f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
f:1:PUSH_ARGUMENTS:CORE_ADDR:push_arguments:int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:nargs, args, sp, struct_return, struct_addr::0:0
f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0
-f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
+F:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
f:2:POP_FRAME:void:pop_frame:void:-:::0
#
f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf:::0
F:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf:::0
-f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::0
+f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::generic_use_struct_convention::0
#
f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
-f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
+F:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
#
f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
f:2:PROLOGUE_FRAMELESS_P:int:prologue_frameless_p:CORE_ADDR ip:ip::0:generic_prologue_frameless_p::0
F:2:SOFTWARE_SINGLE_STEP:void:software_single_step:enum target_signal sig, int insert_breakpoints_p:sig, insert_breakpoints_p::0:0
f:2:TARGET_PRINT_INSN:int:print_insn:bfd_vma vma, disassemble_info *info:vma, info:::legacy_print_insn::0
f:2:SKIP_TRAMPOLINE_CODE:CORE_ADDR:skip_trampoline_code:CORE_ADDR pc:pc:::generic_skip_trampoline_code::0
+# For SVR4 shared libraries, each call goes through a small piece of
+# trampoline code in the ".plt" section. IN_SOLIB_CALL_TRAMPOLINE evaluates
+# to nonzero if we are current stopped in one of these.
+f:2:IN_SOLIB_CALL_TRAMPOLINE:int:in_solib_call_trampoline:CORE_ADDR pc, char *name:pc, name:::generic_in_solib_call_trampoline::0
+# A target might have problems with watchpoints as soon as the stack
+# frame of the current function has been destroyed. This mostly happens
+# as the first action in a funtion's epilogue. in_function_epilogue_p()
+# is defined to return a non-zero value if either the given addr is one
+# instruction after the stack destroying instruction up to the trailing
+# return instruction or if we can figure out that the stack frame has
+# already been invalidated regardless of the value of addr. Targets
+# which don't suffer from that problem could just let this functionality
+# untouched.
+m:::int:in_function_epilogue_p:CORE_ADDR addr:addr::0:generic_in_function_epilogue_p::0
+# Given a vector of command-line arguments, return a newly allocated
+# string which, when passed to the create_inferior function, will be
+# parsed (on Unix systems, by the shell) to yield the same vector.
+# This function should call error() if the argument vector is not
+# representable for this target or if this target does not support
+# command-line arguments.
+# ARGC is the number of elements in the vector.
+# ARGV is an array of strings, one per argument.
+m::CONSTRUCT_INFERIOR_ARGUMENTS:char *:construct_inferior_arguments:int argc, char **argv:argc, argv:::construct_inferior_arguments::0
+F:2:DWARF2_BUILD_FRAME_INFO:void:dwarf2_build_frame_info:struct objfile *objfile:objfile:::0
EOF
}
kill $$
exit 1
fi
+ if class_is_multiarch_p
+ then
+ if class_is_predicate_p ; then :
+ elif test "x${predefault}" = "x"
+ then
+ echo "Error: pure multi-arch function must have a predefault" 1>&2
+ kill $$
+ exit 1
+ fi
+ fi
echo ""
done
#define GDBARCH_H
#include "dis-asm.h" /* Get defs for disassemble_info, which unfortunately is a typedef. */
+#if !GDB_MULTI_ARCH
+#include "value.h" /* For default_coerce_float_to_double which is referenced by a macro. */
+#endif
struct frame_info;
struct value;
-
+struct objfile;
extern struct gdbarch *current_gdbarch;
The INIT function parameter INFO shall, as far as possible, be
pre-initialized with information obtained from INFO.ABFD or
- previously selected architecture (if similar). INIT shall ensure
- that the INFO.BYTE_ORDER is non-zero.
+ previously selected architecture (if similar).
The INIT function shall return any of: NULL - indicating that it
doesn't recognize the selected architecture; an existing \`\`struct
/* Use default: NULL (ZERO). */
const struct bfd_arch_info *bfd_arch_info;
- /* Use default: 0 (ZERO). */
+ /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO). */
int byte_order;
/* Use default: NULL (ZERO). */
#include "gdbthread.h"
#include "annotate.h"
#include "symfile.h" /* for overlay functions */
+#include "value.h" /* For old tm.h/nm.h macros. */
#endif
#include "symcat.h"
gdbarch_alloc (const struct gdbarch_info *info,
struct gdbarch_tdep *tdep)
{
- struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
- memset (gdbarch, 0, sizeof (*gdbarch));
-
- alloc_gdbarch_data (gdbarch);
-
- gdbarch->tdep = tdep;
+ /* NOTE: The new architecture variable is named \`\`current_gdbarch''
+ so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
+ the current local architecture and not the previous global
+ architecture. This ensures that the new architectures initial
+ values are not influenced by the previous architecture. Once
+ everything is parameterised with gdbarch, this will go away. */
+ struct gdbarch *current_gdbarch = XMALLOC (struct gdbarch);
+ memset (current_gdbarch, 0, sizeof (*current_gdbarch));
+
+ alloc_gdbarch_data (current_gdbarch);
+
+ current_gdbarch->tdep = tdep;
EOF
printf "\n"
function_list | while do_read
do
if class_is_info_p
then
- printf " gdbarch->${function} = info->${function};\n"
+ printf " current_gdbarch->${function} = info->${function};\n"
fi
done
printf "\n"
then
if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
then
- printf " gdbarch->${function} = ${predefault};\n"
+ printf " current_gdbarch->${function} = ${predefault};\n"
fi
fi
done
cat <<EOF
/* gdbarch_alloc() */
- return gdbarch;
+ return current_gdbarch;
}
EOF
static void
verify_gdbarch (struct gdbarch *gdbarch)
{
+ struct ui_file *log;
+ struct cleanup *cleanups;
+ long dummy;
+ char *buf;
/* Only perform sanity checks on a multi-arch target. */
if (!GDB_MULTI_ARCH)
return;
+ log = mem_fileopen ();
+ cleanups = make_cleanup_ui_file_delete (log);
/* fundamental */
- if (gdbarch->byte_order == 0)
- internal_error (__FILE__, __LINE__,
- "verify_gdbarch: byte-order unset");
+ if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
+ fprintf_unfiltered (log, "\n\tbyte-order");
if (gdbarch->bfd_arch_info == NULL)
- internal_error (__FILE__, __LINE__,
- "verify_gdbarch: bfd_arch_info unset");
+ fprintf_unfiltered (log, "\n\tbfd_arch_info");
/* Check those that need to be defined for the given multi-arch level. */
EOF
function_list | while do_read
then
printf " if ((GDB_MULTI_ARCH >= ${level})\n"
printf " && (${invalid_p}))\n"
- printf " internal_error (__FILE__, __LINE__,\n"
- printf " \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
+ printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
elif [ -n "${predefault}" ]
then
printf " if ((GDB_MULTI_ARCH >= ${level})\n"
printf " && (gdbarch->${function} == ${predefault}))\n"
- printf " internal_error (__FILE__, __LINE__,\n"
- printf " \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
+ printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
fi
fi
done
cat <<EOF
+ buf = ui_file_xstrdup (log, &dummy);
+ make_cleanup (xfree, buf);
+ if (strlen (buf) > 0)
+ internal_error (__FILE__, __LINE__,
+ "verify_gdbarch: the following are invalid ...%s",
+ buf);
+ do_cleanups (cleanups);
}
EOF
printf " (long) current_gdbarch->${function});\n"
continue
fi
+ # Print the macro definition.
printf "#ifdef ${macro}\n"
if [ "x${returntype}" = "xvoid" ]
then
printf " \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
printf " XSTRING (${macro}));\n"
fi
+ # Print the architecture vector value
if [ "x${returntype}" = "xvoid" ]
then
printf "#endif\n"
info.bfd_arch_info = TARGET_ARCHITECTURE;
/* \`\`(gdb) set byte-order ...'' */
- if (info.byte_order == 0
+ if (info.byte_order == BFD_ENDIAN_UNKNOWN
&& !TARGET_BYTE_ORDER_AUTO)
info.byte_order = TARGET_BYTE_ORDER;
/* From the INFO struct. */
- if (info.byte_order == 0
+ if (info.byte_order == BFD_ENDIAN_UNKNOWN
&& info.abfd != NULL)
- info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
- : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
- : 0);
+ info.byte_order = (bfd_big_endian (info.abfd) ? BFD_ENDIAN_BIG
+ : bfd_little_endian (info.abfd) ? BFD_ENDIAN_LITTLE
+ : BFD_ENDIAN_UNKNOWN);
/* From the current target. */
- if (info.byte_order == 0)
+ if (info.byte_order == BFD_ENDIAN_UNKNOWN)
info.byte_order = TARGET_BYTE_ORDER;
/* Must have found some sort of architecture. */
fprintf_unfiltered (gdb_stdlog,
"gdbarch_update: info.byte_order %d (%s)\n",
info.byte_order,
- (info.byte_order == BIG_ENDIAN ? "big"
- : info.byte_order == LITTLE_ENDIAN ? "little"
+ (info.byte_order == BFD_ENDIAN_BIG ? "big"
+ : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
: "default"));
fprintf_unfiltered (gdb_stdlog,
"gdbarch_update: info.abfd 0x%lx\n",
projects / binutils.git / blobdiff