38#include "opcode/riscv.h"
47#include "floatformat.h"
53#include "gdbsupport/common-defs.h"
54#include "opcode/riscv-opc.h"
62#define SP_ALIGNMENT 16
65#define BIGGEST_ALIGNMENT 16
69#define DECLARE_INSN(INSN_NAME, INSN_MATCH, INSN_MASK) \
70static inline bool is_ ## INSN_NAME ## _insn (long insn) \
72 return (insn & INSN_MASK) == INSN_MATCH; \
74#include "opcode/riscv-opc.h"
139 const int *reg_p = (
const int *) baton;
203 bool prefer_first_name_p,
204 std::vector<riscv_pending_register_alias> *aliases)
const;
237 const struct tdesc_feature *feature,
238 bool prefer_first_name_p,
239 std::vector<riscv_pending_register_alias> *aliases)
const
251 int start_index = prefer_first_name_p ? 1 : 0;
252 for (
int i = start_index; i < this->
names.size (); ++i)
255 if (
alias ==
name && !prefer_first_name_p)
257 aliases->emplace_back (
alias, (
void *) &this->
regnum);
315 return m_registers[
regnum].names[0];
322 std::vector<riscv_pending_register_alias> *aliases,
325 const struct tdesc_feature *feature_cpu = tdesc_feature (tdesc);
327 if (feature_cpu ==
nullptr)
330 bool seen_an_optional_reg_p =
false;
331 for (
const auto ® : m_registers)
333 bool found = reg.check (
tdesc_data, feature_cpu,
true, aliases);
338 if (!found && (!is_optional_reg_p || seen_an_optional_reg_p))
340 else if (found && is_optional_reg_p)
341 seen_an_optional_reg_p =
true;
348 for (
auto &tdesc_reg : feature_cpu->registers)
349 valid_p &= (tdesc_reg->bitsize == xlen_bitsize);
351 features->
xlen = (xlen_bitsize / 8);
352 features->
embedded = !seen_an_optional_reg_p;
402 { RISCV_CSR_FFLAGS_REGNUM, {
"fflags",
"csr1" } },
403 { RISCV_CSR_FRM_REGNUM, {
"frm",
"csr2" } },
404 { RISCV_CSR_FCSR_REGNUM, {
"fcsr",
"csr3" } },
417 return m_registers[
regnum].names[0];
424 std::vector<riscv_pending_register_alias> *aliases,
427 const struct tdesc_feature *feature_fpu = tdesc_feature (tdesc);
431 if (feature_fpu ==
nullptr)
440 for (
const auto ® : m_registers)
442 bool found = reg.check (
tdesc_data, feature_fpu,
true, aliases);
446 if (!found && !is_ctrl_reg_p)
454 for (
const auto ® : m_registers)
461 int reg_bitsize = -1;
462 for (
const char *
name : reg.names)
470 gdb_assert (reg_bitsize != -1);
471 if (fp_bitsize == -1)
472 fp_bitsize = reg_bitsize;
473 else if (fp_bitsize != reg_bitsize)
477 features->
flen = (fp_bitsize / 8);
504 std::vector<riscv_pending_register_alias> *aliases,
507 const struct tdesc_feature *feature_virtual = tdesc_feature (tdesc);
510 if (feature_virtual ==
nullptr)
515 for (
const auto ® : m_registers)
516 reg.check (
tdesc_data, feature_virtual,
true, aliases);
534#define DECLARE_CSR(NAME,VALUE,CLASS,DEFINE_VER,ABORT_VER) \
535 { RISCV_ ## VALUE ## _REGNUM, { # NAME } },
536#include "opcode/riscv-opc.h"
539 riscv_create_csr_aliases ();
544 std::vector<riscv_pending_register_alias> *aliases,
547 const struct tdesc_feature *feature_csr = tdesc_feature (tdesc);
550 if (feature_csr ==
nullptr)
555 for (
const auto ® : m_registers)
556 reg.check (
tdesc_data, feature_csr,
true, aliases);
569 for (
auto ® : m_registers)
572 gdb::unique_xmalloc_ptr<char>
alias = xstrprintf (
"csr%d", csr_num);
573 reg.names.push_back (
alias.release ());
633 return m_registers[
regnum].names[0];
640 std::vector<riscv_pending_register_alias> *aliases,
643 const struct tdesc_feature *feature_vector = tdesc_feature (tdesc);
647 if (feature_vector ==
nullptr)
654 for (
const auto ® : m_registers)
656 if (!reg.check (
tdesc_data, feature_vector,
true, aliases))
663 int vector_bitsize = -1;
664 for (
const auto ® : m_registers)
666 int reg_bitsize = -1;
667 for (
const char *
name : reg.names)
675 gdb_assert (reg_bitsize != -1);
676 if (vector_bitsize == -1)
677 vector_bitsize = reg_bitsize;
678 else if (vector_bitsize != reg_bitsize)
682 features->
vlen = (vector_bitsize / 8);
705 _(
"Debugger's use of compressed breakpoints is set "
727 _(
"RiscV debug variable `%s' is set to: %s\n"),
809 bool unaligned_p =
false;
832 const char *
bp = (unaligned_p || riscv_insn_length (buf[0]) == 2
833 ?
"C.EBREAK" :
"EBREAK");
841 riscv_insn_length (buf[0]));
843 if (unaligned_p || riscv_insn_length (buf[0]) == 2)
856static const gdb_byte *
859 static const gdb_byte ebreak[] = { 0x73, 0x00, 0x10, 0x00, };
860 static const gdb_byte c_ebreak[] = { 0x02, 0x90 };
870 gdb_assert_not_reached (
"unhandled breakpoint kind");
885 gdb_assert (
name !=
nullptr);
940static enum register_status
943 int regnum, gdb_byte *buf)
954 enum register_status
status
964 buf[0] = (buf[0] >> 5) & 0x7;
985 int fcsr_regnum = RISCV_CSR_FCSR_REGNUM;
991 raw_buf[0] = (raw_buf[0] & ~0x1f) | (buf[0] & 0x1f);
993 raw_buf[0] = (raw_buf[0] & ~(0x7 << 5)) | ((buf[0] & 0x7) << 5);
998 gdb_assert_not_reached (
"unknown pseudo register %d",
regnum);
1023 union __gdb_builtin_type_fpreg_d
1033 "__gdb_builtin_type_fpreg_d", TYPE_CODE_UNION);
1037 t->
set_name (
"builtin_type_fpreg_d");
1069 && (strcmp (
type->
name (),
"builtin_type_ieee_double") == 0
1070 || strcmp (
type->
name (),
"double") == 0))
1110 struct type *regtype;
1111 int print_raw_format;
1112 enum tab_stops { value_column_1 = 15 };
1122 catch (
const gdb_exception_error &ex)
1133 if (regtype->
code () == TYPE_CODE_FLT
1134 || (regtype->
code () == TYPE_CODE_UNION
1138 || (regtype->
code () == TYPE_CODE_UNION
1153 if (print_raw_format)
1171 if (print_raw_format)
1173 if (
regnum == RISCV_CSR_MSTATUS_REGNUM)
1184 "\tSD:%X VM:%02X MXR:%X PUM:%X MPRV:%X XS:%X "
1185 "FS:%X MPP:%x HPP:%X SPP:%X MPIE:%X HPIE:%X "
1186 "SPIE:%X UPIE:%X MIE:%X HIE:%X SIE:%X UIE:%X",
1187 (
int) ((d >> (xlen - 1)) & 0x1),
1188 (
int) ((d >> 24) & 0x1f),
1189 (
int) ((d >> 19) & 0x1),
1190 (
int) ((d >> 18) & 0x1),
1191 (
int) ((d >> 17) & 0x1),
1192 (
int) ((d >> 15) & 0x3),
1193 (
int) ((d >> 13) & 0x3),
1194 (
int) ((d >> 11) & 0x3),
1195 (
int) ((d >> 9) & 0x3),
1196 (
int) ((d >> 8) & 0x1),
1197 (
int) ((d >> 7) & 0x1),
1198 (
int) ((d >> 6) & 0x1),
1199 (
int) ((d >> 5) & 0x1),
1200 (
int) ((d >> 4) & 0x1),
1201 (
int) ((d >> 3) & 0x1),
1202 (
int) ((d >> 2) & 0x1),
1203 (
int) ((d >> 1) & 0x1),
1204 (
int) ((d >> 0) & 0x1));
1206 else if (
regnum == RISCV_CSR_MISA_REGNUM)
1217 base = (d >> ((
size * 8) - 2)) & 0x3;
1220 for (; base > 0; base--)
1224 for (i = 0; i < 26; i++)
1230 else if (
regnum == RISCV_CSR_FCSR_REGNUM
1231 ||
regnum == tdep->fflags_regnum
1232 ||
regnum == tdep->frm_regnum)
1237 if (
regnum != tdep->frm_regnum)
1239 "NV:%d DZ:%d OF:%d UF:%d NX:%d",
1240 (
int) ((d >> 4) & 0x1),
1241 (
int) ((d >> 3) & 0x1),
1242 (
int) ((d >> 2) & 0x1),
1243 (
int) ((d >> 1) & 0x1),
1244 (
int) ((d >> 0) & 0x1));
1246 if (
regnum != tdep->fflags_regnum)
1248 static const char *
const sfrm[] =
1250 _(
"RNE (round to nearest; ties to even)"),
1251 _(
"RTZ (Round towards zero)"),
1252 _(
"RDN (Round down towards -INF)"),
1253 _(
"RUP (Round up towards +INF)"),
1254 _(
"RMM (Round to nearest; ties to max magnitude)"),
1260 _(
"INVALID[7] (Dynamic rounding mode)"),
1262 int frm = ((
regnum == RISCV_CSR_FCSR_REGNUM)
1263 ? (d >> 5) : d) & 0x7;
1266 (
regnum == RISCV_CSR_FCSR_REGNUM
1281 static const char *
const sprv[] =
1292 gdb_printf (file,
"\tprv:%d [INVALID]", priv);
1322#define DECLARE_CSR(name, num, class, define_ver, abort_ver) case RISCV_ ## num ## _REGNUM:
1323#include "opcode/riscv-opc.h"
1398 ||
regnum == RISCV_CSR_FCSR_REGNUM
1407 ||
regnum == RISCV_CSR_FCSR_REGNUM
1441 gdb_assert_not_reached (
"unknown pseudo register number %d",
regnum);
1454 gdb_assert_not_reached (
"unknown pseudo register number %d",
regnum);
1475 int regnum,
int print_all)
1481 error (_(
"Not a valid register for the current processor type"));
1571 {
return m_length; }
1575 {
return m_opcode; }
1604 return (
opcode >> offset) & 0x1F;
1610 return ((
opcode >> offset) & 0x7) + 8;
1617 m_rd = decode_register_index (ival, OP_SH_RD);
1618 m_rs1 = decode_register_index (ival, OP_SH_RS1);
1619 m_rs2 = decode_register_index (ival, OP_SH_RS2);
1626 m_rd = m_rs1 = decode_register_index (ival, OP_SH_CRS1S);
1627 m_rs2 = decode_register_index (ival, OP_SH_CRS2);
1634 m_rd = decode_register_index (ival, OP_SH_RD);
1635 m_rs1 = decode_register_index (ival, OP_SH_RS1);
1636 m_imm.s = EXTRACT_ITYPE_IMM (ival);
1643 m_rd = m_rs1 = decode_register_index (ival, OP_SH_CRS1S);
1644 m_imm.s = EXTRACT_CITYPE_IMM (ival);
1651 m_rd = decode_register_index_short (ival, OP_SH_CRS2S);
1652 m_rs1 = decode_register_index_short (ival, OP_SH_CRS1S);
1653 m_imm.s = EXTRACT_CLTYPE_IMM (ival);
1660 m_rs1 = decode_register_index (ival, OP_SH_RS1);
1661 m_rs2 = decode_register_index (ival, OP_SH_RS2);
1662 m_imm.s = EXTRACT_STYPE_IMM (ival);
1673 m_rs1 = decode_register_index_short (ival, OP_SH_CRS1S);
1674 m_rs2 = decode_register_index_short (ival, OP_SH_CRS2S);
1687 m_rs2 = decode_register_index (ival, OP_SH_CRS2);
1694 m_rd = decode_register_index (ival, OP_SH_RD);
1695 m_imm.s = EXTRACT_UTYPE_IMM (ival);
1702 m_rd = decode_register_index (ival, OP_SH_RD);
1703 m_imm.s = EXTRACT_JTYPE_IMM (ival);
1710 m_imm.s = EXTRACT_CJTYPE_IMM (ival);
1716 m_rs1 = decode_register_index (ival, OP_SH_RS1);
1717 m_rs2 = decode_register_index (ival, OP_SH_RS2);
1718 m_imm.s = EXTRACT_BTYPE_IMM (ival);
1724 m_rs1 = decode_register_index_short (ival, OP_SH_CRS1S);
1725 m_imm.s = EXTRACT_CBTYPE_IMM (ival);
1731 CORE_ADDR addr,
int *len);
1770 CORE_ADDR addr,
int *len)
1773 gdb_byte buf[RISCV_MAX_INSN_LEN];
1782 instlen = riscv_insn_length (buf[0]);
1783 gdb_assert (instlen <=
sizeof (buf));
1810 if (is_add_insn (ival))
1811 decode_r_type_insn (
ADD, ival);
1812 else if (is_addw_insn (ival))
1813 decode_r_type_insn (ADDW, ival);
1814 else if (is_addi_insn (ival))
1815 decode_i_type_insn (ADDI, ival);
1816 else if (is_addiw_insn (ival))
1817 decode_i_type_insn (ADDIW, ival);
1818 else if (is_auipc_insn (ival))
1819 decode_u_type_insn (AUIPC, ival);
1820 else if (is_lui_insn (ival))
1821 decode_u_type_insn (LUI, ival);
1822 else if (is_sd_insn (ival))
1823 decode_s_type_insn (SD, ival);
1824 else if (is_sw_insn (ival))
1825 decode_s_type_insn (SW, ival);
1826 else if (is_jal_insn (ival))
1827 decode_j_type_insn (JAL, ival);
1828 else if (is_jalr_insn (ival))
1829 decode_i_type_insn (JALR, ival);
1830 else if (is_beq_insn (ival))
1831 decode_b_type_insn (BEQ, ival);
1832 else if (is_bne_insn (ival))
1833 decode_b_type_insn (BNE, ival);
1834 else if (is_blt_insn (ival))
1835 decode_b_type_insn (BLT, ival);
1836 else if (is_bge_insn (ival))
1837 decode_b_type_insn (BGE, ival);
1838 else if (is_bltu_insn (ival))
1839 decode_b_type_insn (BLTU, ival);
1840 else if (is_bgeu_insn (ival))
1841 decode_b_type_insn (BGEU, ival);
1842 else if (is_lr_w_insn (ival))
1843 decode_r_type_insn (LR, ival);
1844 else if (is_lr_d_insn (ival))
1845 decode_r_type_insn (LR, ival);
1846 else if (is_sc_w_insn (ival))
1847 decode_r_type_insn (SC, ival);
1848 else if (is_sc_d_insn (ival))
1849 decode_r_type_insn (SC, ival);
1850 else if (is_ecall_insn (ival))
1851 decode_i_type_insn (ECALL, ival);
1852 else if (is_ld_insn (ival))
1853 decode_i_type_insn (LD, ival);
1854 else if (is_lw_insn (ival))
1855 decode_i_type_insn (LW, ival);
1860 else if (m_length == 2)
1867 if (is_c_jalr_insn (ival))
1868 decode_cr_type_insn (JALR, ival);
1869 else if (is_c_add_insn (ival))
1870 decode_cr_type_insn (
ADD, ival);
1872 else if (xlen != 4 && is_c_addw_insn (ival))
1873 decode_cr_type_insn (ADDW, ival);
1874 else if (is_c_addi_insn (ival))
1875 decode_ci_type_insn (ADDI, ival);
1878 else if (xlen != 4 && is_c_addiw_insn (ival))
1879 decode_ci_type_insn (ADDIW, ival);
1880 else if (xlen == 4 && is_c_jal_insn (ival))
1881 decode_cj_type_insn (JAL, ival);
1885 else if (is_c_addi16sp_insn (ival))
1888 m_rd = m_rs1 = decode_register_index (ival, OP_SH_RD);
1889 m_imm.s = EXTRACT_CITYPE_ADDI16SP_IMM (ival);
1891 else if (is_c_addi4spn_insn (ival))
1894 m_rd = decode_register_index_short (ival, OP_SH_CRS2S);
1896 m_imm.s = EXTRACT_CIWTYPE_ADDI4SPN_IMM (ival);
1898 else if (is_c_lui_insn (ival))
1901 m_rd = decode_register_index (ival, OP_SH_CRS1S);
1902 m_imm.s = EXTRACT_CITYPE_LUI_IMM (ival);
1906 else if (xlen != 4 && is_c_sd_insn (ival))
1907 decode_cs_type_insn (SD, ival, EXTRACT_CLTYPE_LD_IMM (ival));
1908 else if (is_c_sw_insn (ival))
1909 decode_cs_type_insn (SW, ival, EXTRACT_CLTYPE_LW_IMM (ival));
1910 else if (is_c_swsp_insn (ival))
1911 decode_css_type_insn (SW, ival, EXTRACT_CSSTYPE_SWSP_IMM (ival));
1912 else if (xlen != 4 && is_c_sdsp_insn (ival))
1913 decode_css_type_insn (SD, ival, EXTRACT_CSSTYPE_SDSP_IMM (ival));
1916 else if (is_c_jr_insn (ival))
1917 decode_cr_type_insn (JALR, ival);
1918 else if (is_c_mv_insn (ival))
1919 decode_cr_type_insn (MV, ival);
1920 else if (is_c_j_insn (ival))
1921 decode_cj_type_insn (JAL, ival);
1922 else if (is_c_beqz_insn (ival))
1923 decode_cb_type_insn (BEQ, ival);
1924 else if (is_c_bnez_insn (ival))
1925 decode_cb_type_insn (BNE, ival);
1926 else if (is_c_ld_insn (ival))
1927 decode_cl_type_insn (LD, ival);
1928 else if (is_c_lw_insn (ival))
1929 decode_cl_type_insn (LW, ival);
1939 gdb_assert (m_length > 0 && m_length % 2 == 0);
1954 CORE_ADDR start_pc, CORE_ADDR end_pc,
1957 CORE_ADDR cur_pc, next_pc, after_prologue_pc;
1958 CORE_ADDR end_prologue_addr = 0;
1964 if (after_prologue_pc == 0)
1965 after_prologue_pc = start_pc + 100;
1966 if (after_prologue_pc < end_pc)
1967 end_pc = after_prologue_pc;
1977 "Prologue scan for function starting at %s (limit %s)\n",
1978 core_addr_to_string (start_pc),
1979 core_addr_to_string (end_pc));
1981 for (next_pc = cur_pc = start_pc; cur_pc < end_pc; cur_pc = next_pc)
1988 gdb_assert (insn.
length () > 0);
1989 next_pc = cur_pc + insn.
length ();
2077 regs[insn.
rd ()] =
pv_add (regs[insn.
rs1 ()], regs[insn.
rs2 ()]);
2098 gdb_assert (insn.
rs2 () > 0);
2099 regs[insn.
rd ()] = regs[insn.
rs2 ()];
2103 end_prologue_addr = cur_pc;
2108 if (end_prologue_addr == 0)
2109 end_prologue_addr = cur_pc;
2113 core_addr_to_string (end_prologue_addr));
2149 "Register $%s at stack offset %s\n",
2151 plongest ((LONGEST) offset));
2158 return end_prologue_addr;
2166 CORE_ADDR func_addr;
2173 CORE_ADDR post_prologue_pc
2176 if (post_prologue_pc != 0)
2177 return std::max (pc, post_prologue_pc);
2190 CORE_ADDR funaddr,
struct value **args,
int nargs,
2195 static const gdb_byte nop_insn[] = { 0x13, 0x00, 0x00, 0x00 };
2227 "Writing %s-byte nop instruction to %s: %s\n",
2228 plongest (
sizeof (nop_insn)),
2230 (
status == 0 ?
"success" :
"failed"));
2330 : next_regnum (first),
2392 float_regs.next_regnum = float_regs.last_regnum + 1;
2437 int length,
int offset)
2444 loc->c_length = length;
2445 loc->c_offset = offset;
2463 int length,
int align)
2470 loc->c_length = length;
2518 int len = std::min (ainfo->
length, cinfo->
xlen);
2519 int align = std::max (ainfo->
align, cinfo->
xlen);
2530 &cinfo->
memory, len, align);
2532 if (len < ainfo->length)
2534 len = ainfo->
length - len;
2575 int len = ainfo->
length / 2;
2579 gdb_assert (result);
2583 gdb_assert (result);
2598 : m_number_of_fields (0),
2599 m_types { nullptr, nullptr },
2609 analyse_inner (
type, 0);
2618 {
return m_number_of_fields; }
2626 gdb_assert (index < (
sizeof (m_types) /
sizeof (m_types[0])));
2627 return m_types[index];
2636 gdb_assert (index < (
sizeof (m_offsets) /
sizeof (m_offsets[0])));
2637 return m_offsets[index];
2655 void analyse_inner (
struct type *
type,
int offset);
2666 for (i = 0; i < count; ++i)
2676 switch (field_type->
code ())
2678 case TYPE_CODE_STRUCT:
2679 analyse_inner (field_type, field_offset);
2688 if (m_number_of_fields < 2)
2690 m_types[m_number_of_fields] = field_type;
2691 m_offsets[m_number_of_fields] = field_offset;
2693 m_number_of_fields++;
2702 if (m_number_of_fields > 2)
2740 gdb_assert (result);
2745 gdb_assert (result);
2786 error (_(
"failed during argument setup"));
2796 error (_(
"failed during argument setup"));
2811 error (_(
"failed during argument setup"));
2815 gdb_assert (len1 <= cinfo->xlen);
2818 error (_(
"failed during argument setup"));
2832 gdb_assert (len0 <= cinfo->xlen);
2833 gdb_assert (len1 <= cinfo->flen);
2838 error (_(
"failed during argument setup"));
2844 error (_(
"failed during argument setup"));
2869 struct type *
type,
bool is_unnamed)
2882 case TYPE_CODE_BOOL:
2883 case TYPE_CODE_CHAR:
2884 case TYPE_CODE_RANGE:
2885 case TYPE_CODE_ENUM:
2887 case TYPE_CODE_FIXED_POINT:
2908 case TYPE_CODE_COMPLEX:
2912 case TYPE_CODE_STRUCT:
2930 CORE_ADDR sp_refs, CORE_ADDR sp_args)
2932 gdb_printf (stream,
"type: '%s', length: 0x%x, alignment: 0x%x",
2934 switch (info->argloc[0].loc_type)
2938 (stream,
", register %s",
2940 if (info->argloc[0].c_length < info->length)
2942 switch (info->argloc[1].loc_type)
2946 (stream,
", register %s",
2948 info->argloc[1].loc_data.regno));
2952 gdb_printf (stream,
", on stack at offset 0x%x",
2953 info->argloc[1].loc_data.offset);
2961 error (_(
"invalid argument location"));
2965 if (info->argloc[1].c_offset > info->argloc[0].c_length)
2967 info->argloc[1].c_offset);
2972 gdb_printf (stream,
", on stack at offset 0x%x",
2973 info->argloc[0].loc_data.offset);
2978 (stream,
", by reference, data at offset 0x%x (%s)",
2979 info->argloc[0].loc_data.offset,
2980 core_addr_to_string (sp_refs + info->argloc[0].loc_data.offset));
2981 if (info->argloc[1].loc_type
2984 (stream,
", address in register %s",
2988 gdb_assert (info->argloc[1].loc_type
2991 (stream,
", address on stack at offset 0x%x (%s)",
2992 info->argloc[1].loc_data.offset,
2993 core_addr_to_string (sp_args + info->argloc[1].loc_data.offset));
2998 gdb_assert_not_reached (
"unknown argument location type");
3011 gdb_byte tmp [
sizeof (ULONGEST)];
3015 memset (tmp, -1,
sizeof (tmp));
3017 memset (tmp, 0,
sizeof (tmp));
3018 memcpy (tmp, data, len);
3026 struct value *function,
3030 struct value **args,
3033 CORE_ADDR struct_addr)
3036 CORE_ADDR sp_args, sp_refs;
3048 if (ftype->
code () == TYPE_CODE_PTR)
3055 for (i = 0; i < nargs; ++i)
3057 struct value *arg_value;
3058 struct type *arg_type;
3061 arg_value = args[i];
3067 if (info->type != arg_type)
3068 arg_value =
value_cast (info->type, arg_value);
3085 "[*] struct return pointer in register $A0\n");
3086 for (i = 0; i < nargs; ++i)
3098 core_addr_to_string (osp));
3104 core_addr_to_string_nz (osp - sp));
3112 gdb_byte buf[
sizeof (LONGEST)];
3118 for (i = 0; i < nargs; ++i)
3121 int second_arg_length = 0;
3122 const gdb_byte *second_arg_data;
3125 gdb_assert (info->length > 0);
3127 switch (info->argloc[0].loc_type)
3131 gdb_assert (info->argloc[0].c_length <= info->length);
3135 + info->argloc[0].c_offset),
3136 info->argloc[0].c_length,
3139 (((info->argloc[0].c_length + info->argloc[0].c_offset) < info->length)
3140 ? info->argloc[1].c_length : 0);
3141 second_arg_data = info->contents + info->argloc[1].c_offset;
3146 dst = sp_args + info->argloc[0].loc_data.offset;
3148 second_arg_length = 0;
3152 dst = sp_refs + info->argloc[0].loc_data.offset;
3155 second_arg_length = call_info.
xlen;
3156 second_arg_data = (gdb_byte *) &dst;
3160 gdb_assert_not_reached (
"unknown argument location type");
3163 if (second_arg_length > 0)
3165 switch (info->argloc[1].loc_type)
3170 && second_arg_length <= call_info.
flen)
3171 || second_arg_length <= call_info.
xlen);
3183 arg_addr = sp_args + info->argloc[1].loc_data.offset;
3184 write_memory (arg_addr, second_arg_data, second_arg_length);
3193 error (_(
"invalid argument location"));
3204 core_addr_to_string (bp_addr));
3211 core_addr_to_string (sp));
3221 struct value *function,
3225 const gdb_byte *writebuf)
3229 struct type *arg_type;
3242 if (readbuf !=
nullptr || writebuf !=
nullptr)
3244 unsigned int arg_len;
3245 struct value *abi_val;
3246 gdb_byte *old_readbuf =
nullptr;
3250 gdb_assert (readbuf ==
nullptr || writebuf ==
nullptr);
3260 if (writebuf !=
nullptr)
3262 struct value *arg_val;
3272 unscaled.
read (gdb::make_array_view (writebuf,
3279 info.type->is_unsigned ());
3291 old_readbuf = readbuf;
3294 arg_len = info.type->length ();
3296 switch (info.argloc[0].loc_type)
3301 regnum = info.argloc[0].loc_data.regno;
3302 gdb_assert (info.argloc[0].c_length <= arg_len);
3303 gdb_assert (info.argloc[0].c_length
3308 gdb_byte *ptr = readbuf + info.argloc[0].c_offset;
3310 info.argloc[0].c_length,
3316 const gdb_byte *ptr = writebuf + info.argloc[0].c_offset;
3318 info.argloc[0].c_length,
3324 if (info.argloc[1].c_length > 0)
3326 switch (info.argloc[1].loc_type)
3329 regnum = info.argloc[1].loc_data.regno;
3331 gdb_assert ((info.argloc[0].c_length
3332 + info.argloc[1].c_length) <= arg_len);
3333 gdb_assert (info.argloc[1].c_length
3338 readbuf += info.argloc[1].c_offset;
3340 info.argloc[1].c_length,
3347 = writebuf + info.argloc[1].c_offset;
3349 (
regnum, ptr, info.argloc[1].c_length,
3357 error (_(
"invalid argument location"));
3371 if (readbuf !=
nullptr)
3373 if (writebuf !=
nullptr)
3380 error (_(
"invalid argument location"));
3387 if (readbuf !=
nullptr)
3389 struct value *arg_val;
3400 info.type->is_unsigned ());
3413 switch (info.argloc[0].loc_type)
3421 error (_(
"invalid argument location"));
3430 return align_down (addr, 16);
3439 CORE_ADDR pc, start_addr;
3444 if ((*this_cache) != NULL)
3449 (*this_cache) = cache;
3473 for (regno = 0; regno < numregs; ++regno)
3499 void **prologue_cache,
3509 catch (
const gdb_exception_error &ex)
3518static struct value *
3520 void **prologue_cache,
3560 if (abfd !=
nullptr && bfd_get_flavour (abfd) == bfd_target_elf_flavour)
3562 unsigned char eclass = elf_elfheader (abfd)->e_ident[EI_CLASS];
3563 int e_flags = elf_elfheader (abfd)->e_flags;
3565 if (eclass == ELFCLASS32)
3567 else if (eclass == ELFCLASS64)
3570 internal_error (_(
"unknown ELF header class %d"), eclass);
3572 if (e_flags & EF_RISCV_FLOAT_ABI_DOUBLE)
3574 else if (e_flags & EF_RISCV_FLOAT_ABI_SINGLE)
3577 if (e_flags & EF_RISCV_RVE)
3579 if (features.
xlen == 8)
3581 warning (_(
"64-bit ELF with RV32E flag set! Assuming 32-bit"));
3606 if (features.
xlen == 0)
3607 features.
xlen = info.bfd_arch_info->bits_per_word == 32 ? 4 : 8;
3653 std::string target_options;
3655 target_options =
"-march=rv";
3657 target_options +=
"64";
3659 target_options +=
"32";
3661 target_options +=
"gc";
3662 else if (isa_flen == 4)
3663 target_options +=
"imafc";
3665 target_options +=
"imac";
3667 target_options +=
" -mabi=";
3669 target_options +=
"lp64";
3671 target_options +=
"ilp32";
3673 target_options +=
"d";
3674 else if (abi_flen == 4)
3675 target_options +=
"f";
3678 target_options +=
" -mno-relax";
3680 return target_options;
3691 const char *reg_name,
int possible_regnum)
3720 int *regnum_ptr =
nullptr;
3722 if (strcmp (reg_name,
"fflags") == 0)
3724 else if (strcmp (reg_name,
"frm") == 0)
3726 else if (strcmp (reg_name,
"fcsr") == 0)
3729 if (regnum_ptr !=
nullptr)
3735 if (*regnum_ptr != -1)
3740 *regnum_ptr = possible_regnum;
3741 return possible_regnum;
3756 return possible_regnum;
3772 return "riscv(32|64)?";
3788 const struct target_desc *tdesc = info.target_desc;
3793 gdb_assert (tdesc !=
nullptr);
3799 std::vector<riscv_pending_register_alias> pending_aliases;
3802 &pending_aliases, &features)
3804 &pending_aliases, &features)
3806 &pending_aliases, &features)
3808 &pending_aliases, &features)
3810 &pending_aliases, &features));
3834 if (abi_features.
xlen == 0)
3835 abi_features = features;
3840 if (abi_features.
xlen != features.
xlen)
3841 error (_(
"bfd requires xlen %d, but target has xlen %d"),
3846 if (abi_features.
flen > features.
flen)
3847 error (_(
"bfd requires flen %d, but target has flen %d"),
3859 = gdbarch_tdep<riscv_gdbarch_tdep> (
arches->gdbarch);
3956 int num_pseudo_regs = 0;
3964 pending_aliases.emplace_back (
"csr1", (
void *) &tdep->
fflags_regnum);
3965 next_pseudo_regnum++;
3974 pending_aliases.emplace_back (
"csr2", (
void *) &tdep->
frm_regnum);
3975 next_pseudo_regnum++;
4002 for (
const auto &
alias : pending_aliases)
4011 disassembler_options_riscv ());
4030 = gdbarch_tdep<riscv_gdbarch_tdep> (
gdbarch);
4035 next_pc = pc + insn.
length ();
4043 next_pc = (source + insn.
imm_signed ()) & ~(CORE_ADDR) 0x1;
4079 ULONGEST src1, src2;
4087 ULONGEST src1, src2;
4111 CORE_ADDR cur_step_pc = pc;
4112 CORE_ADDR last_addr = 0;
4118 cur_step_pc = cur_step_pc + insn.
length ();
4124 last_addr = cur_step_pc + insn.
imm_signed ();
4125 cur_step_pc = cur_step_pc + insn.
length ();
4131 cur_step_pc = cur_step_pc + insn.
length ();
4137 if (pc != (cur_step_pc + insn.
imm_signed ()))
4139 cur_step_pc = cur_step_pc + insn.
length ();
4142 if (cur_step_pc != last_addr)
4145 *next_pc = cur_step_pc;
4153std::vector<CORE_ADDR>
4156 CORE_ADDR pc, next_pc;
4181 const void *regs,
size_t len)
4195 int fcsr_regnum = RISCV_CSR_FCSR_REGNUM;
4217 ULONGEST fflags_val = fcsr_val & 0x1f;
4218 ULONGEST frm_val = (fcsr_val >> 5) & 0x7;
4226 (gdb_byte *) &fflags_val,
4227 sizeof (fflags_val),
4233 (gdb_byte *)&frm_val,
4234 sizeof (fflags_val),
4251 _(
"RISC-V specific debug commands."),
4252 _(
"RISC-V specific debug commands."),
4258Set riscv breakpoint debugging."), _(
"\
4259Show riscv breakpoint debugging."), _(
"\
4260When non-zero, print debugging information for the riscv specific parts\n\
4261of the breakpoint mechanism."),
4268Set riscv inferior call debugging."), _(
"\
4269Show riscv inferior call debugging."), _(
"\
4270When non-zero, print debugging information for the riscv specific parts\n\
4271of the inferior call mechanism."),
4278Set riscv stack unwinding debugging."), _(
"\
4279Show riscv stack unwinding debugging."), _(
"\
4280When non-zero, print debugging information for the riscv specific parts\n\
4281of the stack unwinding mechanism."),
4288Set riscv gdbarch initialisation debugging."), _(
"\
4289Show riscv gdbarch initialisation debugging."), _(
"\
4290When non-zero, print debugging information for the riscv gdbarch\n\
4291initialisation process."),
4298 _(
"RISC-V specific commands."),
4299 _(
"RISC-V specific commands."),
4308Set debugger's use of compressed breakpoints."), _(
" \
4309Show debugger's use of compressed breakpoints."), _(
"\
4310Debugging compressed code requires compressed breakpoints to be used. If\n\
4311left to 'auto' then gdb will use them if the existing instruction is a\n\
4312compressed instruction. If that doesn't give the correct behavior, then\n\
4313this option can be used."),
gdb_static_assert(sizeof(splay_tree_key) >=sizeof(CORE_ADDR *))
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)
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
pv_t fetch(pv_t addr, CORE_ADDR size)
bool find_reg(struct gdbarch *gdbarch, int reg, CORE_ADDR *offset_p)
void store(pv_t addr, CORE_ADDR size, pv_t value)
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 raw_read_part(int regnum, int offset, int len, gdb_byte *buf)
enum register_status cooked_read(int regnum, gdb_byte *buf)
void raw_supply_integer(int regnum, const gdb_byte *addr, int addr_len, bool is_signed)
enum register_status get_register_status(int regnum) const override
void raw_supply_zeroed(int regnum)
void cooked_write(int regnum, const gdb_byte *buf)
void raw_write(int regnum, const gdb_byte *buf)
void supply_regset(const struct regset *regset, int regbase, int regnum, const void *buf, size_t size)
void decode_cj_type_insn(enum opcode opcode, ULONGEST ival)
void decode_s_type_insn(enum opcode opcode, ULONGEST ival)
void decode_b_type_insn(enum opcode opcode, ULONGEST ival)
void decode_u_type_insn(enum opcode opcode, ULONGEST ival)
void decode_cr_type_insn(enum opcode opcode, ULONGEST ival)
void decode_i_type_insn(enum opcode opcode, ULONGEST ival)
int decode_register_index(unsigned long opcode, int offset)
void decode_j_type_insn(enum opcode opcode, ULONGEST ival)
enum opcode opcode() const
void decode_r_type_insn(enum opcode opcode, ULONGEST ival)
void decode_cb_type_insn(enum opcode opcode, ULONGEST ival)
void decode_cs_type_insn(enum opcode opcode, ULONGEST ival, int imm)
static ULONGEST fetch_instruction(struct gdbarch *gdbarch, CORE_ADDR addr, int *len)
void decode_css_type_insn(enum opcode opcode, ULONGEST ival, int imm)
void decode(struct gdbarch *gdbarch, CORE_ADDR pc)
void decode_cl_type_insn(enum opcode opcode, ULONGEST ival)
int decode_register_index_short(unsigned long opcode, int offset)
void decode_ci_type_insn(enum opcode opcode, ULONGEST ival)
void create(struct gdbarch *gdbarch) const
riscv_pending_register_alias(const char *name, const void *baton)
void analyse_inner(struct type *type, int offset)
void analyse(struct type *type)
int number_of_fields() const
int field_offset(int index) const
struct type * field_type(int index) const
struct cmd_list_element * showlist
struct cmd_list_element * setlist
struct cmd_list_element * showdebuglist
struct cmd_list_element * setdebuglist
set_show_commands add_setshow_prefix_cmd(const char *name, command_class theclass, const char *set_doc, const char *show_doc, cmd_list_element **set_subcommands_list, cmd_list_element **show_subcommands_list, cmd_list_element **set_list, cmd_list_element **show_list)
set_show_commands add_setshow_auto_boolean_cmd(const char *name, enum command_class theclass, enum auto_boolean *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
set_show_commands add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
void memory_error(enum target_xfer_status err, CORE_ADDR memaddr)
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
@ RETURN_VALUE_REGISTER_CONVENTION
@ RETURN_VALUE_ABI_PRESERVES_ADDRESS
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
struct value * value_of_register(int regnum, frame_info_ptr frame)
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)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
CORE_ADDR get_frame_pc(frame_info_ptr frame)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
frame_info_ptr get_current_frame(void)
#define FRAME_OBSTACK_ZALLOC(TYPE)
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
void set_gdbarch_char_signed(struct gdbarch *gdbarch, int char_signed)
void set_gdbarch_disassembler_options(struct gdbarch *gdbarch, char **disassembler_options)
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)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
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_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
int gdbarch_addr_bit(struct gdbarch *gdbarch)
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name)
void set_gdbarch_push_dummy_code(struct gdbarch *gdbarch, gdbarch_push_dummy_code_ftype *push_dummy_code)
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_have_nonsteppable_watchpoint(struct gdbarch *gdbarch, int have_nonsteppable_watchpoint)
void set_gdbarch_gnu_triplet_regexp(struct gdbarch *gdbarch, gdbarch_gnu_triplet_regexp_ftype *gnu_triplet_regexp)
void set_gdbarch_print_registers_info(struct gdbarch *gdbarch, gdbarch_print_registers_info_ftype *print_registers_info)
int gdbarch_num_regs(struct gdbarch *gdbarch)
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than)
enum bfd_endian gdbarch_byte_order_for_code(struct gdbarch *gdbarch)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
void set_gdbarch_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *register_reggroup_p)
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
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_call_dummy_location(struct gdbarch *gdbarch, enum call_dummy_location_type call_dummy_location)
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type)
void set_gdbarch_gcc_target_options(struct gdbarch *gdbarch, gdbarch_gcc_target_options_ftype *gcc_target_options)
void set_gdbarch_float_bit(struct gdbarch *gdbarch, int float_bit)
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
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)
int gdbarch_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *reggroup)
void set_gdbarch_type_align(struct gdbarch *gdbarch, gdbarch_type_align_ftype *type_align)
void set_gdbarch_cannot_store_register(struct gdbarch *gdbarch, gdbarch_cannot_store_register_ftype *cannot_store_register)
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype *pseudo_register_read)
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_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind)
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)
static int gdbarch_num_cooked_regs(gdbarch *arch)
function_call_return_method
enum bfd_endian type_byte_order(const struct type *type)
int is_integral_type(struct type *t)
struct type * arch_composite_type(struct gdbarch *gdbarch, const char *name, enum type_code code)
const struct floatformat * floatformats_ieee_quad[BFD_ENDIAN_UNKNOWN]
unsigned type_align(struct type *type)
void append_composite_type_field(struct type *t, const char *name, struct type *field)
bool is_fixed_point_type(struct type *type)
struct type * check_typedef(struct type *type)
#define TYPE_SAFE_NAME(type)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
static CORE_ADDR fetch_instruction(CORE_ADDR addr, ia64_instruction_type *it, long long *instr)
const struct language_defn * current_language
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
pv_t pv_constant(CORE_ADDR k)
pv_t pv_register(int reg, CORE_ADDR k)
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)
CORE_ADDR regcache_read_pc(struct regcache *regcache)
int register_size(struct gdbarch *gdbarch, int regnum)
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
const reggroup *const general_reggroup
int default_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *group)
const reggroup * reggroup_new(const char *name, enum reggroup_type type)
const reggroup *const system_reggroup
const reggroup *const float_reggroup
const reggroup *const save_reggroup
const reggroup *const all_reggroup
void reggroup_add(struct gdbarch *gdbarch, const reggroup *group)
const reggroup *const restore_reggroup
const reggroup *const vector_reggroup
void register_riscv_ravenscar_ops(struct gdbarch *gdbarch)
static int riscv_pseudo_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *reggroup)
static struct cmd_list_element * setriscvcmdlist
static ULONGEST riscv_type_align(gdbarch *gdbarch, type *type)
static void riscv_assign_stack_location(struct riscv_arg_info::location *loc, struct riscv_memory_offsets *memory, int length, int align)
static void riscv_init_reggroups()
bool riscv_abi_embedded(struct gdbarch *gdbarch)
static const struct target_desc * riscv_find_default_target_description(const struct gdbarch_info info)
static void riscv_call_arg_scalar_int(struct riscv_arg_info *ainfo, struct riscv_call_info *cinfo)
static unsigned int riscv_debug_breakpoints
static bool riscv_is_regnum_a_named_csr(int regnum)
static enum auto_boolean use_compressed_breakpoints
static void riscv_regcache_cooked_write(int regnum, const gdb_byte *data, int len, struct regcache *regcache, int flen)
int riscv_abi_flen(struct gdbarch *gdbarch)
static const char * riscv_feature_name_virtual
static CORE_ADDR riscv_scan_prologue(struct gdbarch *gdbarch, CORE_ADDR start_pc, CORE_ADDR end_pc, struct riscv_unwind_cache *cache)
static CORE_ADDR riscv_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
static struct gdbarch * riscv_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
static void riscv_print_arg_location(ui_file *stream, struct gdbarch *gdbarch, struct riscv_arg_info *info, CORE_ADDR sp_refs, CORE_ADDR sp_args)
static void riscv_call_arg_complex_float(struct riscv_arg_info *ainfo, struct riscv_call_info *cinfo)
static struct cmd_list_element * showriscvcmdlist
static CORE_ADDR riscv_frame_align(struct gdbarch *gdbarch, CORE_ADDR addr)
static bool riscv_is_unknown_csr(struct gdbarch *gdbarch, int regnum)
static unsigned int riscv_debug_unwinder
static bool riscv_assign_reg_location(struct riscv_arg_info::location *loc, struct riscv_arg_reg *reg, int length, int offset)
static bool riscv_is_fp_regno_p(int regno)
static int riscv_arg_regs_available(struct riscv_arg_reg *reg)
void riscv_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *regs, size_t len)
static void riscv_print_one_register_info(struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, int regnum)
static const char * riscv_feature_name_fpu
static void riscv_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, const gdb_byte *buf)
static unsigned int riscv_debug_infcall
static int riscv_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *reggroup)
int riscv_abi_xlen(struct gdbarch *gdbarch)
static enum register_status riscv_pseudo_register_read(struct gdbarch *gdbarch, readable_regcache *regcache, int regnum, gdb_byte *buf)
static int riscv_breakpoint_kind_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr)
static struct cmd_list_element * setdebugriscvcmdlist
static const gdb_byte * riscv_sw_breakpoint_from_kind(struct gdbarch *gdbarch, int kind, int *size)
static void show_use_compressed_breakpoints(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
int riscv_isa_xlen(struct gdbarch *gdbarch)
static bool riscv_has_fp_abi(struct gdbarch *gdbarch)
static bool riscv_has_fp_regs(struct gdbarch *gdbarch)
static void riscv_print_registers_info(struct gdbarch *gdbarch, struct ui_file *file, frame_info_ptr frame, int regnum, int print_all)
#define BIGGEST_ALIGNMENT
static char * riscv_disassembler_options
static unsigned int riscv_debug_gdbarch
static const char * riscv_gnu_triplet_regexp(struct gdbarch *gdbarch)
static const char * riscv_feature_name_vector
const char * riscv_feature_name_csr
static struct type * riscv_pseudo_register_type(struct gdbarch *gdbarch, int regnum)
static struct value * riscv_frame_prev_register(frame_info_ptr this_frame, void **prologue_cache, int regnum)
int riscv_isa_flen(struct gdbarch *gdbarch)
static const struct frame_unwind riscv_frame_unwind
static void show_riscv_debug_variable(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
static void riscv_add_reggroups(struct gdbarch *gdbarch)
static int riscv_cannot_store_register(struct gdbarch *gdbarch, int regnum)
static struct type * riscv_fpreg_d_type(struct gdbarch *gdbarch)
static const reggroup * csr_reggroup
static int riscv_dwarf_reg_to_regnum(struct gdbarch *gdbarch, int reg)
static struct riscv_gdbarch_features riscv_features_from_bfd(const bfd *abfd)
static void riscv_call_arg_struct(struct riscv_arg_info *ainfo, struct riscv_call_info *cinfo)
void _initialize_riscv_tdep()
static CORE_ADDR riscv_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 void riscv_arg_location(struct gdbarch *gdbarch, struct riscv_arg_info *ainfo, struct riscv_call_info *cinfo, struct type *type, bool is_unnamed)
static const char * riscv_pseudo_register_name(struct gdbarch *gdbarch, int regnum)
static std::string riscv_gcc_target_options(struct gdbarch *gdbarch)
static struct type * riscv_register_type(struct gdbarch *gdbarch, int regnum)
std::vector< CORE_ADDR > riscv_software_single_step(struct regcache *regcache)
static const char * riscv_register_name(struct gdbarch *gdbarch, int regnum)
static void riscv_call_arg_scalar_float(struct riscv_arg_info *ainfo, struct riscv_call_info *cinfo)
static enum return_value_convention riscv_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
static int riscv_tdesc_unknown_reg(struct gdbarch *gdbarch, tdesc_feature *feature, const char *reg_name, int possible_regnum)
static bool riscv_next_pc_atomic_sequence(struct regcache *regcache, CORE_ADDR pc, CORE_ADDR *next_pc)
static void riscv_frame_this_id(frame_info_ptr this_frame, void **prologue_cache, struct frame_id *this_id)
static struct riscv_unwind_cache * riscv_frame_cache(frame_info_ptr this_frame, void **this_cache)
static CORE_ADDR riscv_push_dummy_code(struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache)
static struct value * value_of_riscv_user_reg(frame_info_ptr frame, const void *baton)
static CORE_ADDR riscv_next_pc(struct regcache *regcache, CORE_ADDR pc)
static struct cmd_list_element * showdebugriscvcmdlist
static const char * riscv_feature_name_cpu
const target_desc * riscv_lookup_target_description(const struct riscv_gdbarch_features features)
struct type * builtin_long_long
struct type * builtin_double
struct type * builtin_func_ptr
struct type * builtin_long
struct type * builtin_data_ptr
struct type * builtin_int32
struct type * builtin_float
LONGEST loc_bitpos() const
field_loc_kind loc_kind() const
struct type * type() const
void read(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order, bool unsigned_p)
void write(gdb::array_view< gdb_byte > buf, enum bfd_endian byte_order, bool unsigned_p) const
enum riscv_arg_info::location::location_type loc_type
union riscv_arg_info::location::@161 loc_data
struct riscv_arg_info::location argloc[2]
const gdb_byte * contents
riscv_arg_reg(int first, int last)
struct riscv_memory_offsets memory
struct riscv_arg_reg float_regs
struct riscv_arg_reg int_regs
riscv_call_info(struct gdbarch *gdbarch)
void riscv_create_csr_aliases()
bool check(const struct target_desc *tdesc, struct tdesc_arch_data *tdesc_data, std::vector< riscv_pending_register_alias > *aliases, struct riscv_gdbarch_features *features) const
const char * register_name(int regnum) const
bool check(const struct target_desc *tdesc, struct tdesc_arch_data *tdesc_data, std::vector< riscv_pending_register_alias > *aliases, struct riscv_gdbarch_features *features) const
struct type * riscv_fpreg_d_type
int duplicate_fcsr_regnum
int unknown_csrs_first_regnum
int duplicate_fflags_regnum
CORE_ADDR(* syscall_next_pc)(frame_info_ptr frame)
struct riscv_gdbarch_features abi_features
struct riscv_gdbarch_features isa_features
std::vector< const char * > names
bool check(struct tdesc_arch_data *tdesc_data, const struct tdesc_feature *feature, bool prefer_first_name_p, std::vector< riscv_pending_register_alias > *aliases) const
std::vector< struct register_info > m_registers
const char * name() const
riscv_register_feature()=delete
riscv_register_feature(const char *feature_name)
const char * m_feature_name
const struct tdesc_feature * tdesc_feature(const struct target_desc *tdesc) const
DISABLE_COPY_AND_ASSIGN(riscv_register_feature)
trad_frame_saved_reg * regs
bool check(const struct target_desc *tdesc, struct tdesc_arch_data *tdesc_data, std::vector< riscv_pending_register_alias > *aliases, struct riscv_gdbarch_features *features) const
const char * register_name(int regnum) const
bool check(const struct target_desc *tdesc, struct tdesc_arch_data *tdesc_data, std::vector< riscv_pending_register_alias > *aliases, struct riscv_gdbarch_features *features) const
bool check(const struct target_desc *tdesc, struct tdesc_arch_data *tdesc_data, std::vector< riscv_pending_register_alias > *aliases, struct riscv_gdbarch_features *features) const
const char * register_name(int regnum) const
void set_addr(LONGEST addr)
void set_value(LONGEST val)
struct type * target_type() const
struct field & field(int idx) const
void set_name(const char *name)
void set_is_vector(bool is_vector)
const char * name() const
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)
const char * tdesc_feature_name(const struct tdesc_feature *feature)
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)
int tdesc_register_bitsize(const struct tdesc_feature *feature, const char *name)
const char * tdesc_register_name(struct gdbarch *gdbarch, int regno)
int tdesc_unnumbered_register(const struct tdesc_feature *feature, const char *name)
bool tdesc_found_register(struct tdesc_arch_data *data, int regno)
int tdesc_register_in_reggroup_p(struct gdbarch *gdbarch, int regno, const struct reggroup *reggroup)
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
int target_read_code(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
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)
void user_reg_add(struct gdbarch *gdbarch, const char *name, user_reg_read_ftype *xread, const void *baton)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
void print_spaces(int n, struct ui_file *stream)
void gdb_printf(struct ui_file *stream, const char *format,...)
void gdb_puts(const char *linebuffer, struct ui_file *stream)
struct value * value_cast(struct type *type, struct value *arg2)
void get_formatted_print_options(struct value_print_options *opts, char format)
void get_user_print_options(struct value_print_options *opts)
void print_hex_chars(struct ui_file *stream, const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order, bool zero_pad)
void common_val_print(struct value *value, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
struct type * value_type(const struct value *value)
int value_entirely_available(struct value *value)
struct value * allocate_value(struct type *type)
gdb::array_view< gdb_byte > value_contents_raw(struct value *value)
struct value * value_from_contents(struct type *type, const gdb_byte *contents)
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)
gdb::array_view< const gdb_byte > value_contents_for_printing(struct value *value)