75 case TYPE_CODE_DECFLOAT:
94 static int s390_instrlen[] = { 2, 4, 4, 6 };
99 instrlen = s390_instrlen[instr[0] >> 6];
125is_ri (bfd_byte *insn,
int op1,
int op2,
unsigned int *r1,
int *i2)
127 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
129 *r1 = (insn[1] >> 4) & 0xf;
131 *i2 = (((insn[2] << 8) | insn[3]) ^ 0x8000) - 0x8000;
142 unsigned int *r1,
int *i2)
144 if (insn[0] == op1 && (insn[1] & 0xf) == op2)
146 *r1 = (insn[1] >> 4) & 0xf;
150 *i2 = (((insn[2] << 24)
153 | (insn[5])) ^ 0x80000000) - 0x80000000;
163is_rr (bfd_byte *insn,
int op,
unsigned int *r1,
unsigned int *r2)
167 *r1 = (insn[1] >> 4) & 0xf;
178is_rre (bfd_byte *insn,
int op,
unsigned int *r1,
unsigned int *r2)
180 if (((insn[0] << 8) | insn[1]) == op)
183 *r1 = (insn[3] >> 4) & 0xf;
195 unsigned int *r1,
unsigned int *r3,
int *d2,
unsigned int *b2)
199 *r1 = (insn[1] >> 4) & 0xf;
201 *b2 = (insn[2] >> 4) & 0xf;
202 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
213 unsigned int *r1,
unsigned int *r3,
int *d2,
unsigned int *b2)
218 *r1 = (insn[1] >> 4) & 0xf;
220 *b2 = (insn[2] >> 4) & 0xf;
222 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
223 ^ 0x80000) - 0x80000;
234 unsigned int *r1,
int *d2,
unsigned int *x2,
unsigned int *b2)
238 *r1 = (insn[1] >> 4) & 0xf;
240 *b2 = (insn[2] >> 4) & 0xf;
241 *d2 = ((insn[2] & 0xf) << 8) | insn[3];
252 unsigned int *r1,
int *d2,
unsigned int *x2,
unsigned int *b2)
257 *r1 = (insn[1] >> 4) & 0xf;
259 *b2 = (insn[2] >> 4) & 0xf;
261 *d2 = ((((insn[2] & 0xf) << 8) | insn[3] | (insn[4] << 12))
262 ^ 0x80000) - 0x80000;
291 if ((insn & 0xff) == 0x8e)
336static std::vector<CORE_ADDR>
361 if (insn != (uint16_t) -(len / 2))
378 gdb_byte op1 = insn[0];
382 gdb_byte op2 = insn[1] & 0x0f;
400 else if (op1 == 0xc6)
402 gdb_byte op2 = insn[1] & 0x0f;
432 CORE_ADDR from, CORE_ADDR to,
436 std::unique_ptr<s390_displaced_step_copy_insn_closure> closure
438 gdb_byte *buf = closure->buf.data ();
449 offset = (from - to + offset * 2) / 2;
455 if (offset < INT32_MIN || offset >
INT32_MAX)
460 "%s out of range", plongest (offset));
484 CORE_ADDR from, CORE_ADDR to,
490 gdb_byte *insn = closure->
buf.data ();
491 static int s390_instrlen[] = { 2, 4, 4, 6 };
492 int insnlen = s390_instrlen[insn[0] >> 6];
495 unsigned int b2, r1, r2, x2, r3;
519 amode | (from + insnlen));
521 if (op_basr_p && r2 == 0)
538 if (pc == to + insnlen)
550 amode | (from + insnlen));
564 else if (insn[0] == 0x0 && insn[1] == 0x1)
626 int d2,
unsigned int x2,
unsigned int b2)
632 result =
pv_add (result, data->gpr[x2]);
634 result =
pv_add (result, data->gpr[b2]);
643 int d2,
unsigned int x2,
unsigned int b2, CORE_ADDR
size,
653 if (
size == data->gpr_size
656 data->back_chain_saved_p = 1;
661 if (!data->stack->store_would_trash (addr))
676 int d2,
unsigned int x2,
unsigned int b2, CORE_ADDR
size)
697 return data->stack->fetch (
addr,
size);
718 offset = 16 * data->gpr_size + 32 - addr.
k;
725 if (
size == data->gpr_size
727 if (data->gpr_slot[i] == 0
728 || data->gpr_slot[i] > offset)
730 data->gpr_slot[i] = offset;
735 if (
size == data->fpr_size
737 if (data->fpr_slot[i] == 0
738 || data->fpr_slot[i] > offset)
740 data->fpr_slot[i] = offset;
754 CORE_ADDR current_pc,
763 CORE_ADDR result = start_pc;
772 scoped_restore restore_stack = make_scoped_restore (&data->stack, &
stack);
781 data->gpr_size = word_size;
792 data->gpr_slot[i] = 0;
795 data->fpr_slot[i] = 0;
797 data->back_chain_saved_p = 0;
802 for (pc = start_pc; pc > 0 && pc < current_pc; pc = next_pc)
808 bfd_byte *insn32 = word_size == 4 ? insn :
dummy;
809 bfd_byte *insn64 = word_size == 8 ? insn :
dummy;
812 unsigned int b2, r1, r2, x2, r3;
817 pv_t pre_insn_sp, pre_insn_fp;
819 int pre_insn_back_chain_saved_p;
828 next_pc = pc + insn_len;
832 pre_insn_back_chain_saved_p = data->back_chain_saved_p;
846 data->gpr[r1] = data->gpr[r2];
851 else if (
is_rx (insn32,
op_l, &r1, &d2, &x2, &b2)
854 data->gpr[r1] =
s390_load (data, d2, x2, b2, data->gpr_size);
859 else if (
is_rx (insn32,
op_st, &r1, &d2, &x2, &b2)
862 s390_store (data, d2, x2, b2, data->gpr_size, data->gpr[r1]);
866 s390_store (data, d2, x2, b2, data->fpr_size, data->fpr[r1]);
872 else if (
is_rs (insn32,
op_stm, &r1, &r3, &d2, &b2)
876 for (; r1 <= r3; r1++, d2 += data->gpr_size)
877 s390_store (data, d2, 0, b2, data->gpr_size, data->gpr[r1]);
895 (CORE_ADDR)i2 & 0xffffffff);
901 data->gpr[r1] =
pv_add (data->gpr[r1], data->gpr[r2]);
906 else if (
is_rx (insn32,
op_a, &r1, &d2, &x2, &b2)
909 data->gpr[r1] =
pv_add (data->gpr[r1],
910 s390_load (data, d2, x2, b2, data->gpr_size));
917 -((CORE_ADDR)i2 & 0xffffffff));
923 data->gpr[r1] =
pv_subtract (data->gpr[r1], data->gpr[r2]);
928 else if (
is_rx (insn32,
op_s, &r1, &d2, &x2, &b2)
932 s390_load (data, d2, x2, b2, data->gpr_size));
936 else if (
is_rx (insn,
op_la, &r1, &d2, &x2, &b2)
938 data->gpr[r1] =
s390_addr (data, d2, x2, b2);
954 next_pc = pc + i2 * 2;
967 if (r1 != 0 && i2 != 1 && i2 != 2)
972 if (r1 != 0 && i2 != 3)
1009 || pre_insn_back_chain_saved_p != data->back_chain_saved_p)
1027 CORE_ADDR skip_pc, func_addr;
1031 CORE_ADDR post_prologue_pc
1033 if (post_prologue_pc != 0)
1034 return std::max (pc, post_prologue_pc);
1038 return skip_pc ? skip_pc : pc;
1081 gdb_byte *reg = (gdb_byte *) alloca (sz);
1082 ULONGEST pswm, pswa;
1090 pswa = addr | 0x80000000UL;
1091 pswm = 0x070d0000UL;
1096 pswm = 0x0705000180000000ULL;
1135 -1, -1, -1, -1, -1, -1, -1, -1,
1136 -1, -1, -1, -1, -1, -1, -1, -1,
1212 && regnum <= tdep->gpr_full_regnum + 15);
1223 && regnum <= tdep->v0_full_regnum + 15);
1230static struct value *
1263 static const char *full_name[] = {
1264 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
1265 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15"
1272 static const char *full_name[] = {
1273 "v0",
"v1",
"v2",
"v3",
"v4",
"v5",
"v6",
"v7",
1274 "v8",
"v9",
"v10",
"v11",
"v12",
"v13",
"v14",
"v15"
1279 internal_error (_(
"invalid regnum"));
1302 internal_error (_(
"invalid regnum"));
1307static enum register_status
1309 int regnum, gdb_byte *buf)
1318 enum register_status
status;
1332 enum register_status
status;
1338 val = (val >> 12) & 3;
1340 val = (val >> 44) & 3;
1348 enum register_status
status;
1359 val |= val_upper << 32;
1367 enum register_status
status;
1377 internal_error (_(
"invalid regnum"));
1384 int regnum,
const gdb_byte *buf)
1397 val = (psw & 0x80000000) | (val & 0x7fffffff);
1408 val = (psw & ~((ULONGEST)3 << 12)) | ((val & 3) << 12);
1410 val = (psw & ~((ULONGEST)3 << 44)) | ((val & 3) << 44);
1434 internal_error (_(
"invalid regnum"));
1496 internal_error (_(
"invalid regnum"));
1542 internal_error (_(
"invalid regnum"));
1569 return addr & 0x7fffffff;
1575static type_instance_flags
1589 type_instance_flags type_flags)
1603 type_instance_flags *type_flags_ptr)
1605 if (strcmp (
name,
"mode32") == 0)
1632 while (
type->
code () == TYPE_CODE_STRUCT)
1634 struct type *inner = NULL;
1652 if (inner->
length () < min_size)
1675 return (
type->
code () == TYPE_CODE_FLT
1676 ||
type->
code () == TYPE_CODE_DECFLOAT);
1698 return n && ((n & (n - 1)) == 0);
1713 if (
code == TYPE_CODE_INT
1714 ||
code == TYPE_CODE_ENUM
1715 ||
code == TYPE_CODE_RANGE
1716 ||
code == TYPE_CODE_CHAR
1717 ||
code == TYPE_CODE_BOOL
1718 ||
code == TYPE_CODE_PTR
1722 return ((
code == TYPE_CODE_UNION ||
code == TYPE_CODE_STRUCT)
1750 enum bfd_endian byte_order,
int is_unnamed)
1754 int write_mode = as->
regcache != NULL;
1783 static const char use_vr[] = {24, 26, 28, 30, 25, 27, 29, 31};
1785 if (!is_unnamed && as->
vr < ARRAY_SIZE (use_vr))
1831 as->
argp += word_size;
1880 byte_order, as->
copy);
1881 as->
argp += word_size;
1904 int nargs,
struct value **args, CORE_ADDR sp,
1906 CORE_ADDR struct_addr)
1913 CORE_ADDR param_area_start, new_sp;
1916 if (ftype->
code () == TYPE_CODE_PTR)
1927 arg_state = arg_prep;
1931 for (i = 0; i < nargs; i++)
1935 param_area_start = align_down (arg_state.
copy - arg_state.
argp, 8);
1939 new_sp = param_area_start - (16 * word_size + 32);
1946 error (_(
"Stack overflow"));
1953 arg_state = arg_prep;
1954 arg_state.
argp = param_area_start;
1958 for (i = 0; i < nargs; i++)
1967 bp_addr = (bp_addr & 0x7fffffff) | (pswa & 0x80000000);
1976 return param_area_start;
2011 gdb_byte *out,
const gdb_byte *in)
2018 if (
code == TYPE_CODE_FLT ||
code == TYPE_CODE_DECFLOAT)
2026 else if (
code == TYPE_CODE_ARRAY)
2034 else if (length <= word_size)
2049 else if (length == 2 * word_size)
2064 internal_error (_(
"invalid return type"));
2072 gdb_byte *out,
const gdb_byte *in)
2080 case TYPE_CODE_STRUCT:
2081 case TYPE_CODE_UNION:
2082 case TYPE_CODE_COMPLEX:
2085 case TYPE_CODE_ARRAY:
2100 if (in != NULL || out != NULL)
2104 else if (in != NULL)
2105 error (_(
"Cannot set function return value."));
2107 error (_(
"Function return value unknown."));
2142 unsigned int r1, r3, b2;
2189static struct value *
2260static struct value *
2436 && (next_frame == NULL
2443 memset (&data, 0,
sizeof (data));
2454 cfa = prev_sp + 16*word_size + 32;
2459 info->saved_regs[i].set_unknown ();
2469 for (i = 0; i < 16; i++)
2471 && data.gpr_slot[i] != 0)
2472 info->saved_regs[
S390_R0_REGNUM + i].set_addr (cfa - data.gpr_slot[i]);
2474 for (i = 0; i < 16; i++)
2476 && data.fpr_slot[i] != 0)
2477 info->saved_regs[
S390_F0_REGNUM + i].set_addr (cfa - data.fpr_slot[i]);
2507 info->frame_base = prev_sp + 16*word_size + 32;
2508 info->local_base = prev_sp -
size;
2524 CORE_ADDR backchain;
2532 info->saved_regs[i].set_unknown ();
2541 backchain = (CORE_ADDR) tmp;
2549 word_size, byte_order, &sp)
2550 && (CORE_ADDR)sp == backchain)
2564 info->frame_base = backchain + 16*word_size + 32;
2565 info->local_base = reg;
2576 void **this_prologue_cache)
2580 if (*this_prologue_cache)
2584 *this_prologue_cache = info;
2587 info->frame_base = -1;
2588 info->local_base = -1;
2597 catch (
const gdb_exception_error &ex)
2599 if (ex.error != NOT_AVAILABLE_ERROR)
2610 void **this_prologue_cache,
2616 if (info->frame_base == -1)
2618 if (info->func != -1)
2628static struct value *
2630 void **this_prologue_cache,
int regnum)
2665 void **this_prologue_cache)
2672 if (*this_prologue_cache)
2676 *this_prologue_cache = info;
2684 info->frame_base = reg + 16*word_size + 32;
2693 void **this_prologue_cache,
2703static struct value *
2705 void **this_prologue_cache,
int regnum)
2717 void **this_prologue_cache)
2719 CORE_ADDR addr_in_block;
2751 return info->frame_base;
2759 return info->local_base;
2779 ULONGEST pswm, pswa;
2784 am = pswa >> 31 & 1;
2789 am = pswm >> 31 & 3;
2794 return val & 0xffffff;
2796 return val & 0x7fffffff;
2811 ULONGEST x, uint16_t bd, int8_t dh)
2813 uint8_t rb = bd >> 12 & 0xf;
2814 int32_t d = (bd & 0xfff) | ((int32_t)dh << 12);
2816 CORE_ADDR res = d + x;
2830 uint8_t rx, uint16_t bd, int8_t dh)
2842 uint8_t vx, uint8_t el, uint8_t es, uint16_t bd,
2843 int8_t dh, CORE_ADDR *res)
2864 CORE_ADDR addr, uint16_t i1, uint16_t i2)
2866 int32_t ri = i1 << 16 | i2;
2943 uint16_t insn[3] = {0};
2950 CORE_ADDR oaddr, oaddr2, oaddr3;
2964 insn[0] |= ex & 0xff;
2966 if (insn[0] >= 0x4000)
2971 if (insn[0] >= 0xc000)
2976 for (i = 0; i < 3; i++)
2978 ibyte[i*2] = insn[i] >> 8 & 0xff;
2979 ibyte[i*2+1] = insn[i] & 0xff;
2981 for (i = 0; i < 6; i++)
2983 inib[i*2] = ibyte[i] >> 4 & 0xf;
2984 inib[i*2+1] = ibyte[i] & 0xf;
2987 ivec[0] = (inib[9] >> 3 & 1) << 4 | inib[2];
2988 ivec[1] = (inib[9] >> 2 & 1) << 4 | inib[3];
2989 ivec[2] = (inib[9] >> 1 & 1) << 4 | inib[4];
2990 ivec[3] = (inib[9] >> 0 & 1) << 4 | inib[8];
3011 if (!(tmp & 0x80000000u))
3013 uint8_t ofc = tmp >> 16 & 0xff;
3392 if (inib[2] <= inib[3])
3393 n = inib[3] - inib[2] + 1;
3395 n = inib[3] + 0x10 - inib[2] + 1;
3418 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
3428 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
3441 switch (ibyte[0] << 4 | inib[3])
3675 }
while (cur != end);
4363 if (insn[0] == 0xb92f)
4390 if (tmp != 0 && insn[0] == 0xb929)
4672 if (insn[0] == 0xb93e)
4736 if (insn[0] == 0xb991)
4738 if (insn[0] == 0xb992)
4859 switch (ibyte[0] << 4 | inib[3])
5028 switch (ibyte[0] << 4 | inib[3])
5046 sc = tmp >> 8 & 0xff;
5204 switch (ibyte[0] << 8 | ibyte[5])
5738 for (i = ivec[0]; i != ivec[1]; i++, i &= 0x1f)
5752 if (ivec[0] <= ivec[1])
5753 n = ivec[1] - ivec[0] + 1;
5755 n = ivec[1] + 0x20 - ivec[0] + 1;
5886 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
5926 if (inib[2] <= inib[3])
5927 n = inib[3] - inib[2] + 1;
5929 n = inib[3] + 0x10 - inib[2] + 1;
5940 if (inib[2] <= inib[3])
5941 n = inib[3] - inib[2] + 1;
5943 n = inib[3] + 0x10 - inib[2] + 1;
6092 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6102 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6112 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6365 for (i = 0; i < 16; i++)
6383 switch (ibyte[0] << 8 | ibyte[5])
6492 uint8_t fc = tmp & 0xff;
6721 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6814 return ((isdigit (*s) && s[1] ==
'(' && s[2] ==
'%')
6824#define s390_validate_reg_range(feature, tdesc_data, start, names) \
6827 for (int i = 0; i < ARRAY_SIZE (names); i++) \
6828 if (!tdesc_numbered_register (feature, tdesc_data, start + i, names[i])) \
6840 static const char *
const psw[] = {
6843 static const char *
const gprs[] = {
6844 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
6845 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15"
6847 static const char *
const fprs[] = {
6848 "f0",
"f1",
"f2",
"f3",
"f4",
"f5",
"f6",
"f7",
6849 "f8",
"f9",
"f10",
"f11",
"f12",
"f13",
"f14",
"f15"
6851 static const char *
const acrs[] = {
6852 "acr0",
"acr1",
"acr2",
"acr3",
"acr4",
"acr5",
"acr6",
"acr7",
6853 "acr8",
"acr9",
"acr10",
"acr11",
"acr12",
"acr13",
"acr14",
"acr15"
6855 static const char *
const gprs_lower[] = {
6856 "r0l",
"r1l",
"r2l",
"r3l",
"r4l",
"r5l",
"r6l",
"r7l",
6857 "r8l",
"r9l",
"r10l",
"r11l",
"r12l",
"r13l",
"r14l",
"r15l"
6859 static const char *
const gprs_upper[] = {
6860 "r0h",
"r1h",
"r2h",
"r3h",
"r4h",
"r5h",
"r6h",
"r7h",
6861 "r8h",
"r9h",
"r10h",
"r11h",
"r12h",
"r13h",
"r14h",
"r15h"
6863 static const char *
const tdb_regs[] = {
6864 "tdb0",
"tac",
"tct",
"atia",
6865 "tr0",
"tr1",
"tr2",
"tr3",
"tr4",
"tr5",
"tr6",
"tr7",
6866 "tr8",
"tr9",
"tr10",
"tr11",
"tr12",
"tr13",
"tr14",
"tr15"
6868 static const char *
const vxrs_low[] = {
6869 "v0l",
"v1l",
"v2l",
"v3l",
"v4l",
"v5l",
"v6l",
"v7l",
"v8l",
6870 "v9l",
"v10l",
"v11l",
"v12l",
"v13l",
"v14l",
"v15l",
6872 static const char *
const vxrs_high[] = {
6873 "v16",
"v17",
"v18",
"v19",
"v20",
"v21",
"v22",
"v23",
"v24",
6874 "v25",
"v26",
"v27",
"v28",
"v29",
"v30",
"v31",
6876 static const char *
const gs_cb[] = {
6877 "gsd",
"gssm",
"gsepla",
6879 static const char *
const gs_bc[] = {
6880 "bc_gsd",
"bc_gssm",
"bc_gsepla",
6884 const struct tdesc_feature *feature;
6891 if (feature == NULL)
6911 if (feature == NULL)
6921 if (feature == NULL)
7021 const struct target_desc *tdesc = info.target_desc;
7022 int first_pseudo_reg, last_pseudo_reg;
7023 static const char *
const stap_register_prefixes[] = {
"%", NULL };
7024 static const char *
const stap_register_indirection_prefixes[] = {
"(",
7026 static const char *
const stap_register_indirection_suffixes[] = {
")",
7103 switch (
info.bfd_arch_info->mach)
7105 case bfd_mach_s390_31:
7109 case bfd_mach_s390_64:
7125 stap_register_indirection_prefixes);
7127 stap_register_indirection_suffixes);
7131 disassembler_options_s390 ());
7149 if (
info.bfd_arch_info->mach == bfd_mach_s390_31)
7154 tdep->
tdesc = tdesc;
7167 &&
info.abfd != NULL
7168 &&
info.abfd->format == bfd_object
7169 && bfd_get_flavour (
info.abfd) == bfd_target_elf_flavour
7170 && bfd_elf_get_obj_attr_int (
info.abfd, OBJ_ATTR_GNU,
7171 Tag_GNU_S390_ABI_Vector) == 2)
7181 = gdbarch_tdep<s390_gdbarch_tdep> (
arches->gdbarch);
7189 if (tmp->vector_abi != tdep->vector_abi)
7202 last_pseudo_reg = first_pseudo_reg;
7206 last_pseudo_reg += 16;
7211 last_pseudo_reg += 16;
void gdbarch_free(struct gdbarch *arch)
static std::vector< const char * > arches
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
#define BP_MANIPULATION(BREAK_INSN)
void ax_zero_ext(struct agent_expr *x, int n)
void ax_reg_mask(struct agent_expr *ax, int reg)
void ax_simple(struct agent_expr *x, enum agent_op op)
void ax_const_l(struct agent_expr *x, LONGEST l)
void ax_reg(struct agent_expr *x, int reg)
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
CORE_ADDR get_pc_function_start(CORE_ADDR pc)
enum register_status raw_read(int regnum, gdb_byte *buf)
enum register_status cooked_read_part(int regnum, int offset, int len, gdb_byte *buf)
enum register_status cooked_read(int regnum, gdb_byte *buf)
void raw_supply(int regnum, const void *buf) override
void cooked_write(int regnum, const gdb_byte *buf)
void cooked_write_part(int regnum, int offset, int len, const gdb_byte *buf)
void raw_write(int regnum, const gdb_byte *buf)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
void write_memory_unsigned_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, ULONGEST value)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
int safe_read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order, LONGEST *return_value)
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
static void store_signed_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, LONGEST val)
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
static LONGEST extract_signed_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
@ RETURN_VALUE_REGISTER_CONVENTION
@ RETURN_VALUE_STRUCT_CONVENTION
#define displaced_debug_printf(fmt,...)
std::unique_ptr< displaced_step_copy_insn_closure > displaced_step_copy_insn_closure_up
void dwarf2_frame_set_adjust_regnum(struct gdbarch *gdbarch, int(*adjust_regnum)(struct gdbarch *, int, int))
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
const struct frame_base * dwarf2_frame_base_sniffer(frame_info_ptr this_frame)
void dwarf2_frame_set_init_reg(struct gdbarch *gdbarch, void(*init_reg)(struct gdbarch *, int, struct dwarf2_frame_state_reg *, frame_info_ptr))
@ DWARF2_FRAME_REG_SAME_VALUE
@ DWARF2_FRAME_REG_UNDEFINED
struct value * default_value_from_register(struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id)
void frame_base_append_sniffer(struct gdbarch *gdbarch, frame_base_sniffer_ftype *sniffer)
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
int default_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
frame_info_ptr get_next_frame(frame_info_ptr this_frame)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
ULONGEST frame_unwind_register_unsigned(frame_info_ptr next_frame, int regnum)
CORE_ADDR get_frame_pc(frame_info_ptr frame)
bool get_frame_func_if_available(frame_info_ptr this_frame, CORE_ADDR *pc)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
struct value * frame_unwind_register_value(frame_info_ptr next_frame, int regnum)
enum frame_type get_frame_type(frame_info_ptr frame)
struct frame_id frame_id_build_unavailable_stack(CORE_ADDR code_addr)
CORE_ADDR get_frame_address_in_block(frame_info_ptr this_frame)
#define FRAME_OBSTACK_ZALLOC(TYPE)
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
void set_gdbarch_stab_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum)
void set_gdbarch_process_record(struct gdbarch *gdbarch, gdbarch_process_record_ftype *process_record)
void set_gdbarch_char_signed(struct gdbarch *gdbarch, int char_signed)
void set_gdbarch_unwind_pc(struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype *unwind_pc)
void set_gdbarch_disassembler_options(struct gdbarch *gdbarch, char **disassembler_options)
void set_gdbarch_gen_return_address(struct gdbarch *gdbarch, gdbarch_gen_return_address_ftype *gen_return_address)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
void set_gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc)
void set_gdbarch_software_single_step(struct gdbarch *gdbarch, gdbarch_software_single_step_ftype *software_single_step)
void set_gdbarch_valid_disassembler_options(struct gdbarch *gdbarch, const disasm_options_and_args_t *valid_disassembler_options)
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align)
void set_gdbarch_max_insn_length(struct gdbarch *gdbarch, ULONGEST max_insn_length)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
void set_gdbarch_addr_bits_remove(struct gdbarch *gdbarch, gdbarch_addr_bits_remove_ftype *addr_bits_remove)
void set_gdbarch_address_class_type_flags_to_name(struct gdbarch *gdbarch, gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name)
int gdbarch_addr_bit(struct gdbarch *gdbarch)
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name)
void set_gdbarch_address_class_type_flags(struct gdbarch *gdbarch, gdbarch_address_class_type_flags_ftype *address_class_type_flags)
void set_gdbarch_stap_is_single_operand(struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype *stap_is_single_operand)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_decr_pc_after_break(struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break)
void set_gdbarch_believe_pcc_promotion(struct gdbarch *gdbarch, int believe_pcc_promotion)
void set_gdbarch_gnu_triplet_regexp(struct gdbarch *gdbarch, gdbarch_gnu_triplet_regexp_ftype *gnu_triplet_regexp)
int gdbarch_num_regs(struct gdbarch *gdbarch)
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
void set_gdbarch_value_from_register(struct gdbarch *gdbarch, gdbarch_value_from_register_ftype *value_from_register)
void set_gdbarch_displaced_step_copy_insn(struct gdbarch *gdbarch, gdbarch_displaced_step_copy_insn_ftype *displaced_step_copy_insn)
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than)
void set_gdbarch_stap_register_indirection_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_prefixes)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
void set_gdbarch_ax_pseudo_register_collect(struct gdbarch *gdbarch, gdbarch_ax_pseudo_register_collect_ftype *ax_pseudo_register_collect)
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
void set_gdbarch_address_class_name_to_type_flags(struct gdbarch *gdbarch, gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags)
void set_gdbarch_gcc_target_options(struct gdbarch *gdbarch, gdbarch_gcc_target_options_ftype *gcc_target_options)
void set_gdbarch_displaced_step_fixup(struct gdbarch *gdbarch, gdbarch_displaced_step_fixup_ftype *displaced_step_fixup)
void set_gdbarch_stack_frame_destroyed_p(struct gdbarch *gdbarch, gdbarch_stack_frame_destroyed_p_ftype *stack_frame_destroyed_p)
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype *pseudo_register_write)
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
void set_gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum)
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
void set_gdbarch_type_align(struct gdbarch *gdbarch, gdbarch_type_align_ftype *type_align)
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype *pseudo_register_read)
void set_gdbarch_ax_pseudo_register_push_stack(struct gdbarch *gdbarch, gdbarch_ax_pseudo_register_push_stack_ftype *ax_pseudo_register_push_stack)
void set_gdbarch_guess_tracepoint_registers(struct gdbarch *gdbarch, gdbarch_guess_tracepoint_registers_ftype *guess_tracepoint_registers)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
void set_gdbarch_displaced_step_hw_singlestep(struct gdbarch *gdbarch, gdbarch_displaced_step_hw_singlestep_ftype *displaced_step_hw_singlestep)
void set_gdbarch_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
void set_gdbarch_stap_register_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_prefixes)
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype *dummy_id)
void set_gdbarch_unwind_sp(struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype *unwind_sp)
void set_gdbarch_stap_register_indirection_suffixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_suffixes)
ULONGEST gdbarch_max_insn_length(struct gdbarch *gdbarch)
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep_base *tdep)
function_call_return_method
int field_is_static(struct field *f)
const struct floatformat * floatformats_ieee_quad[BFD_ENDIAN_UNKNOWN]
struct type * check_typedef(struct type *type)
#define TYPE_IS_REFERENCE(t)
@ TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
struct inferior * current_inferior(void)
std::string displaced_step_dump_bytes(const gdb_byte *buf, size_t len)
static int in_plt_section(CORE_ADDR pc)
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
pv_t pv_subtract(pv_t a, pv_t b)
pv_t pv_constant(CORE_ADDR k)
int pv_is_register_k(pv_t a, int r, CORE_ADDR k)
pv_t pv_register(int reg, CORE_ADDR k)
int pv_is_identical(pv_t a, pv_t b)
pv_t pv_add(pv_t a, pv_t b)
pv_t pv_add_constant(pv_t v, CORE_ADDR k)
int pv_is_register(pv_t a, int r)
int pv_is_constant(pv_t a)
int record_full_arch_list_add_reg(struct regcache *regcache, int regnum)
int record_full_arch_list_add_mem(CORE_ADDR addr, int len)
int record_full_arch_list_add_end(void)
int record_full_is_used(void)
CORE_ADDR regcache_read_pc(struct regcache *regcache)
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
int register_size(struct gdbarch *gdbarch, int regnum)
void regcache_cooked_write_signed(struct regcache *regcache, int regnum, LONGEST val)
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
void regcache_raw_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
struct type * register_type(struct gdbarch *gdbarch, int regnum)
const reggroup *const general_reggroup
int default_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *group)
const reggroup *const save_reggroup
const reggroup *const restore_reggroup
const reggroup *const vector_reggroup
void(* func)(remote_target *remote, char *)
static void initialize_tdesc_s390_linux32(void)
const struct target_desc * tdesc_s390_linux32
static int regnum_is_gpr_full(s390_gdbarch_tdep *tdep, int regnum)
static struct value * s390_value_from_register(struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id)
static int is_power_of_two(unsigned int n)
static const struct frame_unwind s390_frame_unwind
buf_displaced_step_copy_insn_closure s390_displaced_step_copy_insn_closure
static int s390_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
static struct value * s390_stub_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
static int s390_prologue_frame_unwind_cache(frame_info_ptr this_frame, struct s390_unwind_cache *info)
static CORE_ADDR s390_unwind_pc(struct gdbarch *gdbarch, frame_info_ptr next_frame)
static int is_rx(bfd_byte *insn, int op, unsigned int *r1, int *d2, unsigned int *x2, unsigned int *b2)
static CORE_ADDR s390_record_address_mask(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val)
static int is_rsy(bfd_byte *insn, int op1, int op2, unsigned int *r1, unsigned int *r3, int *d2, unsigned int *b2)
static int s390_register_call_saved(struct gdbarch *gdbarch, int regnum)
static CORE_ADDR s390_local_base_address(frame_info_ptr this_frame, void **this_cache)
static const char * s390_pseudo_register_name(struct gdbarch *gdbarch, int regnum)
struct value * s390_trad_frame_prev_register(frame_info_ptr this_frame, trad_frame_saved_reg saved_regs[], int regnum)
static int s390_popcnt(unsigned int x)
static int is_rr(bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
static enum return_value_convention s390_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *out, const gdb_byte *in)
static bool s390_tdesc_valid(s390_gdbarch_tdep *tdep, struct tdesc_arch_data *tdesc_data)
static CORE_ADDR s390_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
static const struct frame_base s390_frame_base
static void s390_guess_tracepoint_registers(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
static const struct frame_unwind s390_stub_frame_unwind
static void s390_stub_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
static int s390_stub_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
static void s390_backchain_frame_unwind_cache(frame_info_ptr this_frame, struct s390_unwind_cache *info)
static int s390_stap_is_single_operand(struct gdbarch *gdbarch, const char *s)
static CORE_ADDR s390_record_calc_disp_common(struct gdbarch *gdbarch, struct regcache *regcache, ULONGEST x, uint16_t bd, int8_t dh)
static void s390_gen_return_address(struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope)
static int is_rxy(bfd_byte *insn, int op1, int op2, unsigned int *r1, int *d2, unsigned int *x2, unsigned int *b2)
static CORE_ADDR s390_record_calc_rl(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr, uint16_t i1, uint16_t i2)
static int is_non_branch_ril(gdb_byte *insn)
static struct s390_stub_unwind_cache * s390_stub_frame_unwind_cache(frame_info_ptr this_frame, void **this_prologue_cache)
static void s390_register_return_value(struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, gdb_byte *out, const gdb_byte *in)
static const char * s390_register_name(struct gdbarch *gdbarch, int regnum)
static void s390_handle_arg(struct s390_arg_state *as, struct value *arg, s390_gdbarch_tdep *tdep, int word_size, enum bfd_endian byte_order, int is_unnamed)
void _initialize_s390_tdep()
static CORE_ADDR s390_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR start_pc, CORE_ADDR current_pc, struct s390_prologue_data *data)
static int is_ril(bfd_byte *insn, int op1, int op2, unsigned int *r1, int *i2)
static s390_gdbarch_tdep * s390_gdbarch_tdep_alloc()
static void s390_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
static CORE_ADDR s390_record_calc_disp(struct gdbarch *gdbarch, struct regcache *regcache, uint8_t rx, uint16_t bd, int8_t dh)
static int s390_pseudo_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *group)
static CORE_ADDR s390_frame_base_address(frame_info_ptr this_frame, void **this_cache)
static const char * s390_address_class_type_flags_to_name(struct gdbarch *gdbarch, type_instance_flags type_flags)
static enum register_status s390_pseudo_register_read(struct gdbarch *gdbarch, readable_regcache *regcache, int regnum, gdb_byte *buf)
static struct value * s390_unwind_pseudo_register(frame_info_ptr this_frame, int regnum)
static pv_t s390_addr(struct s390_prologue_data *data, int d2, unsigned int x2, unsigned int b2)
static struct value * s390_dwarf2_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
static int s390_record_gpr_h(struct gdbarch *gdbarch, struct regcache *regcache, int i)
static type_instance_flags s390_address_class_type_flags(int byte_size, int dwarf2_addr_class)
static struct type * s390_effective_inner_type(struct type *type, unsigned int min_size)
static int s390_readinstruction(bfd_byte instr[], CORE_ADDR at)
static struct s390_unwind_cache * s390_frame_unwind_cache(frame_info_ptr this_frame, void **this_prologue_cache)
static void s390_check_for_saved(void *data_untyped, pv_t addr, CORE_ADDR size, pv_t value)
static pv_t s390_load(struct s390_prologue_data *data, int d2, unsigned int x2, unsigned int b2, CORE_ADDR size)
static CORE_ADDR s390_unwind_sp(struct gdbarch *gdbarch, frame_info_ptr next_frame)
static int s390_process_record(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
static int s390_record_gpr_g(struct gdbarch *gdbarch, struct regcache *regcache, int i)
static int s390_dwarf_reg_to_regnum(struct gdbarch *gdbarch, int reg)
static CORE_ADDR s390_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr)
static CORE_ADDR s390_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
static int s390_adjust_frame_regnum(struct gdbarch *gdbarch, int num, int eh_frame_p)
static int s390_record_calc_disp_vsce(struct gdbarch *gdbarch, struct regcache *regcache, uint8_t vx, uint8_t el, uint8_t es, uint16_t bd, int8_t dh, CORE_ADDR *res)
static int is_rre(bfd_byte *insn, int op, unsigned int *r1, unsigned int *r2)
static int is_ri(bfd_byte *insn, int op1, int op2, unsigned int *r1, int *i2)
static int s390_record_vr(struct gdbarch *gdbarch, struct regcache *regcache, int i)
static std::vector< CORE_ADDR > s390_software_single_step(struct regcache *regcache)
static int s390_ax_pseudo_register_collect(struct gdbarch *gdbarch, struct agent_expr *ax, int regnum)
static struct type * s390_pseudo_register_type(struct gdbarch *gdbarch, int regnum)
static void s390_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, const gdb_byte *buf)
#define s390_validate_reg_range(feature, tdesc_data, start, names)
static displaced_step_copy_insn_closure_up s390_displaced_step_copy_insn(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
static void s390_store(struct s390_prologue_data *data, int d2, unsigned int x2, unsigned int b2, CORE_ADDR size, pv_t value)
static int s390_ax_pseudo_register_push_stack(struct gdbarch *gdbarch, struct agent_expr *ax, int regnum)
static int s390_function_arg_vector(struct type *type)
static int regnum_is_vxr_full(s390_gdbarch_tdep *tdep, int regnum)
static std::string s390_gcc_target_options(struct gdbarch *gdbarch)
static void s390_dwarf2_frame_init_reg(struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, frame_info_ptr this_frame)
constexpr gdb_byte s390_break_insn[]
static bool s390_displaced_step_hw_singlestep(struct gdbarch *gdbarch)
static struct value * s390_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
static int s390_function_arg_integer(struct type *type)
static struct gdbarch * s390_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
static const short s390_dwarf_regmap[]
static struct frame_id s390_dummy_id(struct gdbarch *gdbarch, frame_info_ptr this_frame)
static bool s390_address_class_name_to_type_flags(struct gdbarch *gdbarch, const char *name, type_instance_flags *type_flags_ptr)
static int s390_function_arg_float(struct type *type)
static int is_rs(bfd_byte *insn, int op, unsigned int *r1, unsigned int *r3, int *d2, unsigned int *b2)
static int s390_is_partial_instruction(struct gdbarch *gdbarch, CORE_ADDR loc, int *len)
static CORE_ADDR s390_frame_align(struct gdbarch *gdbarch, CORE_ADDR addr)
static const char * s390_gnu_triplet_regexp(struct gdbarch *gdbarch)
static void s390_displaced_step_fixup(struct gdbarch *gdbarch, displaced_step_copy_insn_closure *closure_, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
static char * s390_disassembler_options
#define S390_BC_GSD_REGNUM
#define S390_LAST_BREAK_REGNUM
#define S390_R0_UPPER_REGNUM
#define S390_FRAME_REGNUM
#define S390_RETADDR_REGNUM
#define S390_TDB_CONFLICT_TOKEN_REGNUM
#define S390_MAX_INSTR_SIZE
#define S390_TDB_ABORT_CODE_REGNUM
#define S390_V15_LOWER_REGNUM
#define S390_TDB_R0_REGNUM
#define S390_SYSTEM_CALL_REGNUM
#define S390_V0_LOWER_REGNUM
#define S390_TDB_ATIA_REGNUM
#define S390_ORIG_R2_REGNUM
#define S390_TDB_DWORD0_REGNUM
const struct target_desc * tdesc_s390x_linux64
static void initialize_tdesc_s390x_linux64(void)
struct type * builtin_func_ptr
struct type * builtin_uint64
struct type * builtin_int
struct type * type() const
enum prologue_value_kind kind
struct regcache * regcache
const struct target_desc * tdesc
int(* s390_syscall_record)(struct regcache *regcache, LONGEST svc_number)
enum bfd_endian byte_order
int gpr_slot[S390_NUM_GPRS]
int fpr_slot[S390_NUM_FPRS]
trad_frame_saved_reg * saved_regs
trad_frame_saved_reg * saved_regs
struct bfd_section * the_bfd_section
struct type * target_type() const
struct field & field(int idx) const
struct value::@195::@196 reg
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
tdesc_arch_data_up tdesc_data_alloc(void)
const struct tdesc_feature * tdesc_find_feature(const struct target_desc *target_desc, const char *name)
int tdesc_numbered_register(const struct tdesc_feature *feature, struct tdesc_arch_data *data, int regno, const char *name)
static const registry< gdbarch >::key< tdesc_arch_data > tdesc_data
void tdesc_use_registers(struct gdbarch *gdbarch, const struct target_desc *target_desc, tdesc_arch_data_up &&early_data, tdesc_unknown_register_ftype unk_reg_cb)
void set_tdesc_pseudo_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *pseudo_name)
int tdesc_has_registers(const struct target_desc *target_desc)
void set_tdesc_pseudo_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *pseudo_type)
struct type * tdesc_register_type(struct gdbarch *gdbarch, int regno)
const char * tdesc_register_name(struct gdbarch *gdbarch, int regno)
int tdesc_unnumbered_register(const struct tdesc_feature *feature, const char *name)
void set_tdesc_pseudo_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
std::unique_ptr< tdesc_arch_data, tdesc_arch_data_deleter > tdesc_arch_data_up
const struct target_section * target_section_by_addr(struct target_ops *target, CORE_ADDR addr)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
struct value * trad_frame_get_prev_register(frame_info_ptr this_frame, trad_frame_saved_reg this_saved_regs[], int regnum)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
void gdb_printf(struct ui_file *stream, const char *format,...)
struct value * value_cast(struct type *type, struct value *arg2)
struct type * value_type(const struct value *value)
void set_value_offset(struct value *value, LONGEST offset)
struct value * allocate_optimized_out_value(struct type *type)
struct value * value_from_longest(struct type *type, LONGEST num)
gdb::array_view< const gdb_byte > value_contents(struct value *value)
LONGEST value_as_long(struct value *val)
int value_optimized_out(struct value *value)
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)