| /* Target dependent code for ARC processor family, for GDB, the GNU debugger. |
| |
| Copyright 2005, 2008, 2009 Free Software Foundation, Inc. |
| |
| Contributed by Codito Technologies Pvt. Ltd. (www.codito.com) |
| |
| Authors: |
| Soam Vasani <soam.vasani@codito.com> |
| Ramana Radhakrishnan <ramana.radhakrishnan@codito.com> |
| Richard Stuckey <richard.stuckey@arc.com> |
| |
| 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 3 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, see <http://www.gnu.org/licenses/>. */ |
| |
| /******************************************************************************/ |
| /* */ |
| /* Outline: */ |
| /* This module provides support for the ARC processor family's target */ |
| /* dependencies which are specific to the arc-linux-uclibc configuration */ |
| /* of the ARC gdb. */ |
| /* */ |
| /* Functionality: */ |
| /* This module provides a number of operations, including: */ |
| /* */ |
| /* 1) a function which returns the name of a register, given its number */ |
| /* */ |
| /* 2) a function which determines whether a given register belongs to a */ |
| /* particular group (e.g. the group of registers which should be saved */ |
| /* and restored across a function call) */ |
| /* */ |
| /* 3) a function which prints out registers */ |
| /* */ |
| /* */ |
| /* Usage: */ |
| /* The module exports a function _initialize_arc_linux_tdep: the call to */ |
| /* this function is generated by the gdb build mechanism, so this function*/ |
| /* should not be explicitly called. */ |
| /* */ |
| /* Some of the operations provided by this module are registered with gdb */ |
| /* during initialization; gdb then calls them via function pointers, */ |
| /* rather than by name (this allows gdb to handle multiple target */ |
| /* architectures): */ |
| /* */ |
| /* set_gdbarch_XXX (gdbarch, <function>); */ |
| /* */ |
| /* */ |
| /* Register Numbering Scheme: */ |
| /* The N target processor registers are assigned gdb numbers which form a */ |
| /* contiguous range starting at 0. The scheme used is: */ |
| /* */ |
| /* 0 .. 26 : core registers R0 .. R26 */ |
| /* 27 : BTA (Branch Target Address) auxiliary register */ |
| /* 28 : LP_START auxiliary register */ |
| /* 29 : LP_END auxiliary register */ |
| /* 30 : LP_COUNT core register (R60) */ |
| /* 31 : STATUS32 auxiliary register */ |
| /* 32 : BLINK (Branch Link) core register (R31) */ |
| /* 33 : FP (Frame Pointer) core register (R27) */ |
| /* 34 : SP (Stack Pointer) core register (R28) */ |
| /* 35 : EFA (Exception Fault Address) auxiliary register */ |
| /* 36 : RET (Exception Return Address) auxiliary register */ |
| /* 37 : ORIG_R8 */ |
| /* 38 : STOP_PC */ |
| /* */ |
| /* N.B. 1) core registers R61 and R62 are not included in the scheme, as */ |
| /* R61 is reserved, and R62 is not a real register; */ |
| /* */ |
| /* 2) core registers R29 (ILINK1), R30 (ILINK2) and R63 (PCL) are */ |
| /* not included; */ |
| /* */ |
| /* 3) extension core registers R32 .. R59 are not included; */ |
| /* */ |
| /* 4) most auxiliary registers (including all Build Configuration */ |
| /* Registers) are not included. */ |
| /* */ |
| /******************************************************************************/ |
| |
| /* gdb header files */ |
| #include "defs.h" |
| #include "osabi.h" |
| #include "regcache.h" |
| #include "inferior.h" |
| #include "reggroups.h" |
| #include "solib-svr4.h" |
| #include "block.h" |
| #include "regset.h" |
| #include "dis-asm.h" |
| #include "opcode/arc.h" |
| #include "gdb_assert.h" |
| |
| /* ARC header files */ |
| #include "config/arc/tm-linux.h" |
| #include "arc-linux-tdep.h" |
| #include "arc-support.h" |
| #include "arc-tdep.h" |
| #include "opcodes/arcompact-dis.h" |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* local data */ |
| /* -------------------------------------------------------------------------- */ |
| |
| #define STATUS32_L 0x00000100 |
| |
| |
| /* Default breakpoint instruction used for ARC700 Linux. */ |
| static const unsigned char le_breakpoint_instruction[] = { 0x3e, 0x78 }; |
| static const unsigned char be_breakpoint_instruction[] = { 0x78, 0x3e }; |
| |
| |
| /* This array holds the object code of two instructions: |
| mov r8,nr_sigreturn |
| swi |
| */ |
| static const gdb_byte arc_sigtramp_insns[] = { 0x8a, 0x20, 0xc1, 0x1d, |
| 0x6f, 0x22, 0x3f, 0x00 }; |
| |
| #define SIGTRAMP_INSNS_LENGTH sizeof(arc_sigtramp_insns) |
| |
| |
| /* N.B. the array size is specified in the declaration so that the compiler |
| will warn of "excess elements in array initializer" if there is a |
| mismatch (but not of too few elements, unfortunately!). */ |
| static const char *register_names[ARC_NR_REGS + ARC_NR_PSEUDO_REGS] = |
| { |
| "r0", "r1", "r2", "r3", "r4", "r5", "r6", |
| "r7", "r8", "r9", "r10", "r11", "r12", "r13", |
| "r14", "r15", "r16", "r17", "r18", "r19", "r20", |
| "r21", "r22", "r23", "r24", "r25", "r26", |
| |
| "bta", |
| "lp_start", |
| "lp_end", |
| "lp_count", |
| "status32", |
| "blink", |
| "fp", |
| "sp", |
| "efa", |
| |
| /* Linux-only registers. */ |
| "ret", |
| "orig_r8", |
| "pc", // stop pc |
| |
| /* Pseudo-regs. */ |
| "ilink1", |
| "ilink2", |
| "eret", |
| "status_l1", |
| "status_l2", |
| "erstatus" |
| }; |
| |
| |
| /* Mapping between the general-purpose registers in `struct sigcontext' format |
| and GDB's register cache layout. |
| |
| arc_linux_sc_reg_offset[i] is the sigcontext offset of GDB regnum `i'. */ |
| |
| /* From <asm/sigcontext.h>. */ |
| static const int arc_linux_sc_reg_offset[ARC_NR_REGS] = |
| { |
| 23 * BYTES_IN_REGISTER, /* r0 */ |
| 22 * BYTES_IN_REGISTER, /* r1 */ |
| 21 * BYTES_IN_REGISTER, /* r2 */ |
| 20 * BYTES_IN_REGISTER, /* r3 */ |
| 19 * BYTES_IN_REGISTER, /* r4 */ |
| 18 * BYTES_IN_REGISTER, /* r5 */ |
| 17 * BYTES_IN_REGISTER, /* r6 */ |
| 16 * BYTES_IN_REGISTER, /* r7 */ |
| 15 * BYTES_IN_REGISTER, /* r8 */ |
| 14 * BYTES_IN_REGISTER, /* r9 */ |
| 13 * BYTES_IN_REGISTER, /* r10 */ |
| 12 * BYTES_IN_REGISTER, /* r11 */ |
| 11 * BYTES_IN_REGISTER, /* r12 */ |
| REGISTER_NOT_PRESENT, /* r13 */ |
| REGISTER_NOT_PRESENT, /* r14 */ |
| REGISTER_NOT_PRESENT, /* r15 */ |
| REGISTER_NOT_PRESENT, /* r16 */ |
| REGISTER_NOT_PRESENT, /* r17 */ |
| REGISTER_NOT_PRESENT, /* r18 */ |
| REGISTER_NOT_PRESENT, /* r19 */ |
| REGISTER_NOT_PRESENT, /* r20 */ |
| REGISTER_NOT_PRESENT, /* r21 */ |
| REGISTER_NOT_PRESENT, /* r22 */ |
| REGISTER_NOT_PRESENT, /* r23 */ |
| REGISTER_NOT_PRESENT, /* r24 */ |
| REGISTER_NOT_PRESENT, /* r25 */ |
| 10 * BYTES_IN_REGISTER, /* r26 */ |
| 2 * BYTES_IN_REGISTER, /* bta */ |
| 3 * BYTES_IN_REGISTER, /* lp_start */ |
| 4 * BYTES_IN_REGISTER, /* lp_end */ |
| 5 * BYTES_IN_REGISTER, /* lp_count */ |
| 6 * BYTES_IN_REGISTER, /* status32 */ |
| 8 * BYTES_IN_REGISTER, /* blink */ |
| 9 * BYTES_IN_REGISTER, /* fp */ |
| 1 * BYTES_IN_REGISTER, /* sp */ |
| REGISTER_NOT_PRESENT, /* efa */ |
| 7 * BYTES_IN_REGISTER, /* ret */ |
| REGISTER_NOT_PRESENT, /* orig_r8 */ |
| REGISTER_NOT_PRESENT /* stop_pc */ |
| }; |
| |
| |
| /* arcompact_linux_core_reg_offsets[i] is the offset in the .reg section of GDB regnum i. |
| From include/asm-arc/user.h in the ARC Linux sources. */ |
| |
| static const int arcompact_linux_core_reg_offsets[ARC_NR_REGS] = |
| { |
| 22 * BYTES_IN_REGISTER, /* r0 */ |
| 21 * BYTES_IN_REGISTER, /* r1 */ |
| 20 * BYTES_IN_REGISTER, /* r2 */ |
| 19 * BYTES_IN_REGISTER, /* r3 */ |
| 18 * BYTES_IN_REGISTER, /* r4 */ |
| 17 * BYTES_IN_REGISTER, /* r5 */ |
| 16 * BYTES_IN_REGISTER, /* r6 */ |
| 15 * BYTES_IN_REGISTER, /* r7 */ |
| 14 * BYTES_IN_REGISTER, /* r8 */ |
| 13 * BYTES_IN_REGISTER, /* r9 */ |
| 12 * BYTES_IN_REGISTER, /* r10 */ |
| 11 * BYTES_IN_REGISTER, /* r11 */ |
| 10 * BYTES_IN_REGISTER, /* r12 */ |
| 39 * BYTES_IN_REGISTER, /* r13 */ |
| 38 * BYTES_IN_REGISTER, /* r14 */ |
| 37 * BYTES_IN_REGISTER, /* r15 */ |
| 36 * BYTES_IN_REGISTER, /* r16 */ |
| 35 * BYTES_IN_REGISTER, /* r17 */ |
| 34 * BYTES_IN_REGISTER, /* r18 */ |
| 33 * BYTES_IN_REGISTER, /* r19 */ |
| 32 * BYTES_IN_REGISTER, /* r20 */ |
| 31 * BYTES_IN_REGISTER, /* r21 */ |
| 30 * BYTES_IN_REGISTER, /* r22 */ |
| 29 * BYTES_IN_REGISTER, /* r23 */ |
| 28 * BYTES_IN_REGISTER, /* r24 */ |
| 27 * BYTES_IN_REGISTER, /* r25 */ |
| 9 * BYTES_IN_REGISTER, /* r26 */ |
| 1 * BYTES_IN_REGISTER, /* bta */ |
| 2 * BYTES_IN_REGISTER, /* lp_start */ |
| 3 * BYTES_IN_REGISTER, /* lp_end */ |
| 4 * BYTES_IN_REGISTER, /* lp_count */ |
| 5 * BYTES_IN_REGISTER, /* status32 */ |
| 7 * BYTES_IN_REGISTER, /* blink */ |
| 8 * BYTES_IN_REGISTER, /* fp */ |
| 25 * BYTES_IN_REGISTER, /* sp */ |
| REGISTER_NOT_PRESENT, /* efa */ |
| 6 * BYTES_IN_REGISTER, /* ret */ |
| 24 * BYTES_IN_REGISTER, /* orig_r8 */ |
| 40 * BYTES_IN_REGISTER, /* stop_pc */ |
| }; |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* forward declarations */ |
| /* -------------------------------------------------------------------------- */ |
| |
| static int arc_linux_binutils_reg_to_regnum (struct gdbarch *gdbarch, int reg); |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* local macros */ |
| /* -------------------------------------------------------------------------- */ |
| |
| #define PRINT(regnum) \ |
| default_print_registers_info (gdbarch, file, frame, regnum, all) |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* local functions */ |
| /* -------------------------------------------------------------------------- */ |
| |
| /* Returns TRUE if the instruction at PC is a branch (of any kind). |
| *fall_thru is set to the address of the next insn. |
| *target is set to the branch target. */ |
| |
| static Boolean |
| next_pc (CORE_ADDR pc, CORE_ADDR *fall_thru, CORE_ADDR *target) |
| { |
| struct regcache *regcache = get_current_regcache(); |
| struct disassemble_info di; |
| struct arcDisState instr; |
| Boolean two_targets = FALSE; |
| |
| arc_initialize_disassembler(&di); |
| |
| /* So what is the instruction at the given PC? */ |
| instr = arcAnalyzeInstr(pc, &di); |
| |
| /* By default, the next instruction is the one immediately after the one at PC. */ |
| *fall_thru = pc + instr.instructionLen; |
| |
| DEBUG("--- next_pc(%x) = %x, isBranch = %d, tcnt = %d [%x], flow = %s (%d), " |
| "reg for indirect jump = %d, nullifyMode = %s\n", |
| (unsigned int) pc, (unsigned int) *fall_thru, instr.isBranch, instr.tcnt, instr.targets[0], |
| (instr.flow == direct_jump || instr.flow == direct_call) ? "direct" : "indirect", |
| instr.flow, |
| instr.register_for_indirect_jump, |
| ((instr.nullifyMode == (char) BR_exec_always) ? "delay slot" : "no delay")); |
| |
| /* OK, it's a branch. */ |
| if ((Boolean) instr.isBranch) |
| { |
| two_targets = TRUE; |
| |
| /* If it's a direct jump or call, the destination address is encoded in |
| the instruction, so we got it by disassembling the instruction; |
| otherwise, it's an indirect jump to the address held in the register |
| named in the instruction, so we must read that register. */ |
| if (instr.flow == direct_jump || instr.flow == direct_call) |
| *target = (CORE_ADDR) instr.targets[0]; |
| else |
| regcache_cooked_read(regcache, |
| arc_linux_binutils_reg_to_regnum(current_gdbarch, |
| instr.register_for_indirect_jump), |
| (gdb_byte*) target); |
| |
| /* For instructions with delay slots, the fall thru is not the instruction |
| immediately after the branch instruction, but the one after that. */ |
| if (instr.nullifyMode == (char) BR_exec_always) |
| { |
| struct arcDisState instr_d = arcAnalyzeInstr(*fall_thru, &di); |
| |
| *fall_thru += instr_d.instructionLen; |
| } |
| } |
| |
| |
| /* Check for a zero-overhead loop. */ |
| { |
| unsigned int lp_end, lp_start, lp_count, status32; |
| |
| regcache_cooked_read(regcache, ARC_LP_START_REGNUM, (gdb_byte*) &lp_start); |
| regcache_cooked_read(regcache, ARC_LP_END_REGNUM, (gdb_byte*) &lp_end); |
| regcache_cooked_read(regcache, ARC_LP_COUNT_REGNUM, (gdb_byte*) &lp_count); |
| regcache_cooked_read(regcache, ARC_STATUS32_REGNUM, (gdb_byte*) &status32); |
| |
| if (!(status32 & STATUS32_L) && *fall_thru == lp_end && lp_count > 1) |
| { |
| /* The instruction is in effect a jump back to the start of the loop. */ |
| two_targets = TRUE; |
| *target = lp_start; |
| } |
| } |
| |
| return two_targets; |
| } |
| |
| |
| /* Extract the register values found in the ABI GREGSET, storing their values in |
| regcache. */ |
| |
| static void |
| arcompact_linux_supply_gregset (struct regcache *regcache, |
| int regnum, |
| const void *gregs, |
| size_t size) |
| { |
| const bfd_byte *buf = gregs; |
| unsigned int reg; |
| |
| for (reg = 0; reg < ELEMENTS_IN_ARRAY(arcompact_linux_core_reg_offsets); reg++) |
| { |
| if (arcompact_linux_core_reg_offsets[reg] != REGISTER_NOT_PRESENT) |
| regcache_raw_supply (regcache, |
| (int) reg, |
| buf + arcompact_linux_core_reg_offsets[reg]); |
| } |
| } |
| |
| |
| /* Return whether the frame preceding next_frame corresponds to a GNU/Linux |
| sigtramp routine. */ |
| |
| static Boolean |
| is_linux_sigtramp (struct frame_info *next_frame) |
| { |
| /* Find the PC for that previous frame. */ |
| CORE_ADDR pc = frame_pc_unwind (next_frame); |
| gdb_byte buf[SIGTRAMP_INSNS_LENGTH]; |
| |
| /* Read the memory at that PC (this gives us the code without any s/w |
| breakpoints that may have been set in it). */ |
| if (!safe_frame_unwind_memory (next_frame, pc, buf, (int) SIGTRAMP_INSNS_LENGTH)) |
| /* Failed to unwind frame. */ |
| return FALSE; |
| |
| /* Is that code the sigtramp instruction sequence? */ |
| if (memcmp(buf, arc_sigtramp_insns, SIGTRAMP_INSNS_LENGTH) == 0) |
| return TRUE; |
| |
| /* No - look one instruction earlier in the code. */ |
| if (!safe_frame_unwind_memory (next_frame, pc - 4, buf, (int) SIGTRAMP_INSNS_LENGTH)) |
| /* Failed to unwind frame. */ |
| return FALSE; |
| |
| if (memcmp(buf, arc_sigtramp_insns, SIGTRAMP_INSNS_LENGTH) == 0) |
| return TRUE; |
| |
| return FALSE; |
| } |
| |
| |
| /* Assuming next_frame is a frame following a GNU/Linux sigtramp |
| routine, return the address of the associated sigcontext structure. */ |
| |
| static CORE_ADDR |
| linux_sigcontext_addr (struct frame_info *next_frame) |
| { |
| gdb_byte buf[4]; |
| |
| frame_unwind_register (next_frame, ARC_SP_REGNUM, buf); |
| |
| return (CORE_ADDR) extract_unsigned_integer (buf, 4); |
| } |
| |
| |
| /* Determine whether the given register is a member of the given group. |
| |
| Returns 0, 1, or -1: |
| 0 means the register is not in the group. |
| 1 means the register is in the group. |
| -1 means the tdep has nothing to say about this register and group. */ |
| |
| static int |
| register_reggroup_p (int regnum, struct reggroup *group) |
| { |
| if (system_reggroup) |
| { |
| if (regnum == ARC_ORIG_R8_REGNUM || |
| regnum == ARC_EFA_REGNUM || |
| regnum == ARC_ERET_REGNUM || |
| regnum == ARC_ERSTATUS_REGNUM) |
| return 1; |
| } |
| else if (group == general_reggroup) |
| { |
| if (regnum == ARC_RET_REGNUM) |
| return 0; |
| |
| return (regnum == ARC_STATUS32_REGNUM) ? 0 : 1; |
| } |
| |
| /* Let the caller sort it out! */ |
| return -1; |
| } |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* local functions called from gdb */ |
| /* -------------------------------------------------------------------------- */ |
| |
| /* The Linux kernel stores only one of (ilink1, ilink2, eret). This is stored |
| in the ret "register". ilink1 is stored when the kernel has been entered |
| because of a level 1 interrupt, etc. |
| |
| Same story for (status_l1, status_l2, erstatus). |
| |
| This disambiguity has been fixed by adding orig_r8 to pt_regs. |
| |
| FIXME: what is pt_regs???? |
| |
| It will take the following values - |
| 1. if an exception of any kind occurs then orig_r8 >= 0 |
| 2. Interrupt level 1 : orig == -1 |
| 3. Interrupt level 2 : orig == -2 |
| |
| Registers whose value we don't know are given the value zero. |
| |
| The only pseudo-registers are: |
| |
| ARC_ILINK1_REGNUM |
| ARC_ILINK2_REGNUM |
| ARC_ERET_REGNUM |
| ARC_STATUS32_L1_REGNUM |
| ARC_STATUS32_L2_REGNUM |
| ARC_ERSTATUS_REGNUM |
| */ |
| |
| static void |
| arc_linux_pseudo_register_read (struct gdbarch *gdbarch, |
| struct regcache *regcache, |
| int gdb_regno, |
| gdb_byte *buf) |
| { |
| unsigned int* contents = (unsigned int *) buf; |
| unsigned int status32, ret; |
| int orig_r8; |
| |
| regcache_cooked_read (regcache, ARC_ORIG_R8_REGNUM, (gdb_byte*) &orig_r8); |
| |
| if (gdb_regno == ARC_ILINK1_REGNUM || |
| gdb_regno == ARC_ILINK2_REGNUM || |
| gdb_regno == ARC_ERET_REGNUM) |
| { |
| regcache_cooked_read (regcache, ARC_RET_REGNUM, (gdb_byte*) &ret); |
| |
| if (gdb_regno == ARC_ILINK1_REGNUM) |
| *contents = ((orig_r8 == -1) ? ret : 0); |
| else if (gdb_regno == ARC_ILINK2_REGNUM) |
| *contents = ((orig_r8 == -2) ? ret : 0); |
| else // (gdb_regno == ARC_ERET_REGNUM) |
| *contents = ((orig_r8 >= 0) ? ret : 0); |
| |
| } |
| else if (gdb_regno == ARC_STATUS32_L1_REGNUM || |
| gdb_regno == ARC_STATUS32_L2_REGNUM || |
| gdb_regno == ARC_ERSTATUS_REGNUM) |
| { |
| regcache_cooked_read (regcache, ARC_STATUS32_REGNUM, (gdb_byte*) &status32); |
| |
| if (gdb_regno == ARC_STATUS32_L1_REGNUM) |
| *contents = ((orig_r8 == -1) ? status32 : 0); |
| else if (gdb_regno == ARC_STATUS32_L2_REGNUM) |
| *contents = ((orig_r8 == -2) ? status32 : 0); |
| else // (gdb_regno == ARC_ERSTATUS_REGNUM) |
| *contents = ((orig_r8 >= 0) ? status32 : 0); |
| } |
| else |
| internal_error(__FILE__, __LINE__, _("%s: bad pseudo register number (%d)"), __FUNCTION__, gdb_regno); |
| } |
| |
| |
| static void |
| arc_linux_pseudo_register_write (struct gdbarch *gdbarch, |
| struct regcache *regcache, |
| int gdb_regno, |
| const gdb_byte *buf) |
| { |
| /* None of our pseudo-regs are writable. */ |
| internal_error(__FILE__, __LINE__, _("%s: pseudo-registers are unwritable"), __FUNCTION__); |
| } |
| |
| |
| /* Mapping from binutils/gcc register number to GDB register number ("regnum"). |
| N.B. registers such as ARC_FP_REGNUM, ARC_SP_REGNUM, etc., actually have |
| different GDB register numbers in the arc-elf32 and arc-linux-uclibc |
| configurations of the ARC gdb. */ |
| |
| static int |
| arc_linux_binutils_reg_to_regnum (struct gdbarch *gdbarch, int reg) |
| { |
| /* From gcc/config/arc/arc.h header file. */ |
| |
| if (reg >= 0 && reg <= 26) |
| return reg; |
| else if (reg == ARC_ABI_FRAME_POINTER) /* fp */ |
| return ARC_FP_REGNUM; |
| else if (reg == ARC_ABI_STACK_POINTER) /* sp */ |
| return ARC_SP_REGNUM; |
| else if (reg == 29) /* ilink1 */ |
| return ARC_ILINK1_REGNUM; |
| else if (reg == 30) /* ilink2 */ |
| return ARC_ILINK2_REGNUM; |
| else if (reg == 31) /* blink */ |
| return ARC_BLINK_REGNUM; |
| else if (IS_EXTENSION_CORE_REGISTER(reg)) /* reserved */ |
| ; |
| else if (reg == 60) /* lp_count */ |
| return ARC_LP_COUNT_REGNUM; |
| #if 0 |
| else if (reg == 61) /* reserved */ |
| ; |
| else if (reg == 62) /* no such register */ |
| ; |
| else if (reg == 63) /* PCL */ |
| ; |
| #endif |
| |
| warning(_("unmapped register #%d encountered"), reg); |
| return -1; |
| } |
| |
| |
| /* Print the contents of one, some or all registers. |
| |
| Print registers in the correct order. |
| Why not have the regnums in the right order in the first place? |
| Because some of the registers have to be pseudo-registers because of |
| the way the kernel is written, and because gdb assumes that |
| pseudo-registers have regnums greater than real register regnums. */ |
| |
| static void |
| arc_linux_print_registers_info (struct gdbarch *gdbarch, |
| struct ui_file *file, |
| struct frame_info *frame, |
| int regnum, |
| int all) |
| { |
| if (regnum >= 0) |
| PRINT (regnum); |
| else /* If regnum < 0, print all registers. */ |
| { |
| int i; |
| |
| /* R0 .. R26 */ |
| for (i = 0; i <= 26; i++) PRINT (i); |
| |
| PRINT (ARC_FP_REGNUM ); |
| PRINT (ARC_SP_REGNUM ); |
| PRINT (ARC_ILINK1_REGNUM ); |
| PRINT (ARC_ILINK2_REGNUM ); |
| PRINT (ARC_BLINK_REGNUM ); |
| PRINT (ARC_LP_COUNT_REGNUM ); |
| |
| /* Now the auxiliary registers. */ |
| |
| PRINT (ARC_BTA_REGNUM ); |
| PRINT (ARC_LP_START_REGNUM ); |
| PRINT (ARC_LP_END_REGNUM ); |
| PRINT (ARC_EFA_REGNUM ); |
| PRINT (ARC_ERET_REGNUM ); |
| PRINT (ARC_STATUS32_L1_REGNUM); |
| PRINT (ARC_STATUS32_L2_REGNUM); |
| PRINT (ARC_ERSTATUS_REGNUM ); |
| |
| /* Show the PC. */ |
| PRINT (ARC_STOP_PC_REGNUM ); |
| } |
| } |
| |
| |
| /* Return the name of the given register. */ |
| |
| static const char* |
| arc_linux_register_name (struct gdbarch *gdbarch, int gdb_regno) |
| { |
| gdb_assert(ELEMENTS_IN_ARRAY(register_names) == (unsigned int) (ARC_NR_REGS + ARC_NR_PSEUDO_REGS)); |
| |
| /* Oh, for a proper language with array bounds checking, like Ada... */ |
| gdb_assert(0 <= gdb_regno && gdb_regno < (int) ELEMENTS_IN_ARRAY(register_names)); |
| |
| return register_names[gdb_regno]; |
| } |
| |
| |
| /* Determine whether the given register is read-only. */ |
| |
| static int |
| arc_linux_cannot_store_register (struct gdbarch *gdbarch, int gdb_regno) |
| { |
| if (gdb_regno == ARC_EFA_REGNUM || |
| gdb_regno == ARC_ERET_REGNUM || |
| gdb_regno == ARC_STATUS32_L1_REGNUM || |
| gdb_regno == ARC_STATUS32_L2_REGNUM || |
| gdb_regno == ARC_ERSTATUS_REGNUM || |
| gdb_regno == ARC_ILINK1_REGNUM || |
| gdb_regno == ARC_ILINK2_REGNUM) |
| { |
| /* No warning should be printed. arc_cannot_store_register being |
| called does not imply that someone is actually writing to regnum. */ |
| |
| /* warning(_("writing to read-only register: %s"), gdbarch_register_name(gdbarch, gdb_regno)); */ |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| |
| /* This function is called just before we resume executing the inferior, if we |
| want to single-step it. We find the target(s) of the instruction about to |
| be executed and and place breakpoints there. */ |
| |
| static int |
| arc_linux_software_single_step (struct frame_info *frame) |
| { |
| CORE_ADDR fall_thru, branch_target; |
| CORE_ADDR pc = get_frame_pc(frame); |
| Boolean two_breakpoints = next_pc(pc, &fall_thru, &branch_target); |
| |
| insert_single_step_breakpoint (fall_thru); |
| |
| if (two_breakpoints) |
| { |
| if (pc != branch_target) |
| insert_single_step_breakpoint (branch_target); |
| } |
| |
| /* Always returns true for now. */ |
| return 1; |
| } |
| |
| |
| /* Set the program counter for process PTID to PC. */ |
| |
| static void |
| arc_linux_write_pc (struct regcache *regcache, CORE_ADDR pc) |
| { |
| regcache_cooked_write_unsigned (regcache, ARC_PC_REGNUM, pc); |
| |
| /* We must be careful with modifying the program counter. If we |
| just interrupted a system call, the kernel might try to restart |
| it when we resume the inferior. On restarting the system call, |
| the kernel will try backing up the program counter even though it |
| no longer points at the system call. This typically results in a |
| SIGSEGV or SIGILL. We can prevent this by writing `-1' in the |
| "orig_r8" pseudo-register. |
| |
| Note that "orig_r8" is saved when setting up a dummy call frame. |
| This means that it is properly restored when that frame is |
| popped, and that the interrupted system call will be restarted |
| when we resume the inferior on return from a function call from |
| within GDB. In all other cases the system call will not be |
| restarted. */ |
| |
| // FIXME: why -3 and not -1? -3 does not appear to be a defined valued for |
| // orig_r8 (i.e. -2, -1 or >= 0) - perhaps it means "none of these"? |
| regcache_cooked_write_signed (regcache, ARC_ORIG_R8_REGNUM, -3); |
| } |
| |
| |
| /* See the comments for SKIP_SOLIB_RESOLVER at the top of infrun.c. |
| |
| This is called on every single step through the PLT and runtime resolver. |
| |
| This function: |
| 1) decides whether a PLT has sent us into the linker to resolve |
| a function reference, and |
| 2) if so, tells us where to set a temporary breakpoint that will |
| trigger when the dynamic linker is done. */ |
| |
| static CORE_ADDR |
| arc_linux_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc) |
| { |
| /* For uClibc 0.9.26. |
| |
| An unresolved PLT entry points to "__dl_linux_resolve", which calls |
| "__dl_linux_resolver" to do the resolving and then eventually jumps to |
| the function. |
| |
| So we look for the symbol `_dl_linux_resolver', and if we are there, |
| gdb sets a breakpoint at the return address, and continues. */ |
| |
| /* Lookup_minimal_symbol didn't work, for some reason. */ |
| struct symbol *resolver = |
| lookup_symbol_global ("_dl_linux_resolver", 0, 0, VAR_DOMAIN, 0); |
| |
| DEBUG((resolver == NULL) ? "--- %s : pc = %x, no resolver found" |
| : "--- %s : pc = %x, resolver at %x\n", |
| __FUNCTION__, |
| (unsigned int) pc, |
| (unsigned int) ((resolver == NULL) ? 0 : BLOCK_START (SYMBOL_BLOCK_VALUE (resolver)))); |
| |
| if ((resolver != NULL) && (BLOCK_START (SYMBOL_BLOCK_VALUE (resolver))) == pc) |
| /* Find the return address. */ |
| return frame_pc_unwind (get_current_frame ()); |
| |
| /* No breakpoint is required. */ |
| return 0; |
| } |
| |
| |
| /* Call the right architecture variant's supply_gregset function. For now, we |
| have only ARCompact. */ |
| |
| static void |
| arc_linux_supply_gregset (const struct regset *regset, |
| struct regcache *regcache, |
| int regnum, |
| const void *gregs, |
| size_t size) |
| { |
| arcompact_linux_supply_gregset (regcache, regnum, gregs, size); |
| } |
| |
| |
| /* Functions for handling core files. |
| The first element is a parameter to pass the rest of the functions. We |
| don't need it. |
| supply_gregset is for reading the core file. |
| collect_regset, which we haven't defined, would be for writing the core |
| file. */ |
| |
| static const struct regset * |
| arc_linux_regset_from_core_section (struct gdbarch *core_arch, |
| const char *sect_name, |
| size_t sect_size) |
| { |
| static const struct regset arc_linux_gregset = |
| { |
| NULL, // descr |
| arc_linux_supply_gregset, // supply_regset |
| NULL, // collect_regset |
| NULL // arch |
| }; |
| |
| if (strcmp (sect_name, ".reg") == 0) |
| return &arc_linux_gregset; |
| |
| return NULL; |
| } |
| |
| |
| /* Initialize for this ABI. */ |
| |
| static void |
| arc_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) |
| { |
| struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); |
| |
| /* Fill in target-dependent info in ARC-private structure. */ |
| |
| tdep->is_sigtramp = is_linux_sigtramp; |
| tdep->sigcontext_addr = linux_sigcontext_addr; |
| tdep->sc_reg_offset = arc_linux_sc_reg_offset; |
| tdep->sc_num_regs = ELEMENTS_IN_ARRAY(arc_linux_sc_reg_offset); |
| tdep->pc_regnum_in_sigcontext = ARC_RET_REGNUM; |
| |
| tdep->le_breakpoint_instruction = le_breakpoint_instruction; |
| tdep->be_breakpoint_instruction = be_breakpoint_instruction; |
| tdep->breakpoint_size = (unsigned int) sizeof(le_breakpoint_instruction); |
| |
| tdep->register_reggroup_p = register_reggroup_p; |
| |
| tdep->lowest_pc = 0x74; // FIXME: why this? |
| tdep->processor_variant_info = NULL; |
| |
| /* Pass target-dependent info to gdb. */ |
| |
| /* ARC_NR_REGS and ARC_NR_PSEUDO_REGS are defined in the tm.h configuration file. */ |
| set_gdbarch_pc_regnum (gdbarch, ARC_STOP_PC_REGNUM); |
| set_gdbarch_num_regs (gdbarch, ARC_NR_REGS); |
| set_gdbarch_num_pseudo_regs (gdbarch, ARC_NR_PSEUDO_REGS); |
| set_gdbarch_print_registers_info (gdbarch, arc_linux_print_registers_info); |
| set_gdbarch_register_name (gdbarch, arc_linux_register_name); |
| set_gdbarch_cannot_store_register (gdbarch, arc_linux_cannot_store_register); |
| set_gdbarch_dwarf2_reg_to_regnum (gdbarch, arc_linux_binutils_reg_to_regnum); |
| |
| set_gdbarch_decr_pc_after_break (gdbarch, 0); |
| set_gdbarch_software_single_step (gdbarch, arc_linux_software_single_step); |
| set_gdbarch_write_pc (gdbarch, arc_linux_write_pc); |
| set_gdbarch_pseudo_register_read (gdbarch, arc_linux_pseudo_register_read); |
| set_gdbarch_pseudo_register_write (gdbarch, arc_linux_pseudo_register_write); |
| set_gdbarch_regset_from_core_section (gdbarch, arc_linux_regset_from_core_section); |
| set_gdbarch_skip_solib_resolver (gdbarch, arc_linux_skip_solib_resolver); |
| |
| /* GNU/Linux uses SVR4-style shared libraries. */ |
| set_solib_svr4_fetch_link_map_offsets (gdbarch, svr4_ilp32_fetch_link_map_offsets); |
| } |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* externally visible functions */ |
| /* -------------------------------------------------------------------------- */ |
| |
| /* Initialize the module. This function is called from the gdb core on start-up. */ |
| |
| void |
| _initialize_arc_linux_tdep (void) |
| { |
| /* Register a handler with gdb for the Linux O/S ABI variant for the ARC |
| processor architecture, providing an initialization function; |
| 'bfd_arch_arc' is an enumeration value specifically denoting the ARC |
| architecture. */ |
| gdbarch_register_osabi (bfd_arch_arc, |
| 0, // machine (irrelevant) |
| GDB_OSABI_LINUX, |
| arc_linux_init_abi); |
| } |
| |
| |
| /* This function is required simply to avoid an undefined symbol at linkage. */ |
| |
| void |
| arc_check_pc_defined (struct gdbarch *gdbarch) |
| { |
| } |
| |
| /******************************************************************************/ |
