OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* Makefile.in (vax-tdep.o): Add $(arch_utils_h), $(inferior_h), 

and vax-tdep.h.
* vax-tdep.h: New file.
* vax-tdep.c: Include inferior.h, arch-utils.h, and vax-tdep.h.
Make several routines static.
(vax_get_saved_register): New function.
(vax_gdbarch_init): New function.
(_initialize_vax_tdep): Register vax_gdbarch_init.
* config/vax/tm-vax.h: Set GDB_MULTI_ARCH to GDB_MULTI_ARCH_PARTIAL.
Remove macros now under the control of gdbarch.
This commit is contained in:
Jason Thorpe 2002-04-23 00:53:31 +00:00
parent 2a290ed49a
commit f267bd6a08
5 changed files with 264 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
gdb/ChangeLog
View File

@ -1,3 +1,16 @@
2002-04-22 Jason Thorpe <thorpej@wasabisystems.com>
* Makefile.in (vax-tdep.o): Add $(arch_utils_h), $(inferior_h),
and vax-tdep.h.
* vax-tdep.h: New file.
* vax-tdep.c: Include inferior.h, arch-utils.h, and vax-tdep.h.
Make several routines static.
(vax_get_saved_register): New function.
(vax_gdbarch_init): New function.
(_initialize_vax_tdep): Register vax_gdbarch_init.
* config/vax/tm-vax.h: Set GDB_MULTI_ARCH to GDB_MULTI_ARCH_PARTIAL.
Remove macros now under the control of gdbarch.
2002-04-22 Michael Snyder <msnyder@redhat.com>
* arm-tdep.c: Some whitespace and coding standards tweaks.

3
gdb/Makefile.in
View File

@ -2156,7 +2156,8 @@ values.o: values.c $(defs_h) $(expression_h) $(frame_h) $(gdbcmd_h) \
$(gdbcore_h) $(gdbtypes_h) $(symtab_h) $(target_h) $(value_h) \
$(gdb_string_h) scm-lang.h $(doublest_h)
vax-tdep.o: vax-tdep.c $(OP_INCLUDE)/vax.h $(defs_h) $(symtab_h)
vax-tdep.o: vax-tdep.c $(OP_INCLUDE)/vax.h $(defs_h) $(symtab_h) \
$(arch_utils_h) $(inferior_h) vax-tdep.h
x86-64-linux-tdep.o : x86-64-linux-tdep.c $(defs_h) $(inferior_h) \
$(gdbcore_h) $(regcache_h) x86-64-tdep.h i386-tdep.h $(dwarf2cfi_h)

150
gdb/config/vax/tm-vax.h
View File

@ -19,16 +19,7 @@
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* Offset from address of function to start of its code.
Zero on most machines. */
#define FUNCTION_START_OFFSET 2
extern CORE_ADDR vax_skip_prologue (CORE_ADDR);
#define SKIP_PROLOGUE(pc) (vax_skip_prologue (pc))
#define SAVED_PC_AFTER_CALL(frame) vax_saved_pc_after_call ((frame))
extern CORE_ADDR vax_saved_pc_after_call (struct frame_info *);
#define GDB_MULTI_ARCH GDB_MULTI_ARCH_PARTIAL
#define TARGET_UPAGES 14
#define TARGET_NBPG 512
@ -40,151 +31,18 @@ extern CORE_ADDR vax_saved_pc_after_call (struct frame_info *);
#define SIGTRAMP_START(pc) STACK_END_ADDR
#define SIGTRAMP_END(pc) 0x80000000
/* Stack grows downward. */
#define INNER_THAN(lhs,rhs) core_addr_lessthan ((lhs), (rhs))
/* Sequence of bytes for breakpoint instruction. */
#define BREAKPOINT {3}
/* Amount PC must be decremented by after a breakpoint.
This is often the number of bytes in BREAKPOINT
but not always. */
#define DECR_PC_AFTER_BREAK 0
/* Say how long (ordinary) registers are. This is a piece of bogosity
used in push_word and a few other places; REGISTER_RAW_SIZE is the
real way to know how big a register is. */
#define REGISTER_SIZE 4
/* Number of machine registers */
#define NUM_REGS 17
/* Return the name of the register specified by N. */
#define REGISTER_NAME(N) vax_register_name ((N))
extern char *vax_register_name (int);
/* Register numbers of various important registers.
Note that some of these values are "real" register numbers,
and correspond to the general registers of the machine,
and some are "phony" register numbers which are too large
to be actual register numbers as far as the user is concerned
but do serve to get the desired values when passed to read_register. */
#define AP_REGNUM 12
#define FP_REGNUM 13 /* Contains address of executing stack frame */
#define SP_REGNUM 14 /* Contains address of top of stack */
#define PC_REGNUM 15 /* Contains program counter */
#define PS_REGNUM 16 /* Contains processor status */
/* Total amount of space needed to store our copies of the machine's
register state, the array `registers'. */
#define REGISTER_BYTES (17*4)
/* Index within `registers' of the first byte of the space for
register N. */
#define REGISTER_BYTE(N) vax_register_byte ((N))
extern int vax_register_byte (int);
/* Number of bytes of storage in the actual machine representation
for register N. On the vax, all regs are 4 bytes. */
#define REGISTER_RAW_SIZE(N) vax_register_raw_size ((N))
extern int vax_register_raw_size (int);
/* Number of bytes of storage in the program's representation
for register N. On the vax, all regs are 4 bytes. */
#define REGISTER_VIRTUAL_SIZE(N) vax_register_virtual_size ((N))
extern int vax_register_virtual_size (int);
/* Largest value REGISTER_RAW_SIZE can have. */
#define MAX_REGISTER_RAW_SIZE 4
/* Largest value REGISTER_VIRTUAL_SIZE can have. */
#define MAX_REGISTER_VIRTUAL_SIZE 4
/* Return the GDB type object for the "standard" data type
of data in register N. */
#define REGISTER_VIRTUAL_TYPE(N) vax_register_virtual_type ((N))
extern struct type *vax_register_virtual_type (int);
#define STORE_STRUCT_RETURN(ADDR, SP) vax_store_struct_return ((ADDR), (SP))
extern void vax_store_struct_return (CORE_ADDR, CORE_ADDR);
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
vax_extract_return_value ((TYPE), (REGBUF), (VALBUF))
extern void vax_extract_return_value (struct type *, char *, char *);
#define STORE_RETURN_VALUE(TYPE,VALBUF) \
vax_store_return_value ((TYPE), (VALBUF))
extern void vax_store_return_value (struct type *, char *);
#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
vax_extract_struct_value_address ((REGBUF))
extern CORE_ADDR vax_extract_struct_value_address (char *);
#define FRAME_CHAIN(FI) vax_frame_chain ((FI))
extern CORE_ADDR vax_frame_chain (struct frame_info *);
#define FRAMELESS_FUNCTION_INVOCATION(FI) \
generic_frameless_function_invocation_not ((FI))
#define AP_REGNUM 12 /* XXXJRT */
/* Offset to saved PC in sigcontext, from <sys/signal.h>. */
/* XXXJRT should go away */
#define SIGCONTEXT_PC_OFFSET 12
#define FRAME_SAVED_PC(FRAME) vax_frame_saved_pc ((FRAME))
extern CORE_ADDR vax_frame_saved_pc (struct frame_info *);
/* XXXJRT not yet under gdbarch control */
#define FRAME_ARGS_ADDRESS_CORRECT(fi) vax_frame_args_address ((fi))
extern CORE_ADDR vax_frame_args_address (struct frame_info *);
#define FRAME_ARGS_ADDRESS(fi) vax_frame_args_address ((fi))
extern CORE_ADDR vax_frame_args_address (struct frame_info *);
#define FRAME_LOCALS_ADDRESS(fi) vax_frame_locals_address ((fi))
extern CORE_ADDR vax_frame_locals_address (struct frame_info *);
extern int vax_frame_num_args (struct frame_info *fi);
#define FRAME_NUM_ARGS(fi) (vax_frame_num_args ((fi)))
/* Return number of bytes at start of arglist that are not really args. */
#define FRAME_ARGS_SKIP 4
#define FRAME_INIT_SAVED_REGS(fi) vax_frame_init_saved_regs ((fi))
extern void vax_frame_init_saved_regs (struct frame_info *);
#define PUSH_DUMMY_FRAME vax_push_dummy_frame()
extern void vax_push_dummy_frame (void);
#define POP_FRAME vax_pop_frame()
extern void vax_pop_frame (void);
#define CALL_DUMMY_WORDS vax_call_dummy_words
extern LONGEST vax_call_dummy_words[];
#define SIZEOF_CALL_DUMMY_WORDS sizeof_vax_call_dummy_words
extern int sizeof_vax_call_dummy_words;
struct value;
#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
vax_fix_call_dummy ((dummyname), (pc), (fun), (nargs), (args), (type), \
(gcc_p))
extern void vax_fix_call_dummy (char *, CORE_ADDR, CORE_ADDR, int,
struct value **, struct type *, int);
#define CALL_DUMMY_START_OFFSET 0 /* Start execution at beginning of dummy */
#define CALL_DUMMY_BREAKPOINT_OFFSET 7
#define FRAME_ARGS_ADDRESS_CORRECT(fi) vax_frame_args_address_correct ((fi))
extern CORE_ADDR vax_frame_args_address_correct (struct frame_info *);
/* If vax pcc says CHAR or SHORT, it provides the correct address. */
#define BELIEVE_PCC_PROMOTION 1

213
gdb/vax-tdep.c
View File

@ -23,9 +23,39 @@
#include "symtab.h"
#include "opcode/vax.h"
#include "gdbcore.h"
#include "inferior.h"
#include "regcache.h"
#include "frame.h"
#include "value.h"
#include "arch-utils.h"
#include "vax-tdep.h"
static gdbarch_register_name_ftype vax_register_name;
static gdbarch_register_byte_ftype vax_register_byte;
static gdbarch_register_raw_size_ftype vax_register_raw_size;
static gdbarch_register_virtual_size_ftype vax_register_virtual_size;
static gdbarch_register_virtual_type_ftype vax_register_virtual_type;
static gdbarch_skip_prologue_ftype vax_skip_prologue;
static gdbarch_saved_pc_after_call_ftype vax_saved_pc_after_call;
static gdbarch_frame_num_args_ftype vax_frame_num_args;
static gdbarch_frame_chain_ftype vax_frame_chain;
static gdbarch_frame_saved_pc_ftype vax_frame_saved_pc;
static gdbarch_frame_args_address_ftype vax_frame_args_address;
static gdbarch_frame_locals_address_ftype vax_frame_locals_address;
static gdbarch_frame_init_saved_regs_ftype vax_frame_init_saved_regs;
static gdbarch_get_saved_register_ftype vax_get_saved_register;
static gdbarch_store_struct_return_ftype vax_store_struct_return;
static gdbarch_extract_return_value_ftype vax_extract_return_value;
static gdbarch_store_return_value_ftype vax_store_return_value;
static gdbarch_extract_struct_value_address_ftype
vax_extract_struct_value_address;
static gdbarch_push_dummy_frame_ftype vax_push_dummy_frame;
static gdbarch_pop_frame_ftype vax_pop_frame;
static gdbarch_fix_call_dummy_ftype vax_fix_call_dummy;
/* Return 1 if P points to an invalid floating point value.
LEN is the length in bytes -- not relevant on the Vax. */
@ -53,7 +83,7 @@
static unsigned char *print_insn_arg ();
char *
static char *
vax_register_name (int regno)
{
static char *register_names[] =
@ -70,31 +100,76 @@ vax_register_name (int regno)
return (register_names[regno]);
}
int
static int
vax_register_byte (int regno)
{
return (regno * 4);
}
int
static int
vax_register_raw_size (int regno)
{
return (4);
}
int
static int
vax_register_virtual_size (int regno)
{
return (4);
}
struct type *
static struct type *
vax_register_virtual_type (int regno)
{
return (builtin_type_int);
}
void
static void
vax_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
struct frame_info *frame, int regnum,
enum lval_type *lval)
{
CORE_ADDR addr;
if (!target_has_registers)
error ("No registers.");
/* Normal systems don't optimize out things with register numbers. */
if (optimized != NULL)
*optimized = 0;
addr = find_saved_register (frame, regnum);
if (addr != 0)
{
if (lval != NULL)
*lval = lval_memory;
if (regnum == SP_REGNUM)
{
if (raw_buffer != NULL)
{
/* Put it back in target format. */
store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
(LONGEST) addr);
}
if (addrp != NULL)
*addrp = 0;
return;
}
if (raw_buffer != NULL)
target_read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
}
else
{
if (lval != NULL)
*lval = lval_register;
addr = REGISTER_BYTE (regnum);
if (raw_buffer != NULL)
read_register_gen (regnum, raw_buffer);
}
if (addrp != NULL)
*addrp = addr;
}
static void
vax_frame_init_saved_regs (struct frame_info *frame)
{
int regnum, regmask;
@ -128,7 +203,7 @@ vax_frame_init_saved_regs (struct frame_info *frame)
frame->saved_regs[PS_REGNUM] = frame->frame + 4;
}
CORE_ADDR
static CORE_ADDR
vax_frame_saved_pc (struct frame_info *frame)
{
if (frame->signal_handler_caller)
@ -155,7 +230,7 @@ vax_frame_args_address_correct (struct frame_info *frame)
return (0);
}
CORE_ADDR
static CORE_ADDR
vax_frame_args_address (struct frame_info *frame)
{
/* In most of GDB, getting the args address is too important to
@ -167,19 +242,19 @@ vax_frame_args_address (struct frame_info *frame)
return (read_register (AP_REGNUM));
}
CORE_ADDR
static CORE_ADDR
vax_frame_locals_address (struct frame_info *frame)
{
return (frame->frame);
}
int
static int
vax_frame_num_args (struct frame_info *fi)
{
return (0xff & read_memory_integer (FRAME_ARGS_ADDRESS (fi), 1));
}
CORE_ADDR
static CORE_ADDR
vax_frame_chain (struct frame_info *frame)
{
/* In the case of the VAX, the frame's nominal address is the FP value,
@ -190,7 +265,7 @@ vax_frame_chain (struct frame_info *frame)
return (read_memory_integer (frame->frame + 12, 4));
}
void
static void
vax_push_dummy_frame (void)
{
CORE_ADDR sp = read_register (SP_REGNUM);
@ -209,7 +284,7 @@ vax_push_dummy_frame (void)
write_register (AP_REGNUM, sp + (17 * 4));
}
void
static void
vax_pop_frame (void)
{
CORE_ADDR fp = read_register (FP_REGNUM);
@ -243,10 +318,10 @@ vax_pop_frame (void)
It is 8 bytes long. The address and argc are patched by
vax_fix_call_dummy(). */
LONGEST vax_call_dummy_words[] = { 0x329f69fb, 0x03323232 };
int sizeof_vax_call_dummy_words = sizeof(vax_call_dummy_words);
static LONGEST vax_call_dummy_words[] = { 0x329f69fb, 0x03323232 };
static int sizeof_vax_call_dummy_words = sizeof(vax_call_dummy_words);
void
static void
vax_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
struct value **args, struct type *type, int gcc_p)
{
@ -254,25 +329,25 @@ vax_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
store_unsigned_integer (dummy + 3, 4, fun);
}
void
static void
vax_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
{
write_register (1, addr);
}
void
static void
vax_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
{
memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (valtype));
}
void
static void
vax_store_return_value (struct type *valtype, char *valbuf)
{
write_register_bytes (0, valbuf, TYPE_LENGTH (valtype));
}
CORE_ADDR
static CORE_ADDR
vax_extract_struct_value_address (char *regbuf)
{
return (extract_address (regbuf + REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
@ -281,7 +356,7 @@ vax_extract_struct_value_address (char *regbuf)
/* Advance PC across any function entry prologue instructions
to reach some "real" code. */
CORE_ADDR
static CORE_ADDR
vax_skip_prologue (CORE_ADDR pc)
{
register int op = (unsigned char) read_memory_integer (pc, 1);
@ -307,7 +382,7 @@ vax_skip_prologue (CORE_ADDR pc)
return pc;
}
CORE_ADDR
static CORE_ADDR
vax_saved_pc_after_call (struct frame_info *frame)
{
return (FRAME_SAVED_PC(frame));
@ -363,7 +438,7 @@ vax_print_insn (CORE_ADDR memaddr, disassemble_info *info)
}
return p - buffer;
}
static unsigned char *
print_insn_arg (char *d, register char *p, CORE_ADDR addr,
disassemble_info *info)
@ -534,9 +609,101 @@ print_insn_arg (char *d, register char *p, CORE_ADDR addr,
return (unsigned char *) p;
}
/* Initialize the current architecture based on INFO. If possible, re-use an
architecture from ARCHES, which is a list of architectures already created
during this debugging session.
Called e.g. at program startup, when reading a core file, and when reading
a binary file. */
static struct gdbarch *
vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
struct gdbarch *gdbarch;
/* Right now there is only one VAX architecture variant. */
if (arches != NULL)
return (arches->gdbarch);
gdbarch = gdbarch_alloc (&info, NULL);
/* Register info */
set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
set_gdbarch_fp_regnum (gdbarch, VAX_FP_REGNUM);
set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
set_gdbarch_register_name (gdbarch, vax_register_name);
set_gdbarch_register_size (gdbarch, VAX_REGISTER_SIZE);
set_gdbarch_register_bytes (gdbarch, VAX_REGISTER_BYTES);
set_gdbarch_register_byte (gdbarch, vax_register_byte);
set_gdbarch_register_raw_size (gdbarch, vax_register_raw_size);
set_gdbarch_max_register_raw_size (gdbarch, VAX_MAX_REGISTER_RAW_SIZE);
set_gdbarch_register_virtual_size (gdbarch, vax_register_virtual_size);
set_gdbarch_max_register_virtual_size (gdbarch,
VAX_MAX_REGISTER_VIRTUAL_SIZE);
set_gdbarch_register_virtual_type (gdbarch, vax_register_virtual_type);
/* Frame and stack info */
set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
set_gdbarch_saved_pc_after_call (gdbarch, vax_saved_pc_after_call);
set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
set_gdbarch_frameless_function_invocation (gdbarch,
generic_frameless_function_invocation_not);
set_gdbarch_frame_chain (gdbarch, vax_frame_chain);
set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
set_gdbarch_frame_saved_pc (gdbarch, vax_frame_saved_pc);
set_gdbarch_frame_args_address (gdbarch, vax_frame_args_address);
set_gdbarch_frame_locals_address (gdbarch, vax_frame_locals_address);
set_gdbarch_frame_init_saved_regs (gdbarch, vax_frame_init_saved_regs);
set_gdbarch_frame_args_skip (gdbarch, 4);
set_gdbarch_get_saved_register (gdbarch, vax_get_saved_register);
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
/* Return value info */
set_gdbarch_store_struct_return (gdbarch, vax_store_struct_return);
set_gdbarch_extract_return_value (gdbarch, vax_extract_return_value);
set_gdbarch_store_return_value (gdbarch, vax_store_return_value);
set_gdbarch_extract_struct_value_address (gdbarch,
vax_extract_struct_value_address);
/* Call dummy info */
set_gdbarch_push_dummy_frame (gdbarch, vax_push_dummy_frame);
set_gdbarch_pop_frame (gdbarch, vax_pop_frame);
set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
set_gdbarch_call_dummy_p (gdbarch, 1);
set_gdbarch_call_dummy_words (gdbarch, vax_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof_vax_call_dummy_words);
set_gdbarch_fix_call_dummy (gdbarch, vax_fix_call_dummy);
set_gdbarch_call_dummy_start_offset (gdbarch, 0);
set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 7);
set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_on_stack);
set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
/* Breakpoint info */
set_gdbarch_decr_pc_after_break (gdbarch, 0);
/* Misc info */
set_gdbarch_function_start_offset (gdbarch, 2);
return (gdbarch);
}
void
_initialize_vax_tdep (void)
{
gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
tm_print_insn = vax_print_insn;
}

55
gdb/vax-tdep.h Normal file
View File

@ -0,0 +1,55 @@
/* Common target dependent code for GDB on VAX systems.
Copyright 2002 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#ifndef VAX_TDEP_H
#define VAX_TDEP_H
/* Say how long (ordinary) registers are. This is a piece of bogosity
used in push_word and a few other places; REGISTER_RAW_SIZE is the
real way to know how big a register is. */
#define VAX_REGISTER_SIZE 4
/* Number of machine registers. */
#define VAX_NUM_REGS 17
/* Total amount of space needed to store our copies of the machine's
register state. */
#define VAX_REGISTER_BYTES (VAX_NUM_REGS * 4)
/* Largest value REGISTER_RAW_SIZE can have. */
#define VAX_MAX_REGISTER_RAW_SIZE 4
/* Largest value REGISTER_VIRTUAL_SIZE can have. */
#define VAX_MAX_REGISTER_VIRTUAL_SIZE 4
/* Register numbers of various important registers.
Note that most of these values are "real" register numbers,
and correspond to the general registers of the machine,
and are "phony" register numbers which is too large
to be an actual register number as far as the user is concerned
but serves to get the desired value when passed to read_register. */
#define VAX_AP_REGNUM 12 /* argument pointer */
#define VAX_FP_REGNUM 13 /* Contains address of executing stack frame */
#define VAX_SP_REGNUM 14 /* Contains address of top of stack */
#define VAX_PC_REGNUM 15 /* Contains program counter */
#define VAX_PS_REGNUM 16 /* Contains processor status */
#endif /* VAX_TDEP_H */