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));
472 bytes_to_string (buf, len).c_str ());
484 CORE_ADDR from, CORE_ADDR to,
485 struct regcache *regs,
bool completed_p)
493 pc = from + (pc - to);
501 gdb_byte *insn = closure->
buf.data ();
502 static int s390_instrlen[] = { 2, 4, 4, 6 };
503 int insnlen = s390_instrlen[insn[0] >> 6];
506 unsigned int b2, r1, r2, x2, r3;
528 amode | (from + insnlen));
530 if (op_basr_p && r2 == 0)
547 if (pc == to + insnlen)
559 amode | (from + insnlen));
573 else if (insn[0] == 0x0 && insn[1] == 0x1)
635 int d2,
unsigned int x2,
unsigned int b2)
641 result =
pv_add (result, data->gpr[x2]);
643 result =
pv_add (result, data->gpr[b2]);
652 int d2,
unsigned int x2,
unsigned int b2, CORE_ADDR
size,
662 if (
size == data->gpr_size
665 data->back_chain_saved_p = 1;
670 if (!data->stack->store_would_trash (addr))
685 int d2,
unsigned int x2,
unsigned int b2, CORE_ADDR
size)
706 return data->stack->fetch (
addr,
size);
727 offset = 16 * data->gpr_size + 32 - addr.
k;
734 if (
size == data->gpr_size
736 if (data->gpr_slot[i] == 0
737 || data->gpr_slot[i] > offset)
739 data->gpr_slot[i] = offset;
744 if (
size == data->fpr_size
746 if (data->fpr_slot[i] == 0
747 || data->fpr_slot[i] > offset)
749 data->fpr_slot[i] = offset;
763 CORE_ADDR current_pc,
772 CORE_ADDR result = start_pc;
781 scoped_restore restore_stack = make_scoped_restore (&data->stack, &
stack);
790 data->gpr_size = word_size;
801 data->gpr_slot[i] = 0;
804 data->fpr_slot[i] = 0;
806 data->back_chain_saved_p = 0;
811 for (pc = start_pc; pc > 0 && pc < current_pc; pc = next_pc)
817 bfd_byte *insn32 = word_size == 4 ? insn :
dummy;
818 bfd_byte *insn64 = word_size == 8 ? insn :
dummy;
821 unsigned int b2, r1, r2, x2, r3;
826 pv_t pre_insn_sp, pre_insn_fp;
828 int pre_insn_back_chain_saved_p;
837 next_pc = pc + insn_len;
841 pre_insn_back_chain_saved_p = data->back_chain_saved_p;
855 data->gpr[r1] = data->gpr[r2];
860 else if (
is_rx (insn32,
op_l, &r1, &d2, &x2, &b2)
863 data->gpr[r1] =
s390_load (data, d2, x2, b2, data->gpr_size);
868 else if (
is_rx (insn32,
op_st, &r1, &d2, &x2, &b2)
871 s390_store (data, d2, x2, b2, data->gpr_size, data->gpr[r1]);
875 s390_store (data, d2, x2, b2, data->fpr_size, data->fpr[r1]);
881 else if (
is_rs (insn32,
op_stm, &r1, &r3, &d2, &b2)
885 for (; r1 <= r3; r1++, d2 += data->gpr_size)
886 s390_store (data, d2, 0, b2, data->gpr_size, data->gpr[r1]);
904 (CORE_ADDR)i2 & 0xffffffff);
910 data->gpr[r1] =
pv_add (data->gpr[r1], data->gpr[r2]);
915 else if (
is_rx (insn32,
op_a, &r1, &d2, &x2, &b2)
918 data->gpr[r1] =
pv_add (data->gpr[r1],
919 s390_load (data, d2, x2, b2, data->gpr_size));
926 -((CORE_ADDR)i2 & 0xffffffff));
932 data->gpr[r1] =
pv_subtract (data->gpr[r1], data->gpr[r2]);
937 else if (
is_rx (insn32,
op_s, &r1, &d2, &x2, &b2)
941 s390_load (data, d2, x2, b2, data->gpr_size));
945 else if (
is_rx (insn,
op_la, &r1, &d2, &x2, &b2)
947 data->gpr[r1] =
s390_addr (data, d2, x2, b2);
963 next_pc = pc + i2 * 2;
976 if (r1 != 0 && i2 != 1 && i2 != 2)
981 if (r1 != 0 && i2 != 3)
1018 || pre_insn_back_chain_saved_p != data->back_chain_saved_p)
1036 CORE_ADDR skip_pc, func_addr;
1040 CORE_ADDR post_prologue_pc
1042 if (post_prologue_pc != 0)
1043 return std::max (pc, post_prologue_pc);
1047 return skip_pc ? skip_pc : pc;
1090 gdb_byte *reg = (gdb_byte *) alloca (sz);
1091 ULONGEST pswm, pswa;
1099 pswa = addr | 0x80000000UL;
1100 pswm = 0x070d0000UL;
1105 pswm = 0x0705000180000000ULL;
1144 -1, -1, -1, -1, -1, -1, -1, -1,
1145 -1, -1, -1, -1, -1, -1, -1, -1,
1221 && regnum <= tdep->gpr_full_regnum + 15);
1232 && regnum <= tdep->v0_full_regnum + 15);
1239static struct value *
1272 static const char *full_name[] = {
1273 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
1274 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15"
1281 static const char *full_name[] = {
1282 "v0",
"v1",
"v2",
"v3",
"v4",
"v5",
"v6",
"v7",
1283 "v8",
"v9",
"v10",
"v11",
"v12",
"v13",
"v14",
"v15"
1288 internal_error (_(
"invalid regnum"));
1311 internal_error (_(
"invalid regnum"));
1316static enum register_status
1318 int regnum, gdb_byte *buf)
1327 enum register_status
status;
1341 enum register_status
status;
1347 val = (val >> 12) & 3;
1349 val = (val >> 44) & 3;
1357 enum register_status
status;
1368 val |= val_upper << 32;
1376 enum register_status
status;
1386 internal_error (_(
"invalid regnum"));
1393 int regnum,
const gdb_byte *buf)
1406 val = (psw & 0x80000000) | (val & 0x7fffffff);
1417 val = (psw & ~((ULONGEST)3 << 12)) | ((val & 3) << 12);
1419 val = (psw & ~((ULONGEST)3 << 44)) | ((val & 3) << 44);
1443 internal_error (_(
"invalid regnum"));
1505 internal_error (_(
"invalid regnum"));
1551 internal_error (_(
"invalid regnum"));
1578 return addr & 0x7fffffff;
1584static type_instance_flags
1598 type_instance_flags type_flags)
1612 type_instance_flags *type_flags_ptr)
1614 if (strcmp (
name,
"mode32") == 0)
1641 while (
type->
code () == TYPE_CODE_STRUCT)
1643 struct type *inner = NULL;
1661 if (inner->
length () < min_size)
1684 return (
type->
code () == TYPE_CODE_FLT
1685 ||
type->
code () == TYPE_CODE_DECFLOAT);
1707 return n && ((n & (n - 1)) == 0);
1722 if (
code == TYPE_CODE_INT
1723 ||
code == TYPE_CODE_ENUM
1724 ||
code == TYPE_CODE_RANGE
1725 ||
code == TYPE_CODE_CHAR
1726 ||
code == TYPE_CODE_BOOL
1727 ||
code == TYPE_CODE_PTR
1731 return ((
code == TYPE_CODE_UNION ||
code == TYPE_CODE_STRUCT)
1759 enum bfd_endian byte_order,
int is_unnamed)
1763 int write_mode = as->
regcache != NULL;
1792 static const char use_vr[] = {24, 26, 28, 30, 25, 27, 29, 31};
1794 if (!is_unnamed && as->
vr < ARRAY_SIZE (use_vr))
1840 as->
argp += word_size;
1853 arg->
contents ().data () + word_size);
1889 byte_order, as->
copy);
1890 as->
argp += word_size;
1913 int nargs,
struct value **args, CORE_ADDR sp,
1915 CORE_ADDR struct_addr)
1922 CORE_ADDR param_area_start, new_sp;
1925 if (ftype->
code () == TYPE_CODE_PTR)
1936 arg_state = arg_prep;
1940 for (i = 0; i < nargs; i++)
1944 param_area_start = align_down (arg_state.
copy - arg_state.
argp, 8);
1948 new_sp = param_area_start - (16 * word_size + 32);
1955 error (_(
"Stack overflow"));
1962 arg_state = arg_prep;
1963 arg_state.
argp = param_area_start;
1967 for (i = 0; i < nargs; i++)
1976 bp_addr = (bp_addr & 0x7fffffff) | (pswa & 0x80000000);
1985 return param_area_start;
2020 gdb_byte *out,
const gdb_byte *in)
2027 if (
code == TYPE_CODE_FLT ||
code == TYPE_CODE_DECFLOAT)
2035 else if (
code == TYPE_CODE_ARRAY)
2043 else if (length <= word_size)
2058 else if (length == 2 * word_size)
2073 internal_error (_(
"invalid return type"));
2081 gdb_byte *out,
const gdb_byte *in)
2089 case TYPE_CODE_STRUCT:
2090 case TYPE_CODE_UNION:
2091 case TYPE_CODE_COMPLEX:
2094 case TYPE_CODE_ARRAY:
2109 if (in != NULL || out != NULL)
2113 else if (in != NULL)
2114 error (_(
"Cannot set function return value."));
2116 error (_(
"Function return value unknown."));
2151 unsigned int r1, r3, b2;
2198static struct value *
2269static struct value *
2445 && (next_frame == NULL
2452 memset (&data, 0,
sizeof (data));
2463 cfa = prev_sp + 16*word_size + 32;
2468 info->saved_regs[i].set_unknown ();
2478 for (i = 0; i < 16; i++)
2480 && data.gpr_slot[i] != 0)
2481 info->saved_regs[
S390_R0_REGNUM + i].set_addr (cfa - data.gpr_slot[i]);
2483 for (i = 0; i < 16; i++)
2485 && data.fpr_slot[i] != 0)
2486 info->saved_regs[
S390_F0_REGNUM + i].set_addr (cfa - data.fpr_slot[i]);
2516 info->frame_base = prev_sp + 16*word_size + 32;
2517 info->local_base = prev_sp -
size;
2533 CORE_ADDR backchain;
2541 info->saved_regs[i].set_unknown ();
2550 backchain = (CORE_ADDR) tmp;
2558 word_size, byte_order, &sp)
2559 && (CORE_ADDR)sp == backchain)
2573 info->frame_base = backchain + 16*word_size + 32;
2574 info->local_base = reg;
2585 void **this_prologue_cache)
2589 if (*this_prologue_cache)
2593 *this_prologue_cache = info;
2596 info->frame_base = -1;
2597 info->local_base = -1;
2606 catch (
const gdb_exception_error &ex)
2608 if (ex.error != NOT_AVAILABLE_ERROR)
2619 void **this_prologue_cache,
2625 if (info->frame_base == -1)
2627 if (info->func != -1)
2637static struct value *
2639 void **this_prologue_cache,
int regnum)
2674 void **this_prologue_cache)
2681 if (*this_prologue_cache)
2685 *this_prologue_cache = info;
2693 info->frame_base = reg + 16*word_size + 32;
2702 void **this_prologue_cache,
2712static struct value *
2714 void **this_prologue_cache,
int regnum)
2726 void **this_prologue_cache)
2728 CORE_ADDR addr_in_block;
2760 return info->frame_base;
2768 return info->local_base;
2788 ULONGEST pswm, pswa;
2793 am = pswa >> 31 & 1;
2798 am = pswm >> 31 & 3;
2803 return val & 0xffffff;
2805 return val & 0x7fffffff;
2820 ULONGEST x, uint16_t bd, int8_t dh)
2822 uint8_t rb = bd >> 12 & 0xf;
2823 int32_t d = (bd & 0xfff) | ((int32_t)dh << 12);
2825 CORE_ADDR res = d + x;
2839 uint8_t rx, uint16_t bd, int8_t dh)
2851 uint8_t vx, uint8_t el, uint8_t es, uint16_t bd,
2852 int8_t dh, CORE_ADDR *res)
2873 CORE_ADDR addr, uint16_t i1, uint16_t i2)
2875 int32_t ri = i1 << 16 | i2;
2952 uint16_t insn[3] = {0};
2959 CORE_ADDR oaddr, oaddr2, oaddr3;
2973 insn[0] |= ex & 0xff;
2975 if (insn[0] >= 0x4000)
2980 if (insn[0] >= 0xc000)
2985 for (i = 0; i < 3; i++)
2987 ibyte[i*2] = insn[i] >> 8 & 0xff;
2988 ibyte[i*2+1] = insn[i] & 0xff;
2990 for (i = 0; i < 6; i++)
2992 inib[i*2] = ibyte[i] >> 4 & 0xf;
2993 inib[i*2+1] = ibyte[i] & 0xf;
2996 ivec[0] = (inib[9] >> 3 & 1) << 4 | inib[2];
2997 ivec[1] = (inib[9] >> 2 & 1) << 4 | inib[3];
2998 ivec[2] = (inib[9] >> 1 & 1) << 4 | inib[4];
2999 ivec[3] = (inib[9] >> 0 & 1) << 4 | inib[8];
3020 if (!(tmp & 0x80000000u))
3022 uint8_t ofc = tmp >> 16 & 0xff;
3401 if (inib[2] <= inib[3])
3402 n = inib[3] - inib[2] + 1;
3404 n = inib[3] + 0x10 - inib[2] + 1;
3427 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
3437 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
3450 switch (ibyte[0] << 4 | inib[3])
3684 }
while (cur != end);
4372 if (insn[0] == 0xb92f)
4399 if (tmp != 0 && insn[0] == 0xb929)
4681 if (insn[0] == 0xb93e)
4745 if (insn[0] == 0xb991)
4747 if (insn[0] == 0xb992)
4868 switch (ibyte[0] << 4 | inib[3])
5037 switch (ibyte[0] << 4 | inib[3])
5055 sc = tmp >> 8 & 0xff;
5213 switch (ibyte[0] << 8 | ibyte[5])
5747 for (i = ivec[0]; i != ivec[1]; i++, i &= 0x1f)
5761 if (ivec[0] <= ivec[1])
5762 n = ivec[1] - ivec[0] + 1;
5764 n = ivec[1] + 0x20 - ivec[0] + 1;
5895 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
5935 if (inib[2] <= inib[3])
5936 n = inib[3] - inib[2] + 1;
5938 n = inib[3] + 0x10 - inib[2] + 1;
5949 if (inib[2] <= inib[3])
5950 n = inib[3] - inib[2] + 1;
5952 n = inib[3] + 0x10 - inib[2] + 1;
6101 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6111 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6121 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6374 for (i = 0; i < 16; i++)
6392 switch (ibyte[0] << 8 | ibyte[5])
6501 uint8_t fc = tmp & 0xff;
6730 for (i = inib[2]; i != inib[3]; i++, i &= 0xf)
6823 return ((isdigit (*s) && s[1] ==
'(' && s[2] ==
'%')
6833#define s390_validate_reg_range(feature, tdesc_data, start, names) \
6836 for (int i = 0; i < ARRAY_SIZE (names); i++) \
6837 if (!tdesc_numbered_register (feature, tdesc_data, start + i, names[i])) \
6849 static const char *
const psw[] = {
6852 static const char *
const gprs[] = {
6853 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
6854 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15"
6856 static const char *
const fprs[] = {
6857 "f0",
"f1",
"f2",
"f3",
"f4",
"f5",
"f6",
"f7",
6858 "f8",
"f9",
"f10",
"f11",
"f12",
"f13",
"f14",
"f15"
6860 static const char *
const acrs[] = {
6861 "acr0",
"acr1",
"acr2",
"acr3",
"acr4",
"acr5",
"acr6",
"acr7",
6862 "acr8",
"acr9",
"acr10",
"acr11",
"acr12",
"acr13",
"acr14",
"acr15"
6864 static const char *
const gprs_lower[] = {
6865 "r0l",
"r1l",
"r2l",
"r3l",
"r4l",
"r5l",
"r6l",
"r7l",
6866 "r8l",
"r9l",
"r10l",
"r11l",
"r12l",
"r13l",
"r14l",
"r15l"
6868 static const char *
const gprs_upper[] = {
6869 "r0h",
"r1h",
"r2h",
"r3h",
"r4h",
"r5h",
"r6h",
"r7h",
6870 "r8h",
"r9h",
"r10h",
"r11h",
"r12h",
"r13h",
"r14h",
"r15h"
6872 static const char *
const tdb_regs[] = {
6873 "tdb0",
"tac",
"tct",
"atia",
6874 "tr0",
"tr1",
"tr2",
"tr3",
"tr4",
"tr5",
"tr6",
"tr7",
6875 "tr8",
"tr9",
"tr10",
"tr11",
"tr12",
"tr13",
"tr14",
"tr15"
6877 static const char *
const vxrs_low[] = {
6878 "v0l",
"v1l",
"v2l",
"v3l",
"v4l",
"v5l",
"v6l",
"v7l",
"v8l",
6879 "v9l",
"v10l",
"v11l",
"v12l",
"v13l",
"v14l",
"v15l",
6881 static const char *
const vxrs_high[] = {
6882 "v16",
"v17",
"v18",
"v19",
"v20",
"v21",
"v22",
"v23",
"v24",
6883 "v25",
"v26",
"v27",
"v28",
"v29",
"v30",
"v31",
6885 static const char *
const gs_cb[] = {
6886 "gsd",
"gssm",
"gsepla",
6888 static const char *
const gs_bc[] = {
6889 "bc_gsd",
"bc_gssm",
"bc_gsepla",
6893 const struct tdesc_feature *feature;
6900 if (feature == NULL)
6920 if (feature == NULL)
6930 if (feature == NULL)
7007 tdep->gpr_full_regnum = -1;
7008 tdep->v0_full_regnum = -1;
7009 tdep->pc_regnum = -1;
7010 tdep->cc_regnum = -1;
7012 tdep->have_upper =
false;
7013 tdep->have_linux_v1 =
false;
7014 tdep->have_linux_v2 =
false;
7015 tdep->have_tdb =
false;
7016 tdep->have_vx =
false;
7017 tdep->have_gs =
false;
7019 tdep->s390_syscall_record = NULL;
7029 const struct target_desc *tdesc = info.target_desc;
7030 int first_pseudo_reg, last_pseudo_reg;
7031 static const char *
const stap_register_prefixes[] = {
"%", NULL };
7111 switch (info.bfd_arch_info->mach)
7113 case bfd_mach_s390_31:
7117 case bfd_mach_s390_64:
7139 disassembler_options_s390 ());
7157 if (info.bfd_arch_info->mach == bfd_mach_s390_31)
7162 tdep->
tdesc = tdesc;
7174 && info.abfd != NULL
7175 && info.abfd->format == bfd_object
7176 && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour
7177 && bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
7178 Tag_GNU_S390_ABI_Vector) == 2)
7188 = gdbarch_tdep<s390_gdbarch_tdep> (
arches->gdbarch);
7196 if (tmp->vector_abi != tdep->vector_abi)
7208 last_pseudo_reg = first_pseudo_reg;
7212 last_pseudo_reg += 16;
7217 last_pseudo_reg += 16;
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep, gdbarch_supports_arch_info_ftype *supports_arch_info)
void gdbarch_free(struct gdbarch *arch)
static std::vector< const char * > arches
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, gdbarch_tdep_up tdep)
function_call_return_method
const struct floatformat * floatformats_ieee_quad[BFD_ENDIAN_UNKNOWN]
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
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)
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 const char *const stap_register_indirection_prefixes[]
static const char *const stap_register_indirection_suffixes[]
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 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 s390_gdbarch_tdep_up s390_gdbarch_tdep_alloc()
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_displaced_step_fixup(struct gdbarch *gdbarch, displaced_step_copy_insn_closure *closure_, CORE_ADDR from, CORE_ADDR to, struct regcache *regs, bool completed_p)
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 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
std::unique_ptr< s390_gdbarch_tdep > s390_gdbarch_tdep_up
#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
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
unsigned int num_fields() const
static struct value * allocate_optimized_out(struct type *type)
gdb::array_view< const gdb_byte > contents()
struct type * type() const
void set_offset(LONGEST offset)
struct value::@203::@204 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 value * value_from_longest(struct type *type, LONGEST num)
LONGEST value_as_long(struct value *val)
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)