From: Ulrich Weigand Date: Wed, 10 Oct 2007 17:01:10 +0000 (+0000) Subject: 2007-10-10 Markus Deuling X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=6b50c0b03ad69814d0a4146f871d0da04161ae0f;p=binutils-gdb.git 2007-10-10 Markus Deuling * xtensa-tdep.c (xtensa_register_type, xtensa_pseudo_register_read) (xtensa_pseudo_register_write, xtensa_register_reggroup_p) (xtensa_unwind_pc, xtensa_unwind_dummy_id, xtensa_push_dummy_call) (xtensa_dump_tdep): Replace current_gdbarch by gdbarch. (xtensa_register_write_masked, xtensa_register_read_masked) (xtensa_supply_gregset, xtensa_store_return_value) (xtensa_extract_return_value): Use get_regcache_arch to get at the current architecture by regcache. (xtensa_frame_cache, call0_frame_get_reg_at_entry, call0_frame_cache) (xtensa_frame_prev_register): Use get_frame_arch to get at the current architecture by frame_info. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index fc1c4177adb..fe68190901e 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,17 @@ +2007-10-10 Markus Deuling + + * xtensa-tdep.c (xtensa_register_type, xtensa_pseudo_register_read) + (xtensa_pseudo_register_write, xtensa_register_reggroup_p) + (xtensa_unwind_pc, xtensa_unwind_dummy_id, xtensa_push_dummy_call) + (xtensa_dump_tdep): Replace current_gdbarch by gdbarch. + (xtensa_register_write_masked, xtensa_register_read_masked) + (xtensa_supply_gregset, xtensa_store_return_value) + (xtensa_extract_return_value): Use get_regcache_arch to get at the + current architecture by regcache. + (xtensa_frame_cache, call0_frame_get_reg_at_entry, call0_frame_cache) + (xtensa_frame_prev_register): Use get_frame_arch to get at the current + architecture by frame_info. + 2007-10-10 Daniel Jacobowitz * arm-tdep.c (struct arm_prologue_cache): Remove frameoffset. diff --git a/gdb/xtensa-tdep.c b/gdb/xtensa-tdep.c index 361e5f98dd0..cce09f55060 100644 --- a/gdb/xtensa-tdep.c +++ b/gdb/xtensa-tdep.c @@ -214,22 +214,22 @@ static struct type * xtensa_register_type (struct gdbarch *gdbarch, int regnum) { /* Return signed integer for ARx and Ax registers. */ - if ((regnum >= gdbarch_tdep (current_gdbarch)->ar_base - && regnum < gdbarch_tdep (current_gdbarch)->ar_base - + gdbarch_tdep (current_gdbarch)->num_aregs) - || (regnum >= gdbarch_tdep (current_gdbarch)->a0_base - && regnum < gdbarch_tdep (current_gdbarch)->a0_base + 16)) + if ((regnum >= gdbarch_tdep (gdbarch)->ar_base + && regnum < gdbarch_tdep (gdbarch)->ar_base + + gdbarch_tdep (gdbarch)->num_aregs) + || (regnum >= gdbarch_tdep (gdbarch)->a0_base + && regnum < gdbarch_tdep (gdbarch)->a0_base + 16)) return builtin_type_int; - if (regnum == gdbarch_pc_regnum (current_gdbarch) - || regnum == gdbarch_tdep (current_gdbarch)->a0_base + 1) + if (regnum == gdbarch_pc_regnum (gdbarch) + || regnum == gdbarch_tdep (gdbarch)->a0_base + 1) return lookup_pointer_type (builtin_type_void); /* Return the stored type for all other registers. */ - else if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch) - + gdbarch_num_pseudo_regs (current_gdbarch)) + else if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch) + + gdbarch_num_pseudo_regs (gdbarch)) { - xtensa_register_t* reg = &gdbarch_tdep (current_gdbarch)->regmap[regnum]; + xtensa_register_t* reg = &gdbarch_tdep (gdbarch)->regmap[regnum]; /* Set ctype for this register (only the first time). */ @@ -342,7 +342,7 @@ xtensa_register_write_masked (struct regcache *regcache, DEBUGTRACE ("xtensa_register_write_masked ()\n"); /* Copy the masked register to host byte-order. */ - if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (get_regcache_arch (regcache)) == BFD_ENDIAN_BIG) for (i = 0; i < bytesize; i++) { mem >>= 8; @@ -472,7 +472,7 @@ xtensa_register_read_masked (struct regcache *regcache, ptr = value; mem = *ptr; - if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (get_regcache_arch (regcache)) == BFD_ENDIAN_BIG) for (i = 0; i < bytesize; i++) { if ((i & 3) == 0) @@ -502,34 +502,33 @@ xtensa_pseudo_register_read (struct gdbarch *gdbarch, DEBUGTRACE ("xtensa_pseudo_register_read (... regnum = %d (%s) ...)\n", regnum, xtensa_register_name (regnum)); - if (regnum == gdbarch_num_regs (current_gdbarch) - + gdbarch_num_pseudo_regs (current_gdbarch)) - regnum = gdbarch_tdep (current_gdbarch)->a0_base + 1; + if (regnum == gdbarch_num_regs (gdbarch) + + gdbarch_num_pseudo_regs (gdbarch)) + regnum = gdbarch_tdep (gdbarch)->a0_base + 1; /* Read aliases a0..a15, if this is a Windowed ABI. */ - if (gdbarch_tdep (current_gdbarch)->isa_use_windowed_registers - && (regnum >= gdbarch_tdep (current_gdbarch)->a0_base + 0) - && (regnum <= gdbarch_tdep (current_gdbarch)->a0_base + 15)) + if (gdbarch_tdep (gdbarch)->isa_use_windowed_registers + && (regnum >= gdbarch_tdep (gdbarch)->a0_base + 0) + && (regnum <= gdbarch_tdep (gdbarch)->a0_base + 15)) { gdb_byte *buf = (gdb_byte *) alloca (MAX_REGISTER_SIZE); - regcache_raw_read (regcache, - gdbarch_tdep (current_gdbarch)->wb_regnum, buf); + regcache_raw_read (regcache, gdbarch_tdep (gdbarch)->wb_regnum, buf); regnum = AREG_NUMBER (regnum, extract_unsigned_integer (buf, 4)); } /* We can always read non-pseudo registers. */ - if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch)) + if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)) regcache_raw_read (regcache, regnum, buffer); /* Pseudo registers. */ else if (regnum >= 0 - && regnum < gdbarch_num_regs (current_gdbarch) - + gdbarch_num_pseudo_regs (current_gdbarch)) + && regnum < gdbarch_num_regs (gdbarch) + + gdbarch_num_pseudo_regs (gdbarch)) { - xtensa_register_t *reg = &gdbarch_tdep (current_gdbarch)->regmap[regnum]; + xtensa_register_t *reg = &gdbarch_tdep (gdbarch)->regmap[regnum]; xtensa_register_type_t type = reg->type; - int flags = gdbarch_tdep (current_gdbarch)->target_flags; + int flags = gdbarch_tdep (gdbarch)->target_flags; /* We cannot read Unknown or Unmapped registers. */ if (type == xtRegisterTypeUnmapped || type == xtRegisterTypeUnknown) @@ -587,36 +586,36 @@ xtensa_pseudo_register_write (struct gdbarch *gdbarch, DEBUGTRACE ("xtensa_pseudo_register_write (... regnum = %d (%s) ...)\n", regnum, xtensa_register_name (regnum)); - if (regnum == gdbarch_num_regs (current_gdbarch) - + gdbarch_num_pseudo_regs (current_gdbarch)) - regnum = gdbarch_tdep (current_gdbarch)->a0_base + 1; + if (regnum == gdbarch_num_regs (gdbarch) + + gdbarch_num_pseudo_regs (gdbarch)) + regnum = gdbarch_tdep (gdbarch)->a0_base + 1; /* Renumber register, if aliase a0..a15 on Windowed ABI. */ - if (gdbarch_tdep (current_gdbarch)->isa_use_windowed_registers - && (regnum >= gdbarch_tdep (current_gdbarch)->a0_base + 0) - && (regnum <= gdbarch_tdep (current_gdbarch)->a0_base + 15)) + if (gdbarch_tdep (gdbarch)->isa_use_windowed_registers + && (regnum >= gdbarch_tdep (gdbarch)->a0_base + 0) + && (regnum <= gdbarch_tdep (gdbarch)->a0_base + 15)) { gdb_byte *buf = (gdb_byte *) alloca (MAX_REGISTER_SIZE); unsigned int wb; regcache_raw_read (regcache, - gdbarch_tdep (current_gdbarch)->wb_regnum, buf); + gdbarch_tdep (gdbarch)->wb_regnum, buf); regnum = AREG_NUMBER (regnum, extract_unsigned_integer (buf, 4)); } /* We can always write 'core' registers. Note: We might have converted Ax->ARy. */ - if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch)) + if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)) regcache_raw_write (regcache, regnum, buffer); /* Pseudo registers. */ else if (regnum >= 0 - && regnum < gdbarch_num_regs (current_gdbarch) - + gdbarch_num_pseudo_regs (current_gdbarch)) + && regnum < gdbarch_num_regs (gdbarch) + + gdbarch_num_pseudo_regs (gdbarch)) { - xtensa_register_t *reg = &gdbarch_tdep (current_gdbarch)->regmap[regnum]; + xtensa_register_t *reg = &gdbarch_tdep (gdbarch)->regmap[regnum]; xtensa_register_type_t type = reg->type; - int flags = gdbarch_tdep (current_gdbarch)->target_flags; + int flags = gdbarch_tdep (gdbarch)->target_flags; /* On most targets, we cannot write registers of type "Unknown" or "Unmapped". */ @@ -733,7 +732,7 @@ xtensa_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *group) { - xtensa_register_t* reg = &gdbarch_tdep (current_gdbarch)->regmap[regnum]; + xtensa_register_t* reg = &gdbarch_tdep (gdbarch)->regmap[regnum]; xtensa_register_type_t type = reg->type; xtensa_register_group_t rg = reg->group; int cp_number; @@ -760,7 +759,7 @@ xtensa_register_reggroup_p (struct gdbarch *gdbarch, if (group == vector_reggroup || group == xtensa_vectra_reggroup) return rg & xtRegisterGroupVectra; if (group == save_reggroup || group == restore_reggroup) - return (regnum < gdbarch_num_regs (current_gdbarch) + return (regnum < gdbarch_num_regs (gdbarch) && (reg->flags & SAVE_REST_FLAGS) == SAVE_REST_VALID); if ((cp_number = xtensa_coprocessor_register_group (group)) >= 0) return rg & (xtRegisterGroupCP0 << cp_number); @@ -781,52 +780,49 @@ xtensa_supply_gregset (const struct regset *regset, size_t len) { const xtensa_elf_gregset_t *regs = gregs; + struct gdbarch *gdbarch = get_regcache_arch (rc); int i; DEBUGTRACE ("xtensa_supply_gregset (..., regnum==%d, ...) \n", regnum); - if (regnum == gdbarch_pc_regnum (current_gdbarch) || regnum == -1) - regcache_raw_supply (rc, - gdbarch_pc_regnum (current_gdbarch), - (char *) ®s->pc); - if (regnum == gdbarch_ps_regnum (current_gdbarch) || regnum == -1) - regcache_raw_supply (rc, gdbarch_ps_regnum (current_gdbarch), - (char *) ®s->ps); - if (regnum == gdbarch_tdep (current_gdbarch)->wb_regnum || regnum == -1) - regcache_raw_supply (rc, gdbarch_tdep (current_gdbarch)->wb_regnum, + if (regnum == gdbarch_pc_regnum (gdbarch) || regnum == -1) + regcache_raw_supply (rc, gdbarch_pc_regnum (gdbarch), (char *) ®s->pc); + if (regnum == gdbarch_ps_regnum (gdbarch) || regnum == -1) + regcache_raw_supply (rc, gdbarch_ps_regnum (gdbarch), (char *) ®s->ps); + if (regnum == gdbarch_tdep (gdbarch)->wb_regnum || regnum == -1) + regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->wb_regnum, (char *) ®s->windowbase); - if (regnum == gdbarch_tdep (current_gdbarch)->ws_regnum || regnum == -1) - regcache_raw_supply (rc, gdbarch_tdep (current_gdbarch)->ws_regnum, + if (regnum == gdbarch_tdep (gdbarch)->ws_regnum || regnum == -1) + regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->ws_regnum, (char *) ®s->windowstart); - if (regnum == gdbarch_tdep (current_gdbarch)->lbeg_regnum || regnum == -1) - regcache_raw_supply (rc, gdbarch_tdep (current_gdbarch)->lbeg_regnum, + if (regnum == gdbarch_tdep (gdbarch)->lbeg_regnum || regnum == -1) + regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->lbeg_regnum, (char *) ®s->lbeg); - if (regnum == gdbarch_tdep (current_gdbarch)->lend_regnum || regnum == -1) - regcache_raw_supply (rc, gdbarch_tdep (current_gdbarch)->lend_regnum, + if (regnum == gdbarch_tdep (gdbarch)->lend_regnum || regnum == -1) + regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->lend_regnum, (char *) ®s->lend); - if (regnum == gdbarch_tdep (current_gdbarch)->lcount_regnum || regnum == -1) - regcache_raw_supply (rc, gdbarch_tdep (current_gdbarch)->lcount_regnum, + if (regnum == gdbarch_tdep (gdbarch)->lcount_regnum || regnum == -1) + regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->lcount_regnum, (char *) ®s->lcount); - if (regnum == gdbarch_tdep (current_gdbarch)->sar_regnum || regnum == -1) - regcache_raw_supply (rc, gdbarch_tdep (current_gdbarch)->sar_regnum, + if (regnum == gdbarch_tdep (gdbarch)->sar_regnum || regnum == -1) + regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->sar_regnum, (char *) ®s->sar); - if (regnum == gdbarch_tdep (current_gdbarch)->exccause_regnum - || regnum == -1) - regcache_raw_supply (rc, gdbarch_tdep (current_gdbarch)->exccause_regnum, + if (regnum == gdbarch_tdep (gdbarch)->exccause_regnum || regnum == -1) + regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->exccause_regnum, (char *) ®s->exccause); - if (regnum == gdbarch_tdep (current_gdbarch)->excvaddr_regnum || regnum == -1) - regcache_raw_supply (rc, gdbarch_tdep (current_gdbarch)->excvaddr_regnum, + if (regnum == gdbarch_tdep (gdbarch)->excvaddr_regnum || regnum == -1) + regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->excvaddr_regnum, (char *) ®s->excvaddr); - if (regnum >=gdbarch_tdep (current_gdbarch)->ar_base - && regnum < gdbarch_tdep (current_gdbarch)->ar_base - + gdbarch_tdep (current_gdbarch)->num_aregs) + if (regnum >=gdbarch_tdep (gdbarch)->ar_base + && regnum < gdbarch_tdep (gdbarch)->ar_base + + gdbarch_tdep (gdbarch)->num_aregs) regcache_raw_supply (rc, regnum, (char *) ®s->ar[regnum - gdbarch_tdep - (current_gdbarch)->ar_base]); + (gdbarch)->ar_base]); else if (regnum == -1) { - for (i = 0; i < gdbarch_tdep (current_gdbarch)->num_aregs; ++i) - regcache_raw_supply (rc, gdbarch_tdep (current_gdbarch)->ar_base + i, + for (i = 0; i < gdbarch_tdep (gdbarch)->num_aregs; ++i) + regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->ar_base + i, (char *) ®s->ar[i]); } } @@ -992,7 +988,7 @@ xtensa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) DEBUGTRACE ("xtensa_unwind_pc (next_frame = %p)\n", next_frame); - frame_unwind_register (next_frame, gdbarch_pc_regnum (current_gdbarch), buf); + frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf); DEBUGINFO ("[xtensa_unwind_pc] pc = 0x%08x\n", (unsigned int) extract_typed_address (buf, builtin_type_void_func_ptr)); @@ -1012,7 +1008,7 @@ xtensa_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) pc = frame_pc_unwind (next_frame); fp = frame_unwind_register_unsigned - (next_frame, gdbarch_tdep (current_gdbarch)->a0_base + 1); + (next_frame, gdbarch_tdep (gdbarch)->a0_base + 1); /* Make dummy frame ID unique by adding a constant. */ return frame_id_build (fp + SP_ALIGNMENT, pc); @@ -1035,7 +1031,8 @@ xtensa_frame_cache (struct frame_info *next_frame, void **this_cache) { xtensa_frame_cache_t *cache; CORE_ADDR ra, wb, ws, pc, sp, ps; - unsigned int ps_regnum = gdbarch_ps_regnum (current_gdbarch); + struct gdbarch *gdbarch = get_frame_arch (next_frame); + unsigned int ps_regnum = gdbarch_ps_regnum (gdbarch); char op1; int windowed; @@ -1052,15 +1049,15 @@ xtensa_frame_cache (struct frame_info *next_frame, void **this_cache) *this_cache = cache; pc = frame_unwind_register_unsigned (next_frame, - gdbarch_pc_regnum (current_gdbarch)); + gdbarch_pc_regnum (gdbarch)); if (windowed) { /* Get WINDOWBASE, WINDOWSTART, and PS registers. */ wb = frame_unwind_register_unsigned - (next_frame, gdbarch_tdep (current_gdbarch)->wb_regnum); + (next_frame, gdbarch_tdep (gdbarch)->wb_regnum); ws = frame_unwind_register_unsigned - (next_frame, gdbarch_tdep (current_gdbarch)->ws_regnum); + (next_frame, gdbarch_tdep (gdbarch)->ws_regnum); ps = frame_unwind_register_unsigned (next_frame, ps_regnum); op1 = read_memory_integer (pc, 1); @@ -1068,8 +1065,7 @@ xtensa_frame_cache (struct frame_info *next_frame, void **this_cache) { int callinc = CALLINC (ps); ra = frame_unwind_register_unsigned - (next_frame, - gdbarch_tdep (current_gdbarch)->a0_base + 0 + callinc * 4); + (next_frame, gdbarch_tdep (gdbarch)->a0_base + 0 + callinc * 4); DEBUGINFO("[xtensa_frame_cache] 'entry' at 0x%08x\n (callinc = %d)", (int)pc, callinc); @@ -1079,16 +1075,15 @@ xtensa_frame_cache (struct frame_info *next_frame, void **this_cache) cache->wd.wb = wb; cache->wd.ws = ws; cache->prev_sp = frame_unwind_register_unsigned - (next_frame, gdbarch_tdep - (current_gdbarch)->a0_base + 1); + (next_frame, gdbarch_tdep (gdbarch)->a0_base + 1); } else { ra = frame_unwind_register_unsigned - (next_frame, gdbarch_tdep (current_gdbarch)->a0_base + 0); + (next_frame, gdbarch_tdep (gdbarch)->a0_base + 0); cache->wd.callsize = WINSIZE (ra); cache->wd.wb = (wb - cache->wd.callsize / 4) - & (gdbarch_tdep (current_gdbarch)->num_aregs / 4 - 1); + & (gdbarch_tdep (gdbarch)->num_aregs / 4 - 1); cache->wd.ws = ws & ~(1 << wb); } @@ -1103,7 +1098,7 @@ xtensa_frame_cache (struct frame_info *next_frame, void **this_cache) /* Set A0...A3. */ sp = frame_unwind_register_unsigned - (next_frame, gdbarch_tdep (current_gdbarch)->a0_base + 1) - 16; + (next_frame, gdbarch_tdep (gdbarch)->a0_base + 1) - 16; for (i = 0; i < 4; i++, sp += 4) { @@ -1134,15 +1129,14 @@ xtensa_frame_cache (struct frame_info *next_frame, void **this_cache) We can read caller's SP from the proper spill loction. */ cache->prev_sp = read_memory_integer (cache->wd.aregs[1], - register_size (current_gdbarch, - gdbarch_tdep (current_gdbarch)->a0_base - + 1)); + register_size (gdbarch, + gdbarch_tdep (gdbarch)->a0_base + 1)); } else { /* Read caller's frame SP directly from the previous window. */ int regnum = AREG_NUMBER - (gdbarch_tdep (current_gdbarch)->a0_base + 1, + (gdbarch_tdep (gdbarch)->a0_base + 1, cache->wd.wb); cache->prev_sp = xtensa_read_register (regnum); @@ -1155,7 +1149,7 @@ xtensa_frame_cache (struct frame_info *next_frame, void **this_cache) } cache->base = frame_unwind_register_unsigned - (next_frame, gdbarch_tdep (current_gdbarch)->a0_base + 1); + (next_frame, gdbarch_tdep (gdbarch)->a0_base + 1); return cache; } @@ -1199,9 +1193,10 @@ call0_frame_get_reg_at_entry (struct frame_info *next_frame, { CORE_ADDR fp, spe; int stkofs; - int reg = (regnum >= gdbarch_tdep (current_gdbarch)->ar_base - && regnum <= (gdbarch_tdep (current_gdbarch)->ar_base + C0_NREGS)) - ? regnum - gdbarch_tdep (current_gdbarch)->ar_base : regnum; + struct gdbarch *gdbarch = get_frame_arch (next_frame); + int reg = (regnum >= gdbarch_tdep (gdbarch)->ar_base + && regnum <= (gdbarch_tdep (gdbarch)->ar_base + C0_NREGS)) + ? regnum - gdbarch_tdep (gdbarch)->ar_base : regnum; /* Determine stack pointer on entry to this function, based on FP. */ spe = cache->c0.c0_fp - cache->c0.c0_rt[cache->c0.fp_regnum].fr_ofs; @@ -1214,7 +1209,7 @@ call0_frame_get_reg_at_entry (struct frame_info *next_frame, *addrp = spe + stkofs; if (valuep) - read_memory (*addrp, valuep, register_size (current_gdbarch, regnum)); + read_memory (*addrp, valuep, register_size (gdbarch, regnum)); return 1; } @@ -1243,6 +1238,7 @@ xtensa_frame_prev_register (struct frame_info *next_frame, int *realnump, gdb_byte *valuep) { + struct gdbarch *gdbarch = get_frame_arch (next_frame); struct xtensa_frame_cache *cache = xtensa_frame_cache (next_frame, this_cache); CORE_ADDR saved_reg = 0; @@ -1254,22 +1250,22 @@ xtensa_frame_prev_register (struct frame_info *next_frame, *this_cache ? (unsigned int) *this_cache : 0, regnum, xtensa_register_name (regnum)); - if (regnum ==gdbarch_pc_regnum (current_gdbarch)) + if (regnum ==gdbarch_pc_regnum (gdbarch)) saved_reg = cache->ra; - else if (regnum == gdbarch_tdep (current_gdbarch)->a0_base + 1) + else if (regnum == gdbarch_tdep (gdbarch)->a0_base + 1) saved_reg = cache->prev_sp; else if (!cache->call0) { - if (regnum == gdbarch_tdep (current_gdbarch)->ws_regnum) + if (regnum == gdbarch_tdep (gdbarch)->ws_regnum) { if (cache->wd.ws != 0) saved_reg = cache->wd.ws; else saved_reg = 1 << cache->wd.wb; } - else if (regnum == gdbarch_tdep (current_gdbarch)->wb_regnum) + else if (regnum == gdbarch_tdep (gdbarch)->wb_regnum) saved_reg = cache->wd.wb; - else if (regnum == gdbarch_ps_regnum (current_gdbarch)) + else if (regnum == gdbarch_ps_regnum (gdbarch)) saved_reg = cache->ps; else done = 0; @@ -1292,16 +1288,16 @@ xtensa_frame_prev_register (struct frame_info *next_frame, if (!cache->call0) /* Windowed ABI. */ { /* Convert A-register numbers to AR-register numbers. */ - if (regnum >= gdbarch_tdep (current_gdbarch)->a0_base + 0 - && regnum <= gdbarch_tdep (current_gdbarch)->a0_base + 15) + if (regnum >= gdbarch_tdep (gdbarch)->a0_base + 0 + && regnum <= gdbarch_tdep (gdbarch)->a0_base + 15) regnum = AREG_NUMBER (regnum, cache->wd.wb); /* Check if AR-register has been saved to stack. */ - if (regnum >= gdbarch_tdep (current_gdbarch)->ar_base - && regnum <= (gdbarch_tdep (current_gdbarch)->ar_base - + gdbarch_tdep (current_gdbarch)->num_aregs)) + if (regnum >= gdbarch_tdep (gdbarch)->ar_base + && regnum <= (gdbarch_tdep (gdbarch)->ar_base + + gdbarch_tdep (gdbarch)->num_aregs)) { - int areg = regnum - gdbarch_tdep (current_gdbarch)->ar_base + int areg = regnum - gdbarch_tdep (gdbarch)->ar_base - (cache->wd.wb * 4); if (areg >= 0 @@ -1315,7 +1311,7 @@ xtensa_frame_prev_register (struct frame_info *next_frame, if (valuep) read_memory (*addrp, valuep, - register_size (current_gdbarch, regnum)); + register_size (gdbarch, regnum)); DEBUGINFO ("[xtensa_frame_prev_register] register on stack\n"); return; @@ -1324,10 +1320,10 @@ xtensa_frame_prev_register (struct frame_info *next_frame, } else /* Call0 ABI. */ { - int reg = (regnum >= gdbarch_tdep (current_gdbarch)->ar_base - && regnum <= (gdbarch_tdep (current_gdbarch)->ar_base + int reg = (regnum >= gdbarch_tdep (gdbarch)->ar_base + && regnum <= (gdbarch_tdep (gdbarch)->ar_base + C0_NREGS)) - ? regnum - gdbarch_tdep (current_gdbarch)->ar_base : regnum; + ? regnum - gdbarch_tdep (gdbarch)->ar_base : regnum; if (reg < C0_NREGS) { @@ -1348,7 +1344,7 @@ xtensa_frame_prev_register (struct frame_info *next_frame, if (valuep) read_memory (*addrp, valuep, - register_size (current_gdbarch, regnum)); + register_size (gdbarch, regnum)); DEBUGINFO ("[xtensa_frame_prev_register] register on stack\n"); return; @@ -1406,6 +1402,7 @@ xtensa_extract_return_value (struct type *type, struct regcache *regcache, void *dst) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); bfd_byte *valbuf = dst; int len = TYPE_LENGTH (type); ULONGEST pc, wb; @@ -1416,11 +1413,10 @@ xtensa_extract_return_value (struct type *type, gdb_assert(len > 0); - if (gdbarch_tdep (current_gdbarch)->call_abi != CallAbiCall0Only) + if (gdbarch_tdep (gdbarch)->call_abi != CallAbiCall0Only) { /* First, we have to find the caller window in the register file. */ - regcache_raw_read_unsigned (regcache, - gdbarch_pc_regnum (current_gdbarch), &pc); + regcache_raw_read_unsigned (regcache, gdbarch_pc_regnum (gdbarch), &pc); callsize = extract_call_winsize (pc); /* On Xtensa, we can return up to 4 words (or 2 for call12). */ @@ -1431,19 +1427,18 @@ xtensa_extract_return_value (struct type *type, /* Get the register offset of the return register (A2) in the caller window. */ regcache_raw_read_unsigned - (regcache, gdbarch_tdep (current_gdbarch)->wb_regnum, &wb); - areg = AREG_NUMBER(gdbarch_tdep (current_gdbarch)->a0_base + 2 + callsize, - wb); + (regcache, gdbarch_tdep (gdbarch)->wb_regnum, &wb); + areg = AREG_NUMBER(gdbarch_tdep (gdbarch)->a0_base + 2 + callsize, wb); } else { /* No windowing hardware - Call0 ABI. */ - areg = gdbarch_tdep (current_gdbarch)->a0_base + 0 + C0_ARGS; + areg = gdbarch_tdep (gdbarch)->a0_base + 0 + C0_ARGS; } DEBUGINFO ("[xtensa_extract_return_value] areg %d len %d\n", areg, len); - if (len < 4 && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) + if (len < 4 && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) offset = 4 - len; for (; len > 0; len -= 4, areg++, valbuf += 4) @@ -1461,6 +1456,7 @@ xtensa_store_return_value (struct type *type, struct regcache *regcache, const void *dst) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); const bfd_byte *valbuf = dst; unsigned int areg; ULONGEST pc, wb; @@ -1470,30 +1466,28 @@ xtensa_store_return_value (struct type *type, DEBUGTRACE ("xtensa_store_return_value (...)\n"); - if (gdbarch_tdep (current_gdbarch)->call_abi != CallAbiCall0Only) + if (gdbarch_tdep (gdbarch)->call_abi != CallAbiCall0Only) { - regcache_raw_read_unsigned - (regcache, gdbarch_tdep (current_gdbarch)->wb_regnum, &wb); - regcache_raw_read_unsigned (regcache, - gdbarch_pc_regnum (current_gdbarch), &pc); + regcache_raw_read_unsigned + (regcache, gdbarch_tdep (gdbarch)->wb_regnum, &wb); + regcache_raw_read_unsigned (regcache, gdbarch_pc_regnum (gdbarch), &pc); callsize = extract_call_winsize (pc); if (len > (callsize > 8 ? 8 : 16)) internal_error (__FILE__, __LINE__, _("unimplemented for this length: %d"), TYPE_LENGTH (type)); - areg = AREG_NUMBER - (gdbarch_tdep (current_gdbarch)->a0_base + 2 + callsize, wb); + areg = AREG_NUMBER (gdbarch_tdep (gdbarch)->a0_base + 2 + callsize, wb); DEBUGTRACE ("[xtensa_store_return_value] callsize %d wb %d\n", callsize, (int) wb); } else { - areg = gdbarch_tdep (current_gdbarch)->a0_base + 0 + C0_ARGS; + areg = gdbarch_tdep (gdbarch)->a0_base + 0 + C0_ARGS; } - if (len < 4 && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) + if (len < 4 && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) offset = 4 - len; for (; len > 0; len -= 4, areg++, valbuf += 4) @@ -1682,7 +1676,7 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch, sp = align_down (sp - onstack_size, SP_ALIGNMENT); /* Simulate MOVSP, if Windowed ABI. */ - if ((gdbarch_tdep (current_gdbarch)->call_abi != CallAbiCall0Only) + if ((gdbarch_tdep (gdbarch)->call_abi != CallAbiCall0Only) && (sp != osp)) { read_memory (osp - 16, buf, 16); @@ -1711,7 +1705,7 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch, applies for structures smaller than one word. */ if (n < REGISTER_SIZE - && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) + && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) offset += (REGISTER_SIZE - n); write_memory (offset, info->contents, info->length); @@ -1730,7 +1724,7 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch, will be left-aligned in the register on both endiannesses. */ if (n < REGISTER_SIZE - && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) + && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) { ULONGEST v = extract_unsigned_integer (cp, REGISTER_SIZE); v = v >> ((REGISTER_SIZE - n) * TARGET_CHAR_BIT); @@ -1758,28 +1752,27 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch, The return address for the current function (in A0) is saved in the dummy frame, so we can savely overwrite A0 here. */ - if (gdbarch_tdep (current_gdbarch)->call_abi != CallAbiCall0Only) + if (gdbarch_tdep (gdbarch)->call_abi != CallAbiCall0Only) { ra = (bp_addr & 0x3fffffff) | 0x40000000; - regcache_raw_read (regcache, gdbarch_ps_regnum (current_gdbarch), buf); + regcache_raw_read (regcache, gdbarch_ps_regnum (gdbarch), buf); ps = extract_unsigned_integer (buf, 4) & ~0x00030000; regcache_cooked_write_unsigned - (regcache, gdbarch_tdep (current_gdbarch)->a0_base + 4, ra); + (regcache, gdbarch_tdep (gdbarch)->a0_base + 4, ra); regcache_cooked_write_unsigned (regcache, - gdbarch_ps_regnum (current_gdbarch), + gdbarch_ps_regnum (gdbarch), ps | 0x00010000); } else { /* Simulate CALL0: write RA into A0 register. */ regcache_cooked_write_unsigned - (regcache, gdbarch_tdep (current_gdbarch)->a0_base + 0, bp_addr); + (regcache, gdbarch_tdep (gdbarch)->a0_base + 0, bp_addr); } /* Set new stack pointer and return it. */ regcache_cooked_write_unsigned (regcache, - gdbarch_tdep (current_gdbarch)->a0_base + 1, - sp); + gdbarch_tdep (gdbarch)->a0_base + 1, sp); /* Make dummy frame ID unique by adding a constant. */ return sp + SP_ALIGNMENT; } @@ -2242,6 +2235,7 @@ static void call0_frame_cache (struct frame_info *next_frame, xtensa_frame_cache_t *cache, CORE_ADDR pc) { + struct gdbarch *gdbarch = get_frame_arch (next_frame); CORE_ADDR start_pc; /* The beginning of the function. */ CORE_ADDR body_pc=UINT_MAX; /* PC, where prologue analysis stopped. */ CORE_ADDR sp, fp, ra; @@ -2258,7 +2252,7 @@ call0_frame_cache (struct frame_info *next_frame, } sp = frame_unwind_register_unsigned - (next_frame, gdbarch_tdep (current_gdbarch)->a0_base + 1); + (next_frame, gdbarch_tdep (gdbarch)->a0_base + 1); fp = sp; /* Assume FP == SP until proven otherwise. */ /* Get the frame information and FP (if used) at the current PC. @@ -2277,12 +2271,12 @@ call0_frame_cache (struct frame_info *next_frame, was derived from SP. Otherwise, it would be C0_FP. */ fp_regnum = c0_hasfp ? C0_FP : C0_SP; c0_frmsz = - cache->c0.c0_rt[fp_regnum].fr_ofs; - fp_regnum += gdbarch_tdep (current_gdbarch)->a0_base; + fp_regnum += gdbarch_tdep (gdbarch)->a0_base; } else /* No data from the prologue analysis. */ { c0_hasfp = 0; - fp_regnum = gdbarch_tdep (current_gdbarch)->a0_base + C0_SP; + fp_regnum = gdbarch_tdep (gdbarch)->a0_base + C0_SP; c0_frmsz = 0; start_pc = pc; } @@ -2339,7 +2333,7 @@ call0_frame_cache (struct frame_info *next_frame, { ra = frame_unwind_register_unsigned (next_frame, - gdbarch_tdep (current_gdbarch)->a0_base + 0 + gdbarch_tdep (gdbarch)->a0_base + 0 + cache->c0.c0_rt[i].fr_reg); } else ra = 0; @@ -2566,7 +2560,7 @@ xtensa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) } static void -xtensa_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file) +xtensa_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file) { error (_("xtensa_dump_tdep(): not implemented")); }