X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fsparc64-tdep.c;h=9e0e6b532cb80c27d8f2c58ed2f563e88dcc96a1;hb=98973784dc4775dbce3470b0933d1cb13f8c5a87;hp=31ee61305457a5807cc8da5ee634711a6f667c55;hpb=fe10a582b69fc09ce4775071aa619b0a6fc5dd1a;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/sparc64-tdep.c b/gdb/sparc64-tdep.c index 31ee613054..9e0e6b532c 100644 --- a/gdb/sparc64-tdep.c +++ b/gdb/sparc64-tdep.c @@ -1,7 +1,6 @@ /* Target-dependent code for UltraSPARC. - Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 - Free Software Foundation, Inc. + Copyright (C) 2003-2017 Free Software Foundation, Inc. This file is part of GDB. @@ -32,12 +31,10 @@ #include "objfiles.h" #include "osabi.h" #include "regcache.h" +#include "target-descriptions.h" #include "target.h" #include "value.h" -#include "gdb_assert.h" -#include "gdb_string.h" - #include "sparc64-tdep.h" /* This file implements the SPARC 64-bit ABI as defined by the @@ -71,6 +68,7 @@ sparc64_integral_or_pointer_p (const struct type *type) return 1; case TYPE_CODE_PTR: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: { int len = TYPE_LENGTH (type); gdb_assert (len == 8); @@ -175,6 +173,31 @@ sparc64_pstate_type (struct gdbarch *gdbarch) return tdep->sparc64_pstate_type; } +static struct type * +sparc64_ccr_type (struct gdbarch *gdbarch) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + if (tdep->sparc64_ccr_type == NULL) + { + struct type *type; + + type = arch_flags_type (gdbarch, "builtin_type_sparc64_ccr", 8); + append_flags_type_flag (type, 0, "icc.c"); + append_flags_type_flag (type, 1, "icc.v"); + append_flags_type_flag (type, 2, "icc.z"); + append_flags_type_flag (type, 3, "icc.n"); + append_flags_type_flag (type, 4, "xcc.c"); + append_flags_type_flag (type, 5, "xcc.v"); + append_flags_type_flag (type, 6, "xcc.z"); + append_flags_type_flag (type, 7, "xcc.n"); + + tdep->sparc64_ccr_type = type; + } + + return tdep->sparc64_ccr_type; +} + static struct type * sparc64_fsr_type (struct gdbarch *gdbarch) { @@ -185,16 +208,16 @@ sparc64_fsr_type (struct gdbarch *gdbarch) struct type *type; type = arch_flags_type (gdbarch, "builtin_type_sparc64_fsr", 8); - append_flags_type_flag (type, 0, "NXA"); - append_flags_type_flag (type, 1, "DZA"); - append_flags_type_flag (type, 2, "UFA"); - append_flags_type_flag (type, 3, "OFA"); - append_flags_type_flag (type, 4, "NVA"); - append_flags_type_flag (type, 5, "NXC"); - append_flags_type_flag (type, 6, "DZC"); - append_flags_type_flag (type, 7, "UFC"); - append_flags_type_flag (type, 8, "OFC"); - append_flags_type_flag (type, 9, "NVC"); + append_flags_type_flag (type, 0, "NXC"); + append_flags_type_flag (type, 1, "DZC"); + append_flags_type_flag (type, 2, "UFC"); + append_flags_type_flag (type, 3, "OFC"); + append_flags_type_flag (type, 4, "NVC"); + append_flags_type_flag (type, 5, "NXA"); + append_flags_type_flag (type, 6, "DZA"); + append_flags_type_flag (type, 7, "UFA"); + append_flags_type_flag (type, 8, "OFA"); + append_flags_type_flag (type, 9, "NVA"); append_flags_type_flag (type, 22, "NS"); append_flags_type_flag (type, 23, "NXM"); append_flags_type_flag (type, 24, "DZM"); @@ -230,28 +253,29 @@ sparc64_fprs_type (struct gdbarch *gdbarch) /* Register information. */ +#define SPARC64_FPU_REGISTERS \ + "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \ + "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \ + "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \ + "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \ + "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", \ + "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62" +#define SPARC64_CP0_REGISTERS \ + "pc", "npc", \ + /* FIXME: Give "state" a name until we start using register groups. */ \ + "state", \ + "fsr", \ + "fprs", \ + "y" + +static const char *sparc64_fpu_register_names[] = { SPARC64_FPU_REGISTERS }; +static const char *sparc64_cp0_register_names[] = { SPARC64_CP0_REGISTERS }; static const char *sparc64_register_names[] = { - "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7", - "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7", - "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7", - "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7", - - "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", - "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", - "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", - "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", - "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", - "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62", - - "pc", "npc", - - /* FIXME: Give "state" a name until we start using register groups. */ - "state", - "fsr", - "fprs", - "y", + SPARC_CORE_REGISTERS, + SPARC64_FPU_REGISTERS, + SPARC64_CP0_REGISTERS }; /* Total number of registers. */ @@ -276,19 +300,59 @@ static const char *sparc64_pseudo_register_names[] = /* Total number of pseudo registers. */ #define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names) +/* Return the name of pseudo register REGNUM. */ + +static const char * +sparc64_pseudo_register_name (struct gdbarch *gdbarch, int regnum) +{ + regnum -= gdbarch_num_regs (gdbarch); + + if (regnum < SPARC64_NUM_PSEUDO_REGS) + return sparc64_pseudo_register_names[regnum]; + + internal_error (__FILE__, __LINE__, + _("sparc64_pseudo_register_name: bad register number %d"), + regnum); +} + /* Return the name of register REGNUM. */ static const char * sparc64_register_name (struct gdbarch *gdbarch, int regnum) { - if (regnum >= 0 && regnum < SPARC64_NUM_REGS) + if (tdesc_has_registers (gdbarch_target_desc (gdbarch))) + return tdesc_register_name (gdbarch, regnum); + + if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)) return sparc64_register_names[regnum]; - if (regnum >= SPARC64_NUM_REGS - && regnum < SPARC64_NUM_REGS + SPARC64_NUM_PSEUDO_REGS) - return sparc64_pseudo_register_names[regnum - SPARC64_NUM_REGS]; + return sparc64_pseudo_register_name (gdbarch, regnum); +} + +/* Return the GDB type object for the "standard" data type of data in + pseudo register REGNUM. */ - return NULL; +static struct type * +sparc64_pseudo_register_type (struct gdbarch *gdbarch, int regnum) +{ + regnum -= gdbarch_num_regs (gdbarch); + + if (regnum == SPARC64_CWP_REGNUM) + return builtin_type (gdbarch)->builtin_int64; + if (regnum == SPARC64_PSTATE_REGNUM) + return sparc64_pstate_type (gdbarch); + if (regnum == SPARC64_ASI_REGNUM) + return builtin_type (gdbarch)->builtin_int64; + if (regnum == SPARC64_CCR_REGNUM) + return sparc64_ccr_type (gdbarch); + if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D62_REGNUM) + return builtin_type (gdbarch)->builtin_double; + if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q60_REGNUM) + return builtin_type (gdbarch)->builtin_long_double; + + internal_error (__FILE__, __LINE__, + _("sparc64_pseudo_register_type: bad register number %d"), + regnum); } /* Return the GDB type object for the "standard" data type of data in @@ -297,8 +361,10 @@ sparc64_register_name (struct gdbarch *gdbarch, int regnum) static struct type * sparc64_register_type (struct gdbarch *gdbarch, int regnum) { - /* Raw registers. */ + if (tdesc_has_registers (gdbarch_target_desc (gdbarch))) + return tdesc_register_type (gdbarch, regnum); + /* Raw registers. */ if (regnum == SPARC_SP_REGNUM || regnum == SPARC_FP_REGNUM) return builtin_type (gdbarch)->builtin_data_ptr; if (regnum >= SPARC_G0_REGNUM && regnum <= SPARC_I7_REGNUM) @@ -323,19 +389,8 @@ sparc64_register_type (struct gdbarch *gdbarch, int regnum) return builtin_type (gdbarch)->builtin_int64; /* Pseudo registers. */ - - if (regnum == SPARC64_CWP_REGNUM) - return builtin_type (gdbarch)->builtin_int64; - if (regnum == SPARC64_PSTATE_REGNUM) - return sparc64_pstate_type (gdbarch); - if (regnum == SPARC64_ASI_REGNUM) - return builtin_type (gdbarch)->builtin_int64; - if (regnum == SPARC64_CCR_REGNUM) - return builtin_type (gdbarch)->builtin_int64; - if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D62_REGNUM) - return builtin_type (gdbarch)->builtin_double; - if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q60_REGNUM) - return builtin_type (gdbarch)->builtin_long_double; + if (regnum >= gdbarch_num_regs (gdbarch)) + return sparc64_pseudo_register_type (gdbarch, regnum); internal_error (__FILE__, __LINE__, _("invalid regnum")); } @@ -348,7 +403,7 @@ sparc64_pseudo_register_read (struct gdbarch *gdbarch, enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); enum register_status status; - gdb_assert (regnum >= SPARC64_NUM_REGS); + regnum -= gdbarch_num_regs (gdbarch); if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM) { @@ -425,7 +480,8 @@ sparc64_pseudo_register_write (struct gdbarch *gdbarch, int regnum, const gdb_byte *buf) { enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - gdb_assert (regnum >= SPARC64_NUM_REGS); + + regnum -= gdbarch_num_regs (gdbarch); if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM) { @@ -613,6 +669,13 @@ static const struct frame_base sparc64_frame_base = static int sparc64_16_byte_align_p (struct type *type) { + if (TYPE_CODE (type) == TYPE_CODE_ARRAY) + { + struct type *t = check_typedef (TYPE_TARGET_TYPE (type)); + + if (sparc64_floating_p (t)) + return 1; + } if (sparc64_floating_p (type) && TYPE_LENGTH (type) == 16) return 1; @@ -642,11 +705,28 @@ static void sparc64_store_floating_fields (struct regcache *regcache, struct type *type, const gdb_byte *valbuf, int element, int bitpos) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); int len = TYPE_LENGTH (type); gdb_assert (element < 16); - if (sparc64_floating_p (type) + if (TYPE_CODE (type) == TYPE_CODE_ARRAY) + { + gdb_byte buf[8]; + int regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32; + + valbuf += bitpos / 8; + if (len < 8) + { + memset (buf, 0, 8 - len); + memcpy (buf + 8 - len, valbuf, len); + valbuf = buf; + len = 8; + } + for (int n = 0; n < (len + 3) / 4; n++) + regcache_cooked_write (regcache, regnum + n, valbuf + n * 4); + } + else if (sparc64_floating_p (type) || (sparc64_complex_floating_p (type) && len <= 16)) { int regnum; @@ -656,14 +736,15 @@ sparc64_store_floating_fields (struct regcache *regcache, struct type *type, gdb_assert (bitpos == 0); gdb_assert ((element % 2) == 0); - regnum = SPARC64_Q0_REGNUM + element / 2; + regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM + element / 2; regcache_cooked_write (regcache, regnum, valbuf); } else if (len == 8) { gdb_assert (bitpos == 0 || bitpos == 64); - regnum = SPARC64_D0_REGNUM + element + bitpos / 64; + regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + + element + bitpos / 64; regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8)); } else @@ -716,7 +797,25 @@ static void sparc64_extract_floating_fields (struct regcache *regcache, struct type *type, gdb_byte *valbuf, int bitpos) { - if (sparc64_floating_p (type)) + struct gdbarch *gdbarch = get_regcache_arch (regcache); + + if (TYPE_CODE (type) == TYPE_CODE_ARRAY) + { + int len = TYPE_LENGTH (type); + int regnum = SPARC_F0_REGNUM + bitpos / 32; + + valbuf += bitpos / 8; + if (len < 4) + { + gdb_byte buf[4]; + regcache_cooked_read (regcache, regnum, buf); + memcpy (valbuf, buf + 4 - len, len); + } + else + for (int i = 0; i < (len + 3) / 4; i++) + regcache_cooked_read (regcache, regnum + i, valbuf + i * 4); + } + else if (sparc64_floating_p (type)) { int len = TYPE_LENGTH (type); int regnum; @@ -725,14 +824,15 @@ sparc64_extract_floating_fields (struct regcache *regcache, struct type *type, { gdb_assert (bitpos == 0 || bitpos == 128); - regnum = SPARC64_Q0_REGNUM + bitpos / 128; + regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM + + bitpos / 128; regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8)); } else if (len == 8) { gdb_assert (bitpos % 64 == 0 && bitpos >= 0 && bitpos < 256); - regnum = SPARC64_D0_REGNUM + bitpos / 64; + regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + bitpos / 64; regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8)); } else @@ -786,7 +886,8 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, struct type *type = value_type (args[i]); int len = TYPE_LENGTH (type); - if (sparc64_structure_or_union_p (type)) + if (sparc64_structure_or_union_p (type) + || (sparc64_complex_floating_p (type) && len == 32)) { /* Structure or Union arguments. */ if (len <= 16) @@ -817,10 +918,9 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, num_elements++; } } - else if (sparc64_floating_p (type)) + else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type)) { /* Floating arguments. */ - if (len == 16) { /* The psABI says that "Each quad-precision parameter @@ -832,7 +932,7 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, quad-aligned, and thus a hole might be introduced into the parameter array to force alignment." Skip an element if necessary. */ - if (num_elements % 2) + if ((num_elements % 2) && sparc64_16_byte_align_p (type)) num_elements++; } else @@ -888,12 +988,14 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, int regnum = -1; gdb_byte buf[16]; - if (sparc64_structure_or_union_p (type)) + if (sparc64_structure_or_union_p (type) + || (sparc64_complex_floating_p (type) && len == 32)) { - /* Structure or Union arguments. */ + /* Structure, Union or long double Complex arguments. */ gdb_assert (len <= 16); memset (buf, 0, sizeof (buf)); - valbuf = memcpy (buf, valbuf, len); + memcpy (buf, valbuf, len); + valbuf = buf; if (element % 2 && sparc64_16_byte_align_p (type)) element++; @@ -908,7 +1010,25 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, if (element < 16) sparc64_store_floating_fields (regcache, type, valbuf, element, 0); } - else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type)) + else if (sparc64_complex_floating_p (type)) + { + /* Float Complex or double Complex arguments. */ + if (element < 16) + { + regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + element; + + if (len == 16) + { + if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D30_REGNUM) + regcache_cooked_write (regcache, regnum + 1, valbuf + 8); + if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D10_REGNUM) + regcache_cooked_write (regcache, + SPARC_O0_REGNUM + element + 1, + valbuf + 8); + } + } + } + else if (sparc64_floating_p (type)) { /* Floating arguments. */ if (len == 16) @@ -916,19 +1036,21 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, if (element % 2) element++; if (element < 16) - regnum = SPARC64_Q0_REGNUM + element / 2; + regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM + + element / 2; } else if (len == 8) { if (element < 16) - regnum = SPARC64_D0_REGNUM + element; + regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + + element; } else if (len == 4) { /* The psABI says "Each single-precision parameter value will be assigned to one extended word in the parameter array, and right-justified within that - word; the left half (even floatregister) is + word; the left half (even float register) is undefined." Even though the psABI says that "the left half is undefined", set it to zero here. */ memset (buf, 0, 4); @@ -936,7 +1058,8 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, valbuf = buf; len = 8; if (element < 16) - regnum = SPARC64_D0_REGNUM + element; + regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + + element; } } else @@ -953,19 +1076,24 @@ sparc64_store_arguments (struct regcache *regcache, int nargs, /* If we're storing the value in a floating-point register, also store it in the corresponding %0 register(s). */ - if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D10_REGNUM) - { - gdb_assert (element < 6); - regnum = SPARC_O0_REGNUM + element; - regcache_cooked_write (regcache, regnum, valbuf); - } - else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM) - { - gdb_assert (element < 6); - regnum = SPARC_O0_REGNUM + element; - regcache_cooked_write (regcache, regnum, valbuf); - regcache_cooked_write (regcache, regnum + 1, valbuf + 8); - } + if (regnum >= gdbarch_num_regs (gdbarch)) + { + regnum -= gdbarch_num_regs (gdbarch); + + if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D10_REGNUM) + { + gdb_assert (element < 6); + regnum = SPARC_O0_REGNUM + element; + regcache_cooked_write (regcache, regnum, valbuf); + } + else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM) + { + gdb_assert (element < 5); + regnum = SPARC_O0_REGNUM + element; + regcache_cooked_write (regcache, regnum, valbuf); + regcache_cooked_write (regcache, regnum + 1, valbuf + 8); + } + } } /* Always store the argument in memory. */ @@ -1035,7 +1163,7 @@ sparc64_extract_return_value (struct type *type, struct regcache *regcache, sparc64_extract_floating_fields (regcache, type, buf, 0); memcpy (valbuf, buf, len); } - else if (sparc64_floating_p (type)) + else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type)) { /* Floating return values. */ for (i = 0; i < len / 4; i++) @@ -1119,7 +1247,7 @@ sparc64_store_return_value (struct type *type, struct regcache *regcache, } static enum return_value_convention -sparc64_return_value (struct gdbarch *gdbarch, struct type *func_type, +sparc64_return_value (struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { @@ -1169,16 +1297,25 @@ sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) tdep->pc_regnum = SPARC64_PC_REGNUM; tdep->npc_regnum = SPARC64_NPC_REGNUM; + tdep->fpu_register_names = sparc64_fpu_register_names; + tdep->fpu_registers_num = ARRAY_SIZE (sparc64_fpu_register_names); + tdep->cp0_register_names = sparc64_cp0_register_names; + tdep->cp0_registers_num = ARRAY_SIZE (sparc64_cp0_register_names); /* This is what all the fuss is about. */ set_gdbarch_long_bit (gdbarch, 64); set_gdbarch_long_long_bit (gdbarch, 64); set_gdbarch_ptr_bit (gdbarch, 64); + set_gdbarch_wchar_bit (gdbarch, 16); + set_gdbarch_wchar_signed (gdbarch, 0); + set_gdbarch_num_regs (gdbarch, SPARC64_NUM_REGS); set_gdbarch_register_name (gdbarch, sparc64_register_name); set_gdbarch_register_type (gdbarch, sparc64_register_type); set_gdbarch_num_pseudo_regs (gdbarch, SPARC64_NUM_PSEUDO_REGS); + set_tdesc_pseudo_register_name (gdbarch, sparc64_pseudo_register_name); + set_tdesc_pseudo_register_type (gdbarch, sparc64_pseudo_register_type); set_gdbarch_pseudo_register_read (gdbarch, sparc64_pseudo_register_read); set_gdbarch_pseudo_register_write (gdbarch, sparc64_pseudo_register_write); @@ -1196,6 +1333,7 @@ sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) (gdbarch, default_stabs_argument_has_addr); set_gdbarch_skip_prologue (gdbarch, sparc64_skip_prologue); + set_gdbarch_stack_frame_destroyed_p (gdbarch, sparc_stack_frame_destroyed_p); /* Hook in the DWARF CFI frame unwinder. */ dwarf2_frame_set_init_reg (gdbarch, sparc64_dwarf2_frame_init_reg); @@ -1221,14 +1359,14 @@ sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) #define PSR_XCC 0x000f0000 void -sparc64_supply_gregset (const struct sparc_gregset *gregset, +sparc64_supply_gregset (const struct sparc_gregmap *gregmap, struct regcache *regcache, int regnum, const void *gregs) { struct gdbarch *gdbarch = get_regcache_arch (regcache); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32); - const gdb_byte *regs = gregs; + const gdb_byte *regs = (const gdb_byte *) gregs; gdb_byte zero[8] = { 0 }; int i; @@ -1236,7 +1374,7 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset, { if (regnum == SPARC32_PSR_REGNUM || regnum == -1) { - int offset = gregset->r_tstate_offset; + int offset = gregmap->r_tstate_offset; ULONGEST tstate, psr; gdb_byte buf[4]; @@ -1249,15 +1387,15 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset, if (regnum == SPARC32_PC_REGNUM || regnum == -1) regcache_raw_supply (regcache, SPARC32_PC_REGNUM, - regs + gregset->r_pc_offset + 4); + regs + gregmap->r_pc_offset + 4); if (regnum == SPARC32_NPC_REGNUM || regnum == -1) regcache_raw_supply (regcache, SPARC32_NPC_REGNUM, - regs + gregset->r_npc_offset + 4); + regs + gregmap->r_npc_offset + 4); if (regnum == SPARC32_Y_REGNUM || regnum == -1) { - int offset = gregset->r_y_offset + 8 - gregset->r_y_size; + int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size; regcache_raw_supply (regcache, SPARC32_Y_REGNUM, regs + offset); } } @@ -1265,30 +1403,30 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset, { if (regnum == SPARC64_STATE_REGNUM || regnum == -1) regcache_raw_supply (regcache, SPARC64_STATE_REGNUM, - regs + gregset->r_tstate_offset); + regs + gregmap->r_tstate_offset); if (regnum == SPARC64_PC_REGNUM || regnum == -1) regcache_raw_supply (regcache, SPARC64_PC_REGNUM, - regs + gregset->r_pc_offset); + regs + gregmap->r_pc_offset); if (regnum == SPARC64_NPC_REGNUM || regnum == -1) regcache_raw_supply (regcache, SPARC64_NPC_REGNUM, - regs + gregset->r_npc_offset); + regs + gregmap->r_npc_offset); if (regnum == SPARC64_Y_REGNUM || regnum == -1) { gdb_byte buf[8]; memset (buf, 0, 8); - memcpy (buf + 8 - gregset->r_y_size, - regs + gregset->r_y_offset, gregset->r_y_size); + memcpy (buf + 8 - gregmap->r_y_size, + regs + gregmap->r_y_offset, gregmap->r_y_size); regcache_raw_supply (regcache, SPARC64_Y_REGNUM, buf); } if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1) - && gregset->r_fprs_offset != -1) + && gregmap->r_fprs_offset != -1) regcache_raw_supply (regcache, SPARC64_FPRS_REGNUM, - regs + gregset->r_fprs_offset); + regs + gregmap->r_fprs_offset); } if (regnum == SPARC_G0_REGNUM || regnum == -1) @@ -1296,7 +1434,7 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset, if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1) { - int offset = gregset->r_g1_offset; + int offset = gregmap->r_g1_offset; if (sparc32) offset += 4; @@ -1313,7 +1451,7 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset, { /* Not all of the register set variants include Locals and Inputs. For those that don't, we read them off the stack. */ - if (gregset->r_l0_offset == -1) + if (gregmap->r_l0_offset == -1) { ULONGEST sp; @@ -1322,7 +1460,7 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset, } else { - int offset = gregset->r_l0_offset; + int offset = gregmap->r_l0_offset; if (sparc32) offset += 4; @@ -1338,21 +1476,21 @@ sparc64_supply_gregset (const struct sparc_gregset *gregset, } void -sparc64_collect_gregset (const struct sparc_gregset *gregset, +sparc64_collect_gregset (const struct sparc_gregmap *gregmap, const struct regcache *regcache, int regnum, void *gregs) { struct gdbarch *gdbarch = get_regcache_arch (regcache); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32); - gdb_byte *regs = gregs; + gdb_byte *regs = (gdb_byte *) gregs; int i; if (sparc32) { if (regnum == SPARC32_PSR_REGNUM || regnum == -1) { - int offset = gregset->r_tstate_offset; + int offset = gregmap->r_tstate_offset; ULONGEST tstate, psr; gdb_byte buf[8]; @@ -1368,15 +1506,15 @@ sparc64_collect_gregset (const struct sparc_gregset *gregset, if (regnum == SPARC32_PC_REGNUM || regnum == -1) regcache_raw_collect (regcache, SPARC32_PC_REGNUM, - regs + gregset->r_pc_offset + 4); + regs + gregmap->r_pc_offset + 4); if (regnum == SPARC32_NPC_REGNUM || regnum == -1) regcache_raw_collect (regcache, SPARC32_NPC_REGNUM, - regs + gregset->r_npc_offset + 4); + regs + gregmap->r_npc_offset + 4); if (regnum == SPARC32_Y_REGNUM || regnum == -1) { - int offset = gregset->r_y_offset + 8 - gregset->r_y_size; + int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size; regcache_raw_collect (regcache, SPARC32_Y_REGNUM, regs + offset); } } @@ -1384,35 +1522,35 @@ sparc64_collect_gregset (const struct sparc_gregset *gregset, { if (regnum == SPARC64_STATE_REGNUM || regnum == -1) regcache_raw_collect (regcache, SPARC64_STATE_REGNUM, - regs + gregset->r_tstate_offset); + regs + gregmap->r_tstate_offset); if (regnum == SPARC64_PC_REGNUM || regnum == -1) regcache_raw_collect (regcache, SPARC64_PC_REGNUM, - regs + gregset->r_pc_offset); + regs + gregmap->r_pc_offset); if (regnum == SPARC64_NPC_REGNUM || regnum == -1) regcache_raw_collect (regcache, SPARC64_NPC_REGNUM, - regs + gregset->r_npc_offset); + regs + gregmap->r_npc_offset); if (regnum == SPARC64_Y_REGNUM || regnum == -1) { gdb_byte buf[8]; regcache_raw_collect (regcache, SPARC64_Y_REGNUM, buf); - memcpy (regs + gregset->r_y_offset, - buf + 8 - gregset->r_y_size, gregset->r_y_size); + memcpy (regs + gregmap->r_y_offset, + buf + 8 - gregmap->r_y_size, gregmap->r_y_size); } if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1) - && gregset->r_fprs_offset != -1) + && gregmap->r_fprs_offset != -1) regcache_raw_collect (regcache, SPARC64_FPRS_REGNUM, - regs + gregset->r_fprs_offset); + regs + gregmap->r_fprs_offset); } if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1) { - int offset = gregset->r_g1_offset; + int offset = gregmap->r_g1_offset; if (sparc32) offset += 4; @@ -1430,9 +1568,9 @@ sparc64_collect_gregset (const struct sparc_gregset *gregset, { /* Not all of the register set variants include Locals and Inputs. For those that don't, we read them off the stack. */ - if (gregset->r_l0_offset != -1) + if (gregmap->r_l0_offset != -1) { - int offset = gregset->r_l0_offset; + int offset = gregmap->r_l0_offset; if (sparc32) offset += 4; @@ -1448,24 +1586,26 @@ sparc64_collect_gregset (const struct sparc_gregset *gregset, } void -sparc64_supply_fpregset (struct regcache *regcache, +sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap, + struct regcache *regcache, int regnum, const void *fpregs) { int sparc32 = (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 32); - const gdb_byte *regs = fpregs; + const gdb_byte *regs = (const gdb_byte *) fpregs; int i; for (i = 0; i < 32; i++) { if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1) - regcache_raw_supply (regcache, SPARC_F0_REGNUM + i, regs + (i * 4)); + regcache_raw_supply (regcache, SPARC_F0_REGNUM + i, + regs + fpregmap->r_f0_offset + (i * 4)); } if (sparc32) { if (regnum == SPARC32_FSR_REGNUM || regnum == -1) regcache_raw_supply (regcache, SPARC32_FSR_REGNUM, - regs + (32 * 4) + (16 * 8) + 4); + regs + fpregmap->r_fsr_offset); } else { @@ -1473,34 +1613,37 @@ sparc64_supply_fpregset (struct regcache *regcache, { if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1) regcache_raw_supply (regcache, SPARC64_F32_REGNUM + i, - regs + (32 * 4) + (i * 8)); + (regs + fpregmap->r_f0_offset + + (32 * 4) + (i * 8))); } if (regnum == SPARC64_FSR_REGNUM || regnum == -1) regcache_raw_supply (regcache, SPARC64_FSR_REGNUM, - regs + (32 * 4) + (16 * 8)); + regs + fpregmap->r_fsr_offset); } } void -sparc64_collect_fpregset (const struct regcache *regcache, +sparc64_collect_fpregset (const struct sparc_fpregmap *fpregmap, + const struct regcache *regcache, int regnum, void *fpregs) { int sparc32 = (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 32); - gdb_byte *regs = fpregs; + gdb_byte *regs = (gdb_byte *) fpregs; int i; for (i = 0; i < 32; i++) { if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1) - regcache_raw_collect (regcache, SPARC_F0_REGNUM + i, regs + (i * 4)); + regcache_raw_collect (regcache, SPARC_F0_REGNUM + i, + regs + fpregmap->r_f0_offset + (i * 4)); } if (sparc32) { if (regnum == SPARC32_FSR_REGNUM || regnum == -1) regcache_raw_collect (regcache, SPARC32_FSR_REGNUM, - regs + (32 * 4) + (16 * 8) + 4); + regs + fpregmap->r_fsr_offset); } else { @@ -1508,12 +1651,18 @@ sparc64_collect_fpregset (const struct regcache *regcache, { if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1) regcache_raw_collect (regcache, SPARC64_F32_REGNUM + i, - regs + (32 * 4) + (i * 8)); + (regs + fpregmap->r_f0_offset + + (32 * 4) + (i * 8))); } if (regnum == SPARC64_FSR_REGNUM || regnum == -1) regcache_raw_collect (regcache, SPARC64_FSR_REGNUM, - regs + (32 * 4) + (16 * 8)); + regs + fpregmap->r_fsr_offset); } } +const struct sparc_fpregmap sparc64_bsd_fpregmap = +{ + 0 * 8, /* %f0 */ + 32 * 8, /* %fsr */ +};