diff options
| author | Andrew Cagney <cagney@redhat.com> | 2002-08-06 14:12:47 +0000 |
|---|---|---|
| committer | Andrew Cagney <cagney@redhat.com> | 2002-08-06 14:12:47 +0000 |
| commit | eb4c54a2884d1fc89fc500ab0a1a2877d8bc8bf7 (patch) | |
| tree | 554ba78477d79267f1ec7aa65997da77fd42b97c | |
| parent | 7fc44b9cd621f388b62375fa9f2f882c679a6eac (diff) | |
| download | gdb-eb4c54a2884d1fc89fc500ab0a1a2877d8bc8bf7.zip gdb-eb4c54a2884d1fc89fc500ab0a1a2877d8bc8bf7.tar.gz gdb-eb4c54a2884d1fc89fc500ab0a1a2877d8bc8bf7.tar.bz2 | |
2002-08-06 Andrew Cagney <cagney@redhat.com>
* configure.tgt: Make arc-*-* obsolete.
* NEWS: Mention that arc-*-* has been identifed as obsolete.
* MAINTAINERS: Make arc-elf obsolete.
* arc-tdep.c: Make file obsolete.
* config/arc/arc.mt: Ditto.
* config/arc/tm-arc.h: Ditto.
| -rw-r--r-- | gdb/ChangeLog | 9 | ||||
| -rw-r--r-- | gdb/MAINTAINERS | 4 | ||||
| -rw-r--r-- | gdb/NEWS | 1 | ||||
| -rw-r--r-- | gdb/arc-tdep.c | 1476 | ||||
| -rw-r--r-- | gdb/config/arc/arc.mt | 6 | ||||
| -rw-r--r-- | gdb/config/arc/tm-arc.h | 672 | ||||
| -rw-r--r-- | gdb/configure.tgt | 2 |
7 files changed, 1089 insertions, 1081 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 80b4df3..0df93d6 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,12 @@ +2002-08-06 Andrew Cagney <cagney@redhat.com> + + * configure.tgt: Make arc-*-* obsolete. + * NEWS: Mention that arc-*-* has been identifed as obsolete. + * MAINTAINERS: Make arc-elf obsolete. + * arc-tdep.c: Make file obsolete. + * config/arc/arc.mt: Ditto. + * config/arc/tm-arc.h: Ditto. + 2002-08-05 Theodore A. Roth <troth@verinet.com> * gdb/avr-tdep.c(avr_skip_prologue): Fix to return the correct pc. diff --git a/gdb/MAINTAINERS b/gdb/MAINTAINERS index 78e1cf8..9965d1b 100644 --- a/gdb/MAINTAINERS +++ b/gdb/MAINTAINERS @@ -59,9 +59,7 @@ maintainer works with the native maintainer when resolving API issues. alpha --target=alpha-dec-osf4.0a -Werror Maintenance only - arc --target=arc-elf ,-Werror - Maintenance only - OBSOLETE candidate, not multi-arch + arc (--target=arc-elf OBSOLETE) arm --target=arm-elf , Fernando Nasser fnasser@redhat.com @@ -59,6 +59,7 @@ Mitsubishi D30V d30v-*-* OS/9000 i[34]86-*-os9k Fujitsu FR30 fr30-*-elf* Motorola Delta 88000 running Sys V m88k-motorola-sysv or delta88 +Argonaut Risc Chip (ARC) arc-*-* * OBSOLETE languages diff --git a/gdb/arc-tdep.c b/gdb/arc-tdep.c index 0614ebe..5c44915 100644 --- a/gdb/arc-tdep.c +++ b/gdb/arc-tdep.c @@ -1,738 +1,738 @@ -/* ARC target-dependent stuff. - Copyright 1995, 1996, 1999, 2000, 2001 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. */ - -#include "defs.h" -#include "frame.h" -#include "inferior.h" -#include "gdbcore.h" -#include "target.h" -#include "floatformat.h" -#include "symtab.h" -#include "gdbcmd.h" -#include "regcache.h" -#include "gdb_string.h" - -/* Local functions */ - -static int arc_set_cpu_type (char *str); - -/* Current CPU, set with the "set cpu" command. */ -static int arc_bfd_mach_type; -char *arc_cpu_type; -char *tmp_arc_cpu_type; - -/* Table of cpu names. */ -struct - { - char *name; - int value; - } -arc_cpu_type_table[] = -{ - { "arc5", bfd_mach_arc_5 }, - { "arc6", bfd_mach_arc_6 }, - { "arc7", bfd_mach_arc_7 }, - { "arc8", bfd_mach_arc_8 }, - { NULL, 0 } -}; - -/* Used by simulator. */ -int display_pipeline_p; -int cpu_timer; -/* This one must have the same type as used in the emulator. - It's currently an enum so this should be ok for now. */ -int debug_pipeline_p; - -#define ARC_CALL_SAVED_REG(r) ((r) >= 16 && (r) < 24) - -#define OPMASK 0xf8000000 - -/* Instruction field accessor macros. - See the Programmer's Reference Manual. */ -#define X_OP(i) (((i) >> 27) & 0x1f) -#define X_A(i) (((i) >> 21) & 0x3f) -#define X_B(i) (((i) >> 15) & 0x3f) -#define X_C(i) (((i) >> 9) & 0x3f) -#define X_D(i) ((((i) & 0x1ff) ^ 0x100) - 0x100) -#define X_L(i) (((((i) >> 5) & 0x3ffffc) ^ 0x200000) - 0x200000) -#define X_N(i) (((i) >> 5) & 3) -#define X_Q(i) ((i) & 0x1f) - -/* Return non-zero if X is a short immediate data indicator. */ -#define SHIMM_P(x) ((x) == 61 || (x) == 63) - -/* Return non-zero if X is a "long" (32 bit) immediate data indicator. */ -#define LIMM_P(x) ((x) == 62) - -/* Build a simple instruction. */ -#define BUILD_INSN(op, a, b, c, d) \ - ((((op) & 31) << 27) \ - | (((a) & 63) << 21) \ - | (((b) & 63) << 15) \ - | (((c) & 63) << 9) \ - | ((d) & 511)) - -/* Codestream stuff. */ -static void codestream_read (unsigned int *, int); -static void codestream_seek (CORE_ADDR); -static unsigned int codestream_fill (int); - -#define CODESTREAM_BUFSIZ 16 -static CORE_ADDR codestream_next_addr; -static CORE_ADDR codestream_addr; -/* FIXME assumes sizeof (int) == 32? */ -static unsigned int codestream_buf[CODESTREAM_BUFSIZ]; -static int codestream_off; -static int codestream_cnt; - -#define codestream_tell() \ - (codestream_addr + codestream_off * sizeof (codestream_buf[0])) -#define codestream_peek() \ - (codestream_cnt == 0 \ - ? codestream_fill (1) \ - : codestream_buf[codestream_off]) -#define codestream_get() \ - (codestream_cnt-- == 0 \ - ? codestream_fill (0) \ - : codestream_buf[codestream_off++]) - -static unsigned int -codestream_fill (int peek_flag) -{ - codestream_addr = codestream_next_addr; - codestream_next_addr += CODESTREAM_BUFSIZ * sizeof (codestream_buf[0]); - codestream_off = 0; - codestream_cnt = CODESTREAM_BUFSIZ; - read_memory (codestream_addr, (char *) codestream_buf, - CODESTREAM_BUFSIZ * sizeof (codestream_buf[0])); - /* FIXME: check return code? */ - - - /* Handle byte order differences -> convert to host byte ordering. */ - { - int i; - for (i = 0; i < CODESTREAM_BUFSIZ; i++) - codestream_buf[i] = - extract_unsigned_integer (&codestream_buf[i], - sizeof (codestream_buf[i])); - } - - if (peek_flag) - return codestream_peek (); - else - return codestream_get (); -} - -static void -codestream_seek (CORE_ADDR place) -{ - codestream_next_addr = place / CODESTREAM_BUFSIZ; - codestream_next_addr *= CODESTREAM_BUFSIZ; - codestream_cnt = 0; - codestream_fill (1); - while (codestream_tell () != place) - codestream_get (); -} - -/* This function is currently unused but leave in for now. */ - -static void -codestream_read (unsigned int *buf, int count) -{ - unsigned int *p; - int i; - p = buf; - for (i = 0; i < count; i++) - *p++ = codestream_get (); -} - -/* Set up prologue scanning and return the first insn. */ - -static unsigned int -setup_prologue_scan (CORE_ADDR pc) -{ - unsigned int insn; - - codestream_seek (pc); - insn = codestream_get (); - - return insn; -} - -/* - * Find & return amount a local space allocated, and advance codestream to - * first register push (if any). - * If entry sequence doesn't make sense, return -1, and leave - * codestream pointer random. - */ - -static long -arc_get_frame_setup (CORE_ADDR pc) -{ - unsigned int insn; - /* Size of frame or -1 if unrecognizable prologue. */ - int frame_size = -1; - /* An initial "sub sp,sp,N" may or may not be for a stdarg fn. */ - int maybe_stdarg_decr = -1; - - insn = setup_prologue_scan (pc); - - /* The authority for what appears here is the home-grown ABI. - The most recent version is 1.2. */ - - /* First insn may be "sub sp,sp,N" if stdarg fn. */ - if ((insn & BUILD_INSN (-1, -1, -1, -1, 0)) - == BUILD_INSN (10, SP_REGNUM, SP_REGNUM, SHIMM_REGNUM, 0)) - { - maybe_stdarg_decr = X_D (insn); - insn = codestream_get (); - } - - if ((insn & BUILD_INSN (-1, 0, -1, -1, -1)) /* st blink,[sp,4] */ - == BUILD_INSN (2, 0, SP_REGNUM, BLINK_REGNUM, 4)) - { - insn = codestream_get (); - /* Frame may not be necessary, even though blink is saved. - At least this is something we recognize. */ - frame_size = 0; - } - - if ((insn & BUILD_INSN (-1, 0, -1, -1, -1)) /* st fp,[sp] */ - == BUILD_INSN (2, 0, SP_REGNUM, FP_REGNUM, 0)) - { - insn = codestream_get (); - if ((insn & BUILD_INSN (-1, -1, -1, -1, 0)) - != BUILD_INSN (12, FP_REGNUM, SP_REGNUM, SP_REGNUM, 0)) - return -1; - - /* Check for stack adjustment sub sp,sp,N. */ - insn = codestream_peek (); - if ((insn & BUILD_INSN (-1, -1, -1, 0, 0)) - == BUILD_INSN (10, SP_REGNUM, SP_REGNUM, 0, 0)) - { - if (LIMM_P (X_C (insn))) - frame_size = codestream_get (); - else if (SHIMM_P (X_C (insn))) - frame_size = X_D (insn); - else - return -1; - if (frame_size < 0) - return -1; - - codestream_get (); - - /* This sequence is used to get the address of the return - buffer for a function that returns a structure. */ - insn = codestream_peek (); - if ((insn & OPMASK) == 0x60000000) - codestream_get (); - } - /* Frameless fn. */ - else - { - frame_size = 0; - } - } - - /* If we found a "sub sp,sp,N" and nothing else, it may or may not be a - stdarg fn. The stdarg decrement is not treated as part of the frame size, - so we have a dilemma: what do we return? For now, if we get a - "sub sp,sp,N" and nothing else assume this isn't a stdarg fn. One way - to fix this completely would be to add a bit to the function descriptor - that says the function is a stdarg function. */ - - if (frame_size < 0 && maybe_stdarg_decr > 0) - return maybe_stdarg_decr; - return frame_size; -} - -/* Given a pc value, skip it forward past the function prologue by - disassembling instructions that appear to be a prologue. - - If FRAMELESS_P is set, we are only testing to see if the function - is frameless. If it is a frameless function, return PC unchanged. - This allows a quicker answer. */ - -CORE_ADDR -arc_skip_prologue (CORE_ADDR pc, int frameless_p) -{ - unsigned int insn; - int i, frame_size; - - if ((frame_size = arc_get_frame_setup (pc)) < 0) - return (pc); - - if (frameless_p) - return frame_size == 0 ? pc : codestream_tell (); - - /* Skip over register saves. */ - for (i = 0; i < 8; i++) - { - insn = codestream_peek (); - if ((insn & BUILD_INSN (-1, 0, -1, 0, 0)) - != BUILD_INSN (2, 0, SP_REGNUM, 0, 0)) - break; /* not st insn */ - if (!ARC_CALL_SAVED_REG (X_C (insn))) - break; - codestream_get (); - } - - return codestream_tell (); -} - -/* Is the prologue at PC frameless? */ - -int -arc_prologue_frameless_p (CORE_ADDR pc) -{ - return (pc == arc_skip_prologue (pc, 1)); -} - -/* Return the return address for a frame. - This is used to implement FRAME_SAVED_PC. - This is taken from frameless_look_for_prologue. */ - -CORE_ADDR -arc_frame_saved_pc (struct frame_info *frame) -{ - CORE_ADDR func_start; - unsigned int insn; - - func_start = get_pc_function_start (frame->pc) + FUNCTION_START_OFFSET; - if (func_start == 0) - { - /* Best guess. */ - return ARC_PC_TO_REAL_ADDRESS (read_memory_integer (FRAME_FP (frame) + 4, 4)); - } - - /* The authority for what appears here is the home-grown ABI. - The most recent version is 1.2. */ - - insn = setup_prologue_scan (func_start); - - /* First insn may be "sub sp,sp,N" if stdarg fn. */ - if ((insn & BUILD_INSN (-1, -1, -1, -1, 0)) - == BUILD_INSN (10, SP_REGNUM, SP_REGNUM, SHIMM_REGNUM, 0)) - insn = codestream_get (); - - /* If the next insn is "st blink,[sp,4]" we can get blink from there. - Otherwise this is a leaf function and we can use blink. Note that - this still allows for the case where a leaf function saves/clobbers/ - restores blink. */ - - if ((insn & BUILD_INSN (-1, 0, -1, -1, -1)) /* st blink,[sp,4] */ - != BUILD_INSN (2, 0, SP_REGNUM, BLINK_REGNUM, 4)) - return ARC_PC_TO_REAL_ADDRESS (read_register (BLINK_REGNUM)); - else - return ARC_PC_TO_REAL_ADDRESS (read_memory_integer (FRAME_FP (frame) + 4, 4)); -} - -/* - * Parse the first few instructions of the function to see - * what registers were stored. - * - * The startup sequence can be at the start of the function. - * 'st blink,[sp+4], st fp,[sp], mov fp,sp' - * - * Local space is allocated just below by sub sp,sp,nnn. - * Next, the registers used by this function are stored (as offsets from sp). - */ - -void -frame_find_saved_regs (struct frame_info *fip, struct frame_saved_regs *fsrp) -{ - long locals; - unsigned int insn; - CORE_ADDR dummy_bottom; - CORE_ADDR adr; - int i, regnum, offset; - - memset (fsrp, 0, sizeof *fsrp); - - /* If frame is the end of a dummy, compute where the beginning would be. */ - dummy_bottom = fip->frame - 4 - REGISTER_BYTES - CALL_DUMMY_LENGTH; - - /* Check if the PC is in the stack, in a dummy frame. */ - if (dummy_bottom <= fip->pc && fip->pc <= fip->frame) - { - /* all regs were saved by push_call_dummy () */ - adr = fip->frame; - for (i = 0; i < NUM_REGS; i++) - { - adr -= REGISTER_RAW_SIZE (i); - fsrp->regs[i] = adr; - } - return; - } - - locals = arc_get_frame_setup (get_pc_function_start (fip->pc)); - - if (locals >= 0) - { - /* Set `adr' to the value of `sp'. */ - adr = fip->frame - locals; - for (i = 0; i < 8; i++) - { - insn = codestream_get (); - if ((insn & BUILD_INSN (-1, 0, -1, 0, 0)) - != BUILD_INSN (2, 0, SP_REGNUM, 0, 0)) - break; - regnum = X_C (insn); - offset = X_D (insn); - fsrp->regs[regnum] = adr + offset; - } - } - - fsrp->regs[PC_REGNUM] = fip->frame + 4; - fsrp->regs[FP_REGNUM] = fip->frame; -} - -void -arc_push_dummy_frame (void) -{ - CORE_ADDR sp = read_register (SP_REGNUM); - int regnum; - char regbuf[MAX_REGISTER_RAW_SIZE]; - - read_register_gen (PC_REGNUM, regbuf); - write_memory (sp + 4, regbuf, REGISTER_SIZE); - read_register_gen (FP_REGNUM, regbuf); - write_memory (sp, regbuf, REGISTER_SIZE); - write_register (FP_REGNUM, sp); - for (regnum = 0; regnum < NUM_REGS; regnum++) - { - read_register_gen (regnum, regbuf); - sp = push_bytes (sp, regbuf, REGISTER_RAW_SIZE (regnum)); - } - sp += (2 * REGISTER_SIZE); - write_register (SP_REGNUM, sp); -} - -void -arc_pop_frame (void) -{ - struct frame_info *frame = get_current_frame (); - CORE_ADDR fp; - int regnum; - struct frame_saved_regs fsr; - char regbuf[MAX_REGISTER_RAW_SIZE]; - - fp = FRAME_FP (frame); - get_frame_saved_regs (frame, &fsr); - for (regnum = 0; regnum < NUM_REGS; regnum++) - { - CORE_ADDR adr; - adr = fsr.regs[regnum]; - if (adr) - { - read_memory (adr, regbuf, REGISTER_RAW_SIZE (regnum)); - write_register_bytes (REGISTER_BYTE (regnum), regbuf, - REGISTER_RAW_SIZE (regnum)); - } - } - write_register (FP_REGNUM, read_memory_integer (fp, 4)); - write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); - write_register (SP_REGNUM, fp + 8); - flush_cached_frames (); -} - -/* Simulate single-step. */ - -typedef enum -{ - NORMAL4, /* a normal 4 byte insn */ - NORMAL8, /* a normal 8 byte insn */ - BRANCH4, /* a 4 byte branch insn, including ones without delay slots */ - BRANCH8, /* an 8 byte branch insn, including ones with delay slots */ -} -insn_type; - -/* Return the type of INSN and store in TARGET the destination address of a - branch if this is one. */ -/* ??? Need to verify all cases are properly handled. */ - -static insn_type -get_insn_type (unsigned long insn, CORE_ADDR pc, CORE_ADDR *target) -{ - unsigned long limm; - - switch (insn >> 27) - { - case 0: - case 1: - case 2: /* load/store insns */ - if (LIMM_P (X_A (insn)) - || LIMM_P (X_B (insn)) - || LIMM_P (X_C (insn))) - return NORMAL8; - return NORMAL4; - case 4: - case 5: - case 6: /* branch insns */ - *target = pc + 4 + X_L (insn); - /* ??? It isn't clear that this is always the right answer. - The problem occurs when the next insn is an 8 byte insn. If the - branch is conditional there's no worry as there shouldn't be an 8 - byte insn following. The programmer may be cheating if s/he knows - the branch will never be taken, but we don't deal with that. - Note that the programmer is also allowed to play games by putting - an insn with long immediate data in the delay slot and then duplicate - the long immediate data at the branch target. Ugh! */ - if (X_N (insn) == 0) - return BRANCH4; - return BRANCH8; - case 7: /* jump insns */ - if (LIMM_P (X_B (insn))) - { - limm = read_memory_integer (pc + 4, 4); - *target = ARC_PC_TO_REAL_ADDRESS (limm); - return BRANCH8; - } - if (SHIMM_P (X_B (insn))) - *target = ARC_PC_TO_REAL_ADDRESS (X_D (insn)); - else - *target = ARC_PC_TO_REAL_ADDRESS (read_register (X_B (insn))); - if (X_Q (insn) == 0 && X_N (insn) == 0) - return BRANCH4; - return BRANCH8; - default: /* arithmetic insns, etc. */ - if (LIMM_P (X_A (insn)) - || LIMM_P (X_B (insn)) - || LIMM_P (X_C (insn))) - return NORMAL8; - return NORMAL4; - } -} - -/* single_step() is called just before we want to resume the inferior, if we - want to single-step it but there is no hardware or kernel single-step - support. We find all the possible targets of the coming instruction and - breakpoint them. - - single_step is also called just after the inferior stops. If we had - set up a simulated single-step, we undo our damage. */ - -void -arc_software_single_step (enum target_signal ignore, /* sig but we don't need it */ - int insert_breakpoints_p) -{ - static CORE_ADDR next_pc, target; - static int brktrg_p; - typedef char binsn_quantum[BREAKPOINT_MAX]; - static binsn_quantum break_mem[2]; - - if (insert_breakpoints_p) - { - insn_type type; - CORE_ADDR pc; - unsigned long insn; - - pc = read_register (PC_REGNUM); - insn = read_memory_integer (pc, 4); - type = get_insn_type (insn, pc, &target); - - /* Always set a breakpoint for the insn after the branch. */ - next_pc = pc + ((type == NORMAL8 || type == BRANCH8) ? 8 : 4); - target_insert_breakpoint (next_pc, break_mem[0]); - - brktrg_p = 0; - - if ((type == BRANCH4 || type == BRANCH8) - /* Watch out for branches to the following location. - We just stored a breakpoint there and another call to - target_insert_breakpoint will think the real insn is the - breakpoint we just stored there. */ - && target != next_pc) - { - brktrg_p = 1; - target_insert_breakpoint (target, break_mem[1]); - } - - } - else - { - /* Remove breakpoints. */ - target_remove_breakpoint (next_pc, break_mem[0]); - - if (brktrg_p) - target_remove_breakpoint (target, break_mem[1]); - - /* Fix the pc. */ - stop_pc -= DECR_PC_AFTER_BREAK; - write_pc (stop_pc); - } -} - -/* Because of Multi-arch, GET_LONGJMP_TARGET is always defined. So test - for a definition of JB_PC. */ -#ifdef JB_PC -/* Figure out where the longjmp will land. Slurp the args out of the stack. - We expect the first arg to be a pointer to the jmp_buf structure from which - we extract the pc (JB_PC) that we will land at. The pc is copied into PC. - This routine returns true on success. */ - -int -get_longjmp_target (CORE_ADDR *pc) -{ - char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT]; - CORE_ADDR sp, jb_addr; - - sp = read_register (SP_REGNUM); - - if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */ - buf, - TARGET_PTR_BIT / TARGET_CHAR_BIT)) - return 0; - - jb_addr = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT); - - if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf, - TARGET_PTR_BIT / TARGET_CHAR_BIT)) - return 0; - - *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT); - - return 1; -} -#endif /* GET_LONGJMP_TARGET */ - -/* Disassemble one instruction. */ - -static int -arc_print_insn (bfd_vma vma, disassemble_info *info) -{ - static int current_mach; - static int current_endian; - static disassembler_ftype current_disasm; - - if (current_disasm == NULL - || arc_bfd_mach_type != current_mach - || TARGET_BYTE_ORDER != current_endian) - { - current_mach = arc_bfd_mach_type; - current_endian = TARGET_BYTE_ORDER; - current_disasm = arc_get_disassembler (NULL); - } - - return (*current_disasm) (vma, info); -} - -/* Command to set cpu type. */ - -void -arc_set_cpu_type_command (char *args, int from_tty) -{ - int i; - - if (tmp_arc_cpu_type == NULL || *tmp_arc_cpu_type == '\0') - { - printf_unfiltered ("The known ARC cpu types are as follows:\n"); - for (i = 0; arc_cpu_type_table[i].name != NULL; ++i) - printf_unfiltered ("%s\n", arc_cpu_type_table[i].name); - - /* Restore the value. */ - tmp_arc_cpu_type = xstrdup (arc_cpu_type); - - return; - } - - if (!arc_set_cpu_type (tmp_arc_cpu_type)) - { - error ("Unknown cpu type `%s'.", tmp_arc_cpu_type); - /* Restore its value. */ - tmp_arc_cpu_type = xstrdup (arc_cpu_type); - } -} - -static void -arc_show_cpu_type_command (char *args, int from_tty) -{ -} - -/* Modify the actual cpu type. - Result is a boolean indicating success. */ - -static int -arc_set_cpu_type (char *str) -{ - int i, j; - - if (str == NULL) - return 0; - - for (i = 0; arc_cpu_type_table[i].name != NULL; ++i) - { - if (strcasecmp (str, arc_cpu_type_table[i].name) == 0) - { - arc_cpu_type = str; - arc_bfd_mach_type = arc_cpu_type_table[i].value; - return 1; - } - } - - return 0; -} - -void -_initialize_arc_tdep (void) -{ - struct cmd_list_element *c; - - c = add_set_cmd ("cpu", class_support, var_string_noescape, - (char *) &tmp_arc_cpu_type, - "Set the type of ARC cpu in use.\n\ -This command has two purposes. In a multi-cpu system it lets one\n\ -change the cpu being debugged. It also gives one access to\n\ -cpu-type-specific registers and recognize cpu-type-specific instructions.\ -", - &setlist); - set_cmd_cfunc (c, arc_set_cpu_type_command); - c = add_show_from_set (c, &showlist); - set_cmd_cfunc (c, arc_show_cpu_type_command); - - /* We have to use xstrdup() here because the `set' command frees it - before setting a new value. */ - tmp_arc_cpu_type = xstrdup (DEFAULT_ARC_CPU_TYPE); - arc_set_cpu_type (tmp_arc_cpu_type); - - c = add_set_cmd ("displaypipeline", class_support, var_zinteger, - (char *) &display_pipeline_p, - "Set pipeline display (simulator only).\n\ -When enabled, the state of the pipeline after each cycle is displayed.", - &setlist); - c = add_show_from_set (c, &showlist); - - c = add_set_cmd ("debugpipeline", class_support, var_zinteger, - (char *) &debug_pipeline_p, - "Set pipeline debug display (simulator only).\n\ -When enabled, debugging information about the pipeline is displayed.", - &setlist); - c = add_show_from_set (c, &showlist); - - c = add_set_cmd ("cputimer", class_support, var_zinteger, - (char *) &cpu_timer, - "Set maximum cycle count (simulator only).\n\ -Control will return to gdb if the timer expires.\n\ -A negative value disables the timer.", - &setlist); - c = add_show_from_set (c, &showlist); - - tm_print_insn = arc_print_insn; -} +// OBSOLETE /* ARC target-dependent stuff. +// OBSOLETE Copyright 1995, 1996, 1999, 2000, 2001 Free Software Foundation, Inc. +// OBSOLETE +// OBSOLETE This file is part of GDB. +// OBSOLETE +// OBSOLETE This program is free software; you can redistribute it and/or modify +// OBSOLETE it under the terms of the GNU General Public License as published by +// OBSOLETE the Free Software Foundation; either version 2 of the License, or +// OBSOLETE (at your option) any later version. +// OBSOLETE +// OBSOLETE This program is distributed in the hope that it will be useful, +// OBSOLETE but WITHOUT ANY WARRANTY; without even the implied warranty of +// OBSOLETE MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// OBSOLETE GNU General Public License for more details. +// OBSOLETE +// OBSOLETE You should have received a copy of the GNU General Public License +// OBSOLETE along with this program; if not, write to the Free Software +// OBSOLETE Foundation, Inc., 59 Temple Place - Suite 330, +// OBSOLETE Boston, MA 02111-1307, USA. */ +// OBSOLETE +// OBSOLETE #include "defs.h" +// OBSOLETE #include "frame.h" +// OBSOLETE #include "inferior.h" +// OBSOLETE #include "gdbcore.h" +// OBSOLETE #include "target.h" +// OBSOLETE #include "floatformat.h" +// OBSOLETE #include "symtab.h" +// OBSOLETE #include "gdbcmd.h" +// OBSOLETE #include "regcache.h" +// OBSOLETE #include "gdb_string.h" +// OBSOLETE +// OBSOLETE /* Local functions */ +// OBSOLETE +// OBSOLETE static int arc_set_cpu_type (char *str); +// OBSOLETE +// OBSOLETE /* Current CPU, set with the "set cpu" command. */ +// OBSOLETE static int arc_bfd_mach_type; +// OBSOLETE char *arc_cpu_type; +// OBSOLETE char *tmp_arc_cpu_type; +// OBSOLETE +// OBSOLETE /* Table of cpu names. */ +// OBSOLETE struct +// OBSOLETE { +// OBSOLETE char *name; +// OBSOLETE int value; +// OBSOLETE } +// OBSOLETE arc_cpu_type_table[] = +// OBSOLETE { +// OBSOLETE { "arc5", bfd_mach_arc_5 }, +// OBSOLETE { "arc6", bfd_mach_arc_6 }, +// OBSOLETE { "arc7", bfd_mach_arc_7 }, +// OBSOLETE { "arc8", bfd_mach_arc_8 }, +// OBSOLETE { NULL, 0 } +// OBSOLETE }; +// OBSOLETE +// OBSOLETE /* Used by simulator. */ +// OBSOLETE int display_pipeline_p; +// OBSOLETE int cpu_timer; +// OBSOLETE /* This one must have the same type as used in the emulator. +// OBSOLETE It's currently an enum so this should be ok for now. */ +// OBSOLETE int debug_pipeline_p; +// OBSOLETE +// OBSOLETE #define ARC_CALL_SAVED_REG(r) ((r) >= 16 && (r) < 24) +// OBSOLETE +// OBSOLETE #define OPMASK 0xf8000000 +// OBSOLETE +// OBSOLETE /* Instruction field accessor macros. +// OBSOLETE See the Programmer's Reference Manual. */ +// OBSOLETE #define X_OP(i) (((i) >> 27) & 0x1f) +// OBSOLETE #define X_A(i) (((i) >> 21) & 0x3f) +// OBSOLETE #define X_B(i) (((i) >> 15) & 0x3f) +// OBSOLETE #define X_C(i) (((i) >> 9) & 0x3f) +// OBSOLETE #define X_D(i) ((((i) & 0x1ff) ^ 0x100) - 0x100) +// OBSOLETE #define X_L(i) (((((i) >> 5) & 0x3ffffc) ^ 0x200000) - 0x200000) +// OBSOLETE #define X_N(i) (((i) >> 5) & 3) +// OBSOLETE #define X_Q(i) ((i) & 0x1f) +// OBSOLETE +// OBSOLETE /* Return non-zero if X is a short immediate data indicator. */ +// OBSOLETE #define SHIMM_P(x) ((x) == 61 || (x) == 63) +// OBSOLETE +// OBSOLETE /* Return non-zero if X is a "long" (32 bit) immediate data indicator. */ +// OBSOLETE #define LIMM_P(x) ((x) == 62) +// OBSOLETE +// OBSOLETE /* Build a simple instruction. */ +// OBSOLETE #define BUILD_INSN(op, a, b, c, d) \ +// OBSOLETE ((((op) & 31) << 27) \ +// OBSOLETE | (((a) & 63) << 21) \ +// OBSOLETE | (((b) & 63) << 15) \ +// OBSOLETE | (((c) & 63) << 9) \ +// OBSOLETE | ((d) & 511)) +// OBSOLETE +// OBSOLETE /* Codestream stuff. */ +// OBSOLETE static void codestream_read (unsigned int *, int); +// OBSOLETE static void codestream_seek (CORE_ADDR); +// OBSOLETE static unsigned int codestream_fill (int); +// OBSOLETE +// OBSOLETE #define CODESTREAM_BUFSIZ 16 +// OBSOLETE static CORE_ADDR codestream_next_addr; +// OBSOLETE static CORE_ADDR codestream_addr; +// OBSOLETE /* FIXME assumes sizeof (int) == 32? */ +// OBSOLETE static unsigned int codestream_buf[CODESTREAM_BUFSIZ]; +// OBSOLETE static int codestream_off; +// OBSOLETE static int codestream_cnt; +// OBSOLETE +// OBSOLETE #define codestream_tell() \ +// OBSOLETE (codestream_addr + codestream_off * sizeof (codestream_buf[0])) +// OBSOLETE #define codestream_peek() \ +// OBSOLETE (codestream_cnt == 0 \ +// OBSOLETE ? codestream_fill (1) \ +// OBSOLETE : codestream_buf[codestream_off]) +// OBSOLETE #define codestream_get() \ +// OBSOLETE (codestream_cnt-- == 0 \ +// OBSOLETE ? codestream_fill (0) \ +// OBSOLETE : codestream_buf[codestream_off++]) +// OBSOLETE +// OBSOLETE static unsigned int +// OBSOLETE codestream_fill (int peek_flag) +// OBSOLETE { +// OBSOLETE codestream_addr = codestream_next_addr; +// OBSOLETE codestream_next_addr += CODESTREAM_BUFSIZ * sizeof (codestream_buf[0]); +// OBSOLETE codestream_off = 0; +// OBSOLETE codestream_cnt = CODESTREAM_BUFSIZ; +// OBSOLETE read_memory (codestream_addr, (char *) codestream_buf, +// OBSOLETE CODESTREAM_BUFSIZ * sizeof (codestream_buf[0])); +// OBSOLETE /* FIXME: check return code? */ +// OBSOLETE +// OBSOLETE +// OBSOLETE /* Handle byte order differences -> convert to host byte ordering. */ +// OBSOLETE { +// OBSOLETE int i; +// OBSOLETE for (i = 0; i < CODESTREAM_BUFSIZ; i++) +// OBSOLETE codestream_buf[i] = +// OBSOLETE extract_unsigned_integer (&codestream_buf[i], +// OBSOLETE sizeof (codestream_buf[i])); +// OBSOLETE } +// OBSOLETE +// OBSOLETE if (peek_flag) +// OBSOLETE return codestream_peek (); +// OBSOLETE else +// OBSOLETE return codestream_get (); +// OBSOLETE } +// OBSOLETE +// OBSOLETE static void +// OBSOLETE codestream_seek (CORE_ADDR place) +// OBSOLETE { +// OBSOLETE codestream_next_addr = place / CODESTREAM_BUFSIZ; +// OBSOLETE codestream_next_addr *= CODESTREAM_BUFSIZ; +// OBSOLETE codestream_cnt = 0; +// OBSOLETE codestream_fill (1); +// OBSOLETE while (codestream_tell () != place) +// OBSOLETE codestream_get (); +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* This function is currently unused but leave in for now. */ +// OBSOLETE +// OBSOLETE static void +// OBSOLETE codestream_read (unsigned int *buf, int count) +// OBSOLETE { +// OBSOLETE unsigned int *p; +// OBSOLETE int i; +// OBSOLETE p = buf; +// OBSOLETE for (i = 0; i < count; i++) +// OBSOLETE *p++ = codestream_get (); +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* Set up prologue scanning and return the first insn. */ +// OBSOLETE +// OBSOLETE static unsigned int +// OBSOLETE setup_prologue_scan (CORE_ADDR pc) +// OBSOLETE { +// OBSOLETE unsigned int insn; +// OBSOLETE +// OBSOLETE codestream_seek (pc); +// OBSOLETE insn = codestream_get (); +// OBSOLETE +// OBSOLETE return insn; +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* +// OBSOLETE * Find & return amount a local space allocated, and advance codestream to +// OBSOLETE * first register push (if any). +// OBSOLETE * If entry sequence doesn't make sense, return -1, and leave +// OBSOLETE * codestream pointer random. +// OBSOLETE */ +// OBSOLETE +// OBSOLETE static long +// OBSOLETE arc_get_frame_setup (CORE_ADDR pc) +// OBSOLETE { +// OBSOLETE unsigned int insn; +// OBSOLETE /* Size of frame or -1 if unrecognizable prologue. */ +// OBSOLETE int frame_size = -1; +// OBSOLETE /* An initial "sub sp,sp,N" may or may not be for a stdarg fn. */ +// OBSOLETE int maybe_stdarg_decr = -1; +// OBSOLETE +// OBSOLETE insn = setup_prologue_scan (pc); +// OBSOLETE +// OBSOLETE /* The authority for what appears here is the home-grown ABI. +// OBSOLETE The most recent version is 1.2. */ +// OBSOLETE +// OBSOLETE /* First insn may be "sub sp,sp,N" if stdarg fn. */ +// OBSOLETE if ((insn & BUILD_INSN (-1, -1, -1, -1, 0)) +// OBSOLETE == BUILD_INSN (10, SP_REGNUM, SP_REGNUM, SHIMM_REGNUM, 0)) +// OBSOLETE { +// OBSOLETE maybe_stdarg_decr = X_D (insn); +// OBSOLETE insn = codestream_get (); +// OBSOLETE } +// OBSOLETE +// OBSOLETE if ((insn & BUILD_INSN (-1, 0, -1, -1, -1)) /* st blink,[sp,4] */ +// OBSOLETE == BUILD_INSN (2, 0, SP_REGNUM, BLINK_REGNUM, 4)) +// OBSOLETE { +// OBSOLETE insn = codestream_get (); +// OBSOLETE /* Frame may not be necessary, even though blink is saved. +// OBSOLETE At least this is something we recognize. */ +// OBSOLETE frame_size = 0; +// OBSOLETE } +// OBSOLETE +// OBSOLETE if ((insn & BUILD_INSN (-1, 0, -1, -1, -1)) /* st fp,[sp] */ +// OBSOLETE == BUILD_INSN (2, 0, SP_REGNUM, FP_REGNUM, 0)) +// OBSOLETE { +// OBSOLETE insn = codestream_get (); +// OBSOLETE if ((insn & BUILD_INSN (-1, -1, -1, -1, 0)) +// OBSOLETE != BUILD_INSN (12, FP_REGNUM, SP_REGNUM, SP_REGNUM, 0)) +// OBSOLETE return -1; +// OBSOLETE +// OBSOLETE /* Check for stack adjustment sub sp,sp,N. */ +// OBSOLETE insn = codestream_peek (); +// OBSOLETE if ((insn & BUILD_INSN (-1, -1, -1, 0, 0)) +// OBSOLETE == BUILD_INSN (10, SP_REGNUM, SP_REGNUM, 0, 0)) +// OBSOLETE { +// OBSOLETE if (LIMM_P (X_C (insn))) +// OBSOLETE frame_size = codestream_get (); +// OBSOLETE else if (SHIMM_P (X_C (insn))) +// OBSOLETE frame_size = X_D (insn); +// OBSOLETE else +// OBSOLETE return -1; +// OBSOLETE if (frame_size < 0) +// OBSOLETE return -1; +// OBSOLETE +// OBSOLETE codestream_get (); +// OBSOLETE +// OBSOLETE /* This sequence is used to get the address of the return +// OBSOLETE buffer for a function that returns a structure. */ +// OBSOLETE insn = codestream_peek (); +// OBSOLETE if ((insn & OPMASK) == 0x60000000) +// OBSOLETE codestream_get (); +// OBSOLETE } +// OBSOLETE /* Frameless fn. */ +// OBSOLETE else +// OBSOLETE { +// OBSOLETE frame_size = 0; +// OBSOLETE } +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* If we found a "sub sp,sp,N" and nothing else, it may or may not be a +// OBSOLETE stdarg fn. The stdarg decrement is not treated as part of the frame size, +// OBSOLETE so we have a dilemma: what do we return? For now, if we get a +// OBSOLETE "sub sp,sp,N" and nothing else assume this isn't a stdarg fn. One way +// OBSOLETE to fix this completely would be to add a bit to the function descriptor +// OBSOLETE that says the function is a stdarg function. */ +// OBSOLETE +// OBSOLETE if (frame_size < 0 && maybe_stdarg_decr > 0) +// OBSOLETE return maybe_stdarg_decr; +// OBSOLETE return frame_size; +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* Given a pc value, skip it forward past the function prologue by +// OBSOLETE disassembling instructions that appear to be a prologue. +// OBSOLETE +// OBSOLETE If FRAMELESS_P is set, we are only testing to see if the function +// OBSOLETE is frameless. If it is a frameless function, return PC unchanged. +// OBSOLETE This allows a quicker answer. */ +// OBSOLETE +// OBSOLETE CORE_ADDR +// OBSOLETE arc_skip_prologue (CORE_ADDR pc, int frameless_p) +// OBSOLETE { +// OBSOLETE unsigned int insn; +// OBSOLETE int i, frame_size; +// OBSOLETE +// OBSOLETE if ((frame_size = arc_get_frame_setup (pc)) < 0) +// OBSOLETE return (pc); +// OBSOLETE +// OBSOLETE if (frameless_p) +// OBSOLETE return frame_size == 0 ? pc : codestream_tell (); +// OBSOLETE +// OBSOLETE /* Skip over register saves. */ +// OBSOLETE for (i = 0; i < 8; i++) +// OBSOLETE { +// OBSOLETE insn = codestream_peek (); +// OBSOLETE if ((insn & BUILD_INSN (-1, 0, -1, 0, 0)) +// OBSOLETE != BUILD_INSN (2, 0, SP_REGNUM, 0, 0)) +// OBSOLETE break; /* not st insn */ +// OBSOLETE if (!ARC_CALL_SAVED_REG (X_C (insn))) +// OBSOLETE break; +// OBSOLETE codestream_get (); +// OBSOLETE } +// OBSOLETE +// OBSOLETE return codestream_tell (); +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* Is the prologue at PC frameless? */ +// OBSOLETE +// OBSOLETE int +// OBSOLETE arc_prologue_frameless_p (CORE_ADDR pc) +// OBSOLETE { +// OBSOLETE return (pc == arc_skip_prologue (pc, 1)); +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* Return the return address for a frame. +// OBSOLETE This is used to implement FRAME_SAVED_PC. +// OBSOLETE This is taken from frameless_look_for_prologue. */ +// OBSOLETE +// OBSOLETE CORE_ADDR +// OBSOLETE arc_frame_saved_pc (struct frame_info *frame) +// OBSOLETE { +// OBSOLETE CORE_ADDR func_start; +// OBSOLETE unsigned int insn; +// OBSOLETE +// OBSOLETE func_start = get_pc_function_start (frame->pc) + FUNCTION_START_OFFSET; +// OBSOLETE if (func_start == 0) +// OBSOLETE { +// OBSOLETE /* Best guess. */ +// OBSOLETE return ARC_PC_TO_REAL_ADDRESS (read_memory_integer (FRAME_FP (frame) + 4, 4)); +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* The authority for what appears here is the home-grown ABI. +// OBSOLETE The most recent version is 1.2. */ +// OBSOLETE +// OBSOLETE insn = setup_prologue_scan (func_start); +// OBSOLETE +// OBSOLETE /* First insn may be "sub sp,sp,N" if stdarg fn. */ +// OBSOLETE if ((insn & BUILD_INSN (-1, -1, -1, -1, 0)) +// OBSOLETE == BUILD_INSN (10, SP_REGNUM, SP_REGNUM, SHIMM_REGNUM, 0)) +// OBSOLETE insn = codestream_get (); +// OBSOLETE +// OBSOLETE /* If the next insn is "st blink,[sp,4]" we can get blink from there. +// OBSOLETE Otherwise this is a leaf function and we can use blink. Note that +// OBSOLETE this still allows for the case where a leaf function saves/clobbers/ +// OBSOLETE restores blink. */ +// OBSOLETE +// OBSOLETE if ((insn & BUILD_INSN (-1, 0, -1, -1, -1)) /* st blink,[sp,4] */ +// OBSOLETE != BUILD_INSN (2, 0, SP_REGNUM, BLINK_REGNUM, 4)) +// OBSOLETE return ARC_PC_TO_REAL_ADDRESS (read_register (BLINK_REGNUM)); +// OBSOLETE else +// OBSOLETE return ARC_PC_TO_REAL_ADDRESS (read_memory_integer (FRAME_FP (frame) + 4, 4)); +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* +// OBSOLETE * Parse the first few instructions of the function to see +// OBSOLETE * what registers were stored. +// OBSOLETE * +// OBSOLETE * The startup sequence can be at the start of the function. +// OBSOLETE * 'st blink,[sp+4], st fp,[sp], mov fp,sp' +// OBSOLETE * +// OBSOLETE * Local space is allocated just below by sub sp,sp,nnn. +// OBSOLETE * Next, the registers used by this function are stored (as offsets from sp). +// OBSOLETE */ +// OBSOLETE +// OBSOLETE void +// OBSOLETE frame_find_saved_regs (struct frame_info *fip, struct frame_saved_regs *fsrp) +// OBSOLETE { +// OBSOLETE long locals; +// OBSOLETE unsigned int insn; +// OBSOLETE CORE_ADDR dummy_bottom; +// OBSOLETE CORE_ADDR adr; +// OBSOLETE int i, regnum, offset; +// OBSOLETE +// OBSOLETE memset (fsrp, 0, sizeof *fsrp); +// OBSOLETE +// OBSOLETE /* If frame is the end of a dummy, compute where the beginning would be. */ +// OBSOLETE dummy_bottom = fip->frame - 4 - REGISTER_BYTES - CALL_DUMMY_LENGTH; +// OBSOLETE +// OBSOLETE /* Check if the PC is in the stack, in a dummy frame. */ +// OBSOLETE if (dummy_bottom <= fip->pc && fip->pc <= fip->frame) +// OBSOLETE { +// OBSOLETE /* all regs were saved by push_call_dummy () */ +// OBSOLETE adr = fip->frame; +// OBSOLETE for (i = 0; i < NUM_REGS; i++) +// OBSOLETE { +// OBSOLETE adr -= REGISTER_RAW_SIZE (i); +// OBSOLETE fsrp->regs[i] = adr; +// OBSOLETE } +// OBSOLETE return; +// OBSOLETE } +// OBSOLETE +// OBSOLETE locals = arc_get_frame_setup (get_pc_function_start (fip->pc)); +// OBSOLETE +// OBSOLETE if (locals >= 0) +// OBSOLETE { +// OBSOLETE /* Set `adr' to the value of `sp'. */ +// OBSOLETE adr = fip->frame - locals; +// OBSOLETE for (i = 0; i < 8; i++) +// OBSOLETE { +// OBSOLETE insn = codestream_get (); +// OBSOLETE if ((insn & BUILD_INSN (-1, 0, -1, 0, 0)) +// OBSOLETE != BUILD_INSN (2, 0, SP_REGNUM, 0, 0)) +// OBSOLETE break; +// OBSOLETE regnum = X_C (insn); +// OBSOLETE offset = X_D (insn); +// OBSOLETE fsrp->regs[regnum] = adr + offset; +// OBSOLETE } +// OBSOLETE } +// OBSOLETE +// OBSOLETE fsrp->regs[PC_REGNUM] = fip->frame + 4; +// OBSOLETE fsrp->regs[FP_REGNUM] = fip->frame; +// OBSOLETE } +// OBSOLETE +// OBSOLETE void +// OBSOLETE arc_push_dummy_frame (void) +// OBSOLETE { +// OBSOLETE CORE_ADDR sp = read_register (SP_REGNUM); +// OBSOLETE int regnum; +// OBSOLETE char regbuf[MAX_REGISTER_RAW_SIZE]; +// OBSOLETE +// OBSOLETE read_register_gen (PC_REGNUM, regbuf); +// OBSOLETE write_memory (sp + 4, regbuf, REGISTER_SIZE); +// OBSOLETE read_register_gen (FP_REGNUM, regbuf); +// OBSOLETE write_memory (sp, regbuf, REGISTER_SIZE); +// OBSOLETE write_register (FP_REGNUM, sp); +// OBSOLETE for (regnum = 0; regnum < NUM_REGS; regnum++) +// OBSOLETE { +// OBSOLETE read_register_gen (regnum, regbuf); +// OBSOLETE sp = push_bytes (sp, regbuf, REGISTER_RAW_SIZE (regnum)); +// OBSOLETE } +// OBSOLETE sp += (2 * REGISTER_SIZE); +// OBSOLETE write_register (SP_REGNUM, sp); +// OBSOLETE } +// OBSOLETE +// OBSOLETE void +// OBSOLETE arc_pop_frame (void) +// OBSOLETE { +// OBSOLETE struct frame_info *frame = get_current_frame (); +// OBSOLETE CORE_ADDR fp; +// OBSOLETE int regnum; +// OBSOLETE struct frame_saved_regs fsr; +// OBSOLETE char regbuf[MAX_REGISTER_RAW_SIZE]; +// OBSOLETE +// OBSOLETE fp = FRAME_FP (frame); +// OBSOLETE get_frame_saved_regs (frame, &fsr); +// OBSOLETE for (regnum = 0; regnum < NUM_REGS; regnum++) +// OBSOLETE { +// OBSOLETE CORE_ADDR adr; +// OBSOLETE adr = fsr.regs[regnum]; +// OBSOLETE if (adr) +// OBSOLETE { +// OBSOLETE read_memory (adr, regbuf, REGISTER_RAW_SIZE (regnum)); +// OBSOLETE write_register_bytes (REGISTER_BYTE (regnum), regbuf, +// OBSOLETE REGISTER_RAW_SIZE (regnum)); +// OBSOLETE } +// OBSOLETE } +// OBSOLETE write_register (FP_REGNUM, read_memory_integer (fp, 4)); +// OBSOLETE write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); +// OBSOLETE write_register (SP_REGNUM, fp + 8); +// OBSOLETE flush_cached_frames (); +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* Simulate single-step. */ +// OBSOLETE +// OBSOLETE typedef enum +// OBSOLETE { +// OBSOLETE NORMAL4, /* a normal 4 byte insn */ +// OBSOLETE NORMAL8, /* a normal 8 byte insn */ +// OBSOLETE BRANCH4, /* a 4 byte branch insn, including ones without delay slots */ +// OBSOLETE BRANCH8, /* an 8 byte branch insn, including ones with delay slots */ +// OBSOLETE } +// OBSOLETE insn_type; +// OBSOLETE +// OBSOLETE /* Return the type of INSN and store in TARGET the destination address of a +// OBSOLETE branch if this is one. */ +// OBSOLETE /* ??? Need to verify all cases are properly handled. */ +// OBSOLETE +// OBSOLETE static insn_type +// OBSOLETE get_insn_type (unsigned long insn, CORE_ADDR pc, CORE_ADDR *target) +// OBSOLETE { +// OBSOLETE unsigned long limm; +// OBSOLETE +// OBSOLETE switch (insn >> 27) +// OBSOLETE { +// OBSOLETE case 0: +// OBSOLETE case 1: +// OBSOLETE case 2: /* load/store insns */ +// OBSOLETE if (LIMM_P (X_A (insn)) +// OBSOLETE || LIMM_P (X_B (insn)) +// OBSOLETE || LIMM_P (X_C (insn))) +// OBSOLETE return NORMAL8; +// OBSOLETE return NORMAL4; +// OBSOLETE case 4: +// OBSOLETE case 5: +// OBSOLETE case 6: /* branch insns */ +// OBSOLETE *target = pc + 4 + X_L (insn); +// OBSOLETE /* ??? It isn't clear that this is always the right answer. +// OBSOLETE The problem occurs when the next insn is an 8 byte insn. If the +// OBSOLETE branch is conditional there's no worry as there shouldn't be an 8 +// OBSOLETE byte insn following. The programmer may be cheating if s/he knows +// OBSOLETE the branch will never be taken, but we don't deal with that. +// OBSOLETE Note that the programmer is also allowed to play games by putting +// OBSOLETE an insn with long immediate data in the delay slot and then duplicate +// OBSOLETE the long immediate data at the branch target. Ugh! */ +// OBSOLETE if (X_N (insn) == 0) +// OBSOLETE return BRANCH4; +// OBSOLETE return BRANCH8; +// OBSOLETE case 7: /* jump insns */ +// OBSOLETE if (LIMM_P (X_B (insn))) +// OBSOLETE { +// OBSOLETE limm = read_memory_integer (pc + 4, 4); +// OBSOLETE *target = ARC_PC_TO_REAL_ADDRESS (limm); +// OBSOLETE return BRANCH8; +// OBSOLETE } +// OBSOLETE if (SHIMM_P (X_B (insn))) +// OBSOLETE *target = ARC_PC_TO_REAL_ADDRESS (X_D (insn)); +// OBSOLETE else +// OBSOLETE *target = ARC_PC_TO_REAL_ADDRESS (read_register (X_B (insn))); +// OBSOLETE if (X_Q (insn) == 0 && X_N (insn) == 0) +// OBSOLETE return BRANCH4; +// OBSOLETE return BRANCH8; +// OBSOLETE default: /* arithmetic insns, etc. */ +// OBSOLETE if (LIMM_P (X_A (insn)) +// OBSOLETE || LIMM_P (X_B (insn)) +// OBSOLETE || LIMM_P (X_C (insn))) +// OBSOLETE return NORMAL8; +// OBSOLETE return NORMAL4; +// OBSOLETE } +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* single_step() is called just before we want to resume the inferior, if we +// OBSOLETE want to single-step it but there is no hardware or kernel single-step +// OBSOLETE support. We find all the possible targets of the coming instruction and +// OBSOLETE breakpoint them. +// OBSOLETE +// OBSOLETE single_step is also called just after the inferior stops. If we had +// OBSOLETE set up a simulated single-step, we undo our damage. */ +// OBSOLETE +// OBSOLETE void +// OBSOLETE arc_software_single_step (enum target_signal ignore, /* sig but we don't need it */ +// OBSOLETE int insert_breakpoints_p) +// OBSOLETE { +// OBSOLETE static CORE_ADDR next_pc, target; +// OBSOLETE static int brktrg_p; +// OBSOLETE typedef char binsn_quantum[BREAKPOINT_MAX]; +// OBSOLETE static binsn_quantum break_mem[2]; +// OBSOLETE +// OBSOLETE if (insert_breakpoints_p) +// OBSOLETE { +// OBSOLETE insn_type type; +// OBSOLETE CORE_ADDR pc; +// OBSOLETE unsigned long insn; +// OBSOLETE +// OBSOLETE pc = read_register (PC_REGNUM); +// OBSOLETE insn = read_memory_integer (pc, 4); +// OBSOLETE type = get_insn_type (insn, pc, &target); +// OBSOLETE +// OBSOLETE /* Always set a breakpoint for the insn after the branch. */ +// OBSOLETE next_pc = pc + ((type == NORMAL8 || type == BRANCH8) ? 8 : 4); +// OBSOLETE target_insert_breakpoint (next_pc, break_mem[0]); +// OBSOLETE +// OBSOLETE brktrg_p = 0; +// OBSOLETE +// OBSOLETE if ((type == BRANCH4 || type == BRANCH8) +// OBSOLETE /* Watch out for branches to the following location. +// OBSOLETE We just stored a breakpoint there and another call to +// OBSOLETE target_insert_breakpoint will think the real insn is the +// OBSOLETE breakpoint we just stored there. */ +// OBSOLETE && target != next_pc) +// OBSOLETE { +// OBSOLETE brktrg_p = 1; +// OBSOLETE target_insert_breakpoint (target, break_mem[1]); +// OBSOLETE } +// OBSOLETE +// OBSOLETE } +// OBSOLETE else +// OBSOLETE { +// OBSOLETE /* Remove breakpoints. */ +// OBSOLETE target_remove_breakpoint (next_pc, break_mem[0]); +// OBSOLETE +// OBSOLETE if (brktrg_p) +// OBSOLETE target_remove_breakpoint (target, break_mem[1]); +// OBSOLETE +// OBSOLETE /* Fix the pc. */ +// OBSOLETE stop_pc -= DECR_PC_AFTER_BREAK; +// OBSOLETE write_pc (stop_pc); +// OBSOLETE } +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* Because of Multi-arch, GET_LONGJMP_TARGET is always defined. So test +// OBSOLETE for a definition of JB_PC. */ +// OBSOLETE #ifdef JB_PC +// OBSOLETE /* Figure out where the longjmp will land. Slurp the args out of the stack. +// OBSOLETE We expect the first arg to be a pointer to the jmp_buf structure from which +// OBSOLETE we extract the pc (JB_PC) that we will land at. The pc is copied into PC. +// OBSOLETE This routine returns true on success. */ +// OBSOLETE +// OBSOLETE int +// OBSOLETE get_longjmp_target (CORE_ADDR *pc) +// OBSOLETE { +// OBSOLETE char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT]; +// OBSOLETE CORE_ADDR sp, jb_addr; +// OBSOLETE +// OBSOLETE sp = read_register (SP_REGNUM); +// OBSOLETE +// OBSOLETE if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */ +// OBSOLETE buf, +// OBSOLETE TARGET_PTR_BIT / TARGET_CHAR_BIT)) +// OBSOLETE return 0; +// OBSOLETE +// OBSOLETE jb_addr = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT); +// OBSOLETE +// OBSOLETE if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf, +// OBSOLETE TARGET_PTR_BIT / TARGET_CHAR_BIT)) +// OBSOLETE return 0; +// OBSOLETE +// OBSOLETE *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT); +// OBSOLETE +// OBSOLETE return 1; +// OBSOLETE } +// OBSOLETE #endif /* GET_LONGJMP_TARGET */ +// OBSOLETE +// OBSOLETE /* Disassemble one instruction. */ +// OBSOLETE +// OBSOLETE static int +// OBSOLETE arc_print_insn (bfd_vma vma, disassemble_info *info) +// OBSOLETE { +// OBSOLETE static int current_mach; +// OBSOLETE static int current_endian; +// OBSOLETE static disassembler_ftype current_disasm; +// OBSOLETE +// OBSOLETE if (current_disasm == NULL +// OBSOLETE || arc_bfd_mach_type != current_mach +// OBSOLETE || TARGET_BYTE_ORDER != current_endian) +// OBSOLETE { +// OBSOLETE current_mach = arc_bfd_mach_type; +// OBSOLETE current_endian = TARGET_BYTE_ORDER; +// OBSOLETE current_disasm = arc_get_disassembler (NULL); +// OBSOLETE } +// OBSOLETE +// OBSOLETE return (*current_disasm) (vma, info); +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* Command to set cpu type. */ +// OBSOLETE +// OBSOLETE void +// OBSOLETE arc_set_cpu_type_command (char *args, int from_tty) +// OBSOLETE { +// OBSOLETE int i; +// OBSOLETE +// OBSOLETE if (tmp_arc_cpu_type == NULL || *tmp_arc_cpu_type == '\0') +// OBSOLETE { +// OBSOLETE printf_unfiltered ("The known ARC cpu types are as follows:\n"); +// OBSOLETE for (i = 0; arc_cpu_type_table[i].name != NULL; ++i) +// OBSOLETE printf_unfiltered ("%s\n", arc_cpu_type_table[i].name); +// OBSOLETE +// OBSOLETE /* Restore the value. */ +// OBSOLETE tmp_arc_cpu_type = xstrdup (arc_cpu_type); +// OBSOLETE +// OBSOLETE return; +// OBSOLETE } +// OBSOLETE +// OBSOLETE if (!arc_set_cpu_type (tmp_arc_cpu_type)) +// OBSOLETE { +// OBSOLETE error ("Unknown cpu type `%s'.", tmp_arc_cpu_type); +// OBSOLETE /* Restore its value. */ +// OBSOLETE tmp_arc_cpu_type = xstrdup (arc_cpu_type); +// OBSOLETE } +// OBSOLETE } +// OBSOLETE +// OBSOLETE static void +// OBSOLETE arc_show_cpu_type_command (char *args, int from_tty) +// OBSOLETE { +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* Modify the actual cpu type. +// OBSOLETE Result is a boolean indicating success. */ +// OBSOLETE +// OBSOLETE static int +// OBSOLETE arc_set_cpu_type (char *str) +// OBSOLETE { +// OBSOLETE int i, j; +// OBSOLETE +// OBSOLETE if (str == NULL) +// OBSOLETE return 0; +// OBSOLETE +// OBSOLETE for (i = 0; arc_cpu_type_table[i].name != NULL; ++i) +// OBSOLETE { +// OBSOLETE if (strcasecmp (str, arc_cpu_type_table[i].name) == 0) +// OBSOLETE { +// OBSOLETE arc_cpu_type = str; +// OBSOLETE arc_bfd_mach_type = arc_cpu_type_table[i].value; +// OBSOLETE return 1; +// OBSOLETE } +// OBSOLETE } +// OBSOLETE +// OBSOLETE return 0; +// OBSOLETE } +// OBSOLETE +// OBSOLETE void +// OBSOLETE _initialize_arc_tdep (void) +// OBSOLETE { +// OBSOLETE struct cmd_list_element *c; +// OBSOLETE +// OBSOLETE c = add_set_cmd ("cpu", class_support, var_string_noescape, +// OBSOLETE (char *) &tmp_arc_cpu_type, +// OBSOLETE "Set the type of ARC cpu in use.\n\ +// OBSOLETE This command has two purposes. In a multi-cpu system it lets one\n\ +// OBSOLETE change the cpu being debugged. It also gives one access to\n\ +// OBSOLETE cpu-type-specific registers and recognize cpu-type-specific instructions.\ +// OBSOLETE ", +// OBSOLETE &setlist); +// OBSOLETE set_cmd_cfunc (c, arc_set_cpu_type_command); +// OBSOLETE c = add_show_from_set (c, &showlist); +// OBSOLETE set_cmd_cfunc (c, arc_show_cpu_type_command); +// OBSOLETE +// OBSOLETE /* We have to use xstrdup() here because the `set' command frees it +// OBSOLETE before setting a new value. */ +// OBSOLETE tmp_arc_cpu_type = xstrdup (DEFAULT_ARC_CPU_TYPE); +// OBSOLETE arc_set_cpu_type (tmp_arc_cpu_type); +// OBSOLETE +// OBSOLETE c = add_set_cmd ("displaypipeline", class_support, var_zinteger, +// OBSOLETE (char *) &display_pipeline_p, +// OBSOLETE "Set pipeline display (simulator only).\n\ +// OBSOLETE When enabled, the state of the pipeline after each cycle is displayed.", +// OBSOLETE &setlist); +// OBSOLETE c = add_show_from_set (c, &showlist); +// OBSOLETE +// OBSOLETE c = add_set_cmd ("debugpipeline", class_support, var_zinteger, +// OBSOLETE (char *) &debug_pipeline_p, +// OBSOLETE "Set pipeline debug display (simulator only).\n\ +// OBSOLETE When enabled, debugging information about the pipeline is displayed.", +// OBSOLETE &setlist); +// OBSOLETE c = add_show_from_set (c, &showlist); +// OBSOLETE +// OBSOLETE c = add_set_cmd ("cputimer", class_support, var_zinteger, +// OBSOLETE (char *) &cpu_timer, +// OBSOLETE "Set maximum cycle count (simulator only).\n\ +// OBSOLETE Control will return to gdb if the timer expires.\n\ +// OBSOLETE A negative value disables the timer.", +// OBSOLETE &setlist); +// OBSOLETE c = add_show_from_set (c, &showlist); +// OBSOLETE +// OBSOLETE tm_print_insn = arc_print_insn; +// OBSOLETE } diff --git a/gdb/config/arc/arc.mt b/gdb/config/arc/arc.mt index 8ee8c3d..3ed7410 100644 --- a/gdb/config/arc/arc.mt +++ b/gdb/config/arc/arc.mt @@ -1,3 +1,3 @@ -# Target: ARC processor -TDEPFILES = arc-tdep.o -TM_FILE = tm-arc.h +# OBSOLETE # Target: ARC processor +# OBSOLETE TDEPFILES = arc-tdep.o +# OBSOLETE TM_FILE = tm-arc.h diff --git a/gdb/config/arc/tm-arc.h b/gdb/config/arc/tm-arc.h index af183b6..1c7c74f 100644 --- a/gdb/config/arc/tm-arc.h +++ b/gdb/config/arc/tm-arc.h @@ -1,336 +1,336 @@ -/* Parameters for target machine ARC, for GDB, the GNU debugger. - Copyright 1995, 1996, 1998, 1999, 2000 Free Software Foundation, Inc. - Contributed by Cygnus Support. - - 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. */ - -#include "regcache.h" - -/* Used by arc-tdep.c to set the default cpu type. */ -#define DEFAULT_ARC_CPU_TYPE "base" - -/* Offset from address of function to start of its code. - Zero on most machines. */ -#define FUNCTION_START_OFFSET 0 - -/* Advance PC across any function entry prologue instructions - to reach some "real" code. */ - -#define SKIP_PROLOGUE(pc) (arc_skip_prologue (pc, 0)) -extern CORE_ADDR arc_skip_prologue (CORE_ADDR, int); - -#define PROLOGUE_FRAMELESS_P(pc) arc_prologue_frameless_p(pc) -extern int arc_prologue_frameless_p (CORE_ADDR); - -/* Sequence of bytes for breakpoint instruction. - ??? The current value is "sr -1,[-1]" and is for the simulator only. - The simulator watches for this and does the right thing. - The hardware version will have to associate with each breakpoint - the sequence "flag 1; nop; nop; nop". IE: The breakpoint insn will not - be a fixed set of bits but instead will be a branch to a semi-random - address. Presumably this will be cleaned up for "second silicon". */ -#define BIG_BREAKPOINT { 0x12, 0x1f, 0xff, 0xff } -#define LITTLE_BREAKPOINT { 0xff, 0xff, 0x1f, 0x12 } - -/* Given the exposed pipeline, there isn't any one correct value. - However, this value must be 4. GDB can't handle any other value (other than - zero). See for example infrun.c: - "prev_pc != stop_pc - DECR_PC_AFTER_BREAK" */ -/* FIXME */ -#define DECR_PC_AFTER_BREAK 8 - -/* We don't have a reliable single step facility. - ??? We do have a cycle single step facility, but that won't work. */ -#define SOFTWARE_SINGLE_STEP_P() 1 -extern void arc_software_single_step (enum target_signal, int); -#define SOFTWARE_SINGLE_STEP(sig,bp_p) arc_software_single_step (sig, bp_p) - -/* FIXME: Need to set STEP_SKIPS_DELAY. */ - -/* Given a pc value as defined by the hardware, return the real address. - Remember that on the ARC blink contains that status register which - includes PC + flags (so we have to mask out the flags). */ -#define ARC_PC_TO_REAL_ADDRESS(pc) (((pc) & 0xffffff) << 2) - -/* Immediately after a function call, return the saved pc. - Can't always go through the frames for this because on some machines - the new frame is not set up until the new function - executes some instructions. */ - -#define SAVED_PC_AFTER_CALL(frame) \ - (ARC_PC_TO_REAL_ADDRESS (read_register (BLINK_REGNUM))) - -/* Stack grows upward */ - -#define INNER_THAN(lhs,rhs) ((lhs) < (rhs)) - -/* 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 92 - -/* Initializer for an array of names of registers. - There should be NUM_REGS strings in this initializer. */ - -#define REGISTER_NAMES \ -{ \ - /* 0 */ "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \ - /* 8 */ "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", \ - /* 16 */ "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", \ - /* 24 */ "r24", "r25", "r26", "fp", "sp", "ilink1", "ilink2", "blink", \ - /* 32 */ "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39", \ - /* 40 */ "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47", \ - /* 48 */ "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55", \ - /* 56 */ "r56", "mlo", "mmid", "mhi", "lp_count", \ - /* 61 */ "status", "sema", "lp_start", "lp_end", "identity", "debug", \ - /* 67 */ "aux10", "aux11", "aux12", "aux13", "aux14", \ - /* 72 */ "aux15", "aux16", "aux17", "aux18", "aux19", \ - /* 77 */ "aux1a", "aux1b", "aux1c", "aux1d", "aux1e", \ - /* 82 */ "aux1f", "aux20", "aux21", "aux22", \ - /* 86 */ "aux30", "aux31", "aux32", "aux33", "aux40", \ - /* 91 */ "pc" \ -} - -/* Register numbers of various important registers (used to index - into arrays of register names and register values). */ - -#define R0_REGNUM 0 /* First local register */ -#define R59_REGNUM 59 /* Last local register */ -#define FP_REGNUM 27 /* Contains address of executing stack frame */ -#define SP_REGNUM 28 /* stack pointer */ -#define BLINK_REGNUM 31 /* link register */ -#define STA_REGNUM 61 /* processor status word */ -#define PC_REGNUM 91 /* instruction pointer */ -#define AUX_BEG_REGNUM 61 /* aux reg begins */ -#define AUX_END_REGNUM 90 /* aux reg ends, pc not real aux reg */ - -/* Fake registers used to mark immediate data. */ -#define SHIMM_FLAG_REGNUM 61 -#define LIMM_REGNUM 62 -#define SHIMM_REGNUM 63 - -#define AUX_REG_MAP \ -{ \ - { 0, 1, 2, 3, 4, 5, \ - 16, -1, -1, -1, -1, \ - -1, -1, -1, -1, -1, \ - -1, -1, -1, -1, 30, \ - -1, 32, 33, -1, \ - 48, 49, 50, 51, 64, \ - 0 \ - }, \ - { 0, 1, 2, 3, 4, 5, \ - 16, -1, -1, -1, -1, \ - -1, -1, -1, -1, -1, \ - -1, -1, -1, -1, 30, \ - 31, 32, 33, -1, \ - -1, -1, -1, -1, -1, \ - 0 \ - }, \ - { 0, 1, 2, 3, 4, 5, \ - 16, 17, 18, 19, 20, \ - 21, 22, 23, 24, 25, \ - 26, 27, 28, 29, 30, \ - 31, 32, 33, 34, \ - -1, -1, -1, -1, -1, \ - 0 \ - } \ -} - -#define PFP_REGNUM R0_REGNUM /* Previous frame pointer */ - -/* Total amount of space needed to store our copies of the machine's - register state, the array `registers'. */ -#define REGISTER_BYTES (NUM_REGS * 4) - -/* Index within `registers' of the first byte of the space for register N. */ -#define REGISTER_BYTE(N) (4*(N)) - -/* Number of bytes of storage in the actual machine representation - for register N. */ -#define REGISTER_RAW_SIZE(N) 4 - -/* Number of bytes of storage in the program's representation for register N. */ -#define REGISTER_VIRTUAL_SIZE(N) 4 - -/* 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) (builtin_type_int) - - -/* Macros for understanding function return values... */ - -/* Does the specified function use the "struct returning" convention - or the "value returning" convention? The "value returning" convention - almost invariably returns the entire value in registers. The - "struct returning" convention often returns the entire value in - memory, and passes a pointer (out of or into the function) saying - where the value (is or should go). - - Since this sometimes depends on whether it was compiled with GCC, - this is also an argument. This is used in call_function to build a - stack, and in value_being_returned to print return values. - - On arc, a structure is always retunred with pointer in r0. */ - -#define USE_STRUCT_CONVENTION(gcc_p, type) 1 - -/* Extract from an array REGBUF containing the (raw) register state - a function return value of type TYPE, and copy that, in virtual format, - into VALBUF. This is only called if USE_STRUCT_CONVENTION for this - type is 0. - */ -#define DEPRECATED_EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ - memcpy(VALBUF, REGBUF+REGISTER_BYTE(R0_REGNUM), TYPE_LENGTH (TYPE)) - -/* If USE_STRUCT_CONVENTION produces a 1, - extract from an array REGBUF containing the (raw) register state - the address in which a function should return its structure value, - as a CORE_ADDR (or an expression that can be used as one). */ -#define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \ - (error("Don't know where large structure is returned on arc"), 0) - -/* Write into appropriate registers a function return value - of type TYPE, given in virtual format, for "value returning" functions. - For 'return' command: not (yet) implemented for arc. */ -#define STORE_RETURN_VALUE(TYPE,VALBUF) \ - error ("Returning values from functions is not implemented in arc gdb") - -/* Store the address of the place in which to copy the structure the - subroutine will return. This is called from call_function. */ -#define STORE_STRUCT_RETURN(ADDR, SP) \ - error ("Returning values from functions is not implemented in arc gdb") - - -/* Describe the pointer in each stack frame to the previous stack frame - (its caller). */ - -/* We cache information about saved registers in the frame structure, - to save us from having to re-scan function prologues every time - a register in a non-current frame is accessed. */ - -#define EXTRA_FRAME_INFO \ - struct frame_saved_regs *fsr; \ - CORE_ADDR arg_pointer; - -/* Zero the frame_saved_regs pointer when the frame is initialized, - so that FRAME_FIND_SAVED_REGS () will know to allocate and - initialize a frame_saved_regs struct the first time it is called. - Set the arg_pointer to -1, which is not valid; 0 and other values - indicate real, cached values. */ - -#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \ - ((fi)->fsr = 0, (fi)->arg_pointer = -1) - -/* FRAME_CHAIN takes a frame's nominal address - and produces the frame's chain-pointer. - However, if FRAME_CHAIN_VALID returns zero, - it means the given frame is the outermost one and has no caller. */ -/* On the arc, we get the chain pointer by reading the PFP saved - on the stack. */ -/* The PFP and RPC is in fp and fp+4. */ - -#define FRAME_CHAIN(thisframe) \ - (read_memory_integer (FRAME_FP (thisframe), 4)) - -/* FRAME_CHAIN_VALID returns zero if the given frame is the outermost one - and has no caller. */ -#define FRAME_CHAIN_VALID(chain, thisframe) nonnull_frame_chain_valid (chain, thisframe) - -/* An expression that tells us whether the function invocation represented - by FI does not have a frame on the stack associated with it. */ - -#define FRAMELESS_FUNCTION_INVOCATION(FI) \ - (((FI)->signal_handler_caller) ? 0 : frameless_look_for_prologue (FI)) - -/* Where is the PC for a specific frame. - A leaf function may never save blink, so we have to check for that here. */ - -#define FRAME_SAVED_PC(frame) (arc_frame_saved_pc (frame)) -struct frame_info; /* in case frame.h not included yet */ -CORE_ADDR arc_frame_saved_pc (struct frame_info *); - -/* If the argument is on the stack, it will be here. - We cache this value in the frame info if we've already looked it up. */ -/* ??? Is the arg_pointer check necessary? */ - -#define FRAME_ARGS_ADDRESS(fi) \ - (((fi)->arg_pointer != -1) ? (fi)->arg_pointer : (fi)->frame) - -/* This is the same except it should return 0 when - it does not really know where the args are, rather than guessing. - This value is not cached since it is only used infrequently. */ - -#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) - -/* Set NUMARGS to the number of args passed to a frame. - Can return -1, meaning no way to tell. */ - -#define FRAME_NUM_ARGS(fi) (-1) - -/* Return number of bytes at start of arglist that are not really args. */ - -#define FRAME_ARGS_SKIP 0 - -/* Produce the positions of the saved registers in a stack frame. */ - -#define FRAME_FIND_SAVED_REGS(frame_info_addr, sr) \ - frame_find_saved_regs (frame_info_addr, &sr) -extern void frame_find_saved_regs (); /* See arc-tdep.c */ - - -/* Things needed for making calls to functions in the inferior process */ -void arc_push_dummy_frame (void); -#define PUSH_DUMMY_FRAME \ - arc_push_dummy_frame () - -/* Discard from the stack the innermost frame, restoring all registers. */ -void arc_pop_frame (void); -#define POP_FRAME \ - arc_pop_frame () - -/* This sequence of words is the instructions bl xxxx, flag 1 */ -#define CALL_DUMMY { 0x28000000, 0x1fbe8001 } -#define CALL_DUMMY_LENGTH 8 - -/* Start execution at beginning of dummy */ -#define CALL_DUMMY_START_OFFSET 0 - -/* Insert the specified number of args and function address - into a call sequence of the above form stored at 'dummyname'. */ -#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ -{ \ - int from, to, delta, loc; \ - loc = (int)(read_register (SP_REGNUM) - CALL_DUMMY_LENGTH); \ - from = loc + 4; \ - to = (int)(fun); \ - delta = (to - from) >> 2; \ - *((char *)(dummyname) + 1) = (delta & 0x1); \ - *((char *)(dummyname) + 2) = ((delta >> 1) & 0xff); \ - *((char *)(dummyname) + 3) = ((delta >> 9) & 0xff); \ - *((char *)(dummyname) + 4) = ((delta >> 17) & 0x7); \ -} +// OBSOLETE /* Parameters for target machine ARC, for GDB, the GNU debugger. +// OBSOLETE Copyright 1995, 1996, 1998, 1999, 2000 Free Software Foundation, Inc. +// OBSOLETE Contributed by Cygnus Support. +// OBSOLETE +// OBSOLETE This file is part of GDB. +// OBSOLETE +// OBSOLETE This program is free software; you can redistribute it and/or modify +// OBSOLETE it under the terms of the GNU General Public License as published by +// OBSOLETE the Free Software Foundation; either version 2 of the License, or +// OBSOLETE (at your option) any later version. +// OBSOLETE +// OBSOLETE This program is distributed in the hope that it will be useful, +// OBSOLETE but WITHOUT ANY WARRANTY; without even the implied warranty of +// OBSOLETE MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// OBSOLETE GNU General Public License for more details. +// OBSOLETE +// OBSOLETE You should have received a copy of the GNU General Public License +// OBSOLETE along with this program; if not, write to the Free Software +// OBSOLETE Foundation, Inc., 59 Temple Place - Suite 330, +// OBSOLETE Boston, MA 02111-1307, USA. */ +// OBSOLETE +// OBSOLETE #include "regcache.h" +// OBSOLETE +// OBSOLETE /* Used by arc-tdep.c to set the default cpu type. */ +// OBSOLETE #define DEFAULT_ARC_CPU_TYPE "base" +// OBSOLETE +// OBSOLETE /* Offset from address of function to start of its code. +// OBSOLETE Zero on most machines. */ +// OBSOLETE #define FUNCTION_START_OFFSET 0 +// OBSOLETE +// OBSOLETE /* Advance PC across any function entry prologue instructions +// OBSOLETE to reach some "real" code. */ +// OBSOLETE +// OBSOLETE #define SKIP_PROLOGUE(pc) (arc_skip_prologue (pc, 0)) +// OBSOLETE extern CORE_ADDR arc_skip_prologue (CORE_ADDR, int); +// OBSOLETE +// OBSOLETE #define PROLOGUE_FRAMELESS_P(pc) arc_prologue_frameless_p(pc) +// OBSOLETE extern int arc_prologue_frameless_p (CORE_ADDR); +// OBSOLETE +// OBSOLETE /* Sequence of bytes for breakpoint instruction. +// OBSOLETE ??? The current value is "sr -1,[-1]" and is for the simulator only. +// OBSOLETE The simulator watches for this and does the right thing. +// OBSOLETE The hardware version will have to associate with each breakpoint +// OBSOLETE the sequence "flag 1; nop; nop; nop". IE: The breakpoint insn will not +// OBSOLETE be a fixed set of bits but instead will be a branch to a semi-random +// OBSOLETE address. Presumably this will be cleaned up for "second silicon". */ +// OBSOLETE #define BIG_BREAKPOINT { 0x12, 0x1f, 0xff, 0xff } +// OBSOLETE #define LITTLE_BREAKPOINT { 0xff, 0xff, 0x1f, 0x12 } +// OBSOLETE +// OBSOLETE /* Given the exposed pipeline, there isn't any one correct value. +// OBSOLETE However, this value must be 4. GDB can't handle any other value (other than +// OBSOLETE zero). See for example infrun.c: +// OBSOLETE "prev_pc != stop_pc - DECR_PC_AFTER_BREAK" */ +// OBSOLETE /* FIXME */ +// OBSOLETE #define DECR_PC_AFTER_BREAK 8 +// OBSOLETE +// OBSOLETE /* We don't have a reliable single step facility. +// OBSOLETE ??? We do have a cycle single step facility, but that won't work. */ +// OBSOLETE #define SOFTWARE_SINGLE_STEP_P() 1 +// OBSOLETE extern void arc_software_single_step (enum target_signal, int); +// OBSOLETE #define SOFTWARE_SINGLE_STEP(sig,bp_p) arc_software_single_step (sig, bp_p) +// OBSOLETE +// OBSOLETE /* FIXME: Need to set STEP_SKIPS_DELAY. */ +// OBSOLETE +// OBSOLETE /* Given a pc value as defined by the hardware, return the real address. +// OBSOLETE Remember that on the ARC blink contains that status register which +// OBSOLETE includes PC + flags (so we have to mask out the flags). */ +// OBSOLETE #define ARC_PC_TO_REAL_ADDRESS(pc) (((pc) & 0xffffff) << 2) +// OBSOLETE +// OBSOLETE /* Immediately after a function call, return the saved pc. +// OBSOLETE Can't always go through the frames for this because on some machines +// OBSOLETE the new frame is not set up until the new function +// OBSOLETE executes some instructions. */ +// OBSOLETE +// OBSOLETE #define SAVED_PC_AFTER_CALL(frame) \ +// OBSOLETE (ARC_PC_TO_REAL_ADDRESS (read_register (BLINK_REGNUM))) +// OBSOLETE +// OBSOLETE /* Stack grows upward */ +// OBSOLETE +// OBSOLETE #define INNER_THAN(lhs,rhs) ((lhs) < (rhs)) +// OBSOLETE +// OBSOLETE /* Say how long (ordinary) registers are. This is a piece of bogosity +// OBSOLETE used in push_word and a few other places; REGISTER_RAW_SIZE is the +// OBSOLETE real way to know how big a register is. */ +// OBSOLETE #define REGISTER_SIZE 4 +// OBSOLETE +// OBSOLETE /* Number of machine registers */ +// OBSOLETE #define NUM_REGS 92 +// OBSOLETE +// OBSOLETE /* Initializer for an array of names of registers. +// OBSOLETE There should be NUM_REGS strings in this initializer. */ +// OBSOLETE +// OBSOLETE #define REGISTER_NAMES \ +// OBSOLETE { \ +// OBSOLETE /* 0 */ "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \ +// OBSOLETE /* 8 */ "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", \ +// OBSOLETE /* 16 */ "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", \ +// OBSOLETE /* 24 */ "r24", "r25", "r26", "fp", "sp", "ilink1", "ilink2", "blink", \ +// OBSOLETE /* 32 */ "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39", \ +// OBSOLETE /* 40 */ "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47", \ +// OBSOLETE /* 48 */ "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55", \ +// OBSOLETE /* 56 */ "r56", "mlo", "mmid", "mhi", "lp_count", \ +// OBSOLETE /* 61 */ "status", "sema", "lp_start", "lp_end", "identity", "debug", \ +// OBSOLETE /* 67 */ "aux10", "aux11", "aux12", "aux13", "aux14", \ +// OBSOLETE /* 72 */ "aux15", "aux16", "aux17", "aux18", "aux19", \ +// OBSOLETE /* 77 */ "aux1a", "aux1b", "aux1c", "aux1d", "aux1e", \ +// OBSOLETE /* 82 */ "aux1f", "aux20", "aux21", "aux22", \ +// OBSOLETE /* 86 */ "aux30", "aux31", "aux32", "aux33", "aux40", \ +// OBSOLETE /* 91 */ "pc" \ +// OBSOLETE } +// OBSOLETE +// OBSOLETE /* Register numbers of various important registers (used to index +// OBSOLETE into arrays of register names and register values). */ +// OBSOLETE +// OBSOLETE #define R0_REGNUM 0 /* First local register */ +// OBSOLETE #define R59_REGNUM 59 /* Last local register */ +// OBSOLETE #define FP_REGNUM 27 /* Contains address of executing stack frame */ +// OBSOLETE #define SP_REGNUM 28 /* stack pointer */ +// OBSOLETE #define BLINK_REGNUM 31 /* link register */ +// OBSOLETE #define STA_REGNUM 61 /* processor status word */ +// OBSOLETE #define PC_REGNUM 91 /* instruction pointer */ +// OBSOLETE #define AUX_BEG_REGNUM 61 /* aux reg begins */ +// OBSOLETE #define AUX_END_REGNUM 90 /* aux reg ends, pc not real aux reg */ +// OBSOLETE +// OBSOLETE /* Fake registers used to mark immediate data. */ +// OBSOLETE #define SHIMM_FLAG_REGNUM 61 +// OBSOLETE #define LIMM_REGNUM 62 +// OBSOLETE #define SHIMM_REGNUM 63 +// OBSOLETE +// OBSOLETE #define AUX_REG_MAP \ +// OBSOLETE { \ +// OBSOLETE { 0, 1, 2, 3, 4, 5, \ +// OBSOLETE 16, -1, -1, -1, -1, \ +// OBSOLETE -1, -1, -1, -1, -1, \ +// OBSOLETE -1, -1, -1, -1, 30, \ +// OBSOLETE -1, 32, 33, -1, \ +// OBSOLETE 48, 49, 50, 51, 64, \ +// OBSOLETE 0 \ +// OBSOLETE }, \ +// OBSOLETE { 0, 1, 2, 3, 4, 5, \ +// OBSOLETE 16, -1, -1, -1, -1, \ +// OBSOLETE -1, -1, -1, -1, -1, \ +// OBSOLETE -1, -1, -1, -1, 30, \ +// OBSOLETE 31, 32, 33, -1, \ +// OBSOLETE -1, -1, -1, -1, -1, \ +// OBSOLETE 0 \ +// OBSOLETE }, \ +// OBSOLETE { 0, 1, 2, 3, 4, 5, \ +// OBSOLETE 16, 17, 18, 19, 20, \ +// OBSOLETE 21, 22, 23, 24, 25, \ +// OBSOLETE 26, 27, 28, 29, 30, \ +// OBSOLETE 31, 32, 33, 34, \ +// OBSOLETE -1, -1, -1, -1, -1, \ +// OBSOLETE 0 \ +// OBSOLETE } \ +// OBSOLETE } +// OBSOLETE +// OBSOLETE #define PFP_REGNUM R0_REGNUM /* Previous frame pointer */ +// OBSOLETE +// OBSOLETE /* Total amount of space needed to store our copies of the machine's +// OBSOLETE register state, the array `registers'. */ +// OBSOLETE #define REGISTER_BYTES (NUM_REGS * 4) +// OBSOLETE +// OBSOLETE /* Index within `registers' of the first byte of the space for register N. */ +// OBSOLETE #define REGISTER_BYTE(N) (4*(N)) +// OBSOLETE +// OBSOLETE /* Number of bytes of storage in the actual machine representation +// OBSOLETE for register N. */ +// OBSOLETE #define REGISTER_RAW_SIZE(N) 4 +// OBSOLETE +// OBSOLETE /* Number of bytes of storage in the program's representation for register N. */ +// OBSOLETE #define REGISTER_VIRTUAL_SIZE(N) 4 +// OBSOLETE +// OBSOLETE /* Largest value REGISTER_RAW_SIZE can have. */ +// OBSOLETE #define MAX_REGISTER_RAW_SIZE 4 +// OBSOLETE +// OBSOLETE /* Largest value REGISTER_VIRTUAL_SIZE can have. */ +// OBSOLETE #define MAX_REGISTER_VIRTUAL_SIZE 4 +// OBSOLETE +// OBSOLETE /* Return the GDB type object for the "standard" data type +// OBSOLETE of data in register N. */ +// OBSOLETE #define REGISTER_VIRTUAL_TYPE(N) (builtin_type_int) +// OBSOLETE +// OBSOLETE +// OBSOLETE /* Macros for understanding function return values... */ +// OBSOLETE +// OBSOLETE /* Does the specified function use the "struct returning" convention +// OBSOLETE or the "value returning" convention? The "value returning" convention +// OBSOLETE almost invariably returns the entire value in registers. The +// OBSOLETE "struct returning" convention often returns the entire value in +// OBSOLETE memory, and passes a pointer (out of or into the function) saying +// OBSOLETE where the value (is or should go). +// OBSOLETE +// OBSOLETE Since this sometimes depends on whether it was compiled with GCC, +// OBSOLETE this is also an argument. This is used in call_function to build a +// OBSOLETE stack, and in value_being_returned to print return values. +// OBSOLETE +// OBSOLETE On arc, a structure is always retunred with pointer in r0. */ +// OBSOLETE +// OBSOLETE #define USE_STRUCT_CONVENTION(gcc_p, type) 1 +// OBSOLETE +// OBSOLETE /* Extract from an array REGBUF containing the (raw) register state +// OBSOLETE a function return value of type TYPE, and copy that, in virtual format, +// OBSOLETE into VALBUF. This is only called if USE_STRUCT_CONVENTION for this +// OBSOLETE type is 0. +// OBSOLETE */ +// OBSOLETE #define DEPRECATED_EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ +// OBSOLETE memcpy(VALBUF, REGBUF+REGISTER_BYTE(R0_REGNUM), TYPE_LENGTH (TYPE)) +// OBSOLETE +// OBSOLETE /* If USE_STRUCT_CONVENTION produces a 1, +// OBSOLETE extract from an array REGBUF containing the (raw) register state +// OBSOLETE the address in which a function should return its structure value, +// OBSOLETE as a CORE_ADDR (or an expression that can be used as one). */ +// OBSOLETE #define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \ +// OBSOLETE (error("Don't know where large structure is returned on arc"), 0) +// OBSOLETE +// OBSOLETE /* Write into appropriate registers a function return value +// OBSOLETE of type TYPE, given in virtual format, for "value returning" functions. +// OBSOLETE For 'return' command: not (yet) implemented for arc. */ +// OBSOLETE #define STORE_RETURN_VALUE(TYPE,VALBUF) \ +// OBSOLETE error ("Returning values from functions is not implemented in arc gdb") +// OBSOLETE +// OBSOLETE /* Store the address of the place in which to copy the structure the +// OBSOLETE subroutine will return. This is called from call_function. */ +// OBSOLETE #define STORE_STRUCT_RETURN(ADDR, SP) \ +// OBSOLETE error ("Returning values from functions is not implemented in arc gdb") +// OBSOLETE +// OBSOLETE +// OBSOLETE /* Describe the pointer in each stack frame to the previous stack frame +// OBSOLETE (its caller). */ +// OBSOLETE +// OBSOLETE /* We cache information about saved registers in the frame structure, +// OBSOLETE to save us from having to re-scan function prologues every time +// OBSOLETE a register in a non-current frame is accessed. */ +// OBSOLETE +// OBSOLETE #define EXTRA_FRAME_INFO \ +// OBSOLETE struct frame_saved_regs *fsr; \ +// OBSOLETE CORE_ADDR arg_pointer; +// OBSOLETE +// OBSOLETE /* Zero the frame_saved_regs pointer when the frame is initialized, +// OBSOLETE so that FRAME_FIND_SAVED_REGS () will know to allocate and +// OBSOLETE initialize a frame_saved_regs struct the first time it is called. +// OBSOLETE Set the arg_pointer to -1, which is not valid; 0 and other values +// OBSOLETE indicate real, cached values. */ +// OBSOLETE +// OBSOLETE #define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \ +// OBSOLETE ((fi)->fsr = 0, (fi)->arg_pointer = -1) +// OBSOLETE +// OBSOLETE /* FRAME_CHAIN takes a frame's nominal address +// OBSOLETE and produces the frame's chain-pointer. +// OBSOLETE However, if FRAME_CHAIN_VALID returns zero, +// OBSOLETE it means the given frame is the outermost one and has no caller. */ +// OBSOLETE /* On the arc, we get the chain pointer by reading the PFP saved +// OBSOLETE on the stack. */ +// OBSOLETE /* The PFP and RPC is in fp and fp+4. */ +// OBSOLETE +// OBSOLETE #define FRAME_CHAIN(thisframe) \ +// OBSOLETE (read_memory_integer (FRAME_FP (thisframe), 4)) +// OBSOLETE +// OBSOLETE /* FRAME_CHAIN_VALID returns zero if the given frame is the outermost one +// OBSOLETE and has no caller. */ +// OBSOLETE #define FRAME_CHAIN_VALID(chain, thisframe) nonnull_frame_chain_valid (chain, thisframe) +// OBSOLETE +// OBSOLETE /* An expression that tells us whether the function invocation represented +// OBSOLETE by FI does not have a frame on the stack associated with it. */ +// OBSOLETE +// OBSOLETE #define FRAMELESS_FUNCTION_INVOCATION(FI) \ +// OBSOLETE (((FI)->signal_handler_caller) ? 0 : frameless_look_for_prologue (FI)) +// OBSOLETE +// OBSOLETE /* Where is the PC for a specific frame. +// OBSOLETE A leaf function may never save blink, so we have to check for that here. */ +// OBSOLETE +// OBSOLETE #define FRAME_SAVED_PC(frame) (arc_frame_saved_pc (frame)) +// OBSOLETE struct frame_info; /* in case frame.h not included yet */ +// OBSOLETE CORE_ADDR arc_frame_saved_pc (struct frame_info *); +// OBSOLETE +// OBSOLETE /* If the argument is on the stack, it will be here. +// OBSOLETE We cache this value in the frame info if we've already looked it up. */ +// OBSOLETE /* ??? Is the arg_pointer check necessary? */ +// OBSOLETE +// OBSOLETE #define FRAME_ARGS_ADDRESS(fi) \ +// OBSOLETE (((fi)->arg_pointer != -1) ? (fi)->arg_pointer : (fi)->frame) +// OBSOLETE +// OBSOLETE /* This is the same except it should return 0 when +// OBSOLETE it does not really know where the args are, rather than guessing. +// OBSOLETE This value is not cached since it is only used infrequently. */ +// OBSOLETE +// OBSOLETE #define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) +// OBSOLETE +// OBSOLETE /* Set NUMARGS to the number of args passed to a frame. +// OBSOLETE Can return -1, meaning no way to tell. */ +// OBSOLETE +// OBSOLETE #define FRAME_NUM_ARGS(fi) (-1) +// OBSOLETE +// OBSOLETE /* Return number of bytes at start of arglist that are not really args. */ +// OBSOLETE +// OBSOLETE #define FRAME_ARGS_SKIP 0 +// OBSOLETE +// OBSOLETE /* Produce the positions of the saved registers in a stack frame. */ +// OBSOLETE +// OBSOLETE #define FRAME_FIND_SAVED_REGS(frame_info_addr, sr) \ +// OBSOLETE frame_find_saved_regs (frame_info_addr, &sr) +// OBSOLETE extern void frame_find_saved_regs (); /* See arc-tdep.c */ +// OBSOLETE +// OBSOLETE +// OBSOLETE /* Things needed for making calls to functions in the inferior process */ +// OBSOLETE void arc_push_dummy_frame (void); +// OBSOLETE #define PUSH_DUMMY_FRAME \ +// OBSOLETE arc_push_dummy_frame () +// OBSOLETE +// OBSOLETE /* Discard from the stack the innermost frame, restoring all registers. */ +// OBSOLETE void arc_pop_frame (void); +// OBSOLETE #define POP_FRAME \ +// OBSOLETE arc_pop_frame () +// OBSOLETE +// OBSOLETE /* This sequence of words is the instructions bl xxxx, flag 1 */ +// OBSOLETE #define CALL_DUMMY { 0x28000000, 0x1fbe8001 } +// OBSOLETE #define CALL_DUMMY_LENGTH 8 +// OBSOLETE +// OBSOLETE /* Start execution at beginning of dummy */ +// OBSOLETE #define CALL_DUMMY_START_OFFSET 0 +// OBSOLETE +// OBSOLETE /* Insert the specified number of args and function address +// OBSOLETE into a call sequence of the above form stored at 'dummyname'. */ +// OBSOLETE #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +// OBSOLETE { \ +// OBSOLETE int from, to, delta, loc; \ +// OBSOLETE loc = (int)(read_register (SP_REGNUM) - CALL_DUMMY_LENGTH); \ +// OBSOLETE from = loc + 4; \ +// OBSOLETE to = (int)(fun); \ +// OBSOLETE delta = (to - from) >> 2; \ +// OBSOLETE *((char *)(dummyname) + 1) = (delta & 0x1); \ +// OBSOLETE *((char *)(dummyname) + 2) = ((delta >> 1) & 0xff); \ +// OBSOLETE *((char *)(dummyname) + 3) = ((delta >> 9) & 0xff); \ +// OBSOLETE *((char *)(dummyname) + 4) = ((delta >> 17) & 0x7); \ +// OBSOLETE } diff --git a/gdb/configure.tgt b/gdb/configure.tgt index 11274ec..d0b13c8 100644 --- a/gdb/configure.tgt +++ b/gdb/configure.tgt @@ -43,7 +43,7 @@ alpha*-*-linux*) gdb_target=alpha-linux ;; alpha*-*-freebsd*) gdb_target=fbsd ;; alpha*-*-netbsd*) gdb_target=nbsd ;; -arc-*-*) gdb_target=arc ;; +# OBSOLETE arc-*-*) gdb_target=arc ;; arm*-wince-pe) gdb_target=wince ;; arm*-*-linux*) gdb_target=linux |