49 #include "elf/aarch64.h"
59 #define AARCH64_Q0_REGNUM 0
60 #define AARCH64_D0_REGNUM (AARCH64_Q0_REGNUM + 32)
61 #define AARCH64_S0_REGNUM (AARCH64_D0_REGNUM + 32)
62 #define AARCH64_H0_REGNUM (AARCH64_S0_REGNUM + 32)
63 #define AARCH64_B0_REGNUM (AARCH64_H0_REGNUM + 32)
120 "x0",
"x1",
"x2",
"x3",
121 "x4",
"x5",
"x6",
"x7",
122 "x8",
"x9",
"x10",
"x11",
123 "x12",
"x13",
"x14",
"x15",
124 "x16",
"x17",
"x18",
"x19",
125 "x20",
"x21",
"x22",
"x23",
126 "x24",
"x25",
"x26",
"x27",
127 "x28",
"x29",
"x30",
"sp",
136 "v0",
"v1",
"v2",
"v3",
137 "v4",
"v5",
"v6",
"v7",
138 "v8",
"v9",
"v10",
"v11",
139 "v12",
"v13",
"v14",
"v15",
140 "v16",
"v17",
"v18",
"v19",
141 "v20",
"v21",
"v22",
"v23",
142 "v24",
"v25",
"v26",
"v27",
143 "v28",
"v29",
"v30",
"v31",
191 unsigned shift_l =
sizeof (int32_t) * 8 - (offset + width);
192 unsigned shift_r =
sizeof (int32_t) * 8 - width;
194 return ((int32_t) insn << shift_l) >> shift_r;
208 return (insn & mask) == pattern;
223 if ((insn & 0x9f000000) == 0x91000000)
228 *rd = (insn >> 0) & 0x1f;
229 *rn = (insn >> 5) & 0x1f;
230 *imm = (insn >> 10) & 0xfff;
231 shift = (insn >> 22) & 0x3;
232 op_is_sub = (insn >> 30) & 0x1;
251 "decode: 0x%s 0x%x add x%u, x%u, #%d\n",
272 *rd = (insn >> 0) & 0x1f;
276 "decode: 0x%s 0x%x adrp x%u, #?\n",
305 "decode: 0x%s 0x%x %s 0x%s\n",
330 *cond = (insn >> 0) & 0xf;
335 "decode: 0x%s 0x%x b<%u> 0x%s\n",
360 *link = (insn >> 21) & 1;
361 *rn = (insn >> 5) & 0x1f;
365 "decode: 0x%s 0x%x %s 0x%x\n",
367 *link ?
"blr" :
"br", *rn);
387 uint32_t insn,
int *is64,
unsigned *op,
unsigned *rn,
395 *rn = (insn >> 0) & 0x1f;
396 *is64 = (insn >> 31) & 0x1;
397 *op = (insn >> 24) & 0x1;
402 "decode: 0x%s 0x%x %s 0x%s\n",
404 *op ?
"cbnz" :
"cbz",
422 if (insn == 0xd69f03e0)
445 *rd = (insn >> 0) & 0x1f;
449 "decode: 0x%s 0x%x movz x%u, #?\n",
470 uint32_t insn,
unsigned *rd,
unsigned *rn,
471 unsigned *rm, int32_t *imm)
475 *rd = (insn >> 0) & 0x1f;
476 *rn = (insn >> 5) & 0x1f;
477 *rm = (insn >> 16) & 0x1f;
478 *imm = (insn >> 10) & 0x3f;
482 "decode: 0x%s 0x%x orr x%u, x%u, x%u, #%u\n",
503 *rn = (insn >> 5) & 0x1f;
506 "decode: 0x%s 0x%x ret x%u\n",
528 unsigned *rt1,
unsigned *rt2,
unsigned *rn, int32_t *imm)
532 *rt1 = (insn >> 0) & 0x1f;
533 *rn = (insn >> 5) & 0x1f;
534 *rt2 = (insn >> 10) & 0x1f;
540 "decode: 0x%s 0x%x stp x%u, x%u, [x%u + #%d]\n",
542 *rt1, *rt2, *rn, *imm);
563 unsigned *rt1,
unsigned *rt2,
unsigned *rn,
568 *rt1 = (insn >> 0) & 0x1f;
569 *rn = (insn >> 5) & 0x1f;
570 *rt2 = (insn >> 10) & 0x1f;
576 "decode: 0x%s 0x%x stp x%u, x%u, [x%u + #%d]!\n",
578 *rt1, *rt2, *rn, *imm);
598 unsigned *rn, int32_t *imm)
602 *is64 = (insn >> 30) & 1;
603 *rt = (insn >> 0) & 0x1f;
604 *rn = (insn >> 5) & 0x1f;
609 "decode: 0x%s 0x%x stur %c%u, [x%u + #%d]\n",
611 *is64 ?
'x' :
'w', *rt, *rn, *imm);
630 uint32_t insn,
unsigned *op,
unsigned *
bit,
unsigned *rt,
638 *rt = (insn >> 0) & 0x1f;
639 *op = insn & (1 << 24);
640 *bit = ((insn >> (31 - 4)) & 0x20) | ((insn >> 19) & 0x1f);
645 "decode: 0x%s 0x%x %s x%u, #%u, 0x%s\n",
647 *op ?
"tbnz" :
"tbz", *rt, *bit,
674 for (; start < limit; start += 4)
698 else if (
decode_b (start, insn, &is_link, &offset))
708 else if (
decode_br (start, insn, &is_link, &rn))
713 else if (
decode_cb (start, insn, &is64, &op, &rn, &offset))
728 if (imm == 0 && rn == 31)
735 "aarch64: prologue analysis gave up addr=0x%s "
736 "opcode=0x%x (orr x register)\n",
747 else if (
decode_stur (start, insn, &is64, &rt, &rn, &offset))
750 is64 ? 8 : 4, regs[rt]);
789 else if (
decode_tb (start, insn, &op, &bit, &rn, &offset))
798 "aarch64: prologue analysis gave up addr=0x%s"
860 if (post_prologue_pc != 0)
861 return max (pc, post_prologue_pc);
904 prologue_end = prev_pc;
906 else if (sal.
end < prologue_end)
909 prologue_end = sal.
end;
912 prologue_end =
min (prologue_end, prev_pc);
971 void **this_cache,
struct frame_id *this_id)
977 if (*this_cache == NULL)
997 static struct value *
999 void **this_cache,
int prev_regnum)
1004 if (*this_cache == NULL)
1006 cache = *this_cache;
1076 void **this_cache,
struct frame_id *this_id)
1080 if (*this_cache == NULL)
1082 cache = *this_cache;
1092 void **this_prologue_cache)
1125 if (*this_cache == NULL)
1127 cache = *this_cache;
1138 aarch64_normal_frame_base
1177 static struct value *
1179 void **this_cache,
int regnum)
1192 _(
"Unexpected register %d"), regnum);
1296 struct type *member0_type;
1305 struct type *member1_type;
1354 const bfd_byte *buf)
1371 if (byte_order == BFD_ENDIAN_BIG
1397 const bfd_byte *buf)
1422 const bfd_byte *buf)
1449 if (info->
nsaa & (align - 1))
1452 int pad = align - (info->
nsaa & (align - 1));
1469 const bfd_byte *buf)
1475 if (info->
ngrn + nregs <= 8)
1477 pass_in_x (gdbarch, regcache, info, type, buf);
1478 info->
ngrn += nregs;
1495 const bfd_byte *buf)
1497 if (!
pass_in_v (gdbarch, regcache, info, buf))
1516 struct type *return_type;
1517 int lang_struct_return;
1519 memset (&info, 0,
sizeof (info));
1567 if (lang_struct_return)
1574 if (struct_return || lang_struct_return)
1586 for (argnum = 0; argnum < nargs; argnum++)
1588 struct value *arg = args[argnum];
1589 struct type *arg_type;
1619 struct type *target_type =
1622 pass_in_v (gdbarch, regcache, &info, buf);
1645 if (info.
nsrn + elements < 8)
1649 for (i = 0; i < elements; i++)
1656 struct type *field_type =
1701 sp -= 16 - (info.
nsaa & 15);
1731 static struct type *
1758 static struct type *
1788 static struct type *
1818 static struct type *
1845 static struct type *
1893 info->symbols = NULL;
1894 return print_insn_aarch64 (memaddr, info);
1931 memcpy (valbuf, buf, len);
1967 memcpy (valbuf, buf, len);
1970 memcpy (valbuf, buf, len);
1980 for (i = 0; i < elements; i++)
1987 "read HFA return value element %d from %s\n",
1992 memcpy (valbuf, buf, len);
2108 for (i = 0; i < elements; i++)
2115 "write HFA return value element %d to %s\n",
2119 memcpy (tmpbuf, valbuf, len);
2135 memcpy (tmpbuf, valbuf,
2204 static const char *
const q_name[] =
2206 "q0",
"q1",
"q2",
"q3",
2207 "q4",
"q5",
"q6",
"q7",
2208 "q8",
"q9",
"q10",
"q11",
2209 "q12",
"q13",
"q14",
"q15",
2210 "q16",
"q17",
"q18",
"q19",
2211 "q20",
"q21",
"q22",
"q23",
2212 "q24",
"q25",
"q26",
"q27",
2213 "q28",
"q29",
"q30",
"q31",
2216 static const char *
const d_name[] =
2218 "d0",
"d1",
"d2",
"d3",
2219 "d4",
"d5",
"d6",
"d7",
2220 "d8",
"d9",
"d10",
"d11",
2221 "d12",
"d13",
"d14",
"d15",
2222 "d16",
"d17",
"d18",
"d19",
2223 "d20",
"d21",
"d22",
"d23",
2224 "d24",
"d25",
"d26",
"d27",
2225 "d28",
"d29",
"d30",
"d31",
2228 static const char *
const s_name[] =
2230 "s0",
"s1",
"s2",
"s3",
2231 "s4",
"s5",
"s6",
"s7",
2232 "s8",
"s9",
"s10",
"s11",
2233 "s12",
"s13",
"s14",
"s15",
2234 "s16",
"s17",
"s18",
"s19",
2235 "s20",
"s21",
"s22",
"s23",
2236 "s24",
"s25",
"s26",
"s27",
2237 "s28",
"s29",
"s30",
"s31",
2240 static const char *
const h_name[] =
2242 "h0",
"h1",
"h2",
"h3",
2243 "h4",
"h5",
"h6",
"h7",
2244 "h8",
"h9",
"h10",
"h11",
2245 "h12",
"h13",
"h14",
"h15",
2246 "h16",
"h17",
"h18",
"h19",
2247 "h20",
"h21",
"h22",
"h23",
2248 "h24",
"h25",
"h26",
"h27",
2249 "h28",
"h29",
"h30",
"h31",
2252 static const char *
const b_name[] =
2254 "b0",
"b1",
"b2",
"b3",
2255 "b4",
"b5",
"b6",
"b7",
2256 "b8",
"b9",
"b10",
"b11",
2257 "b12",
"b13",
"b14",
"b15",
2258 "b16",
"b17",
"b18",
"b19",
2259 "b20",
"b21",
"b22",
"b23",
2260 "b24",
"b25",
"b26",
"b27",
2261 "b28",
"b29",
"b30",
"b31",
2282 _(
"aarch64_pseudo_register_name: bad register number %d"),
2288 static struct type *
2309 _(
"aarch64_pseudo_register_type: bad register number %d"),
2339 static struct value *
2345 struct value *result_value;
2367 return result_value;
2382 return result_value;
2393 return result_value;
2408 return result_value;
2423 return result_value;
2441 memset (reg_buf, 0,
sizeof (reg_buf));
2504 static struct value *
2507 const int *reg_p = baton;
2522 const int insn_size = 4;
2523 const int atomic_sequence_length = 16;
2529 byte_order_for_code);
2532 int bc_insn_count = 0;
2533 int last_breakpoint = 0;
2539 for (insn_count = 0; insn_count < atomic_sequence_length; ++insn_count)
2546 byte_order_for_code);
2551 if (bc_insn_count >= 1)
2555 breaks[1] = loc +
offset;
2574 breaks[0] = loc + insn_size;
2579 && (breaks[1] == breaks[0]
2580 || (breaks[1] >= pc && breaks[1] <= closing_insn)))
2581 last_breakpoint = 0;
2585 for (index = 0; index <= last_breakpoint; index++)
2598 static struct gdbarch *
2602 struct gdbarch *gdbarch;
2607 int have_fpa_registers = 1;
2611 int num_pseudo_regs = 0;
2621 if (feature == NULL)
2648 num_pseudo_regs += 32;
2649 num_pseudo_regs += 32;
2650 num_pseudo_regs += 32;
2651 num_pseudo_regs += 32;
2652 num_pseudo_regs += 32;
2673 if (best_arch != NULL)
2675 if (tdesc_data != NULL)
2763 if (tdep->
jb_pc >= 0)
2802 Set AArch64 debugging."),
_(
"\
2803 Show AArch64 debugging."),
_(
"\
2804 When on, AArch64 specific debugging is enabled."),
2812 #define submask(x) ((1L << ((x) + 1)) - 1)
2813 #define bit(obj,st) (((obj) >> (st)) & 1)
2814 #define bits(obj,st,fn) (((obj) >> (st)) & submask ((fn) - (st)))
2816 #define REG_ALLOC(REGS, LENGTH, RECORD_BUF) \
2819 unsigned int reg_len = LENGTH; \
2822 REGS = XNEWVEC (uint32_t, reg_len); \
2823 memcpy(®S[0], &RECORD_BUF[0], sizeof(uint32_t)*LENGTH); \
2828 #define MEM_ALLOC(MEMS, LENGTH, RECORD_BUF) \
2831 unsigned int mem_len = LENGTH; \
2834 MEMS = XNEWVEC (struct aarch64_mem_r, mem_len); \
2835 memcpy(&MEMS->len, &RECORD_BUF[0], \
2836 sizeof(struct aarch64_mem_r) * LENGTH); \
2874 uint8_t reg_rd, insn_bits24_27, insn_bits21_23;
2875 uint32_t record_buf[4];
2886 if (insn_bits24_27 == 0x0a)
2889 else if (insn_bits24_27 == 0x0b)
2894 record_buf[0] = reg_rd;
2901 if (insn_bits24_27 == 0x0b)
2904 record_buf[0] = reg_rd;
2907 else if (insn_bits24_27 == 0x0a)
2909 if (insn_bits21_23 == 0x00)
2912 record_buf[0] = reg_rd;
2920 else if (insn_bits21_23 == 0x02)
2927 else if (insn_bits21_23 == 0x04 || insn_bits21_23 == 0x06)
2932 record_buf[0] = reg_rd;
2950 uint8_t reg_rd, insn_bit28, insn_bit23, insn_bits24_27, setflags;
2951 uint32_t record_buf[4];
2958 if (insn_bits24_27 == 0x00
2959 || insn_bits24_27 == 0x03
2960 || (insn_bits24_27 == 0x02 && insn_bit23))
2962 record_buf[0] = reg_rd;
2965 else if (insn_bits24_27 == 0x01)
2969 record_buf[0] = reg_rd;
2974 else if (insn_bits24_27 == 0x02 && !insn_bit23)
2978 record_buf[0] = reg_rd;
2997 uint8_t insn_bits24_27, insn_bits28_31, insn_bits22_23;
2998 uint32_t record_buf[4];
3004 if (insn_bits28_31 == 0x0d)
3007 if (insn_bits24_27 == 0x04)
3024 else if (insn_bits24_27 == 0x05 && insn_bits22_23 == 0x00)
3026 uint32_t reg_rt, reg_crn;
3034 record_buf[0] = reg_rt;
3038 else if (reg_crn == 0x02 || reg_crn == 0x04)
3045 else if((insn_bits24_27 & 0x0e) == 0x06)
3055 else if ((insn_bits28_31 & 0x07) == 0x01 && (insn_bits24_27 & 0x0c) == 0x04)
3077 uint64_t addr_offset = 0;
3078 uint32_t record_buf[24];
3079 uint64_t record_buf_mem[24];
3080 uint32_t reg_rn, reg_rt;
3081 uint32_t reg_index = 0, mem_index = 0;
3082 uint8_t opcode_bits, size_bits;
3093 "Process record: Advanced SIMD load/store\n");
3099 uint8_t sindex, scale, selem, esize, replicate = 0;
3100 scale = opcode_bits >> 2;
3101 selem = ((opcode_bits & 0x02) |
3106 if (size_bits & 0x01)
3110 if ((size_bits >> 1) & 0x01)
3112 if (size_bits & 0x01)
3114 if (!((opcode_bits >> 1) & 0x01))
3134 for (sindex = 0; sindex < selem; sindex++)
3137 reg_rt = (reg_rt + 1) % 32;
3141 for (sindex = 0; sindex < selem; sindex++)
3146 record_buf_mem[mem_index++] = esize / 8;
3147 record_buf_mem[mem_index++] = address + addr_offset;
3149 addr_offset = addr_offset + (esize / 8);
3150 reg_rt = (reg_rt + 1) % 32;
3156 uint8_t selem, esize, rpt, elements;
3157 uint8_t eindex, rindex;
3159 esize = 8 << size_bits;
3161 elements = 128 / esize;
3163 elements = 64 / esize;
3165 switch (opcode_bits)
3206 for (rindex = 0; rindex < rpt; rindex++)
3207 for (eindex = 0; eindex < elements; eindex++)
3209 uint8_t reg_tt, sindex;
3210 reg_tt = (reg_rt + rindex) % 32;
3211 for (sindex = 0; sindex < selem; sindex++)
3217 record_buf_mem[mem_index++] = esize / 8;
3218 record_buf_mem[mem_index++] = address + addr_offset;
3220 addr_offset = addr_offset + (esize / 8);
3221 reg_tt = (reg_tt + 1) % 32;
3227 record_buf[reg_index++] = reg_rn;
3243 uint8_t insn_bits24_27, insn_bits28_29, insn_bits10_11;
3244 uint8_t insn_bit23, insn_bit21;
3245 uint8_t opc, size_bits, ld_flag, vector_flag;
3246 uint32_t reg_rn, reg_rt, reg_rt2;
3247 uint64_t datasize,
offset;
3248 uint32_t record_buf[8];
3249 uint64_t record_buf_mem[8];
3265 if (insn_bits24_27 == 0x08 && insn_bits28_29 == 0x00)
3270 "Process record: load/store exclusive\n");
3275 record_buf[0] = reg_rt;
3279 record_buf[1] = reg_rt2;
3286 datasize = (8 << size_bits) * 2;
3288 datasize = (8 << size_bits);
3291 record_buf_mem[0] = datasize / 8;
3292 record_buf_mem[1] = address;
3303 else if ((insn_bits24_27 & 0x0b) == 0x08 && insn_bits28_29 == 0x01)
3308 "Process record: load register (literal)\n");
3313 record_buf[0] = reg_rt;
3317 else if ((insn_bits24_27 & 0x0a) == 0x08 && insn_bits28_29 == 0x02)
3322 "Process record: load/store pair\n");
3334 record_buf[0] = reg_rt;
3335 record_buf[1] = reg_rt2;
3344 size_bits = size_bits >> 1;
3345 datasize = 8 << (2 + size_bits);
3346 offset = (imm7_off & 0x40) ? (~imm7_off & 0x007f) + 1 : imm7_off;
3347 offset = offset << (2 + size_bits);
3350 if (!((insn_bits24_27 & 0x0b) == 0x08 && insn_bit23))
3352 if (imm7_off & 0x40)
3353 address = address -
offset;
3355 address = address +
offset;
3358 record_buf_mem[0] = datasize / 8;
3359 record_buf_mem[1] = address;
3360 record_buf_mem[2] = datasize / 8;
3361 record_buf_mem[3] = address + (datasize / 8);
3368 else if ((insn_bits24_27 & 0x0b) == 0x09 && insn_bits28_29 == 0x03)
3377 if (size_bits != 0x03)
3385 "Process record: load/store (unsigned immediate):"
3386 " size %x V %d opc %x\n", size_bits, vector_flag,
3393 datasize = 8 << size_bits;
3396 offset = offset << size_bits;
3397 address = address +
offset;
3399 record_buf_mem[0] = datasize >> 3;
3400 record_buf_mem[1] = address;
3408 record_buf[0] = reg_rt;
3413 else if ((insn_bits24_27 & 0x0b) == 0x08 && insn_bits28_29 == 0x03
3414 && insn_bits10_11 == 0x02 && insn_bit21)
3419 "Process record: load/store (register offset)\n");
3428 if (size_bits != 0x03)
3435 uint64_t reg_rm_val;
3439 offset = reg_rm_val << size_bits;
3441 offset = reg_rm_val;
3442 datasize = 8 << size_bits;
3445 address = address +
offset;
3446 record_buf_mem[0] = datasize >> 3;
3447 record_buf_mem[1] = address;
3455 record_buf[0] = reg_rt;
3460 else if ((insn_bits24_27 & 0x0b) == 0x08 && insn_bits28_29 == 0x03
3466 "Process record: load/store (immediate and unprivileged)\n");
3475 if (size_bits != 0x03)
3484 offset = (imm9_off & 0x0100) ? (((~imm9_off) & 0x01ff) + 1) : imm9_off;
3485 datasize = 8 << size_bits;
3488 if (insn_bits10_11 != 0x01)
3490 if (imm9_off & 0x0100)
3491 address = address -
offset;
3493 address = address +
offset;
3495 record_buf_mem[0] = datasize >> 3;
3496 record_buf_mem[1] = address;
3504 record_buf[0] = reg_rt;
3507 if (insn_bits10_11 == 0x01 || insn_bits10_11 == 0x03)
3526 uint8_t insn_bit21, opcode, rmode, reg_rd;
3527 uint8_t insn_bits24_27, insn_bits28_31, insn_bits10_11, insn_bits12_15;
3528 uint8_t insn_bits11_14;
3529 uint32_t record_buf[2];
3544 "Process record: data processing SIMD/FP: ");
3547 if ((insn_bits28_31 & 0x05) == 0x01 && insn_bits24_27 == 0x0e)
3555 if ((opcode >> 1) == 0x0 && rmode == 0x03)
3556 record_buf[0] = reg_rd;
3561 else if (insn_bits10_11 == 0x01)
3570 else if (insn_bits10_11 == 0x02 || insn_bits10_11 == 0x03)
3577 else if (insn_bits10_11 == 0x00)
3580 if ((insn_bits12_15 & 0x01) == 0x01
3581 || (insn_bits12_15 & 0x07) == 0x04)
3588 else if ((insn_bits12_15 & 0x03) == 0x02)
3595 else if (insn_bits12_15 == 0x00)
3598 if (!(opcode >> 1) || ((opcode >> 1) == 0x02 && !rmode))
3606 else if ((opcode >> 1) == 0x01 && !rmode)
3614 else if ((opcode >> 1) == 0x03)
3619 if (!(opcode & 0x01))
3633 else if ((insn_bits28_31 & 0x09) == 0x00 && insn_bits24_27 == 0x0e)
3643 if (insn_bits11_14 == 0x05 || insn_bits11_14 == 0x07)
3675 uint32_t ins_bit25, ins_bit26, ins_bit27, ins_bit28;
3683 if (!ins_bit26 && !ins_bit27 && ins_bit28)
3687 if (ins_bit26 && !ins_bit27 && ins_bit28)
3691 if (!ins_bit25 && ins_bit27)
3695 if (ins_bit25 && !ins_bit26 && ins_bit27)
3699 if (ins_bit25 && ins_bit26 && ins_bit27)
3722 uint32_t rec_no = 0;
3723 uint8_t insn_size = 4;
3729 memset (&buf[0], 0, insn_size);
3736 aarch64_record.
regcache = regcache;
3738 aarch64_record.
gdbarch = gdbarch;
3744 "0x%0x at address %s.\n"),
3759 for (rec_no = 0; rec_no < aarch64_record.
reg_rec_count; rec_no++)
3766 for (rec_no = 0; rec_no < aarch64_record.
mem_rec_count; rec_no++)
static int aarch64_software_single_step(struct frame_info *frame)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
static const struct @0 aarch64_register_aliases[]
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype frame_align)
void set_gdbarch_have_nonsteppable_watchpoint(struct gdbarch *gdbarch, int have_nonsteppable_watchpoint)
static const gdb_byte aarch64_default_breakpoint[]
void set_gdbarch_float_format(struct gdbarch *gdbarch, const struct floatformat **float_format)
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
static void aarch64_dump_tdep(struct gdbarch *gdbarch, struct ui_file *file)
static int decode_add_sub_imm(CORE_ADDR addr, uint32_t insn, unsigned *rd, unsigned *rn, int32_t *imm)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
void set_gdbarch_get_longjmp_target(struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype get_longjmp_target)
CORE_ADDR get_frame_address_in_block(struct frame_info *this_frame)
struct value * value_primitive_field(struct value *arg1, int offset, int fieldno, struct type *arg_type)
static int aarch64_get_longjmp_target(struct frame_info *frame, CORE_ADDR *pc)
void set_tdesc_pseudo_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *pseudo_name)
void set_gdbarch_float_bit(struct gdbarch *gdbarch, int float_bit)
#define AARCH64_X_REGISTER_COUNT
CORE_ADDR get_frame_pc(struct frame_info *frame)
static void pass_on_stack(struct aarch64_call_info *info, struct type *type, const bfd_byte *buf)
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
static void aarch64_scan_prologue(struct frame_info *this_frame, struct aarch64_prologue_cache *cache)
static CORE_ADDR aarch64_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR start, CORE_ADDR limit, struct aarch64_prologue_cache *cache)
pv_t pv_add_constant(pv_t v, CORE_ADDR k)
struct frame_unwind aarch64_prologue_unwind
struct value * trad_frame_get_prev_register(struct frame_info *this_frame, struct trad_frame_saved_reg this_saved_regs[], int regnum)
static const char * aarch64_pseudo_register_name(struct gdbarch *gdbarch, int regnum)
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
static void aarch64_prologue_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
int trad_frame_addr_p(struct trad_frame_saved_reg this_saved_regs[], int regnum)
void store_signed_integer(gdb_byte *, int, enum bfd_endian, LONGEST)
int record_full_arch_list_add_reg(struct regcache *regcache, int regnum)
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
static struct type * aarch64_vnq_type(struct gdbarch *gdbarch)
void set_tdesc_pseudo_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *pseudo_type)
static struct type * aarch64_pseudo_register_type(struct gdbarch *gdbarch, int regnum)
static int decode_stp_offset(CORE_ADDR addr, uint32_t insn, unsigned *rt1, unsigned *rt2, unsigned *rn, int32_t *imm)
struct cleanup * make_cleanup_free_pv_area(struct pv_area *area)
ULONGEST align_down(ULONGEST v, int n)
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
static int is_hfa(struct type *ty)
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
static int decode_br(CORE_ADDR addr, uint32_t insn, unsigned *link, unsigned *rn)
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
char * phex(ULONGEST l, int sizeof_l)
int pv_is_register(pv_t a, int r)
void internal_error(const char *file, int line, const char *fmt,...)
int(* aarch64_syscall_record)(struct regcache *regcache, unsigned long svc_number)
unsigned int record_debug
static CORE_ADDR aarch64_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
static void aarch64_dwarf2_frame_init_reg(struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, struct frame_info *this_frame)
struct type * builtin_uint8
static unsigned int aarch64_record_load_store(insn_decode_record *aarch64_insn_r)
static const char *const aarch64_r_register_names[]
struct type * builtin_uint16
static void initialize_tdesc_aarch64(void)
union dwarf2_frame_state_reg::@51 loc
int pv_area_find_reg(struct pv_area *area, struct gdbarch *gdbarch, int reg, CORE_ADDR *offset_p)
struct type * arch_composite_type(struct gdbarch *gdbarch, char *name, enum type_code code)
static struct value * aarch64_dwarf2_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
const struct floatformat * floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN]
static unsigned int aarch64_record_data_proc_simd_fp(insn_decode_record *aarch64_insn_r)
static void pass_in_x_or_stack(struct gdbarch *gdbarch, struct regcache *regcache, struct aarch64_call_info *info, struct type *type, const bfd_byte *buf)
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
static struct value * aarch64_pseudo_read_value(struct gdbarch *gdbarch, struct regcache *regcache, int regnum)
void mark_value_bytes_unavailable(struct value *value, int offset, int length)
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
#define VEC_safe_push(T, V, O)
struct gdbarch_list * next
struct address_space * get_frame_address_space(struct frame_info *frame)
int gdbarch_num_regs(struct gdbarch *gdbarch)
static struct aarch64_prologue_cache * aarch64_make_stub_cache(struct frame_info *this_frame)
struct reggroup *const all_reggroup
static struct frame_id aarch64_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
static int aarch64_stub_unwind_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
static void deallocate_reg_mem(insn_decode_record *record)
void set_gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
struct gdbarch_tdep_info * tdep_info
#define bits(obj, st, fn)
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
static int decode_ret(CORE_ADDR addr, uint32_t insn, unsigned *rn)
static void show_aarch64_debug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
void tdesc_data_cleanup(void *data_untyped)
#define TYPE_FIELD_TYPE(thistype, n)
struct target_desc * tdesc_aarch64
struct value * allocate_value(struct type *type)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
static struct gdbarch * aarch64_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
struct type * builtin_int32
static unsigned int aarch64_record_data_proc_reg(insn_decode_record *aarch64_insn_r)
static struct aarch64_prologue_cache * aarch64_make_prologue_cache(struct frame_info *this_frame)
#define FRAME_OBSTACK_ZALLOC(TYPE)
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
static CORE_ADDR aarch64_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
struct reggroup *const float_reggroup
int tdesc_numbered_register(const struct tdesc_feature *feature, struct tdesc_arch_data *data, int regno, const char *name)
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
struct type * builtin_int128
static int decode_tb(CORE_ADDR addr, uint32_t insn, unsigned *op, unsigned *bit, unsigned *rt, int32_t *imm)
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype pseudo_register_write)
static const gdb_byte * aarch64_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
void set_gdbarch_pseudo_register_read_value(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_value_ftype pseudo_register_read_value)
struct type * check_typedef(struct type *type)
static int decode_adrp(CORE_ADDR addr, uint32_t insn, unsigned *rd)
const gdb_byte * value_contents(struct value *value)
static unsigned int aarch64_record_asimd_load_store(insn_decode_record *aarch64_insn_r)
static int aarch64_pseudo_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *group)
static void aarch64_store_return_value(struct type *type, struct regcache *regs, const gdb_byte *valbuf)
void dwarf2_frame_set_init_reg(struct gdbarch *gdbarch, void(*init_reg)(struct gdbarch *, int, struct dwarf2_frame_state_reg *, struct frame_info *))
static struct type * aarch64_vns_type(struct gdbarch *gdbarch)
void initialize_file_ftype(void)
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
void fprintf_filtered(struct ui_file *stream, const char *format,...)
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
static unsigned int aarch64_record_data_proc_imm(insn_decode_record *aarch64_insn_r)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
struct type * register_type(struct gdbarch *gdbarch, int regnum)
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
static CORE_ADDR aarch64_unwind_sp(struct gdbarch *gdbarch, struct frame_info *this_frame)
void insert_single_step_breakpoint(struct gdbarch *gdbarch, struct address_space *aspace, CORE_ADDR next_pc)
#define gdb_assert_not_reached(message)
struct type * builtin_int16
static int decode_stur(CORE_ADDR addr, uint32_t insn, int *is64, unsigned *rt, unsigned *rn, int32_t *imm)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
#define VALUE_REGNUM(val)
void set_gdbarch_unwind_pc(struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype unwind_pc)
void set_gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
struct type * builtin_uint32
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
gdb_byte * value_contents_writeable(struct value *value)
void pv_area_store(struct pv_area *area, pv_t addr, CORE_ADDR size, pv_t value)
static unsigned int aarch64_record_branch_except_sys(insn_decode_record *aarch64_insn_r)
static struct type * aarch64_vnb_type(struct gdbarch *gdbarch)
int pv_area_store_would_trash(struct pv_area *area, pv_t addr)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
struct value * value_cast(struct type *type, struct value *arg2)
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
initialize_file_ftype _initialize_aarch64_tdep
int gdbarch_addr_bit(struct gdbarch *gdbarch)
void set_gdbarch_unwind_sp(struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype unwind_sp)
static int decode_orr_shifted_register_x(CORE_ADDR addr, uint32_t insn, unsigned *rd, unsigned *rn, unsigned *rm, int32_t *imm)
static int aarch64_return_in_memory(struct gdbarch *gdbarch, struct type *type)
void printf_unfiltered(const char *format,...)
struct cmd_list_element * setdebuglist
struct reggroup *const vector_reggroup
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
struct ui_file * gdb_stdlog
static int pass_in_v(struct gdbarch *gdbarch, struct regcache *regcache, struct aarch64_call_info *info, const bfd_byte *buf)
static struct value * value_of_aarch64_user_reg(struct frame_info *frame, const void *baton)
struct type * builtin_uint128
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
#define REG_ALLOC(REGS, LENGTH, RECORD_BUF)
static int decode_masked_match(uint32_t insn, uint32_t mask, uint32_t pattern)
static void aarch64_pseudo_write(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, const gdb_byte *buf)
struct aarch64_mem_r * aarch64_mems
int record_full_arch_list_add_mem(CORE_ADDR addr, int len)
const struct target_desc * target_desc
void set_gdbarch_software_single_step(struct gdbarch *gdbarch, gdbarch_software_single_step_ftype software_single_step)
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
static const char *const aarch64_v_register_names[]
#define AARCH64_S0_REGNUM
static int aarch64_type_align(struct type *t)
struct pv_area * make_pv_area(int base_reg, int addr_bit)
struct trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct frame_info *this_frame)
void tdesc_use_registers(struct gdbarch *gdbarch, const struct target_desc *target_desc, struct tdesc_arch_data *early_data)
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
static int decode_b(CORE_ADDR addr, uint32_t insn, unsigned *link, int32_t *offset)
void append_composite_type_field(struct type *t, char *name, struct type *field)
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
static struct type * aarch64_vnd_type(struct gdbarch *gdbarch)
static int32_t extract_signed_bitfield(uint32_t insn, unsigned width, unsigned offset)
ULONGEST align_up(ULONGEST v, int n)
void set_gdbarch_char_signed(struct gdbarch *gdbarch, int char_signed)
#define TYPE_TARGET_TYPE(thistype)
struct type * builtin_double
struct trad_frame_saved_reg * saved_regs
static CORE_ADDR aarch64_unwind_pc(struct gdbarch *gdbarch, struct frame_info *this_frame)
static CORE_ADDR aarch64_normal_frame_base(struct frame_info *this_frame, void **this_cache)
#define TYPE_CODE(thistype)
struct value * value_of_register(int regnum, struct frame_info *frame)
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
struct regcache * regcache
static void aarch64_extract_return_value(struct type *type, struct regcache *regs, gdb_byte *valbuf)
static int in_plt_section(CORE_ADDR pc)
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
static struct type * aarch64_vnh_type(struct gdbarch *gdbarch)
static int decode_movz(CORE_ADDR addr, uint32_t insn, unsigned *rd)
static int decode_bcond(CORE_ADDR addr, uint32_t insn, unsigned *cond, int32_t *offset)
#define TYPE_NFIELDS(thistype)
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
int aarch64_process_record(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR insn_addr)
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
struct m32c_reg regs[M32C_MAX_NUM_REGS]
#define CHECK_TYPEDEF(TYPE)
static CORE_ADDR aarch64_frame_align(struct gdbarch *gdbarch, CORE_ADDR sp)
static int decode_cb(CORE_ADDR addr, uint32_t insn, int *is64, unsigned *op, unsigned *rn, int32_t *offset)
void set_gdbarch_double_format(struct gdbarch *gdbarch, const struct floatformat **double_format)
struct tdesc_arch_data * tdesc_data_alloc(void)
static enum return_value_convention aarch64_return_value(struct gdbarch *gdbarch, struct value *func_value, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
unsigned long long ULONGEST
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
const struct tdesc_feature * tdesc_find_feature(const struct target_desc *target_desc, const char *name)
void user_reg_add(struct gdbarch *gdbarch, const char *name, user_reg_read_ftype *read, const void *baton)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
struct type * value_type(const struct value *value)
struct type * builtin_int64
enum bfd_endian byte_order_for_code
static int aarch64_dwarf_reg_to_regnum(struct gdbarch *gdbarch, int reg)
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
struct cmd_list_element * showdebuglist
#define MEM_ALLOC(MEMS, LENGTH, RECORD_BUF)
void set_tdesc_pseudo_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
gdb_byte * value_contents_raw(struct value *value)
#define TYPE_LENGTH(thistype)
static void pass_in_x(struct gdbarch *gdbarch, struct regcache *regcache, struct aarch64_call_info *info, struct type *type, const bfd_byte *buf)
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
struct type * builtin_uint64
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype skip_prologue)
struct type * builtin_int8
static struct gdbarch_data * tdesc_data
static void pass_in_v_or_stack(struct gdbarch *gdbarch, struct regcache *regcache, struct aarch64_call_info *info, struct type *type, const bfd_byte *buf)
static unsigned int aarch64_record_decode_insn_handler(insn_decode_record *aarch64_insn_r)
PTR xcalloc(size_t number, size_t size)
const char * core_addr_to_string_nz(const CORE_ADDR addr)
enum bfd_endian byte_order
enum bfd_endian gdbarch_byte_order_for_code(struct gdbarch *gdbarch)
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
int record_full_arch_list_add_end(void)
int tdesc_has_registers(const struct target_desc *target_desc)
#define AARCH64_D0_REGNUM
CORE_ADDR get_frame_func(struct frame_info *this_frame)
static int decode_stp_offset_wb(CORE_ADDR addr, uint32_t insn, unsigned *rt1, unsigned *rt2, unsigned *rn, int32_t *imm)
enum dwarf2_frame_reg_rule how
pv_t pv_register(int reg, CORE_ADDR k)
static void aarch64_stub_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep *tdep)
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype inner_than)
#define AARCH64_H0_REGNUM
#define AARCH64_Q0_REGNUM
struct type * lookup_pointer_type(struct type *type)
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
static int decode_eret(CORE_ADDR addr, uint32_t insn)
void do_cleanups(struct cleanup *old_chain)
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
int language_pass_by_reference(struct type *type)
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype print_insn)
struct value *(* fn)(struct frame_info *this_frame, void **this_cache, int regnum)
#define AARCH64_B0_REGNUM
struct type * builtin_float
static struct value * aarch64_prologue_prev_register(struct frame_info *this_frame, void **this_cache, int prev_regnum)
static int aarch64_gdb_print_insn(bfd_vma memaddr, disassemble_info *info)
struct insn_decode_record_t insn_decode_record
void regcache_raw_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
const ULONGEST const LONGEST len
void set_gdbarch_vbit_in_delta(struct gdbarch *gdbarch, int vbit_in_delta)