X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Farm-linux-nat.c;h=84aaaf6b4e897fea8bc6dc539afa73df9357a6b7;hb=ec948987302c988cdde4811c4f04809c8fa0b7a5;hp=52d6c64b4f60ae5e7843aa9dc47dc7ab3c41c958;hpb=c215244117f848e06f0e10be5fc4514fdb954a0d;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/arm-linux-nat.c b/gdb/arm-linux-nat.c index 52d6c64b4f..84aaaf6b4e 100644 --- a/gdb/arm-linux-nat.c +++ b/gdb/arm-linux-nat.c @@ -1,5 +1,6 @@ /* GNU/Linux on ARM native support. - Copyright 1999, 2000, 2001 Free Software Foundation, Inc. + Copyright 1999, 2000, 2001, 2002, 2004, 2005 + Free Software Foundation, Inc. This file is part of GDB. @@ -23,6 +24,10 @@ #include "gdbcore.h" #include "gdb_string.h" #include "regcache.h" +#include "target.h" +#include "linux-nat.h" + +#include "arm-tdep.h" #include #include @@ -39,7 +44,7 @@ extern int arm_apcs_32; #define typeDouble 0x02 #define typeExtended 0x03 #define FPWORDS 28 -#define CPSR_REGNUM 16 +#define ARM_CPSR_REGNUM 16 typedef union tagFPREG { @@ -61,9 +66,9 @@ typedef struct tagFPA11 FPA11; /* The following variables are used to determine the version of the - underlying Linux operating system. Examples: + underlying GNU/Linux operating system. Examples: - Linux 2.0.35 Linux 2.2.12 + GNU/Linux 2.0.35 GNU/Linux 2.2.12 os_version = 0x00020023 os_version = 0x0002020c os_major = 2 os_major = 2 os_minor = 0 os_minor = 2 @@ -76,11 +81,11 @@ FPA11; static unsigned int os_version, os_major, os_minor, os_release; -/* On Linux, threads are implemented as pseudo-processes, in which +/* On GNU/Linux, threads are implemented as pseudo-processes, in which case we may be tracing more than one process at a time. In that case, inferior_ptid will contain the main process ID and the - individual thread (process) ID. get_thread_id () is used to - get the thread id if it's available, and the process id otherwise. */ + individual thread (process) ID. get_thread_id () is used to get + the thread id if it's available, and the process id otherwise. */ int get_thread_id (ptid_t ptid) @@ -100,7 +105,7 @@ fetch_nwfpe_single (unsigned int fn, FPA11 * fpa11) mem[0] = fpa11->fpreg[fn].fSingle; mem[1] = 0; mem[2] = 0; - supply_register (F0_REGNUM + fn, (char *) &mem[0]); + regcache_raw_supply (current_regcache, ARM_F0_REGNUM + fn, (char *) &mem[0]); } static void @@ -111,7 +116,7 @@ fetch_nwfpe_double (unsigned int fn, FPA11 * fpa11) mem[0] = fpa11->fpreg[fn].fDouble[1]; mem[1] = fpa11->fpreg[fn].fDouble[0]; mem[2] = 0; - supply_register (F0_REGNUM + fn, (char *) &mem[0]); + regcache_raw_supply (current_regcache, ARM_F0_REGNUM + fn, (char *) &mem[0]); } static void @@ -120,7 +125,7 @@ fetch_nwfpe_none (unsigned int fn) unsigned int mem[3] = {0, 0, 0}; - supply_register (F0_REGNUM + fn, (char *) &mem[0]); + regcache_raw_supply (current_regcache, ARM_F0_REGNUM + fn, (char *) &mem[0]); } static void @@ -131,13 +136,13 @@ fetch_nwfpe_extended (unsigned int fn, FPA11 * fpa11) mem[0] = fpa11->fpreg[fn].fExtended[0]; /* sign & exponent */ mem[1] = fpa11->fpreg[fn].fExtended[2]; /* ls bits */ mem[2] = fpa11->fpreg[fn].fExtended[1]; /* ms bits */ - supply_register (F0_REGNUM + fn, (char *) &mem[0]); + regcache_raw_supply (current_regcache, ARM_F0_REGNUM + fn, (char *) &mem[0]); } static void fetch_nwfpe_register (int regno, FPA11 * fpa11) { - int fn = regno - F0_REGNUM; + int fn = regno - ARM_F0_REGNUM; switch (fpa11->fType[fn]) { @@ -159,32 +164,35 @@ fetch_nwfpe_register (int regno, FPA11 * fpa11) } static void -store_nwfpe_single (unsigned int fn, FPA11 * fpa11) +store_nwfpe_single (unsigned int fn, FPA11 *fpa11) { unsigned int mem[3]; - read_register_gen (F0_REGNUM + fn, (char *) &mem[0]); + regcache_raw_collect (current_regcache, ARM_F0_REGNUM + fn, + (char *) &mem[0]); fpa11->fpreg[fn].fSingle = mem[0]; fpa11->fType[fn] = typeSingle; } static void -store_nwfpe_double (unsigned int fn, FPA11 * fpa11) +store_nwfpe_double (unsigned int fn, FPA11 *fpa11) { unsigned int mem[3]; - read_register_gen (F0_REGNUM + fn, (char *) &mem[0]); + regcache_raw_collect (current_regcache, ARM_F0_REGNUM + fn, + (char *) &mem[0]); fpa11->fpreg[fn].fDouble[1] = mem[0]; fpa11->fpreg[fn].fDouble[0] = mem[1]; fpa11->fType[fn] = typeDouble; } void -store_nwfpe_extended (unsigned int fn, FPA11 * fpa11) +store_nwfpe_extended (unsigned int fn, FPA11 *fpa11) { unsigned int mem[3]; - read_register_gen (F0_REGNUM + fn, (char *) &mem[0]); + regcache_raw_collect (current_regcache, ARM_F0_REGNUM + fn, + (char *) &mem[0]); fpa11->fpreg[fn].fExtended[0] = mem[0]; /* sign & exponent */ fpa11->fpreg[fn].fExtended[2] = mem[1]; /* ls bits */ fpa11->fpreg[fn].fExtended[1] = mem[2]; /* ms bits */ @@ -194,9 +202,9 @@ store_nwfpe_extended (unsigned int fn, FPA11 * fpa11) void store_nwfpe_register (int regno, FPA11 * fpa11) { - if (register_valid[regno]) + if (register_cached (regno)) { - unsigned int fn = regno - F0_REGNUM; + unsigned int fn = regno - ARM_F0_REGNUM; switch (fpa11->fType[fn]) { case typeSingle: @@ -216,7 +224,7 @@ store_nwfpe_register (int regno, FPA11 * fpa11) /* Get the value of a particular register from the floating point - state of the process and store it into registers[]. */ + state of the process and store it into regcache. */ static void fetch_fpregister (int regno) @@ -231,18 +239,18 @@ fetch_fpregister (int regno) ret = ptrace (PT_GETFPREGS, tid, 0, &fp); if (ret < 0) { - warning ("Unable to fetch floating point register."); + warning (_("Unable to fetch floating point register.")); return; } /* Fetch fpsr. */ - if (FPS_REGNUM == regno) - supply_register (FPS_REGNUM, (char *) &fp.fpsr); + if (ARM_FPS_REGNUM == regno) + regcache_raw_supply (current_regcache, ARM_FPS_REGNUM, (char *) &fp.fpsr); /* Fetch the floating point register. */ - if (regno >= F0_REGNUM && regno <= F7_REGNUM) + if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM) { - int fn = regno - F0_REGNUM; + int fn = regno - ARM_F0_REGNUM; switch (fp.fType[fn]) { @@ -265,7 +273,7 @@ fetch_fpregister (int regno) } /* Get the whole floating point state of the process and store it - into registers[]. */ + into regcache. */ static void fetch_fpregs (void) @@ -280,17 +288,17 @@ fetch_fpregs (void) ret = ptrace (PT_GETFPREGS, tid, 0, &fp); if (ret < 0) { - warning ("Unable to fetch the floating point registers."); + warning (_("Unable to fetch the floating point registers.")); return; } /* Fetch fpsr. */ - supply_register (FPS_REGNUM, (char *) &fp.fpsr); + regcache_raw_supply (current_regcache, ARM_FPS_REGNUM, (char *) &fp.fpsr); /* Fetch the floating point registers. */ - for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++) + for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++) { - int fn = regno - F0_REGNUM; + int fn = regno - ARM_F0_REGNUM; switch (fp.fType[fn]) { @@ -313,7 +321,7 @@ fetch_fpregs (void) } /* Save a particular register into the floating point state of the - process using the contents from registers[]. */ + process using the contents from regcache. */ static void store_fpregister (int regno) @@ -328,16 +336,16 @@ store_fpregister (int regno) ret = ptrace (PT_GETFPREGS, tid, 0, &fp); if (ret < 0) { - warning ("Unable to fetch the floating point registers."); + warning (_("Unable to fetch the floating point registers.")); return; } /* Store fpsr. */ - if (FPS_REGNUM == regno && register_valid[FPS_REGNUM]) - read_register_gen (FPS_REGNUM, (char *) &fp.fpsr); + if (ARM_FPS_REGNUM == regno && register_cached (ARM_FPS_REGNUM)) + regcache_raw_collect (current_regcache, ARM_FPS_REGNUM, (char *) &fp.fpsr); /* Store the floating point register. */ - if (regno >= F0_REGNUM && regno <= F7_REGNUM) + if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM) { store_nwfpe_register (regno, &fp); } @@ -345,13 +353,13 @@ store_fpregister (int regno) ret = ptrace (PTRACE_SETFPREGS, tid, 0, &fp); if (ret < 0) { - warning ("Unable to store floating point register."); + warning (_("Unable to store floating point register.")); return; } } /* Save the whole floating point state of the process using - the contents from registers[]. */ + the contents from regcache. */ static void store_fpregs (void) @@ -366,16 +374,16 @@ store_fpregs (void) ret = ptrace (PT_GETFPREGS, tid, 0, &fp); if (ret < 0) { - warning ("Unable to fetch the floating point registers."); + warning (_("Unable to fetch the floating point registers.")); return; } /* Store fpsr. */ - if (register_valid[FPS_REGNUM]) - read_register_gen (FPS_REGNUM, (char *) &fp.fpsr); + if (register_cached (ARM_FPS_REGNUM)) + regcache_raw_collect (current_regcache, ARM_FPS_REGNUM, (char *) &fp.fpsr); /* Store the floating point registers. */ - for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++) + for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++) { fetch_nwfpe_register (regno, &fp); } @@ -383,13 +391,13 @@ store_fpregs (void) ret = ptrace (PTRACE_SETFPREGS, tid, 0, &fp); if (ret < 0) { - warning ("Unable to store floating point registers."); + warning (_("Unable to store floating point registers.")); return; } } /* Fetch a general register of the process and store into - registers[]. */ + regcache. */ static void fetch_register (int regno) @@ -403,30 +411,33 @@ fetch_register (int regno) ret = ptrace (PTRACE_GETREGS, tid, 0, ®s); if (ret < 0) { - warning ("Unable to fetch general register."); + warning (_("Unable to fetch general register.")); return; } - if (regno >= A1_REGNUM && regno < PC_REGNUM) - supply_register (regno, (char *) ®s[regno]); + if (regno >= ARM_A1_REGNUM && regno < ARM_PC_REGNUM) + regcache_raw_supply (current_regcache, regno, (char *) ®s[regno]); - if (PS_REGNUM == regno) + if (ARM_PS_REGNUM == regno) { if (arm_apcs_32) - supply_register (PS_REGNUM, (char *) ®s[CPSR_REGNUM]); + regcache_raw_supply (current_regcache, ARM_PS_REGNUM, + (char *) ®s[ARM_CPSR_REGNUM]); else - supply_register (PS_REGNUM, (char *) ®s[PC_REGNUM]); + regcache_raw_supply (current_regcache, ARM_PS_REGNUM, + (char *) ®s[ARM_PC_REGNUM]); } - if (PC_REGNUM == regno) + if (ARM_PC_REGNUM == regno) { - regs[PC_REGNUM] = ADDR_BITS_REMOVE (regs[PC_REGNUM]); - supply_register (PC_REGNUM, (char *) ®s[PC_REGNUM]); + regs[ARM_PC_REGNUM] = ADDR_BITS_REMOVE (regs[ARM_PC_REGNUM]); + regcache_raw_supply (current_regcache, ARM_PC_REGNUM, + (char *) ®s[ARM_PC_REGNUM]); } } /* Fetch all general registers of the process and store into - registers[]. */ + regcache. */ static void fetch_regs (void) @@ -440,24 +451,27 @@ fetch_regs (void) ret = ptrace (PTRACE_GETREGS, tid, 0, ®s); if (ret < 0) { - warning ("Unable to fetch general registers."); + warning (_("Unable to fetch general registers.")); return; } - for (regno = A1_REGNUM; regno < PC_REGNUM; regno++) - supply_register (regno, (char *) ®s[regno]); + for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++) + regcache_raw_supply (current_regcache, regno, (char *) ®s[regno]); if (arm_apcs_32) - supply_register (PS_REGNUM, (char *) ®s[CPSR_REGNUM]); + regcache_raw_supply (current_regcache, ARM_PS_REGNUM, + (char *) ®s[ARM_CPSR_REGNUM]); else - supply_register (PS_REGNUM, (char *) ®s[PC_REGNUM]); + regcache_raw_supply (current_regcache, ARM_PS_REGNUM, + (char *) ®s[ARM_PC_REGNUM]); - regs[PC_REGNUM] = ADDR_BITS_REMOVE (regs[PC_REGNUM]); - supply_register (PC_REGNUM, (char *) ®s[PC_REGNUM]); + regs[ARM_PC_REGNUM] = ADDR_BITS_REMOVE (regs[ARM_PC_REGNUM]); + regcache_raw_supply (current_regcache, ARM_PC_REGNUM, + (char *) ®s[ARM_PC_REGNUM]); } /* Store all general registers of the process from the values in - registers[]. */ + regcache. */ static void store_register (int regno) @@ -465,7 +479,7 @@ store_register (int regno) int ret, tid; elf_gregset_t regs; - if (!register_valid[regno]) + if (!register_cached (regno)) return; /* Get the thread id for the ptrace call. */ @@ -475,17 +489,23 @@ store_register (int regno) ret = ptrace (PTRACE_GETREGS, tid, 0, ®s); if (ret < 0) { - warning ("Unable to fetch general registers."); + warning (_("Unable to fetch general registers.")); return; } - if (regno >= A1_REGNUM && regno <= PC_REGNUM) - read_register_gen (regno, (char *) ®s[regno]); + if (regno >= ARM_A1_REGNUM && regno <= ARM_PC_REGNUM) + regcache_raw_collect (current_regcache, regno, (char *) ®s[regno]); + else if (arm_apcs_32 && regno == ARM_PS_REGNUM) + regcache_raw_collect (current_regcache, regno, + (char *) ®s[ARM_CPSR_REGNUM]); + else if (!arm_apcs_32 && regno == ARM_PS_REGNUM) + regcache_raw_collect (current_regcache, ARM_PC_REGNUM, + (char *) ®s[ARM_PC_REGNUM]); ret = ptrace (PTRACE_SETREGS, tid, 0, ®s); if (ret < 0) { - warning ("Unable to store general register."); + warning (_("Unable to store general register.")); return; } } @@ -503,21 +523,25 @@ store_regs (void) ret = ptrace (PTRACE_GETREGS, tid, 0, ®s); if (ret < 0) { - warning ("Unable to fetch general registers."); + warning (_("Unable to fetch general registers.")); return; } - for (regno = A1_REGNUM; regno <= PC_REGNUM; regno++) + for (regno = ARM_A1_REGNUM; regno <= ARM_PC_REGNUM; regno++) { - if (register_valid[regno]) - read_register_gen (regno, (char *) ®s[regno]); + if (register_cached (regno)) + regcache_raw_collect (current_regcache, regno, (char *) ®s[regno]); } + if (arm_apcs_32 && register_cached (ARM_PS_REGNUM)) + regcache_raw_collect (current_regcache, ARM_PS_REGNUM, + (char *) ®s[ARM_CPSR_REGNUM]); + ret = ptrace (PTRACE_SETREGS, tid, 0, ®s); if (ret < 0) { - warning ("Unable to store general registers."); + warning (_("Unable to store general registers.")); return; } } @@ -526,8 +550,8 @@ store_regs (void) regno == -1, otherwise fetch all general registers or all floating point registers depending upon the value of regno. */ -void -fetch_inferior_registers (int regno) +static void +arm_linux_fetch_inferior_registers (int regno) { if (-1 == regno) { @@ -536,10 +560,10 @@ fetch_inferior_registers (int regno) } else { - if (regno < F0_REGNUM || regno > FPS_REGNUM) + if (regno < ARM_F0_REGNUM || regno > ARM_FPS_REGNUM) fetch_register (regno); - if (regno >= F0_REGNUM && regno <= FPS_REGNUM) + if (regno >= ARM_F0_REGNUM && regno <= ARM_FPS_REGNUM) fetch_fpregister (regno); } } @@ -548,8 +572,8 @@ fetch_inferior_registers (int regno) regno == -1, otherwise store all general registers or all floating point registers depending upon the value of regno. */ -void -store_inferior_registers (int regno) +static void +arm_linux_store_inferior_registers (int regno) { if (-1 == regno) { @@ -558,10 +582,10 @@ store_inferior_registers (int regno) } else { - if ((regno < F0_REGNUM) || (regno > FPS_REGNUM)) + if ((regno < ARM_F0_REGNUM) || (regno > ARM_FPS_REGNUM)) store_register (regno); - if ((regno >= F0_REGNUM) && (regno <= FPS_REGNUM)) + if ((regno >= ARM_F0_REGNUM) && (regno <= ARM_FPS_REGNUM)) store_fpregister (regno); } } @@ -576,18 +600,22 @@ fill_gregset (gdb_gregset_t *gregsetp, int regno) if (-1 == regno) { int regnum; - for (regnum = A1_REGNUM; regnum <= PC_REGNUM; regnum++) - read_register_gen (regnum, (char *) &(*gregsetp)[regnum]); + for (regnum = ARM_A1_REGNUM; regnum <= ARM_PC_REGNUM; regnum++) + regcache_raw_collect (current_regcache, regnum, + (char *) &(*gregsetp)[regnum]); } - else if (regno >= A1_REGNUM && regno <= PC_REGNUM) - read_register_gen (regno, (char *) &(*gregsetp)[regno]); + else if (regno >= ARM_A1_REGNUM && regno <= ARM_PC_REGNUM) + regcache_raw_collect (current_regcache, regno, + (char *) &(*gregsetp)[regno]); - if (PS_REGNUM == regno || -1 == regno) + if (ARM_PS_REGNUM == regno || -1 == regno) { if (arm_apcs_32) - read_register_gen (PS_REGNUM, (char *) &(*gregsetp)[CPSR_REGNUM]); + regcache_raw_collect (current_regcache, ARM_PS_REGNUM, + (char *) &(*gregsetp)[ARM_CPSR_REGNUM]); else - read_register_gen (PC_REGNUM, (char *) &(*gregsetp)[PC_REGNUM]); + regcache_raw_collect (current_regcache, ARM_PC_REGNUM, + (char *) &(*gregsetp)[ARM_PC_REGNUM]); } } @@ -599,16 +627,19 @@ supply_gregset (gdb_gregset_t *gregsetp) { int regno, reg_pc; - for (regno = A1_REGNUM; regno < PC_REGNUM; regno++) - supply_register (regno, (char *) &(*gregsetp)[regno]); + for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++) + regcache_raw_supply (current_regcache, regno, + (char *) &(*gregsetp)[regno]); if (arm_apcs_32) - supply_register (PS_REGNUM, (char *) &(*gregsetp)[CPSR_REGNUM]); + regcache_raw_supply (current_regcache, ARM_PS_REGNUM, + (char *) &(*gregsetp)[ARM_CPSR_REGNUM]); else - supply_register (PS_REGNUM, (char *) &(*gregsetp)[PC_REGNUM]); + regcache_raw_supply (current_regcache, ARM_PS_REGNUM, + (char *) &(*gregsetp)[ARM_PC_REGNUM]); - reg_pc = ADDR_BITS_REMOVE ((CORE_ADDR)(*gregsetp)[PC_REGNUM]); - supply_register (PC_REGNUM, (char *) ®_pc); + reg_pc = ADDR_BITS_REMOVE ((CORE_ADDR)(*gregsetp)[ARM_PC_REGNUM]); + regcache_raw_supply (current_regcache, ARM_PC_REGNUM, (char *) ®_pc); } /* Fill register regno (if it is a floating-point register) in @@ -623,18 +654,19 @@ fill_fpregset (gdb_fpregset_t *fpregsetp, int regno) if (-1 == regno) { int regnum; - for (regnum = F0_REGNUM; regnum <= F7_REGNUM; regnum++) + for (regnum = ARM_F0_REGNUM; regnum <= ARM_F7_REGNUM; regnum++) store_nwfpe_register (regnum, fp); } - else if (regno >= F0_REGNUM && regno <= F7_REGNUM) + else if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM) { store_nwfpe_register (regno, fp); return; } /* Store fpsr. */ - if (FPS_REGNUM == regno || -1 == regno) - read_register_gen (FPS_REGNUM, (char *) &fp->fpsr); + if (ARM_FPS_REGNUM == regno || -1 == regno) + regcache_raw_collect (current_regcache, ARM_FPS_REGNUM, + (char *) &fp->fpsr); } /* Fill GDB's register array with the floating-point register values @@ -647,10 +679,10 @@ supply_fpregset (gdb_fpregset_t *fpregsetp) FPA11 *fp = (FPA11 *) fpregsetp; /* Fetch fpsr. */ - supply_register (FPS_REGNUM, (char *) &fp->fpsr); + regcache_raw_supply (current_regcache, ARM_FPS_REGNUM, (char *) &fp->fpsr); /* Fetch the floating point registers. */ - for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++) + for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++) { fetch_nwfpe_register (regno, fp); } @@ -672,7 +704,7 @@ get_linux_version (unsigned int *vmajor, if (-1 == uname (&info)) { - warning ("Unable to determine Linux version."); + warning (_("Unable to determine GNU/Linux version.")); return -1; } @@ -687,8 +719,22 @@ get_linux_version (unsigned int *vmajor, return ((*vmajor << 16) | (*vminor << 8) | *vrelease); } +void _initialize_arm_linux_nat (void); + void _initialize_arm_linux_nat (void) { + struct target_ops *t; + os_version = get_linux_version (&os_major, &os_minor, &os_release); + + /* Fill in the generic GNU/Linux methods. */ + t = linux_target (); + + /* Add our register access methods. */ + t->to_fetch_registers = arm_linux_fetch_inferior_registers; + t->to_store_registers = arm_linux_store_inferior_registers; + + /* Register the target. */ + add_target (t); }