* xstormy16-tdep.c (xstormy16_push_return_address): Make static.
(xstormy16_save_dummy_frame_tos): Make static.
(_initialize_xstormy16_tdep): Add declaration.
* vax-tdep.c (_initialize_vax_tdep): Add declaration.
* v850-tdep.c: Make local functions static.
(_initialize_v850_tdep): Add declaration.
* sparc-tdep.c: Make local functions static.
(_initialize_sparc_tdep): Add declaration.
* sh-tdep.c: Make local functions static.
(_initialize_sh_tdep): Add declaration.
* sh3-rom.c (_initialize_sh3_rom): Add declaration.
* s390-tdep.c: Make local functions static.
(_initialize_s390_tdep): Add declaration.
* dbxread.c (find_stab_function_addr): Make static.
* ppc-bdm.c (_initialize_bdm_ppc): Add declaration.
* ocd.c (_initialize_remote_ocd): Add declaration.
* dink32-rom.c (_initialize_dink32_rom): Add declaration.
* ppcbug-rom.c (_initialize_ppcbug_rom): Add declaration.
* ns32k-tdep.c (_initialize_ns32k_tdep): Add declaration.
* ns32knbsd-tdep.c (_initialize_ns32knbsd_tdep): Add declaration.
* mips-tdep.c (_initialize_mips_tdep): Add declaration.
* remote-array.c (_initialize_array): Add declaration.
(_initialize_remote_monitors): Add declaration.
* remote-mips.c: Make local functions static.
(_initialize_remote_mips): Add declaration.
* mcore-tdep.c: Make all local functions static.
(_initialize_mcore_tdep): Add declaration.
* dbug-rom.c (_initialize_dbug_rom): Add declaration.
* abug-rom.c (_initialize_abug_rom): Add declaration.
* rom68k-rom.c (_initialize_rom68k): Add declaration.
* cpu32bug-rom.c (_initialize_cpu32bug_rom): Add declaration.
* m68k-tdep.c (_initialize_m68k_tdep): Add declaration.
* remote-est.c (_initialize_est): Add declaration.
* m68hc11-tdep.c (_initialize_m68hc11_tdep): Add declaration.
(m68hc11_call_dummy_address): Make static.
* ia64-tdep.c: Make local functions static.
(_initialize_ia64_tdep): Add declaration.
* solib-legacy.c (_initialize_svr4_lm): Add declaration.
* monitor.c (monitor_wait_filter): Make static.
(_initialize_remote_monitors): Add declaration.
* remote-hms.c (_initialize_remote_hms): Add declaration.
* remote-e7000.c (fetch_regs_from_dump): Make static.
(expect_n): Make static.
(_initialize_remote_e7000): Add declaration.
* ser-e7kpc.c: Always include "defs.h".
(_initialize_ser_e7000pc): Add declaration.
* h8300-tdep.c (_initialize_h8300_tdep): Add declaration.
* cris-tdep.c: Make all but one function static.
(_initialize_cris_tdep): Add declaration.
* solib-svr4.c (_initialize_svr4_solib): Add declaration.
* solib.c (update_solib_list): Make static.
(_initialize_solib): Add declaration.
* avr-tdep.c (avr_breakpoint_from_pc): Make static.
(_initialize_avr_tdep): Add declaration.
* remote-rdi.c (voiddummy): Make static.
(_initialize_remote_rdi): Add declaration.
* arm-tdep.c (_initialize_arm_tdep): Add declaration.
* remote-rdp.c (send_rdp): Make static.
(_initialize_remote_rdp): Add declaration.
* alpha-tdep.c (_initialize_alpha_tdep): Add declaration.
+2003-06-11 Andrew Cagney <cagney@redhat.com>
+
+ * xstormy16-tdep.c (xstormy16_push_return_address): Make static.
+ (xstormy16_save_dummy_frame_tos): Make static.
+ (_initialize_xstormy16_tdep): Add declaration.
+ * vax-tdep.c (_initialize_vax_tdep): Add declaration.
+ * v850-tdep.c: Make local functions static.
+ (_initialize_v850_tdep): Add declaration.
+ * sparc-tdep.c: Make local functions static.
+ (_initialize_sparc_tdep): Add declaration.
+ * sh-tdep.c: Make local functions static.
+ (_initialize_sh_tdep): Add declaration.
+ * sh3-rom.c (_initialize_sh3_rom): Add declaration.
+ * s390-tdep.c: Make local functions static.
+ (_initialize_s390_tdep): Add declaration.
+ * dbxread.c (find_stab_function_addr): Make static.
+ * ppc-bdm.c (_initialize_bdm_ppc): Add declaration.
+ * ocd.c (_initialize_remote_ocd): Add declaration.
+ * dink32-rom.c (_initialize_dink32_rom): Add declaration.
+ * ppcbug-rom.c (_initialize_ppcbug_rom): Add declaration.
+ * ns32k-tdep.c (_initialize_ns32k_tdep): Add declaration.
+ * ns32knbsd-tdep.c (_initialize_ns32knbsd_tdep): Add declaration.
+ * mips-tdep.c (_initialize_mips_tdep): Add declaration.
+ * remote-array.c (_initialize_array): Add declaration.
+ (_initialize_remote_monitors): Add declaration.
+ * remote-mips.c: Make local functions static.
+ (_initialize_remote_mips): Add declaration.
+ * mcore-tdep.c: Make all local functions static.
+ (_initialize_mcore_tdep): Add declaration.
+ * dbug-rom.c (_initialize_dbug_rom): Add declaration.
+ * abug-rom.c (_initialize_abug_rom): Add declaration.
+ * rom68k-rom.c (_initialize_rom68k): Add declaration.
+ * cpu32bug-rom.c (_initialize_cpu32bug_rom): Add declaration.
+ * m68k-tdep.c (_initialize_m68k_tdep): Add declaration.
+ * remote-est.c (_initialize_est): Add declaration.
+ * m68hc11-tdep.c (_initialize_m68hc11_tdep): Add declaration.
+ (m68hc11_call_dummy_address): Make static.
+ * ia64-tdep.c: Make local functions static.
+ (_initialize_ia64_tdep): Add declaration.
+ * solib-legacy.c (_initialize_svr4_lm): Add declaration.
+ * monitor.c (monitor_wait_filter): Make static.
+ (_initialize_remote_monitors): Add declaration.
+ * remote-hms.c (_initialize_remote_hms): Add declaration.
+ * remote-e7000.c (fetch_regs_from_dump): Make static.
+ (expect_n): Make static.
+ (_initialize_remote_e7000): Add declaration.
+ * ser-e7kpc.c: Always include "defs.h".
+ (_initialize_ser_e7000pc): Add declaration.
+ * h8300-tdep.c (_initialize_h8300_tdep): Add declaration.
+ * cris-tdep.c: Make all but one function static.
+ (_initialize_cris_tdep): Add declaration.
+ * solib-svr4.c (_initialize_svr4_solib): Add declaration.
+ * solib.c (update_solib_list): Make static.
+ (_initialize_solib): Add declaration.
+ * avr-tdep.c (avr_breakpoint_from_pc): Make static.
+ (_initialize_avr_tdep): Add declaration.
+ * remote-rdi.c (voiddummy): Make static.
+ (_initialize_remote_rdi): Add declaration.
+ * arm-tdep.c (_initialize_arm_tdep): Add declaration.
+ * remote-rdp.c (send_rdp): Make static.
+ (_initialize_remote_rdp): Add declaration.
+ * alpha-tdep.c (_initialize_alpha_tdep): Add declaration.
+
2003-06-11 Corinna Vinschen <vinschen@redhat.com>
* remote-fileio.c: Make ari happy.
monitor_open (args, &abug_cmds, from_tty);
}
+extern initialize_file_ftype _initialize_abug_rom; /* -Wmissing-prototypes */
+
void
_initialize_abug_rom (void)
{
set_gdbarch_dwarf2_build_frame_info (gdbarch, dwarf2_build_frame_info);
}
+extern initialize_file_ftype _initialize_alpha_tdep; /* -Wmissing-prototypes */
+
void
_initialize_alpha_tdep (void)
{
/* */
-extern initialize_file_ftype _initialize_gdbarch_utils;
+extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
void
_initialize_gdbarch_utils (void)
/* Place-holder. */
}
+extern initialize_file_ftype _initialize_arm_tdep; /* -Wmissing-prototypes */
+
void
_initialize_arm_tdep (void)
{
it as a NOP. Thus, it should be ok. Since the avr is currently a remote
only target, this shouldn't be a problem (I hope). TRoth/2003-05-14 */
-const unsigned char *
+static const unsigned char *
avr_breakpoint_from_pc (CORE_ADDR * pcptr, int *lenptr)
{
static unsigned char avr_break_insn [] = { 0x98, 0x95 };
}
}
+extern initialize_file_ftype _initialize_avr_tdep; /* -Wmissing-prototypes */
+
void
_initialize_avr_tdep (void)
{
monitor_open (args, &cpu32bug_cmds, from_tty);
}
+extern initialize_file_ftype _initialize_cpu32bug_rom; /* -Wmissing-prototypes */
+
void
_initialize_cpu32bug_rom (void)
{
the entire prologue is examined (0) or just enough instructions to
determine that it is a prologue (1). */
-CORE_ADDR
+static CORE_ADDR
cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
int frameless_p)
{
/* Advance pc beyond any function entry prologue instructions at pc
to reach some "real" code. */
-CORE_ADDR
+static CORE_ADDR
cris_skip_prologue (CORE_ADDR pc)
{
return cris_skip_prologue_main (pc, 0);
has a frame. Its result is equal to its input pc if the function is
frameless, unequal otherwise. */
-CORE_ADDR
+static CORE_ADDR
cris_skip_prologue_frameless_p (CORE_ADDR pc)
{
return cris_skip_prologue_main (pc, 1);
/* Given a PC value corresponding to the start of a function, return the PC
of the first instruction after the function prologue. */
-CORE_ADDR
+static CORE_ADDR
cris_skip_prologue_main (CORE_ADDR pc, int frameless_p)
{
struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
adjusts pcptr (if necessary) to point to the actual memory location where
the breakpoint should be inserted. */
-const unsigned char *
+static const unsigned char *
cris_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
{
static unsigned char break_insn[] = {0x38, 0xe9};
/* Returns 1 if spec_reg is applicable to the current gdbarch's CRIS version,
0 otherwise. */
-int
+static int
cris_spec_reg_applicable (struct cris_spec_reg spec_reg)
{
int version = cris_version ();
/* Returns the register size in unit byte. Returns 0 for an unimplemented
register, -1 for an invalid register. */
-int
+static int
cris_register_size (int regno)
{
int i;
/* Nonzero if regno should not be fetched from the target. This is the case
for unimplemented (size 0) and non-existant registers. */
-int
+static int
cris_cannot_fetch_register (int regno)
{
return ((regno < 0 || regno >= NUM_REGS)
/* Nonzero if regno should not be written to the target, for various
reasons. */
-int
+static int
cris_cannot_store_register (int regno)
{
/* There are three kinds of registers we refuse to write to.
in the saved register state. Returns -1 for an invalid or unimplemented
register. */
-int
+static int
cris_register_offset (int regno)
{
int i;
/* Return the GDB type (defined in gdbtypes.c) for the "standard" data type
of data in register regno. */
-struct type *
+static struct type *
cris_register_virtual_type (int regno)
{
if (regno == SP_REGNUM || regno == PC_REGNUM
/* In the original CRIS ABI, R10 is used to store return values. */
-void
+static void
cris_abi_original_store_return_value (struct type *type, char *valbuf)
{
int len = TYPE_LENGTH (type);
/* In the CRIS ABI V2, R10 and R11 are used to store return values. */
-void
+static void
cris_abi_v2_store_return_value (struct type *type, char *valbuf)
{
int len = TYPE_LENGTH (type);
/* Return the name of register regno as a string. Return NULL for an invalid or
unimplemented register. */
-const char *
+static const char *
cris_register_name (int regno)
{
static char *cris_genreg_names[] =
}
}
-int
+static int
cris_register_bytes_ok (long bytes)
{
return (bytes == DEPRECATED_REGISTER_BYTES);
/* In the original CRIS ABI, R10 is used to return values. */
-void
+static void
cris_abi_original_extract_return_value (struct type *type, char *regbuf,
char *valbuf)
{
/* In the CRIS ABI V2, R10 and R11 are used to store return values. */
-void
+static void
cris_abi_v2_extract_return_value (struct type *type, char *regbuf,
char *valbuf)
{
be stored. R9 is call-clobbered, which means we must save it here for
later use. */
-void
+static void
cris_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
{
write_register (STR_REGNUM, addr);
structure value. It's not there in the CRIS ABI, so we must do it another
way. */
-CORE_ADDR
+static CORE_ADDR
cris_extract_struct_value_address (char *regbuf)
{
return struct_return_address;
function by reference in register R9 to a caller-allocated area, so
this is always true. */
-int
+static int
cris_use_struct_convention (int gcc_p, struct type *type)
{
return 1;
/* In the original CRIS ABI, arguments shorter than or equal to 32 bits are
passed by value. */
-int
+static int
cris_abi_original_reg_struct_has_addr (int gcc_p, struct type *type)
{
return (TYPE_LENGTH (type) > 4);
/* In the CRIS ABI V2, arguments shorter than or equal to 64 bits are passed
by value. */
-int
+static int
cris_abi_v2_reg_struct_has_addr (int gcc_p, struct type *type)
{
return (TYPE_LENGTH (type) > 8);
/* Returns 1 if the function invocation represented by fi does not have a
stack frame associated with it. Otherwise return 0. */
-int
+static int
cris_frameless_function_invocation (struct frame_info *fi)
{
if ((get_frame_type (fi) == SIGTRAMP_FRAME))
frame->saved_regs shall be allocated by
DEPRECATED_FRAME_INIT_SAVED_REGS using frame_saved_regs_zalloc. */
-void
+static void
cris_frame_init_saved_regs (struct frame_info *fi)
{
CORE_ADDR ip;
When the call is from get_prev_frame_info, fromleaf is determined by
cris_frameless_function_invocation. */
-void
+static void
cris_init_extra_frame_info (int fromleaf, struct frame_info *fi)
{
if (get_next_frame (fi))
/* Return the content of the frame pointer in the present frame. In other
words, determine the address of the calling function's frame. */
-CORE_ADDR
+static CORE_ADDR
cris_frame_chain (struct frame_info *fi)
{
if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi),
/* Return the saved PC (which equals the return address) of this frame. */
-CORE_ADDR
+static CORE_ADDR
cris_frame_saved_pc (struct frame_info *fi)
{
return get_frame_extra_info (fi)->return_pc;
/* Setup the function arguments for calling a function in the inferior. */
-CORE_ADDR
+static CORE_ADDR
cris_abi_original_push_arguments (int nargs, struct value **args,
CORE_ADDR sp, int struct_return,
CORE_ADDR struct_addr)
return sp;
}
-CORE_ADDR
+static CORE_ADDR
cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_addr)
{
by the called function unless it is a leaf-function. Due to the BRP
register the PC will change when continue is sent. */
-CORE_ADDR
+static CORE_ADDR
cris_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
{
write_register (SRP_REGNUM, CALL_DUMMY_ADDRESS ());
was created. Discard the innermost frame from the stack and restore
all saved registers. */
-void
+static void
cris_pop_frame (void)
{
register struct frame_info *fi = get_current_frame ();
digs through the opcodes in order to find all possible targets.
Either one ordinary target or two targets for branches may be found. */
-void
+static void
cris_software_single_step (enum target_signal ignore, int insert_breakpoints)
{
inst_env_type inst_env;
/* Calculates the prefix value for quick offset addressing mode. */
-void
+static void
quick_mode_bdap_prefix (unsigned short inst, inst_env_type *inst_env)
{
/* It's invalid to be in a delay slot. You can't have a prefix to this
from the size of the operation. The PC is always kept aligned on even
word addresses. */
-void
+static void
process_autoincrement (int size, unsigned short inst, inst_env_type *inst_env)
{
if (size == INST_BYTE_SIZE)
/* Just a forward declaration. */
-unsigned long get_data_from_address (unsigned short *inst, CORE_ADDR address);
+static unsigned long get_data_from_address (unsigned short *inst,
+ CORE_ADDR address);
/* Calculates the prefix value for the general case of offset addressing
mode. */
-void
+static void
bdap_prefix (unsigned short inst, inst_env_type *inst_env)
{
/* Calculates the prefix value for the index addressing mode. */
-void
+static void
biap_prefix (unsigned short inst, inst_env_type *inst_env)
{
/* It's invalid to be in a delay slot. I can't see that it's possible to
/* Calculates the prefix value for the double indirect addressing mode. */
-void
+static void
dip_prefix (unsigned short inst, inst_env_type *inst_env)
{
/* Finds the destination for a branch with 8-bits offset. */
-void
+static void
eight_bit_offset_branch_op (unsigned short inst, inst_env_type *inst_env)
{
/* Finds the destination for a branch with 16-bits offset. */
-void
+static void
sixteen_bit_offset_branch_op (unsigned short inst, inst_env_type *inst_env)
{
short offset;
/* Handles the ABS instruction. */
-void
+static void
abs_op (unsigned short inst, inst_env_type *inst_env)
{
/* Handles the ADDI instruction. */
-void
+static void
addi_op (unsigned short inst, inst_env_type *inst_env)
{
/* It's invalid to have the PC as base register. And ADDI can't have
/* Handles the ASR instruction. */
-void
+static void
asr_op (unsigned short inst, inst_env_type *inst_env)
{
int shift_steps;
/* Handles the ASRQ instruction. */
-void
+static void
asrq_op (unsigned short inst, inst_env_type *inst_env)
{
/* Handles the AX, EI and SETF instruction. */
-void
+static void
ax_ei_setf_op (unsigned short inst, inst_env_type *inst_env)
{
if (inst_env->prefix_found)
register. Note that check_assign assumes that the caller has checked that
there is a prefix to this instruction. The mode check depends on this. */
-void
+static void
check_assign (unsigned short inst, inst_env_type *inst_env)
{
/* Check if it's an assign addressing mode. */
/* Handles the 2-operand BOUND instruction. */
-void
+static void
two_operand_bound_op (unsigned short inst, inst_env_type *inst_env)
{
/* It's invalid to have the PC as the index operand. */
/* Handles the 3-operand BOUND instruction. */
-void
+static void
three_operand_bound_op (unsigned short inst, inst_env_type *inst_env)
{
/* It's an error if we haven't got a prefix. And it's also an error
/* Clears the status flags in inst_env. */
-void
+static void
btst_nop_op (unsigned short inst, inst_env_type *inst_env)
{
/* It's an error if we have got a prefix. */
/* Clears the status flags in inst_env. */
-void
+static void
clearf_di_op (unsigned short inst, inst_env_type *inst_env)
{
/* It's an error if we have got a prefix. */
/* Handles the CLEAR instruction if it's in register mode. */
-void
+static void
reg_mode_clear_op (unsigned short inst, inst_env_type *inst_env)
{
/* Check if the target is the PC. */
/* Handles the TEST instruction if it's in register mode. */
-void
+static void
reg_mode_test_op (unsigned short inst, inst_env_type *inst_env)
{
/* It's an error if we have got a prefix. */
/* Handles the CLEAR and TEST instruction if the instruction isn't
in register mode. */
-void
+static void
none_reg_mode_clear_test_op (unsigned short inst, inst_env_type *inst_env)
{
/* Check if we are in a prefix mode. */
/* Checks that the PC isn't the destination register or the instructions has
a prefix. */
-void
+static void
dstep_logshift_mstep_neg_not_op (unsigned short inst, inst_env_type *inst_env)
{
/* It's invalid to have the PC as the destination. The instruction can't
/* Checks that the instruction doesn't have a prefix. */
-void
+static void
break_op (unsigned short inst, inst_env_type *inst_env)
{
/* The instruction can't have a prefix. */
/* Checks that the PC isn't the destination register and that the instruction
doesn't have a prefix. */
-void
+static void
scc_op (unsigned short inst, inst_env_type *inst_env)
{
/* It's invalid to have the PC as the destination. The instruction can't
/* Handles the register mode JUMP instruction. */
-void
+static void
reg_mode_jump_op (unsigned short inst, inst_env_type *inst_env)
{
/* It's invalid to do a JUMP in a delay slot. The mode is register, so
/* Handles the JUMP instruction for all modes except register. */
-void none_reg_mode_jump_op (unsigned short inst, inst_env_type *inst_env)
+static void
+none_reg_mode_jump_op (unsigned short inst, inst_env_type *inst_env)
{
unsigned long newpc;
CORE_ADDR address;
/* Handles moves to special registers (aka P-register) for all modes. */
-void
+static void
move_to_preg_op (unsigned short inst, inst_env_type *inst_env)
{
if (inst_env->prefix_found)
/* Handles moves from special registers (aka P-register) for all modes
except register. */
-void
+static void
none_reg_mode_move_from_preg_op (unsigned short inst, inst_env_type *inst_env)
{
if (inst_env->prefix_found)
/* Handles moves from special registers (aka P-register) when the mode
is register. */
-void
+static void
reg_mode_move_from_preg_op (unsigned short inst, inst_env_type *inst_env)
{
/* Register mode move from special register can't have a prefix. */
/* Handles the MOVEM from memory to general register instruction. */
-void
+static void
move_mem_to_reg_movem_op (unsigned short inst, inst_env_type *inst_env)
{
if (inst_env->prefix_found)
/* Handles the MOVEM to memory from general register instruction. */
-void
+static void
move_reg_to_mem_movem_op (unsigned short inst, inst_env_type *inst_env)
{
if (inst_env->prefix_found)
/* Handles the pop instruction to a general register.
POP is a assembler macro for MOVE.D [SP+], Rd. */
-void
+static void
reg_pop_op (unsigned short inst, inst_env_type *inst_env)
{
/* POP can't have a prefix. */
/* Handles moves from register to memory. */
-void
+static void
move_reg_to_mem_index_inc_op (unsigned short inst, inst_env_type *inst_env)
{
/* Check if we have a prefix. */
/* Handles the intructions that's not yet implemented, by setting
inst_env->invalid to true. */
-void
+static void
not_implemented_op (unsigned short inst, inst_env_type *inst_env)
{
inst_env->invalid = 1;
/* Handles the XOR instruction. */
-void
+static void
xor_op (unsigned short inst, inst_env_type *inst_env)
{
/* XOR can't have a prefix. */
/* Handles the MULS instruction. */
-void
+static void
muls_op (unsigned short inst, inst_env_type *inst_env)
{
/* MULS/U can't have a prefix. */
/* Handles the MULU instruction. */
-void
+static void
mulu_op (unsigned short inst, inst_env_type *inst_env)
{
/* MULS/U can't have a prefix. */
/* Calculate the result of the instruction for ADD, SUB, CMP AND, OR and MOVE.
The MOVE instruction is the move from source to register. */
-void
+static void
add_sub_cmp_and_or_move_action (unsigned short inst, inst_env_type *inst_env,
unsigned long source1, unsigned long source2)
{
is zero extend then the value is extended with zero. If instead the mode
is signed extend the sign bit of the value is taken into consideration. */
-unsigned long
+static unsigned long
do_sign_or_zero_extend (unsigned long value, unsigned short *inst)
{
/* The size can be either byte or word, check which one it is.
/* Handles the register mode for the ADD, SUB, CMP, AND, OR and MOVE
instruction. The MOVE instruction is the move from source to register. */
-void
+static void
reg_mode_add_sub_cmp_and_or_move_op (unsigned short inst,
inst_env_type *inst_env)
{
the size of the operation. If the instruction is a zero or signed
extend instruction, the size field is changed in instruction. */
-unsigned long
+static unsigned long
get_data_from_address (unsigned short *inst, CORE_ADDR address)
{
int size = cris_get_size (*inst);
/* Handles the assign addresing mode for the ADD, SUB, CMP, AND, OR and MOVE
instructions. The MOVE instruction is the move from source to register. */
-void
+static void
handle_prefix_assign_mode_for_aritm_op (unsigned short inst,
inst_env_type *inst_env)
{
OR instructions. Note that for this to work as expected, the calling
function must have made sure that there is a prefix to this instruction. */
-void
+static void
three_operand_add_sub_cmp_and_or_op (unsigned short inst,
inst_env_type *inst_env)
{
/* Handles the index addresing mode for the ADD, SUB, CMP, AND, OR and MOVE
instructions. The MOVE instruction is the move from source to register. */
-void
+static void
handle_prefix_index_mode_for_aritm_op (unsigned short inst,
inst_env_type *inst_env)
{
CMP, AND OR and MOVE instruction. The MOVE instruction is the move from
source to register. */
-void
+static void
handle_inc_and_index_mode_for_aritm_op (unsigned short inst,
inst_env_type *inst_env)
{
/* Handles the two-operand addressing mode, all modes except register, for
the ADD, SUB CMP, AND and OR instruction. */
-void
+static void
none_reg_mode_add_sub_cmp_and_or_move_op (unsigned short inst,
inst_env_type *inst_env)
{
/* Handles the quick addressing mode for the ADD and SUB instruction. */
-void
+static void
quick_mode_add_sub_op (unsigned short inst, inst_env_type *inst_env)
{
unsigned long operand1;
/* Handles the quick addressing mode for the CMP, AND and OR instruction. */
-void
+static void
quick_mode_and_cmp_move_or_op (unsigned short inst, inst_env_type *inst_env)
{
unsigned long operand1;
/* Translate op_type to a function and call it. */
-static void cris_gdb_func (enum cris_op_type op_type, unsigned short inst,
- inst_env_type *inst_env)
+static void
+cris_gdb_func (enum cris_op_type op_type, unsigned short inst,
+ inst_env_type *inst_env)
{
switch (op_type)
{
/* Unpack an elf_gregset_t into GDB's register cache. */
-void
+static void
supply_gregset (elf_gregset_t *gregsetp)
{
int i;
See gdb/solib-svr4.h for an explanation of these fields. */
-struct link_map_offsets *
+static struct link_map_offsets *
cris_linux_svr4_fetch_link_map_offsets (void)
{
static struct link_map_offsets lmo;
}
}
+extern initialize_file_ftype _initialize_cris_tdep; /* -Wmissing-prototypes */
+
void
_initialize_cris_tdep (void)
{
monitor_open (args, &dbug_cmds, from_tty);
}
+extern initialize_file_ftype _initialize_dbug_rom; /* -Wmissing-prototypes */
+
void
_initialize_dbug_rom (void)
{
}
#ifdef SOFUN_ADDRESS_MAYBE_MISSING
-CORE_ADDR
+static CORE_ADDR
find_stab_function_addr (char *namestring, char *filename,
struct objfile *objfile)
{
monitor_open (args, &dink32_cmds, from_tty);
}
+extern initialize_file_ftype _initialize_dink32_rom; /* -Wmissing-prototypes */
+
void
_initialize_dink32_rom (void)
{
return table->default_base;
}
-extern initialize_file_ftype _initialize_frame_base; /* -Wmissing-protypes */
+extern initialize_file_ftype _initialize_frame_base; /* -Wmissing-prototypes */
void
_initialize_frame_base (void)
return gdbarch;
}
+extern initialize_file_ftype _initialize_h8300_tdep; /* -Wmissing-prototypes */
+
void
_initialize_h8300_tdep (void)
{
/* Return true iff register N's virtual format is different from
its raw format. */
-int
+static int
ia64_register_convertible (int nr)
{
return (IA64_FR0_REGNUM <= nr && nr <= IA64_FR127_REGNUM);
floatformat_intbit_yes
};
-void
+static void
ia64_register_convert_to_virtual (int regnum, struct type *type,
char *from, char *to)
{
error("ia64_register_convert_to_virtual called with non floating point register number");
}
-void
+static void
ia64_register_convert_to_raw (struct type *type, int regnum,
char *from, char *to)
{
return read_register (SP_REGNUM);
}
-CORE_ADDR
+static CORE_ADDR
ia64_read_pc (ptid_t ptid)
{
CORE_ADDR psr_value = read_register_pid (IA64_PSR_REGNUM, ptid);
return pc_value | (slot_num * SLOT_MULTIPLIER);
}
-void
+static void
ia64_write_pc (CORE_ADDR new_pc, ptid_t ptid)
{
int slot_num = (int) (new_pc & 0xf) / SLOT_MULTIPLIER;
represent the frame chain as the end of the previous frame instead
of the beginning. */
-CORE_ADDR
+static CORE_ADDR
ia64_frame_chain (struct frame_info *frame)
{
if ((get_frame_type (frame) == SIGTRAMP_FRAME))
}
}
-CORE_ADDR
+static CORE_ADDR
ia64_frame_saved_pc (struct frame_info *frame)
{
if ((get_frame_type (frame) == SIGTRAMP_FRAME))
return examine_prologue (pc, pc+1024, 0);
}
-void
+static void
ia64_frame_init_saved_regs (struct frame_info *frame)
{
if (get_frame_saved_regs (frame))
}
}
-void
+static void
ia64_get_saved_register (char *raw_buffer,
int *optimized,
CORE_ADDR *addrp,
return struct_return_address;
}
-void
+static void
ia64_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
{
/* FIXME: See above. */
return read_register (IA64_BR0_REGNUM);
}
-CORE_ADDR
+static CORE_ADDR
ia64_frame_args_address (struct frame_info *frame)
{
/* frame->frame points at the SP for this frame; But we want the start
return ia64_frame_chain (frame);
}
-CORE_ADDR
+static CORE_ADDR
ia64_frame_locals_address (struct frame_info *frame)
{
/* frame->frame points at the SP for this frame; But we want the start
return ia64_frame_chain (frame);
}
-void
+static void
ia64_init_extra_frame_info (int fromleaf, struct frame_info *frame)
{
CORE_ADDR bsp, cfm;
return fdesc;
}
-CORE_ADDR
+static CORE_ADDR
ia64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_addr)
{
return sp;
}
-CORE_ADDR
+static CORE_ADDR
ia64_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
{
CORE_ADDR global_pointer = FIND_GLOBAL_POINTER (pc);
return sp;
}
-void
+static void
ia64_store_return_value (struct type *type, char *valbuf)
{
if (TYPE_CODE (type) == TYPE_CODE_FLT)
valbuf, TYPE_LENGTH (type));
}
-void
+static void
ia64_pop_frame (void)
{
generic_pop_current_frame (ia64_pop_frame_regular);
return gdbarch;
}
+extern initialize_file_ftype _initialize_ia64_tdep; /* -Wmissing-prototypes */
+
void
_initialize_ia64_tdep (void)
{
/* Return a location where we can set a breakpoint that will be hit
when an inferior function call returns. */
-CORE_ADDR
+static CORE_ADDR
m68hc11_call_dummy_address (void)
{
return entry_point_address ();
return gdbarch;
}
+extern initialize_file_ftype _initialize_m68hc11_tdep; /* -Wmissing-prototypes */
+
void
_initialize_m68hc11_tdep (void)
{
return;
}
+extern initialize_file_ftype _initialize_m68k_tdep; /* -Wmissing-prototypes */
+
void
_initialize_m68k_tdep (void)
{
\f
/* Initializing the `macrocmd' module. */
-extern initialize_file_ftype _initialize_macrocmd;
+extern initialize_file_ftype _initialize_macrocmd; /* -Wmissing-prototypes */
void
_initialize_macrocmd (void)
#include "gdb_string.h"
#include "disasm.h"
-/* Functions declared and used only in this file */
-
-static CORE_ADDR mcore_analyze_prologue (struct frame_info *fi, CORE_ADDR pc, int skip_prologue);
-
-static struct frame_info *analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame);
-
+static CORE_ADDR mcore_analyze_prologue (struct frame_info *fi, CORE_ADDR pc,
+ int skip_prologue);
static int get_insn (CORE_ADDR pc);
-/* Functions exported from this file */
-
-int mcore_use_struct_convention (int gcc_p, struct type *type);
-
-void _initialize_mcore (void);
-
-void mcore_init_extra_frame_info (int fromleaf, struct frame_info *fi);
-
-CORE_ADDR mcore_frame_saved_pc (struct frame_info *fi);
-
-CORE_ADDR mcore_find_callers_reg (struct frame_info *fi, int regnum);
-
-CORE_ADDR mcore_frame_args_address (struct frame_info *fi);
-
-CORE_ADDR mcore_frame_locals_address (struct frame_info *fi);
-
-CORE_ADDR mcore_push_return_address (CORE_ADDR pc, CORE_ADDR sp);
-
-CORE_ADDR mcore_push_arguments (int nargs, struct value ** args, CORE_ADDR sp,
- int struct_return, CORE_ADDR struct_addr);
-
-void mcore_pop_frame ();
-
-CORE_ADDR mcore_skip_prologue (CORE_ADDR pc);
-
-CORE_ADDR mcore_frame_chain (struct frame_info *fi);
-
-const unsigned char *mcore_breakpoint_from_pc (CORE_ADDR * bp_addr, int *bp_size);
-
-int mcore_use_struct_convention (int gcc_p, struct type *type);
-
-void mcore_store_return_value (struct type *type, char *valbuf);
-
-CORE_ADDR mcore_extract_struct_value_address (char *regbuf);
-
-void mcore_extract_return_value (struct type *type, char *regbuf, char *valbuf);
-
#ifdef MCORE_DEBUG
int mcore_debug = 0;
#endif
/* Return the frame pointer in use at address PC. */
-void
+static void
mcore_virtual_frame_pointer (CORE_ADDR pc, int *reg, LONGEST *offset)
{
struct frame_info *dummy = analyze_dummy_frame (pc, 0);
/* This routine gets called when either the user uses the "return"
command, or the call dummy breakpoint gets hit. */
-void
+static void
mcore_pop_frame (void)
{
int rn;
}
+extern initialize_file_ftype _initialize_mcore_tdep; /* -Wmissing-prototypes */
+
void
_initialize_mcore_tdep (void)
{
_PROC_MAGIC_);
}
+extern initialize_file_ftype _initialize_mips_tdep; /* -Wmissing-prototypes */
+
void
_initialize_mips_tdep (void)
{
-void
+static void
monitor_wait_filter (char *buf,
int bufmax,
int *ext_resp_len,
- struct target_waitstatus *status
-)
+ struct target_waitstatus *status)
{
int resp_len;
do
/* Define additional commands that are usually only used by monitors. */
+extern initialize_file_ftype _initialize_remote_monitors; /* -Wmissing-prototypes */
+
void
_initialize_remote_monitors (void)
{
return (gdbarch);
}
+extern initialize_file_ftype _initialize_ns32k_tdep; /* -Wmissing-prototypes */
+
void
_initialize_ns32k_tdep (void)
{
return GDB_OSABI_UNKNOWN;
}
+extern initialize_file_ftype _initialize_ns32knbsd_tdep; /* -Wmissing-prototypes */
+
void
_initialize_ns32knbsd_tdep (void)
{
return 0;
}
-extern initialize_file_ftype _initialize_objc_language;
+extern initialize_file_ftype _initialize_objc_language; /* -Wmissing-prototypes */
void
_initialize_objc_language (void)
}
\f
+extern initialize_file_ftype _initialize_remote_ocd; /* -Wmissing-prototypes */
+
void
_initialize_remote_ocd (void)
{
bdm_ppc_ops.to_magic = OPS_MAGIC;
} /* init_bdm_ppc_ops */
+extern initialize_file_ftype _initialize_bdm_ppc; /* -Wmissing-prototypes */
+
void
_initialize_bdm_ppc (void)
{
monitor_open (args, &ppcbug_cmds1, from_tty);
}
+extern initialize_file_ftype _initialize_ppcbug_rom; /* -Wmissing-prototypes */
+
void
_initialize_ppcbug_rom (void)
{
return (high << 4) + low;
}
-void
+static void
fetch_regs_from_dump (int (*nextchar) (), char *want)
{
int regno;
/* Suck characters, if a string match, then return the strings index
otherwise echo them. */
-int
+static int
expect_n (char **strings)
{
char *(ptr[10]);
e7000_ops.to_magic = OPS_MAGIC;
};
+extern initialize_file_ftype _initialize_remote_e7000; /* -Wmissing-prototypes */
+
void
_initialize_remote_e7000 (void)
{
monitor_open (args, &est_cmds, from_tty);
}
+extern initialize_file_ftype _initialize_est; /* -Wmissing-prototypes */
+
void
_initialize_est (void)
{
int write_dos_tick_delay;
+extern initialize_file_ftype _initialize_remote_hms; /* -Wmissing-prototypes */
+
void
_initialize_remote_hms (void)
{
timed out. TIMEOUT specifies timeout value in seconds.
*/
-int
+static int
mips_expect_timeout (const char *string, int timeout)
{
const char *p = string;
mips_expect_timeout if a different timeout value is needed.
*/
-int
+static int
mips_expect (const char *string)
{
return mips_expect_timeout (string, remote_timeout);
/* Read the required number of characters into the given buffer (which
is assumed to be large enough). The only failure is a timeout. */
-int
+static int
mips_getstring (char *string, int n)
{
char *p = string;
/* Return the signal corresponding to SIG, where SIG is the number which
the MIPS protocol uses for the signal. */
-enum target_signal
+static enum target_signal
mips_signal_from_protocol (int sig)
{
/* We allow a few more signals than the IDT board actually returns, on
/* Insert a hardware breakpoint. This works only on LSI targets, which
implement ordinary breakpoints using hardware facilities. */
-int
+static int
remote_mips_insert_hw_breakpoint (CORE_ADDR addr, char *contents_cache)
{
if (strcmp (target_shortname, "lsi") == 0)
/* Remove a hardware breakpoint. This works only on LSI targets, which
implement ordinary breakpoints using hardware facilities. */
-int
+static int
remote_mips_remove_hw_breakpoint (CORE_ADDR addr, char *contents_cache)
{
if (strcmp (target_shortname, "lsi") == 0)
printf_filtered ("Received packet: %s\n", buf);
}
\f
+extern initialize_file_ftype _initialize_remote_mips; /* -Wmissing-prototypes */
+
void
_initialize_remote_mips (void)
{
/* Helper callbacks for the "host interface" structure. RDI functions call
these to forward output from the target system and so forth. */
-void
+static void
voiddummy (void *dummy)
{
fprintf_unfiltered (gdb_stdout, "void dummy\n");
" try y or n\n", args);
}
+extern initialize_file_ftype _initialize_remote_rdi; /* -Wmissing-prototypes */
+
void
_initialize_remote_rdi (void)
{
}
-void
+static void
send_rdp (char *template,...)
{
char buf[200];
remote_rdp_ops.to_magic = OPS_MAGIC;
}
+extern initialize_file_ftype _initialize_remote_rdp; /* -Wmissing-prototypes */
+
void
_initialize_remote_rdp (void)
{
monitor_open (args, &rom68k_cmds, from_tty);
}
+extern initialize_file_ftype _initialize_rom68k; /* -Wmissing-prototypes */
+
void
_initialize_rom68k (void)
{
/* Initialization code. */
-extern initialize_file_ftype _initialize_rs6000_tdep; /* -Wmissing-protypes */
+extern initialize_file_ftype _initialize_rs6000_tdep; /* -Wmissing-prototypes */
void
_initialize_rs6000_tdep (void)
/* Number of bytes of storage in the actual machine representation
for register N. */
-int
+static int
s390_register_raw_size (int reg_nr)
{
if (S390_FP0_REGNUM <= reg_nr
return 4;
}
-int
+static int
s390x_register_raw_size (int reg_nr)
{
return (reg_nr == S390_FPC_REGNUM)
|| (reg_nr >= S390_FIRST_ACR && reg_nr <= S390_LAST_ACR) ? 4 : 8;
}
-int
+static int
s390_cannot_fetch_register (int regno)
{
return (regno >= S390_FIRST_CR && regno < (S390_FIRST_CR + 9)) ||
(regno >= (S390_FIRST_CR + 12) && regno <= S390_LAST_CR);
}
-int
+static int
s390_register_byte (int reg_nr)
{
if (reg_nr <= S390_GP_LAST_REGNUM)
static CORE_ADDR s390_frame_saved_pc_nofix (struct frame_info *fi);
-int
+static int
s390_readinstruction (bfd_byte instr[], CORE_ADDR at,
struct disassemble_info *info)
{
-const char *
+static const char *
s390_register_name (int reg_nr)
{
static char *register_names[] = {
-int
+static int
s390_stab_reg_to_regnum (int regno)
{
return regno >= 64 ? S390_PSWM_REGNUM - 64 :
*/
-int
+static int
s390_get_frame_info (CORE_ADDR pc, struct frame_extra_info *fextra_info,
struct frame_info *fi, int init_extra_info)
{
}
-int
+static int
s390_check_function_end (CORE_ADDR pc)
{
bfd_byte instr[S390_MAX_INSTR_SIZE];
-CORE_ADDR
+static CORE_ADDR
s390_function_start (struct frame_info *fi)
{
CORE_ADDR function_start = 0;
-int
+static int
s390_frameless_function_invocation (struct frame_info *fi)
{
struct frame_extra_info fextra_info, *fextra_info_ptr;
for the moment.
For some reason the blockframe.c calls us with fi->next->fromleaf
so this seems of little use to us. */
-CORE_ADDR
+static CORE_ADDR
s390_init_frame_pc_first (int next_fromleaf, struct frame_info *fi)
{
CORE_ADDR sigcaller_pc;
return pc;
}
-void
+static void
s390_init_extra_frame_info (int fromleaf, struct frame_info *fi)
{
frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
&FEXTRA_INFOP contains struct frame_extra_info; TDATAP can be NULL,
in which case the framedata are read. */
-void
+static void
s390_frame_init_saved_regs (struct frame_info *fi)
{
return 0;
}
-CORE_ADDR
+static CORE_ADDR
s390_frame_saved_pc (struct frame_info *fi)
{
CORE_ADDR saved_pc = 0, sig_pc;
/* We want backtraces out of signal handlers so we don't set
(get_frame_type (thisframe) == SIGTRAMP_FRAME) to 1 */
-CORE_ADDR
+static CORE_ADDR
s390_frame_chain (struct frame_info *thisframe)
{
CORE_ADDR prev_fp = 0;
/* a given return value in `regbuf' with a type `valtype', extract and copy its
value into `valbuf' */
-void
+static void
s390_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
{
/* floats and doubles are returned in fpr0. fpr's have a size of 8 bytes.
return (value);
}
-void
+static void
s390_store_return_value (struct type *valtype, char *valbuf)
{
int arglen;
/* Not the most efficent code in the world */
-int
+static int
s390_fp_regnum (void)
{
int regno = S390_SP_REGNUM;
return regno;
}
-CORE_ADDR
+static CORE_ADDR
s390_read_fp (void)
{
return read_register (s390_fp_regnum ());
machine state that was in effect before the frame was created.
Used in the contexts of the "return" command, and of
target function calls from the debugger. */
-void
+static void
s390_pop_frame (void)
{
/* This function checks for and handles generic dummy frames, and
Our caller has taken care of any type promotions needed to satisfy
prototypes or the old K&R argument-passing rules. */
-CORE_ADDR
+static CORE_ADDR
s390_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_addr)
{
/* Return the GDB type object for the "standard" data type
of data in register N. */
-struct type *
+static struct type *
s390_register_virtual_type (int regno)
{
if (S390_FP0_REGNUM <= regno && regno < S390_FP0_REGNUM + S390_NUM_FPRS)
}
-struct type *
+static struct type *
s390x_register_virtual_type (int regno)
{
return (regno == S390_FPC_REGNUM) ||
-void
+static void
s390_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
{
write_register (S390_GP0_REGNUM + 2, addr);
-const static unsigned char *
+static const unsigned char *
s390_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
{
static unsigned char breakpoint[] = { 0x0, 0x1 };
/* Advance PC across any function entry prologue instructions to reach some
"real" code. */
-CORE_ADDR
+static CORE_ADDR
s390_skip_prologue (CORE_ADDR pc)
{
struct frame_extra_info fextra_info;
Can't go through the frames for this because on some machines
the new frame is not set up until the new function executes
some instructions. */
-CORE_ADDR
+static CORE_ADDR
s390_saved_pc_after_call (struct frame_info *frame)
{
return ADDR_BITS_REMOVE (read_register (S390_RETADDR_REGNUM));
return NULL;
}
-int
+static int
s390_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name,
int *type_flags_ptr)
{
return 0;
}
-struct gdbarch *
+static struct gdbarch *
s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
static LONGEST s390_call_dummy_words[] = { 0 };
+extern initialize_file_ftype _initialize_s390_tdep; /* -Wmissing-prototypes */
+
void
_initialize_s390_tdep (void)
{
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-#if defined __GO32__ || defined _WIN32
#include "defs.h"
+#if defined __GO32__ || defined _WIN32
#include "serial.h"
#include "gdb_string.h"
#endif /*_WIN32 or __GO32__*/
+extern initialize_file_ftype _initialize_ser_e7000pc; /* -Wmissing-prototypes */
+
void
_initialize_ser_e7000pc (void)
{
#define MSYMBOL_IS_SPECIAL(msym) \
(((long) MSYMBOL_INFO (msym) & 0x80000000) != 0)
-void
+static void
sh64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
{
if (msym == NULL)
&& rn <= tdep->FV_LAST_REGNUM);
}
-int
+static int
sh64_get_gdb_regnum (int gcc_regnum, CORE_ADDR pc)
{
return translate_insn_rn (gcc_regnum, pc_is_isa32 (pc));
}
}
-void
+static void
sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
struct frame_info *frame, int regnum,
enum lval_type *lval)
sh64_show_compact_regs ();
}
-void sh_show_regs_command (char *args, int from_tty)
+static void
+sh_show_regs_command (char *args, int from_tty)
{
if (sh_show_regs)
(*sh_show_regs)();
error ("sh_register_convert_to_virtual called with non DR register number");
}
-void
+static void
sh_sh64_register_convert_to_virtual (int regnum, struct type *type,
char *from, char *to)
{
error("sh_register_convert_to_raw called with non DR register number");
}
-void
+static void
sh_sh64_register_convert_to_raw (struct type *type, int regnum,
const void *from, void *to)
{
error("sh_register_convert_to_raw called with non DR register number");
}
-void
+static void
sh_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
int reg_nr, void *buffer)
{
}
}
-void
+static void
sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
int reg_nr, const void *buffer)
{
}
}
-void
+static void
sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
int reg_nr, const void *buffer)
{
do_pseudo_register (regnum);
}
-void
+static void
sh_do_registers_info (int regnum, int fpregs)
{
if (regnum != -1) /* do one specified register */
}
}
-void
+static void
sh_compact_do_registers_info (int regnum, int fpregs)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
}
}
-void
+static void
sh64_do_registers_info (int regnum, int fpregs)
{
if (pc_is_isa32 (get_frame_pc (deprecated_selected_frame)))
/* FIXME: dump the rest of gdbarch_tdep. */
}
+extern initialize_file_ftype _initialize_sh_tdep; /* -Wmissing-prototypes */
+
void
_initialize_sh_tdep (void)
{
}
}
+extern initialize_file_ftype _initialize_sh3_rom; /* -Wmissing-prototypes */
+
void
_initialize_sh3_rom (void)
{
#endif /* HAVE_LINK_H */
+extern initialize_file_ftype _initialize_svr4_lm; /* -Wmissing-prototypes */
+
void
_initialize_svr4_lm (void)
{
static struct target_so_ops svr4_so_ops;
+extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */
+
void
_initialize_svr4_solib (void)
{
the section table. But we only use this for core files and
processes we've just attached to, so that's okay. */
-void
+static void
update_solib_list (int from_tty, struct target_ops *target)
{
struct so_list *inferior = TARGET_SO_CURRENT_SOS ();
solib_add (NULL, from_tty, NULL, auto_solib_add);
}
+extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */
+
void
_initialize_solib (void)
{
#endif
\f
-int
+static int
gdb_print_insn_sparc (bfd_vma memaddr, disassemble_info *info)
{
/* It's necessary to override mach again because print_insn messes it up. */
/* FIXME: kettenis/2003/05/24: Still used for sparc64. */
-void
+static void
sparc_store_return_value (struct type *type, char *valbuf)
{
int regno;
struct gdbarch_list *arches);
static void sparc_dump_tdep (struct gdbarch *, struct ui_file *);
+extern initialize_file_ftype _initialize_sparc_tdep; /* -Wmissing-prototypes */
+
void
_initialize_sparc_tdep (void)
{
/* Compensate for stack bias. Note that we currently don't handle
mixed 32/64 bit code. */
-CORE_ADDR
+static CORE_ADDR
sparc64_read_sp (void)
{
CORE_ADDR sp = read_register (SP_REGNUM);
return sp;
}
-CORE_ADDR
+static CORE_ADDR
sparc64_read_fp (void)
{
CORE_ADDR fp = read_register (DEPRECATED_FP_REGNUM);
return fp;
}
-void
+static void
sparc64_write_sp (CORE_ADDR val)
{
CORE_ADDR oldsp = read_register (SP_REGNUM);
for both; this means that if the arguments alternate between
int and float, we will waste every other register of both types. */
-CORE_ADDR
+static CORE_ADDR
sparc64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_retaddr)
{
/* Values <= 32 bytes are returned in o0-o3 (floating-point values are
returned in f0-f3). */
-void
+static void
sp64_extract_return_value (struct type *type, char *regbuf, char *valbuf,
int bitoffset)
{
}
}
-extern void
+static void
sparc64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
{
sp64_extract_return_value (type, regbuf, valbuf, 0);
return ((addr + 7) & -8);
}
-extern CORE_ADDR
+static CORE_ADDR
sparc64_stack_align (CORE_ADDR addr)
{
return ((addr + 15) & -16);
// OBSOLETE }
#endif
-CORE_ADDR
+static CORE_ADDR
sparc_push_return_address (CORE_ADDR pc_unused, CORE_ADDR sp)
{
if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
/* Supply the Y register number to those that need it. */
-int
+static int
sparc_y_regnum (void)
{
return gdbarch_tdep (current_gdbarch)->y_regnum;
return (gcc_p != 1);
}
-int
+static int
sparc_intreg_size (void)
{
return SPARC_INTREG_SIZE;
}
/* Get the ith function argument for the current function. */
-CORE_ADDR
-sparc_fetch_pointer_argument (struct frame_info *frame, int argi, struct type *type)
+static CORE_ADDR
+sparc_fetch_pointer_argument (struct frame_info *frame, int argi,
+ struct type *type)
{
CORE_ADDR addr;
frame_read_register (frame, O0_REGNUM + argi, &addr);
when trying to get the value of caller-saves registers for an inner
frame. */
-CORE_ADDR
+static CORE_ADDR
v850_find_callers_reg (struct frame_info *fi, int regnum)
{
for (; fi; fi = get_next_frame (fi))
just return the stack pointer that was in use at the time the
function call was made. */
-CORE_ADDR
+static CORE_ADDR
v850_frame_chain (struct frame_info *fi)
{
struct prologue_info pi;
/* Function: skip_prologue
Return the address of the first code past the prologue of the function. */
-CORE_ADDR
+static CORE_ADDR
v850_skip_prologue (CORE_ADDR pc)
{
CORE_ADDR func_addr, func_end;
This routine gets called when either the user uses the `return'
command, or the call dummy breakpoint gets hit. */
-void
+static void
v850_pop_frame (void)
{
struct frame_info *frame = get_current_frame ();
Stack space for the args has NOT been allocated: that job is up to us.
*/
-CORE_ADDR
+static CORE_ADDR
v850_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_addr)
{
Set up the return address for the inferior function call.
Needed for targets where we don't actually execute a JSR/BSR instruction */
-CORE_ADDR
+static CORE_ADDR
v850_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
{
write_register (E_RP_REGNUM, CALL_DUMMY_ADDRESS ());
instead of RP, because that's where "caller" of the dummy-frame
will be found. */
-CORE_ADDR
+static CORE_ADDR
v850_frame_saved_pc (struct frame_info *fi)
{
if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
trap
*/
-void
+static void
v850_fix_call_dummy (char *dummy, CORE_ADDR sp, CORE_ADDR fun, int nargs,
struct value **args, struct type *type, int gcc_p)
{
return gdbarch;
}
+extern initialize_file_ftype _initialize_v850_tdep; /* -Wmissing-prototypes */
+
void
_initialize_v850_tdep (void)
{
return (gdbarch);
}
+extern initialize_file_ftype _initialize_vax_tdep; /* -Wmissing-prototypes */
+
void
_initialize_vax_tdep (void)
{
(which may or may not be the same as before).
*/
-CORE_ADDR
+static CORE_ADDR
xstormy16_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
{
unsigned char buf[xstormy16_pc_size];
return addr;
}
-void
+static void
xstormy16_save_dummy_frame_tos (CORE_ADDR sp)
{
generic_save_dummy_frame_tos (sp - xstormy16_pc_size);
Initializer function for the Sanyo Xstormy16a module.
Called by gdb at start-up. */
+extern initialize_file_ftype _initialize_xstormy16_tdep; /* -Wmissing-prototypes */
+
void
_initialize_xstormy16_tdep (void)
{
projects / thirdparty / binutils-gdb.git / commitdiff
