1 /* 2 * QEMU RISC-V CPU 3 * 4 * Copyright (c) 2016-2017 Sagar Karandikar, sagark@eecs.berkeley.edu 5 * Copyright (c) 2017-2018 SiFive, Inc. 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms and conditions of the GNU General Public License, 9 * version 2 or later, as published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14 * more details. 15 * 16 * You should have received a copy of the GNU General Public License along with 17 * this program. If not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #include "qemu/osdep.h" 21 #include "qemu/qemu-print.h" 22 #include "qemu/ctype.h" 23 #include "qemu/log.h" 24 #include "cpu.h" 25 #include "cpu_vendorid.h" 26 #include "internals.h" 27 #include "exec/exec-all.h" 28 #include "qapi/error.h" 29 #include "qapi/visitor.h" 30 #include "qemu/error-report.h" 31 #include "hw/qdev-properties.h" 32 #include "hw/core/qdev-prop-internal.h" 33 #include "migration/vmstate.h" 34 #include "fpu/softfloat-helpers.h" 35 #include "system/device_tree.h" 36 #include "system/kvm.h" 37 #include "system/tcg.h" 38 #include "kvm/kvm_riscv.h" 39 #include "tcg/tcg-cpu.h" 40 #include "tcg/tcg.h" 41 42 /* RISC-V CPU definitions */ 43 static const char riscv_single_letter_exts[] = "IEMAFDQCBPVH"; 44 const uint32_t misa_bits[] = {RVI, RVE, RVM, RVA, RVF, RVD, RVV, 45 RVC, RVS, RVU, RVH, RVG, RVB, 0}; 46 47 /* 48 * From vector_helper.c 49 * Note that vector data is stored in host-endian 64-bit chunks, 50 * so addressing bytes needs a host-endian fixup. 51 */ 52 #if HOST_BIG_ENDIAN 53 #define BYTE(x) ((x) ^ 7) 54 #else 55 #define BYTE(x) (x) 56 #endif 57 58 bool riscv_cpu_is_32bit(RISCVCPU *cpu) 59 { 60 return riscv_cpu_mxl(&cpu->env) == MXL_RV32; 61 } 62 63 /* Hash that stores general user set numeric options */ 64 static GHashTable *general_user_opts; 65 66 static void cpu_option_add_user_setting(const char *optname, uint32_t value) 67 { 68 g_hash_table_insert(general_user_opts, (gpointer)optname, 69 GUINT_TO_POINTER(value)); 70 } 71 72 bool riscv_cpu_option_set(const char *optname) 73 { 74 return g_hash_table_contains(general_user_opts, optname); 75 } 76 77 #define ISA_EXT_DATA_ENTRY(_name, _min_ver, _prop) \ 78 {#_name, _min_ver, CPU_CFG_OFFSET(_prop)} 79 80 /* 81 * Here are the ordering rules of extension naming defined by RISC-V 82 * specification : 83 * 1. All extensions should be separated from other multi-letter extensions 84 * by an underscore. 85 * 2. The first letter following the 'Z' conventionally indicates the most 86 * closely related alphabetical extension category, IMAFDQLCBKJTPVH. 87 * If multiple 'Z' extensions are named, they should be ordered first 88 * by category, then alphabetically within a category. 89 * 3. Standard supervisor-level extensions (starts with 'S') should be 90 * listed after standard unprivileged extensions. If multiple 91 * supervisor-level extensions are listed, they should be ordered 92 * alphabetically. 93 * 4. Non-standard extensions (starts with 'X') must be listed after all 94 * standard extensions. They must be separated from other multi-letter 95 * extensions by an underscore. 96 * 97 * Single letter extensions are checked in riscv_cpu_validate_misa_priv() 98 * instead. 99 */ 100 const RISCVIsaExtData isa_edata_arr[] = { 101 ISA_EXT_DATA_ENTRY(zic64b, PRIV_VERSION_1_12_0, ext_zic64b), 102 ISA_EXT_DATA_ENTRY(zicbom, PRIV_VERSION_1_12_0, ext_zicbom), 103 ISA_EXT_DATA_ENTRY(zicbop, PRIV_VERSION_1_12_0, ext_zicbop), 104 ISA_EXT_DATA_ENTRY(zicboz, PRIV_VERSION_1_12_0, ext_zicboz), 105 ISA_EXT_DATA_ENTRY(ziccamoa, PRIV_VERSION_1_11_0, has_priv_1_11), 106 ISA_EXT_DATA_ENTRY(ziccif, PRIV_VERSION_1_11_0, has_priv_1_11), 107 ISA_EXT_DATA_ENTRY(zicclsm, PRIV_VERSION_1_11_0, has_priv_1_11), 108 ISA_EXT_DATA_ENTRY(ziccrse, PRIV_VERSION_1_11_0, ext_ziccrse), 109 ISA_EXT_DATA_ENTRY(zicfilp, PRIV_VERSION_1_12_0, ext_zicfilp), 110 ISA_EXT_DATA_ENTRY(zicfiss, PRIV_VERSION_1_13_0, ext_zicfiss), 111 ISA_EXT_DATA_ENTRY(zicond, PRIV_VERSION_1_12_0, ext_zicond), 112 ISA_EXT_DATA_ENTRY(zicntr, PRIV_VERSION_1_12_0, ext_zicntr), 113 ISA_EXT_DATA_ENTRY(zicsr, PRIV_VERSION_1_10_0, ext_zicsr), 114 ISA_EXT_DATA_ENTRY(zifencei, PRIV_VERSION_1_10_0, ext_zifencei), 115 ISA_EXT_DATA_ENTRY(zihintntl, PRIV_VERSION_1_10_0, ext_zihintntl), 116 ISA_EXT_DATA_ENTRY(zihintpause, PRIV_VERSION_1_10_0, ext_zihintpause), 117 ISA_EXT_DATA_ENTRY(zihpm, PRIV_VERSION_1_12_0, ext_zihpm), 118 ISA_EXT_DATA_ENTRY(zimop, PRIV_VERSION_1_13_0, ext_zimop), 119 ISA_EXT_DATA_ENTRY(zmmul, PRIV_VERSION_1_12_0, ext_zmmul), 120 ISA_EXT_DATA_ENTRY(za64rs, PRIV_VERSION_1_12_0, has_priv_1_12), 121 ISA_EXT_DATA_ENTRY(zaamo, PRIV_VERSION_1_12_0, ext_zaamo), 122 ISA_EXT_DATA_ENTRY(zabha, PRIV_VERSION_1_13_0, ext_zabha), 123 ISA_EXT_DATA_ENTRY(zacas, PRIV_VERSION_1_12_0, ext_zacas), 124 ISA_EXT_DATA_ENTRY(zama16b, PRIV_VERSION_1_13_0, ext_zama16b), 125 ISA_EXT_DATA_ENTRY(zalrsc, PRIV_VERSION_1_12_0, ext_zalrsc), 126 ISA_EXT_DATA_ENTRY(zawrs, PRIV_VERSION_1_12_0, ext_zawrs), 127 ISA_EXT_DATA_ENTRY(zfa, PRIV_VERSION_1_12_0, ext_zfa), 128 ISA_EXT_DATA_ENTRY(zfbfmin, PRIV_VERSION_1_12_0, ext_zfbfmin), 129 ISA_EXT_DATA_ENTRY(zfh, PRIV_VERSION_1_11_0, ext_zfh), 130 ISA_EXT_DATA_ENTRY(zfhmin, PRIV_VERSION_1_11_0, ext_zfhmin), 131 ISA_EXT_DATA_ENTRY(zfinx, PRIV_VERSION_1_12_0, ext_zfinx), 132 ISA_EXT_DATA_ENTRY(zdinx, PRIV_VERSION_1_12_0, ext_zdinx), 133 ISA_EXT_DATA_ENTRY(zca, PRIV_VERSION_1_12_0, ext_zca), 134 ISA_EXT_DATA_ENTRY(zcb, PRIV_VERSION_1_12_0, ext_zcb), 135 ISA_EXT_DATA_ENTRY(zcf, PRIV_VERSION_1_12_0, ext_zcf), 136 ISA_EXT_DATA_ENTRY(zcd, PRIV_VERSION_1_12_0, ext_zcd), 137 ISA_EXT_DATA_ENTRY(zce, PRIV_VERSION_1_12_0, ext_zce), 138 ISA_EXT_DATA_ENTRY(zcmop, PRIV_VERSION_1_13_0, ext_zcmop), 139 ISA_EXT_DATA_ENTRY(zcmp, PRIV_VERSION_1_12_0, ext_zcmp), 140 ISA_EXT_DATA_ENTRY(zcmt, PRIV_VERSION_1_12_0, ext_zcmt), 141 ISA_EXT_DATA_ENTRY(zba, PRIV_VERSION_1_12_0, ext_zba), 142 ISA_EXT_DATA_ENTRY(zbb, PRIV_VERSION_1_12_0, ext_zbb), 143 ISA_EXT_DATA_ENTRY(zbc, PRIV_VERSION_1_12_0, ext_zbc), 144 ISA_EXT_DATA_ENTRY(zbkb, PRIV_VERSION_1_12_0, ext_zbkb), 145 ISA_EXT_DATA_ENTRY(zbkc, PRIV_VERSION_1_12_0, ext_zbkc), 146 ISA_EXT_DATA_ENTRY(zbkx, PRIV_VERSION_1_12_0, ext_zbkx), 147 ISA_EXT_DATA_ENTRY(zbs, PRIV_VERSION_1_12_0, ext_zbs), 148 ISA_EXT_DATA_ENTRY(zk, PRIV_VERSION_1_12_0, ext_zk), 149 ISA_EXT_DATA_ENTRY(zkn, PRIV_VERSION_1_12_0, ext_zkn), 150 ISA_EXT_DATA_ENTRY(zknd, PRIV_VERSION_1_12_0, ext_zknd), 151 ISA_EXT_DATA_ENTRY(zkne, PRIV_VERSION_1_12_0, ext_zkne), 152 ISA_EXT_DATA_ENTRY(zknh, PRIV_VERSION_1_12_0, ext_zknh), 153 ISA_EXT_DATA_ENTRY(zkr, PRIV_VERSION_1_12_0, ext_zkr), 154 ISA_EXT_DATA_ENTRY(zks, PRIV_VERSION_1_12_0, ext_zks), 155 ISA_EXT_DATA_ENTRY(zksed, PRIV_VERSION_1_12_0, ext_zksed), 156 ISA_EXT_DATA_ENTRY(zksh, PRIV_VERSION_1_12_0, ext_zksh), 157 ISA_EXT_DATA_ENTRY(zkt, PRIV_VERSION_1_12_0, ext_zkt), 158 ISA_EXT_DATA_ENTRY(ztso, PRIV_VERSION_1_12_0, ext_ztso), 159 ISA_EXT_DATA_ENTRY(zvbb, PRIV_VERSION_1_12_0, ext_zvbb), 160 ISA_EXT_DATA_ENTRY(zvbc, PRIV_VERSION_1_12_0, ext_zvbc), 161 ISA_EXT_DATA_ENTRY(zve32f, PRIV_VERSION_1_10_0, ext_zve32f), 162 ISA_EXT_DATA_ENTRY(zve32x, PRIV_VERSION_1_10_0, ext_zve32x), 163 ISA_EXT_DATA_ENTRY(zve64f, PRIV_VERSION_1_10_0, ext_zve64f), 164 ISA_EXT_DATA_ENTRY(zve64d, PRIV_VERSION_1_10_0, ext_zve64d), 165 ISA_EXT_DATA_ENTRY(zve64x, PRIV_VERSION_1_10_0, ext_zve64x), 166 ISA_EXT_DATA_ENTRY(zvfbfmin, PRIV_VERSION_1_12_0, ext_zvfbfmin), 167 ISA_EXT_DATA_ENTRY(zvfbfwma, PRIV_VERSION_1_12_0, ext_zvfbfwma), 168 ISA_EXT_DATA_ENTRY(zvfh, PRIV_VERSION_1_12_0, ext_zvfh), 169 ISA_EXT_DATA_ENTRY(zvfhmin, PRIV_VERSION_1_12_0, ext_zvfhmin), 170 ISA_EXT_DATA_ENTRY(zvkb, PRIV_VERSION_1_12_0, ext_zvkb), 171 ISA_EXT_DATA_ENTRY(zvkg, PRIV_VERSION_1_12_0, ext_zvkg), 172 ISA_EXT_DATA_ENTRY(zvkn, PRIV_VERSION_1_12_0, ext_zvkn), 173 ISA_EXT_DATA_ENTRY(zvknc, PRIV_VERSION_1_12_0, ext_zvknc), 174 ISA_EXT_DATA_ENTRY(zvkned, PRIV_VERSION_1_12_0, ext_zvkned), 175 ISA_EXT_DATA_ENTRY(zvkng, PRIV_VERSION_1_12_0, ext_zvkng), 176 ISA_EXT_DATA_ENTRY(zvknha, PRIV_VERSION_1_12_0, ext_zvknha), 177 ISA_EXT_DATA_ENTRY(zvknhb, PRIV_VERSION_1_12_0, ext_zvknhb), 178 ISA_EXT_DATA_ENTRY(zvks, PRIV_VERSION_1_12_0, ext_zvks), 179 ISA_EXT_DATA_ENTRY(zvksc, PRIV_VERSION_1_12_0, ext_zvksc), 180 ISA_EXT_DATA_ENTRY(zvksed, PRIV_VERSION_1_12_0, ext_zvksed), 181 ISA_EXT_DATA_ENTRY(zvksg, PRIV_VERSION_1_12_0, ext_zvksg), 182 ISA_EXT_DATA_ENTRY(zvksh, PRIV_VERSION_1_12_0, ext_zvksh), 183 ISA_EXT_DATA_ENTRY(zvkt, PRIV_VERSION_1_12_0, ext_zvkt), 184 ISA_EXT_DATA_ENTRY(zhinx, PRIV_VERSION_1_12_0, ext_zhinx), 185 ISA_EXT_DATA_ENTRY(zhinxmin, PRIV_VERSION_1_12_0, ext_zhinxmin), 186 ISA_EXT_DATA_ENTRY(shcounterenw, PRIV_VERSION_1_12_0, has_priv_1_12), 187 ISA_EXT_DATA_ENTRY(sha, PRIV_VERSION_1_12_0, ext_sha), 188 ISA_EXT_DATA_ENTRY(shgatpa, PRIV_VERSION_1_12_0, has_priv_1_12), 189 ISA_EXT_DATA_ENTRY(shtvala, PRIV_VERSION_1_12_0, has_priv_1_12), 190 ISA_EXT_DATA_ENTRY(shvsatpa, PRIV_VERSION_1_12_0, has_priv_1_12), 191 ISA_EXT_DATA_ENTRY(shvstvala, PRIV_VERSION_1_12_0, has_priv_1_12), 192 ISA_EXT_DATA_ENTRY(shvstvecd, PRIV_VERSION_1_12_0, has_priv_1_12), 193 ISA_EXT_DATA_ENTRY(smaia, PRIV_VERSION_1_12_0, ext_smaia), 194 ISA_EXT_DATA_ENTRY(smcdeleg, PRIV_VERSION_1_13_0, ext_smcdeleg), 195 ISA_EXT_DATA_ENTRY(smcntrpmf, PRIV_VERSION_1_12_0, ext_smcntrpmf), 196 ISA_EXT_DATA_ENTRY(smcsrind, PRIV_VERSION_1_13_0, ext_smcsrind), 197 ISA_EXT_DATA_ENTRY(smdbltrp, PRIV_VERSION_1_13_0, ext_smdbltrp), 198 ISA_EXT_DATA_ENTRY(smepmp, PRIV_VERSION_1_12_0, ext_smepmp), 199 ISA_EXT_DATA_ENTRY(smrnmi, PRIV_VERSION_1_12_0, ext_smrnmi), 200 ISA_EXT_DATA_ENTRY(smmpm, PRIV_VERSION_1_13_0, ext_smmpm), 201 ISA_EXT_DATA_ENTRY(smnpm, PRIV_VERSION_1_13_0, ext_smnpm), 202 ISA_EXT_DATA_ENTRY(smstateen, PRIV_VERSION_1_12_0, ext_smstateen), 203 ISA_EXT_DATA_ENTRY(ssaia, PRIV_VERSION_1_12_0, ext_ssaia), 204 ISA_EXT_DATA_ENTRY(ssccfg, PRIV_VERSION_1_13_0, ext_ssccfg), 205 ISA_EXT_DATA_ENTRY(ssccptr, PRIV_VERSION_1_11_0, has_priv_1_11), 206 ISA_EXT_DATA_ENTRY(sscofpmf, PRIV_VERSION_1_12_0, ext_sscofpmf), 207 ISA_EXT_DATA_ENTRY(sscounterenw, PRIV_VERSION_1_12_0, has_priv_1_12), 208 ISA_EXT_DATA_ENTRY(sscsrind, PRIV_VERSION_1_12_0, ext_sscsrind), 209 ISA_EXT_DATA_ENTRY(ssdbltrp, PRIV_VERSION_1_13_0, ext_ssdbltrp), 210 ISA_EXT_DATA_ENTRY(ssnpm, PRIV_VERSION_1_13_0, ext_ssnpm), 211 ISA_EXT_DATA_ENTRY(sspm, PRIV_VERSION_1_13_0, ext_sspm), 212 ISA_EXT_DATA_ENTRY(ssstateen, PRIV_VERSION_1_12_0, ext_ssstateen), 213 ISA_EXT_DATA_ENTRY(sstc, PRIV_VERSION_1_12_0, ext_sstc), 214 ISA_EXT_DATA_ENTRY(sstvala, PRIV_VERSION_1_12_0, has_priv_1_12), 215 ISA_EXT_DATA_ENTRY(sstvecd, PRIV_VERSION_1_12_0, has_priv_1_12), 216 ISA_EXT_DATA_ENTRY(ssu64xl, PRIV_VERSION_1_12_0, has_priv_1_12), 217 ISA_EXT_DATA_ENTRY(supm, PRIV_VERSION_1_13_0, ext_supm), 218 ISA_EXT_DATA_ENTRY(svade, PRIV_VERSION_1_11_0, ext_svade), 219 ISA_EXT_DATA_ENTRY(smctr, PRIV_VERSION_1_12_0, ext_smctr), 220 ISA_EXT_DATA_ENTRY(ssctr, PRIV_VERSION_1_12_0, ext_ssctr), 221 ISA_EXT_DATA_ENTRY(svadu, PRIV_VERSION_1_12_0, ext_svadu), 222 ISA_EXT_DATA_ENTRY(svinval, PRIV_VERSION_1_12_0, ext_svinval), 223 ISA_EXT_DATA_ENTRY(svnapot, PRIV_VERSION_1_12_0, ext_svnapot), 224 ISA_EXT_DATA_ENTRY(svpbmt, PRIV_VERSION_1_12_0, ext_svpbmt), 225 ISA_EXT_DATA_ENTRY(svukte, PRIV_VERSION_1_13_0, ext_svukte), 226 ISA_EXT_DATA_ENTRY(svvptc, PRIV_VERSION_1_13_0, ext_svvptc), 227 ISA_EXT_DATA_ENTRY(xtheadba, PRIV_VERSION_1_11_0, ext_xtheadba), 228 ISA_EXT_DATA_ENTRY(xtheadbb, PRIV_VERSION_1_11_0, ext_xtheadbb), 229 ISA_EXT_DATA_ENTRY(xtheadbs, PRIV_VERSION_1_11_0, ext_xtheadbs), 230 ISA_EXT_DATA_ENTRY(xtheadcmo, PRIV_VERSION_1_11_0, ext_xtheadcmo), 231 ISA_EXT_DATA_ENTRY(xtheadcondmov, PRIV_VERSION_1_11_0, ext_xtheadcondmov), 232 ISA_EXT_DATA_ENTRY(xtheadfmemidx, PRIV_VERSION_1_11_0, ext_xtheadfmemidx), 233 ISA_EXT_DATA_ENTRY(xtheadfmv, PRIV_VERSION_1_11_0, ext_xtheadfmv), 234 ISA_EXT_DATA_ENTRY(xtheadmac, PRIV_VERSION_1_11_0, ext_xtheadmac), 235 ISA_EXT_DATA_ENTRY(xtheadmemidx, PRIV_VERSION_1_11_0, ext_xtheadmemidx), 236 ISA_EXT_DATA_ENTRY(xtheadmempair, PRIV_VERSION_1_11_0, ext_xtheadmempair), 237 ISA_EXT_DATA_ENTRY(xtheadsync, PRIV_VERSION_1_11_0, ext_xtheadsync), 238 ISA_EXT_DATA_ENTRY(xventanacondops, PRIV_VERSION_1_12_0, ext_XVentanaCondOps), 239 240 { }, 241 }; 242 243 bool isa_ext_is_enabled(RISCVCPU *cpu, uint32_t ext_offset) 244 { 245 bool *ext_enabled = (void *)&cpu->cfg + ext_offset; 246 247 return *ext_enabled; 248 } 249 250 void isa_ext_update_enabled(RISCVCPU *cpu, uint32_t ext_offset, bool en) 251 { 252 bool *ext_enabled = (void *)&cpu->cfg + ext_offset; 253 254 *ext_enabled = en; 255 } 256 257 bool riscv_cpu_is_vendor(Object *cpu_obj) 258 { 259 return object_dynamic_cast(cpu_obj, TYPE_RISCV_VENDOR_CPU) != NULL; 260 } 261 262 const char * const riscv_int_regnames[] = { 263 "x0/zero", "x1/ra", "x2/sp", "x3/gp", "x4/tp", "x5/t0", "x6/t1", 264 "x7/t2", "x8/s0", "x9/s1", "x10/a0", "x11/a1", "x12/a2", "x13/a3", 265 "x14/a4", "x15/a5", "x16/a6", "x17/a7", "x18/s2", "x19/s3", "x20/s4", 266 "x21/s5", "x22/s6", "x23/s7", "x24/s8", "x25/s9", "x26/s10", "x27/s11", 267 "x28/t3", "x29/t4", "x30/t5", "x31/t6" 268 }; 269 270 const char * const riscv_int_regnamesh[] = { 271 "x0h/zeroh", "x1h/rah", "x2h/sph", "x3h/gph", "x4h/tph", "x5h/t0h", 272 "x6h/t1h", "x7h/t2h", "x8h/s0h", "x9h/s1h", "x10h/a0h", "x11h/a1h", 273 "x12h/a2h", "x13h/a3h", "x14h/a4h", "x15h/a5h", "x16h/a6h", "x17h/a7h", 274 "x18h/s2h", "x19h/s3h", "x20h/s4h", "x21h/s5h", "x22h/s6h", "x23h/s7h", 275 "x24h/s8h", "x25h/s9h", "x26h/s10h", "x27h/s11h", "x28h/t3h", "x29h/t4h", 276 "x30h/t5h", "x31h/t6h" 277 }; 278 279 const char * const riscv_fpr_regnames[] = { 280 "f0/ft0", "f1/ft1", "f2/ft2", "f3/ft3", "f4/ft4", "f5/ft5", 281 "f6/ft6", "f7/ft7", "f8/fs0", "f9/fs1", "f10/fa0", "f11/fa1", 282 "f12/fa2", "f13/fa3", "f14/fa4", "f15/fa5", "f16/fa6", "f17/fa7", 283 "f18/fs2", "f19/fs3", "f20/fs4", "f21/fs5", "f22/fs6", "f23/fs7", 284 "f24/fs8", "f25/fs9", "f26/fs10", "f27/fs11", "f28/ft8", "f29/ft9", 285 "f30/ft10", "f31/ft11" 286 }; 287 288 const char * const riscv_rvv_regnames[] = { 289 "v0", "v1", "v2", "v3", "v4", "v5", "v6", 290 "v7", "v8", "v9", "v10", "v11", "v12", "v13", 291 "v14", "v15", "v16", "v17", "v18", "v19", "v20", 292 "v21", "v22", "v23", "v24", "v25", "v26", "v27", 293 "v28", "v29", "v30", "v31" 294 }; 295 296 static const char * const riscv_excp_names[] = { 297 "misaligned_fetch", 298 "fault_fetch", 299 "illegal_instruction", 300 "breakpoint", 301 "misaligned_load", 302 "fault_load", 303 "misaligned_store", 304 "fault_store", 305 "user_ecall", 306 "supervisor_ecall", 307 "hypervisor_ecall", 308 "machine_ecall", 309 "exec_page_fault", 310 "load_page_fault", 311 "reserved", 312 "store_page_fault", 313 "double_trap", 314 "reserved", 315 "reserved", 316 "reserved", 317 "guest_exec_page_fault", 318 "guest_load_page_fault", 319 "reserved", 320 "guest_store_page_fault", 321 }; 322 323 static const char * const riscv_intr_names[] = { 324 "u_software", 325 "s_software", 326 "vs_software", 327 "m_software", 328 "u_timer", 329 "s_timer", 330 "vs_timer", 331 "m_timer", 332 "u_external", 333 "s_external", 334 "vs_external", 335 "m_external", 336 "reserved", 337 "reserved", 338 "reserved", 339 "reserved" 340 }; 341 342 const char *riscv_cpu_get_trap_name(target_ulong cause, bool async) 343 { 344 if (async) { 345 return (cause < ARRAY_SIZE(riscv_intr_names)) ? 346 riscv_intr_names[cause] : "(unknown)"; 347 } else { 348 return (cause < ARRAY_SIZE(riscv_excp_names)) ? 349 riscv_excp_names[cause] : "(unknown)"; 350 } 351 } 352 353 void riscv_cpu_set_misa_ext(CPURISCVState *env, uint32_t ext) 354 { 355 env->misa_ext_mask = env->misa_ext = ext; 356 } 357 358 int riscv_cpu_max_xlen(RISCVCPUClass *mcc) 359 { 360 return 16 << mcc->misa_mxl_max; 361 } 362 363 #ifndef CONFIG_USER_ONLY 364 static uint8_t satp_mode_from_str(const char *satp_mode_str) 365 { 366 if (!strncmp(satp_mode_str, "mbare", 5)) { 367 return VM_1_10_MBARE; 368 } 369 370 if (!strncmp(satp_mode_str, "sv32", 4)) { 371 return VM_1_10_SV32; 372 } 373 374 if (!strncmp(satp_mode_str, "sv39", 4)) { 375 return VM_1_10_SV39; 376 } 377 378 if (!strncmp(satp_mode_str, "sv48", 4)) { 379 return VM_1_10_SV48; 380 } 381 382 if (!strncmp(satp_mode_str, "sv57", 4)) { 383 return VM_1_10_SV57; 384 } 385 386 if (!strncmp(satp_mode_str, "sv64", 4)) { 387 return VM_1_10_SV64; 388 } 389 390 g_assert_not_reached(); 391 } 392 393 uint8_t satp_mode_max_from_map(uint32_t map) 394 { 395 /* 396 * 'map = 0' will make us return (31 - 32), which C will 397 * happily overflow to UINT_MAX. There's no good result to 398 * return if 'map = 0' (e.g. returning 0 will be ambiguous 399 * with the result for 'map = 1'). 400 * 401 * Assert out if map = 0. Callers will have to deal with 402 * it outside of this function. 403 */ 404 g_assert(map > 0); 405 406 /* map here has at least one bit set, so no problem with clz */ 407 return 31 - __builtin_clz(map); 408 } 409 410 const char *satp_mode_str(uint8_t satp_mode, bool is_32_bit) 411 { 412 if (is_32_bit) { 413 switch (satp_mode) { 414 case VM_1_10_SV32: 415 return "sv32"; 416 case VM_1_10_MBARE: 417 return "none"; 418 } 419 } else { 420 switch (satp_mode) { 421 case VM_1_10_SV64: 422 return "sv64"; 423 case VM_1_10_SV57: 424 return "sv57"; 425 case VM_1_10_SV48: 426 return "sv48"; 427 case VM_1_10_SV39: 428 return "sv39"; 429 case VM_1_10_MBARE: 430 return "none"; 431 } 432 } 433 434 g_assert_not_reached(); 435 } 436 437 static void set_satp_mode_max_supported(RISCVCPU *cpu, 438 uint8_t satp_mode) 439 { 440 bool rv32 = riscv_cpu_mxl(&cpu->env) == MXL_RV32; 441 const bool *valid_vm = rv32 ? valid_vm_1_10_32 : valid_vm_1_10_64; 442 443 for (int i = 0; i <= satp_mode; ++i) { 444 if (valid_vm[i]) { 445 cpu->cfg.satp_mode.supported |= (1 << i); 446 } 447 } 448 } 449 450 /* Set the satp mode to the max supported */ 451 static void set_satp_mode_default_map(RISCVCPU *cpu) 452 { 453 /* 454 * Bare CPUs do not default to the max available. 455 * Users must set a valid satp_mode in the command 456 * line. 457 */ 458 if (object_dynamic_cast(OBJECT(cpu), TYPE_RISCV_BARE_CPU) != NULL) { 459 warn_report("No satp mode set. Defaulting to 'bare'"); 460 cpu->cfg.satp_mode.map = (1 << VM_1_10_MBARE); 461 return; 462 } 463 464 cpu->cfg.satp_mode.map = cpu->cfg.satp_mode.supported; 465 } 466 #endif 467 468 static void riscv_max_cpu_init(Object *obj) 469 { 470 RISCVCPU *cpu = RISCV_CPU(obj); 471 CPURISCVState *env = &cpu->env; 472 473 cpu->cfg.mmu = true; 474 cpu->cfg.pmp = true; 475 476 env->priv_ver = PRIV_VERSION_LATEST; 477 #ifndef CONFIG_USER_ONLY 478 set_satp_mode_max_supported(RISCV_CPU(obj), 479 riscv_cpu_mxl(&RISCV_CPU(obj)->env) == MXL_RV32 ? 480 VM_1_10_SV32 : VM_1_10_SV57); 481 #endif 482 } 483 484 #if defined(TARGET_RISCV64) 485 static void rv64_base_cpu_init(Object *obj) 486 { 487 RISCVCPU *cpu = RISCV_CPU(obj); 488 CPURISCVState *env = &cpu->env; 489 490 cpu->cfg.mmu = true; 491 cpu->cfg.pmp = true; 492 493 /* Set latest version of privileged specification */ 494 env->priv_ver = PRIV_VERSION_LATEST; 495 #ifndef CONFIG_USER_ONLY 496 set_satp_mode_max_supported(RISCV_CPU(obj), VM_1_10_SV57); 497 #endif 498 } 499 500 static void rv64_sifive_u_cpu_init(Object *obj) 501 { 502 RISCVCPU *cpu = RISCV_CPU(obj); 503 CPURISCVState *env = &cpu->env; 504 riscv_cpu_set_misa_ext(env, RVI | RVM | RVA | RVF | RVD | RVC | RVS | RVU); 505 env->priv_ver = PRIV_VERSION_1_10_0; 506 #ifndef CONFIG_USER_ONLY 507 set_satp_mode_max_supported(RISCV_CPU(obj), VM_1_10_SV39); 508 #endif 509 510 /* inherited from parent obj via riscv_cpu_init() */ 511 cpu->cfg.ext_zifencei = true; 512 cpu->cfg.ext_zicsr = true; 513 cpu->cfg.mmu = true; 514 cpu->cfg.pmp = true; 515 } 516 517 static void rv64_sifive_e_cpu_init(Object *obj) 518 { 519 CPURISCVState *env = &RISCV_CPU(obj)->env; 520 RISCVCPU *cpu = RISCV_CPU(obj); 521 522 riscv_cpu_set_misa_ext(env, RVI | RVM | RVA | RVC | RVU); 523 env->priv_ver = PRIV_VERSION_1_10_0; 524 #ifndef CONFIG_USER_ONLY 525 set_satp_mode_max_supported(cpu, VM_1_10_MBARE); 526 #endif 527 528 /* inherited from parent obj via riscv_cpu_init() */ 529 cpu->cfg.ext_zifencei = true; 530 cpu->cfg.ext_zicsr = true; 531 cpu->cfg.pmp = true; 532 } 533 534 static void rv64_thead_c906_cpu_init(Object *obj) 535 { 536 CPURISCVState *env = &RISCV_CPU(obj)->env; 537 RISCVCPU *cpu = RISCV_CPU(obj); 538 539 riscv_cpu_set_misa_ext(env, RVG | RVC | RVS | RVU); 540 env->priv_ver = PRIV_VERSION_1_11_0; 541 542 cpu->cfg.ext_zfa = true; 543 cpu->cfg.ext_zfh = true; 544 cpu->cfg.mmu = true; 545 cpu->cfg.ext_xtheadba = true; 546 cpu->cfg.ext_xtheadbb = true; 547 cpu->cfg.ext_xtheadbs = true; 548 cpu->cfg.ext_xtheadcmo = true; 549 cpu->cfg.ext_xtheadcondmov = true; 550 cpu->cfg.ext_xtheadfmemidx = true; 551 cpu->cfg.ext_xtheadmac = true; 552 cpu->cfg.ext_xtheadmemidx = true; 553 cpu->cfg.ext_xtheadmempair = true; 554 cpu->cfg.ext_xtheadsync = true; 555 556 cpu->cfg.mvendorid = THEAD_VENDOR_ID; 557 #ifndef CONFIG_USER_ONLY 558 set_satp_mode_max_supported(cpu, VM_1_10_SV39); 559 th_register_custom_csrs(cpu); 560 #endif 561 562 /* inherited from parent obj via riscv_cpu_init() */ 563 cpu->cfg.pmp = true; 564 } 565 566 static void rv64_veyron_v1_cpu_init(Object *obj) 567 { 568 CPURISCVState *env = &RISCV_CPU(obj)->env; 569 RISCVCPU *cpu = RISCV_CPU(obj); 570 571 riscv_cpu_set_misa_ext(env, RVG | RVC | RVS | RVU | RVH); 572 env->priv_ver = PRIV_VERSION_1_12_0; 573 574 /* Enable ISA extensions */ 575 cpu->cfg.mmu = true; 576 cpu->cfg.ext_zifencei = true; 577 cpu->cfg.ext_zicsr = true; 578 cpu->cfg.pmp = true; 579 cpu->cfg.ext_zicbom = true; 580 cpu->cfg.cbom_blocksize = 64; 581 cpu->cfg.cboz_blocksize = 64; 582 cpu->cfg.ext_zicboz = true; 583 cpu->cfg.ext_smaia = true; 584 cpu->cfg.ext_ssaia = true; 585 cpu->cfg.ext_sscofpmf = true; 586 cpu->cfg.ext_sstc = true; 587 cpu->cfg.ext_svinval = true; 588 cpu->cfg.ext_svnapot = true; 589 cpu->cfg.ext_svpbmt = true; 590 cpu->cfg.ext_smstateen = true; 591 cpu->cfg.ext_zba = true; 592 cpu->cfg.ext_zbb = true; 593 cpu->cfg.ext_zbc = true; 594 cpu->cfg.ext_zbs = true; 595 cpu->cfg.ext_XVentanaCondOps = true; 596 597 cpu->cfg.mvendorid = VEYRON_V1_MVENDORID; 598 cpu->cfg.marchid = VEYRON_V1_MARCHID; 599 cpu->cfg.mimpid = VEYRON_V1_MIMPID; 600 601 #ifndef CONFIG_USER_ONLY 602 set_satp_mode_max_supported(cpu, VM_1_10_SV48); 603 #endif 604 } 605 606 /* Tenstorrent Ascalon */ 607 static void rv64_tt_ascalon_cpu_init(Object *obj) 608 { 609 CPURISCVState *env = &RISCV_CPU(obj)->env; 610 RISCVCPU *cpu = RISCV_CPU(obj); 611 612 riscv_cpu_set_misa_ext(env, RVG | RVC | RVS | RVU | RVH | RVV); 613 env->priv_ver = PRIV_VERSION_1_13_0; 614 615 /* Enable ISA extensions */ 616 cpu->cfg.mmu = true; 617 cpu->cfg.vlenb = 256 >> 3; 618 cpu->cfg.elen = 64; 619 cpu->env.vext_ver = VEXT_VERSION_1_00_0; 620 cpu->cfg.rvv_ma_all_1s = true; 621 cpu->cfg.rvv_ta_all_1s = true; 622 cpu->cfg.misa_w = true; 623 cpu->cfg.pmp = true; 624 cpu->cfg.cbom_blocksize = 64; 625 cpu->cfg.cbop_blocksize = 64; 626 cpu->cfg.cboz_blocksize = 64; 627 cpu->cfg.ext_zic64b = true; 628 cpu->cfg.ext_zicbom = true; 629 cpu->cfg.ext_zicbop = true; 630 cpu->cfg.ext_zicboz = true; 631 cpu->cfg.ext_zicntr = true; 632 cpu->cfg.ext_zicond = true; 633 cpu->cfg.ext_zicsr = true; 634 cpu->cfg.ext_zifencei = true; 635 cpu->cfg.ext_zihintntl = true; 636 cpu->cfg.ext_zihintpause = true; 637 cpu->cfg.ext_zihpm = true; 638 cpu->cfg.ext_zimop = true; 639 cpu->cfg.ext_zawrs = true; 640 cpu->cfg.ext_zfa = true; 641 cpu->cfg.ext_zfbfmin = true; 642 cpu->cfg.ext_zfh = true; 643 cpu->cfg.ext_zfhmin = true; 644 cpu->cfg.ext_zcb = true; 645 cpu->cfg.ext_zcmop = true; 646 cpu->cfg.ext_zba = true; 647 cpu->cfg.ext_zbb = true; 648 cpu->cfg.ext_zbs = true; 649 cpu->cfg.ext_zkt = true; 650 cpu->cfg.ext_zvbb = true; 651 cpu->cfg.ext_zvbc = true; 652 cpu->cfg.ext_zvfbfmin = true; 653 cpu->cfg.ext_zvfbfwma = true; 654 cpu->cfg.ext_zvfh = true; 655 cpu->cfg.ext_zvfhmin = true; 656 cpu->cfg.ext_zvkng = true; 657 cpu->cfg.ext_smaia = true; 658 cpu->cfg.ext_smstateen = true; 659 cpu->cfg.ext_ssaia = true; 660 cpu->cfg.ext_sscofpmf = true; 661 cpu->cfg.ext_sstc = true; 662 cpu->cfg.ext_svade = true; 663 cpu->cfg.ext_svinval = true; 664 cpu->cfg.ext_svnapot = true; 665 cpu->cfg.ext_svpbmt = true; 666 667 #ifndef CONFIG_USER_ONLY 668 set_satp_mode_max_supported(cpu, VM_1_10_SV57); 669 #endif 670 } 671 672 static void rv64_xiangshan_nanhu_cpu_init(Object *obj) 673 { 674 CPURISCVState *env = &RISCV_CPU(obj)->env; 675 RISCVCPU *cpu = RISCV_CPU(obj); 676 677 riscv_cpu_set_misa_ext(env, RVG | RVC | RVB | RVS | RVU); 678 env->priv_ver = PRIV_VERSION_1_12_0; 679 680 /* Enable ISA extensions */ 681 cpu->cfg.ext_zbc = true; 682 cpu->cfg.ext_zbkb = true; 683 cpu->cfg.ext_zbkc = true; 684 cpu->cfg.ext_zbkx = true; 685 cpu->cfg.ext_zknd = true; 686 cpu->cfg.ext_zkne = true; 687 cpu->cfg.ext_zknh = true; 688 cpu->cfg.ext_zksed = true; 689 cpu->cfg.ext_zksh = true; 690 cpu->cfg.ext_svinval = true; 691 692 cpu->cfg.mmu = true; 693 cpu->cfg.pmp = true; 694 695 #ifndef CONFIG_USER_ONLY 696 set_satp_mode_max_supported(cpu, VM_1_10_SV39); 697 #endif 698 } 699 700 #ifdef CONFIG_TCG 701 static void rv128_base_cpu_init(Object *obj) 702 { 703 RISCVCPU *cpu = RISCV_CPU(obj); 704 CPURISCVState *env = &cpu->env; 705 706 cpu->cfg.mmu = true; 707 cpu->cfg.pmp = true; 708 709 /* Set latest version of privileged specification */ 710 env->priv_ver = PRIV_VERSION_LATEST; 711 #ifndef CONFIG_USER_ONLY 712 set_satp_mode_max_supported(RISCV_CPU(obj), VM_1_10_SV57); 713 #endif 714 } 715 #endif /* CONFIG_TCG */ 716 717 static void rv64i_bare_cpu_init(Object *obj) 718 { 719 CPURISCVState *env = &RISCV_CPU(obj)->env; 720 riscv_cpu_set_misa_ext(env, RVI); 721 } 722 723 static void rv64e_bare_cpu_init(Object *obj) 724 { 725 CPURISCVState *env = &RISCV_CPU(obj)->env; 726 riscv_cpu_set_misa_ext(env, RVE); 727 } 728 729 #endif /* !TARGET_RISCV64 */ 730 731 #if defined(TARGET_RISCV32) || \ 732 (defined(TARGET_RISCV64) && !defined(CONFIG_USER_ONLY)) 733 734 static void rv32_base_cpu_init(Object *obj) 735 { 736 RISCVCPU *cpu = RISCV_CPU(obj); 737 CPURISCVState *env = &cpu->env; 738 739 cpu->cfg.mmu = true; 740 cpu->cfg.pmp = true; 741 742 /* Set latest version of privileged specification */ 743 env->priv_ver = PRIV_VERSION_LATEST; 744 #ifndef CONFIG_USER_ONLY 745 set_satp_mode_max_supported(RISCV_CPU(obj), VM_1_10_SV32); 746 #endif 747 } 748 749 static void rv32_sifive_u_cpu_init(Object *obj) 750 { 751 RISCVCPU *cpu = RISCV_CPU(obj); 752 CPURISCVState *env = &cpu->env; 753 riscv_cpu_set_misa_ext(env, RVI | RVM | RVA | RVF | RVD | RVC | RVS | RVU); 754 env->priv_ver = PRIV_VERSION_1_10_0; 755 #ifndef CONFIG_USER_ONLY 756 set_satp_mode_max_supported(RISCV_CPU(obj), VM_1_10_SV32); 757 #endif 758 759 /* inherited from parent obj via riscv_cpu_init() */ 760 cpu->cfg.ext_zifencei = true; 761 cpu->cfg.ext_zicsr = true; 762 cpu->cfg.mmu = true; 763 cpu->cfg.pmp = true; 764 } 765 766 static void rv32_sifive_e_cpu_init(Object *obj) 767 { 768 CPURISCVState *env = &RISCV_CPU(obj)->env; 769 RISCVCPU *cpu = RISCV_CPU(obj); 770 771 riscv_cpu_set_misa_ext(env, RVI | RVM | RVA | RVC | RVU); 772 env->priv_ver = PRIV_VERSION_1_10_0; 773 #ifndef CONFIG_USER_ONLY 774 set_satp_mode_max_supported(cpu, VM_1_10_MBARE); 775 #endif 776 777 /* inherited from parent obj via riscv_cpu_init() */ 778 cpu->cfg.ext_zifencei = true; 779 cpu->cfg.ext_zicsr = true; 780 cpu->cfg.pmp = true; 781 } 782 783 static void rv32_ibex_cpu_init(Object *obj) 784 { 785 CPURISCVState *env = &RISCV_CPU(obj)->env; 786 RISCVCPU *cpu = RISCV_CPU(obj); 787 788 riscv_cpu_set_misa_ext(env, RVI | RVM | RVC | RVU); 789 env->priv_ver = PRIV_VERSION_1_12_0; 790 #ifndef CONFIG_USER_ONLY 791 set_satp_mode_max_supported(cpu, VM_1_10_MBARE); 792 #endif 793 /* inherited from parent obj via riscv_cpu_init() */ 794 cpu->cfg.ext_zifencei = true; 795 cpu->cfg.ext_zicsr = true; 796 cpu->cfg.pmp = true; 797 cpu->cfg.ext_smepmp = true; 798 799 cpu->cfg.ext_zba = true; 800 cpu->cfg.ext_zbb = true; 801 cpu->cfg.ext_zbc = true; 802 cpu->cfg.ext_zbs = true; 803 } 804 805 static void rv32_imafcu_nommu_cpu_init(Object *obj) 806 { 807 CPURISCVState *env = &RISCV_CPU(obj)->env; 808 RISCVCPU *cpu = RISCV_CPU(obj); 809 810 riscv_cpu_set_misa_ext(env, RVI | RVM | RVA | RVF | RVC | RVU); 811 env->priv_ver = PRIV_VERSION_1_10_0; 812 #ifndef CONFIG_USER_ONLY 813 set_satp_mode_max_supported(cpu, VM_1_10_MBARE); 814 #endif 815 816 /* inherited from parent obj via riscv_cpu_init() */ 817 cpu->cfg.ext_zifencei = true; 818 cpu->cfg.ext_zicsr = true; 819 cpu->cfg.pmp = true; 820 } 821 822 static void rv32i_bare_cpu_init(Object *obj) 823 { 824 CPURISCVState *env = &RISCV_CPU(obj)->env; 825 riscv_cpu_set_misa_ext(env, RVI); 826 } 827 828 static void rv32e_bare_cpu_init(Object *obj) 829 { 830 CPURISCVState *env = &RISCV_CPU(obj)->env; 831 riscv_cpu_set_misa_ext(env, RVE); 832 } 833 #endif 834 835 static ObjectClass *riscv_cpu_class_by_name(const char *cpu_model) 836 { 837 ObjectClass *oc; 838 char *typename; 839 char **cpuname; 840 841 cpuname = g_strsplit(cpu_model, ",", 1); 842 typename = g_strdup_printf(RISCV_CPU_TYPE_NAME("%s"), cpuname[0]); 843 oc = object_class_by_name(typename); 844 g_strfreev(cpuname); 845 g_free(typename); 846 847 return oc; 848 } 849 850 char *riscv_cpu_get_name(RISCVCPU *cpu) 851 { 852 RISCVCPUClass *rcc = RISCV_CPU_GET_CLASS(cpu); 853 const char *typename = object_class_get_name(OBJECT_CLASS(rcc)); 854 855 g_assert(g_str_has_suffix(typename, RISCV_CPU_TYPE_SUFFIX)); 856 857 return cpu_model_from_type(typename); 858 } 859 860 static void riscv_cpu_dump_state(CPUState *cs, FILE *f, int flags) 861 { 862 RISCVCPU *cpu = RISCV_CPU(cs); 863 CPURISCVState *env = &cpu->env; 864 int i, j; 865 uint8_t *p; 866 867 #if !defined(CONFIG_USER_ONLY) 868 if (riscv_has_ext(env, RVH)) { 869 qemu_fprintf(f, " %s %d\n", "V = ", env->virt_enabled); 870 } 871 #endif 872 qemu_fprintf(f, " %s " TARGET_FMT_lx "\n", "pc ", env->pc); 873 #ifndef CONFIG_USER_ONLY 874 { 875 static const int dump_csrs[] = { 876 CSR_MHARTID, 877 CSR_MSTATUS, 878 CSR_MSTATUSH, 879 /* 880 * CSR_SSTATUS is intentionally omitted here as its value 881 * can be figured out by looking at CSR_MSTATUS 882 */ 883 CSR_HSTATUS, 884 CSR_VSSTATUS, 885 CSR_MIP, 886 CSR_MIE, 887 CSR_MIDELEG, 888 CSR_HIDELEG, 889 CSR_MEDELEG, 890 CSR_HEDELEG, 891 CSR_MTVEC, 892 CSR_STVEC, 893 CSR_VSTVEC, 894 CSR_MEPC, 895 CSR_SEPC, 896 CSR_VSEPC, 897 CSR_MCAUSE, 898 CSR_SCAUSE, 899 CSR_VSCAUSE, 900 CSR_MTVAL, 901 CSR_STVAL, 902 CSR_HTVAL, 903 CSR_MTVAL2, 904 CSR_MSCRATCH, 905 CSR_SSCRATCH, 906 CSR_SATP, 907 }; 908 909 for (i = 0; i < ARRAY_SIZE(dump_csrs); ++i) { 910 int csrno = dump_csrs[i]; 911 target_ulong val = 0; 912 RISCVException res = riscv_csrrw_debug(env, csrno, &val, 0, 0); 913 914 /* 915 * Rely on the smode, hmode, etc, predicates within csr.c 916 * to do the filtering of the registers that are present. 917 */ 918 if (res == RISCV_EXCP_NONE) { 919 qemu_fprintf(f, " %-8s " TARGET_FMT_lx "\n", 920 csr_ops[csrno].name, val); 921 } 922 } 923 } 924 #endif 925 926 for (i = 0; i < 32; i++) { 927 qemu_fprintf(f, " %-8s " TARGET_FMT_lx, 928 riscv_int_regnames[i], env->gpr[i]); 929 if ((i & 3) == 3) { 930 qemu_fprintf(f, "\n"); 931 } 932 } 933 if (flags & CPU_DUMP_FPU) { 934 target_ulong val = 0; 935 RISCVException res = riscv_csrrw_debug(env, CSR_FCSR, &val, 0, 0); 936 if (res == RISCV_EXCP_NONE) { 937 qemu_fprintf(f, " %-8s " TARGET_FMT_lx "\n", 938 csr_ops[CSR_FCSR].name, val); 939 } 940 for (i = 0; i < 32; i++) { 941 qemu_fprintf(f, " %-8s %016" PRIx64, 942 riscv_fpr_regnames[i], env->fpr[i]); 943 if ((i & 3) == 3) { 944 qemu_fprintf(f, "\n"); 945 } 946 } 947 } 948 if (riscv_has_ext(env, RVV) && (flags & CPU_DUMP_VPU)) { 949 static const int dump_rvv_csrs[] = { 950 CSR_VSTART, 951 CSR_VXSAT, 952 CSR_VXRM, 953 CSR_VCSR, 954 CSR_VL, 955 CSR_VTYPE, 956 CSR_VLENB, 957 }; 958 for (i = 0; i < ARRAY_SIZE(dump_rvv_csrs); ++i) { 959 int csrno = dump_rvv_csrs[i]; 960 target_ulong val = 0; 961 RISCVException res = riscv_csrrw_debug(env, csrno, &val, 0, 0); 962 963 /* 964 * Rely on the smode, hmode, etc, predicates within csr.c 965 * to do the filtering of the registers that are present. 966 */ 967 if (res == RISCV_EXCP_NONE) { 968 qemu_fprintf(f, " %-8s " TARGET_FMT_lx "\n", 969 csr_ops[csrno].name, val); 970 } 971 } 972 uint16_t vlenb = cpu->cfg.vlenb; 973 974 for (i = 0; i < 32; i++) { 975 qemu_fprintf(f, " %-8s ", riscv_rvv_regnames[i]); 976 p = (uint8_t *)env->vreg; 977 for (j = vlenb - 1 ; j >= 0; j--) { 978 qemu_fprintf(f, "%02x", *(p + i * vlenb + BYTE(j))); 979 } 980 qemu_fprintf(f, "\n"); 981 } 982 } 983 } 984 985 static void riscv_cpu_set_pc(CPUState *cs, vaddr value) 986 { 987 RISCVCPU *cpu = RISCV_CPU(cs); 988 CPURISCVState *env = &cpu->env; 989 990 if (env->xl == MXL_RV32) { 991 env->pc = (int32_t)value; 992 } else { 993 env->pc = value; 994 } 995 } 996 997 static vaddr riscv_cpu_get_pc(CPUState *cs) 998 { 999 RISCVCPU *cpu = RISCV_CPU(cs); 1000 CPURISCVState *env = &cpu->env; 1001 1002 /* Match cpu_get_tb_cpu_state. */ 1003 if (env->xl == MXL_RV32) { 1004 return env->pc & UINT32_MAX; 1005 } 1006 return env->pc; 1007 } 1008 1009 bool riscv_cpu_has_work(CPUState *cs) 1010 { 1011 #ifndef CONFIG_USER_ONLY 1012 RISCVCPU *cpu = RISCV_CPU(cs); 1013 CPURISCVState *env = &cpu->env; 1014 /* 1015 * Definition of the WFI instruction requires it to ignore the privilege 1016 * mode and delegation registers, but respect individual enables 1017 */ 1018 return riscv_cpu_all_pending(env) != 0 || 1019 riscv_cpu_sirq_pending(env) != RISCV_EXCP_NONE || 1020 riscv_cpu_vsirq_pending(env) != RISCV_EXCP_NONE; 1021 #else 1022 return true; 1023 #endif 1024 } 1025 1026 static int riscv_cpu_mmu_index(CPUState *cs, bool ifetch) 1027 { 1028 return riscv_env_mmu_index(cpu_env(cs), ifetch); 1029 } 1030 1031 static void riscv_cpu_reset_hold(Object *obj, ResetType type) 1032 { 1033 #ifndef CONFIG_USER_ONLY 1034 uint8_t iprio; 1035 int i, irq, rdzero; 1036 #endif 1037 CPUState *cs = CPU(obj); 1038 RISCVCPU *cpu = RISCV_CPU(cs); 1039 RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(obj); 1040 CPURISCVState *env = &cpu->env; 1041 1042 if (mcc->parent_phases.hold) { 1043 mcc->parent_phases.hold(obj, type); 1044 } 1045 #ifndef CONFIG_USER_ONLY 1046 env->misa_mxl = mcc->misa_mxl_max; 1047 env->priv = PRV_M; 1048 env->mstatus &= ~(MSTATUS_MIE | MSTATUS_MPRV); 1049 if (env->misa_mxl > MXL_RV32) { 1050 /* 1051 * The reset status of SXL/UXL is undefined, but mstatus is WARL 1052 * and we must ensure that the value after init is valid for read. 1053 */ 1054 env->mstatus = set_field(env->mstatus, MSTATUS64_SXL, env->misa_mxl); 1055 env->mstatus = set_field(env->mstatus, MSTATUS64_UXL, env->misa_mxl); 1056 if (riscv_has_ext(env, RVH)) { 1057 env->vsstatus = set_field(env->vsstatus, 1058 MSTATUS64_SXL, env->misa_mxl); 1059 env->vsstatus = set_field(env->vsstatus, 1060 MSTATUS64_UXL, env->misa_mxl); 1061 env->mstatus_hs = set_field(env->mstatus_hs, 1062 MSTATUS64_SXL, env->misa_mxl); 1063 env->mstatus_hs = set_field(env->mstatus_hs, 1064 MSTATUS64_UXL, env->misa_mxl); 1065 } 1066 if (riscv_cpu_cfg(env)->ext_smdbltrp) { 1067 env->mstatus = set_field(env->mstatus, MSTATUS_MDT, 1); 1068 } 1069 } 1070 env->mcause = 0; 1071 env->miclaim = MIP_SGEIP; 1072 env->pc = env->resetvec; 1073 env->bins = 0; 1074 env->two_stage_lookup = false; 1075 1076 env->menvcfg = (cpu->cfg.ext_svpbmt ? MENVCFG_PBMTE : 0) | 1077 (!cpu->cfg.ext_svade && cpu->cfg.ext_svadu ? 1078 MENVCFG_ADUE : 0); 1079 env->henvcfg = 0; 1080 1081 /* Initialized default priorities of local interrupts. */ 1082 for (i = 0; i < ARRAY_SIZE(env->miprio); i++) { 1083 iprio = riscv_cpu_default_priority(i); 1084 env->miprio[i] = (i == IRQ_M_EXT) ? 0 : iprio; 1085 env->siprio[i] = (i == IRQ_S_EXT) ? 0 : iprio; 1086 env->hviprio[i] = 0; 1087 } 1088 i = 0; 1089 while (!riscv_cpu_hviprio_index2irq(i, &irq, &rdzero)) { 1090 if (!rdzero) { 1091 env->hviprio[irq] = env->miprio[irq]; 1092 } 1093 i++; 1094 } 1095 1096 /* 1097 * Bits 10, 6, 2 and 12 of mideleg are read only 1 when the Hypervisor 1098 * extension is enabled. 1099 */ 1100 if (riscv_has_ext(env, RVH)) { 1101 env->mideleg |= HS_MODE_INTERRUPTS; 1102 } 1103 1104 /* 1105 * Clear mseccfg and unlock all the PMP entries upon reset. 1106 * This is allowed as per the priv and smepmp specifications 1107 * and is needed to clear stale entries across reboots. 1108 */ 1109 if (riscv_cpu_cfg(env)->ext_smepmp) { 1110 env->mseccfg = 0; 1111 } 1112 1113 pmp_unlock_entries(env); 1114 #else 1115 env->priv = PRV_U; 1116 env->senvcfg = 0; 1117 env->menvcfg = 0; 1118 #endif 1119 1120 /* on reset elp is clear */ 1121 env->elp = false; 1122 /* on reset ssp is set to 0 */ 1123 env->ssp = 0; 1124 1125 env->xl = riscv_cpu_mxl(env); 1126 cs->exception_index = RISCV_EXCP_NONE; 1127 env->load_res = -1; 1128 set_default_nan_mode(1, &env->fp_status); 1129 /* Default NaN value: sign bit clear, frac msb set */ 1130 set_float_default_nan_pattern(0b01000000, &env->fp_status); 1131 env->vill = true; 1132 1133 #ifndef CONFIG_USER_ONLY 1134 if (cpu->cfg.debug) { 1135 riscv_trigger_reset_hold(env); 1136 } 1137 1138 if (cpu->cfg.ext_smrnmi) { 1139 env->rnmip = 0; 1140 env->mnstatus = set_field(env->mnstatus, MNSTATUS_NMIE, false); 1141 } 1142 1143 if (kvm_enabled()) { 1144 kvm_riscv_reset_vcpu(cpu); 1145 } 1146 #endif 1147 } 1148 1149 static void riscv_cpu_disas_set_info(CPUState *s, disassemble_info *info) 1150 { 1151 RISCVCPU *cpu = RISCV_CPU(s); 1152 CPURISCVState *env = &cpu->env; 1153 info->target_info = &cpu->cfg; 1154 1155 /* 1156 * A couple of bits in MSTATUS set the endianness: 1157 * - MSTATUS_UBE (User-mode), 1158 * - MSTATUS_SBE (Supervisor-mode), 1159 * - MSTATUS_MBE (Machine-mode) 1160 * but we don't implement that yet. 1161 */ 1162 info->endian = BFD_ENDIAN_LITTLE; 1163 1164 switch (env->xl) { 1165 case MXL_RV32: 1166 info->print_insn = print_insn_riscv32; 1167 break; 1168 case MXL_RV64: 1169 info->print_insn = print_insn_riscv64; 1170 break; 1171 case MXL_RV128: 1172 info->print_insn = print_insn_riscv128; 1173 break; 1174 default: 1175 g_assert_not_reached(); 1176 } 1177 } 1178 1179 #ifndef CONFIG_USER_ONLY 1180 static void riscv_cpu_satp_mode_finalize(RISCVCPU *cpu, Error **errp) 1181 { 1182 bool rv32 = riscv_cpu_is_32bit(cpu); 1183 uint8_t satp_mode_map_max, satp_mode_supported_max; 1184 1185 /* The CPU wants the OS to decide which satp mode to use */ 1186 if (cpu->cfg.satp_mode.supported == 0) { 1187 return; 1188 } 1189 1190 satp_mode_supported_max = 1191 satp_mode_max_from_map(cpu->cfg.satp_mode.supported); 1192 1193 if (cpu->cfg.satp_mode.map == 0) { 1194 if (cpu->cfg.satp_mode.init == 0) { 1195 /* If unset by the user, we fallback to the default satp mode. */ 1196 set_satp_mode_default_map(cpu); 1197 } else { 1198 /* 1199 * Find the lowest level that was disabled and then enable the 1200 * first valid level below which can be found in 1201 * valid_vm_1_10_32/64. 1202 */ 1203 for (int i = 1; i < 16; ++i) { 1204 if ((cpu->cfg.satp_mode.init & (1 << i)) && 1205 (cpu->cfg.satp_mode.supported & (1 << i))) { 1206 for (int j = i - 1; j >= 0; --j) { 1207 if (cpu->cfg.satp_mode.supported & (1 << j)) { 1208 cpu->cfg.satp_mode.map |= (1 << j); 1209 break; 1210 } 1211 } 1212 break; 1213 } 1214 } 1215 } 1216 } 1217 1218 satp_mode_map_max = satp_mode_max_from_map(cpu->cfg.satp_mode.map); 1219 1220 /* Make sure the user asked for a supported configuration (HW and qemu) */ 1221 if (satp_mode_map_max > satp_mode_supported_max) { 1222 error_setg(errp, "satp_mode %s is higher than hw max capability %s", 1223 satp_mode_str(satp_mode_map_max, rv32), 1224 satp_mode_str(satp_mode_supported_max, rv32)); 1225 return; 1226 } 1227 1228 /* 1229 * Make sure the user did not ask for an invalid configuration as per 1230 * the specification. 1231 */ 1232 if (!rv32) { 1233 for (int i = satp_mode_map_max - 1; i >= 0; --i) { 1234 if (!(cpu->cfg.satp_mode.map & (1 << i)) && 1235 (cpu->cfg.satp_mode.init & (1 << i)) && 1236 (cpu->cfg.satp_mode.supported & (1 << i))) { 1237 error_setg(errp, "cannot disable %s satp mode if %s " 1238 "is enabled", satp_mode_str(i, false), 1239 satp_mode_str(satp_mode_map_max, false)); 1240 return; 1241 } 1242 } 1243 } 1244 1245 /* Finally expand the map so that all valid modes are set */ 1246 for (int i = satp_mode_map_max - 1; i >= 0; --i) { 1247 if (cpu->cfg.satp_mode.supported & (1 << i)) { 1248 cpu->cfg.satp_mode.map |= (1 << i); 1249 } 1250 } 1251 } 1252 #endif 1253 1254 void riscv_cpu_finalize_features(RISCVCPU *cpu, Error **errp) 1255 { 1256 Error *local_err = NULL; 1257 1258 #ifndef CONFIG_USER_ONLY 1259 riscv_cpu_satp_mode_finalize(cpu, &local_err); 1260 if (local_err != NULL) { 1261 error_propagate(errp, local_err); 1262 return; 1263 } 1264 #endif 1265 1266 if (tcg_enabled()) { 1267 riscv_tcg_cpu_finalize_features(cpu, &local_err); 1268 if (local_err != NULL) { 1269 error_propagate(errp, local_err); 1270 return; 1271 } 1272 riscv_tcg_cpu_finalize_dynamic_decoder(cpu); 1273 } else if (kvm_enabled()) { 1274 riscv_kvm_cpu_finalize_features(cpu, &local_err); 1275 if (local_err != NULL) { 1276 error_propagate(errp, local_err); 1277 return; 1278 } 1279 } 1280 } 1281 1282 static void riscv_cpu_realize(DeviceState *dev, Error **errp) 1283 { 1284 CPUState *cs = CPU(dev); 1285 RISCVCPU *cpu = RISCV_CPU(dev); 1286 RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(dev); 1287 Error *local_err = NULL; 1288 1289 cpu_exec_realizefn(cs, &local_err); 1290 if (local_err != NULL) { 1291 error_propagate(errp, local_err); 1292 return; 1293 } 1294 1295 riscv_cpu_finalize_features(cpu, &local_err); 1296 if (local_err != NULL) { 1297 error_propagate(errp, local_err); 1298 return; 1299 } 1300 1301 riscv_cpu_register_gdb_regs_for_features(cs); 1302 1303 #ifndef CONFIG_USER_ONLY 1304 if (cpu->cfg.debug) { 1305 riscv_trigger_realize(&cpu->env); 1306 } 1307 #endif 1308 1309 qemu_init_vcpu(cs); 1310 cpu_reset(cs); 1311 1312 mcc->parent_realize(dev, errp); 1313 } 1314 1315 bool riscv_cpu_accelerator_compatible(RISCVCPU *cpu) 1316 { 1317 if (tcg_enabled()) { 1318 return riscv_cpu_tcg_compatible(cpu); 1319 } 1320 1321 return true; 1322 } 1323 1324 #ifndef CONFIG_USER_ONLY 1325 static void cpu_riscv_get_satp(Object *obj, Visitor *v, const char *name, 1326 void *opaque, Error **errp) 1327 { 1328 RISCVSATPMap *satp_map = opaque; 1329 uint8_t satp = satp_mode_from_str(name); 1330 bool value; 1331 1332 value = satp_map->map & (1 << satp); 1333 1334 visit_type_bool(v, name, &value, errp); 1335 } 1336 1337 static void cpu_riscv_set_satp(Object *obj, Visitor *v, const char *name, 1338 void *opaque, Error **errp) 1339 { 1340 RISCVSATPMap *satp_map = opaque; 1341 uint8_t satp = satp_mode_from_str(name); 1342 bool value; 1343 1344 if (!visit_type_bool(v, name, &value, errp)) { 1345 return; 1346 } 1347 1348 satp_map->map = deposit32(satp_map->map, satp, 1, value); 1349 satp_map->init |= 1 << satp; 1350 } 1351 1352 void riscv_add_satp_mode_properties(Object *obj) 1353 { 1354 RISCVCPU *cpu = RISCV_CPU(obj); 1355 1356 if (cpu->env.misa_mxl == MXL_RV32) { 1357 object_property_add(obj, "sv32", "bool", cpu_riscv_get_satp, 1358 cpu_riscv_set_satp, NULL, &cpu->cfg.satp_mode); 1359 } else { 1360 object_property_add(obj, "sv39", "bool", cpu_riscv_get_satp, 1361 cpu_riscv_set_satp, NULL, &cpu->cfg.satp_mode); 1362 object_property_add(obj, "sv48", "bool", cpu_riscv_get_satp, 1363 cpu_riscv_set_satp, NULL, &cpu->cfg.satp_mode); 1364 object_property_add(obj, "sv57", "bool", cpu_riscv_get_satp, 1365 cpu_riscv_set_satp, NULL, &cpu->cfg.satp_mode); 1366 object_property_add(obj, "sv64", "bool", cpu_riscv_get_satp, 1367 cpu_riscv_set_satp, NULL, &cpu->cfg.satp_mode); 1368 } 1369 } 1370 1371 static void riscv_cpu_set_irq(void *opaque, int irq, int level) 1372 { 1373 RISCVCPU *cpu = RISCV_CPU(opaque); 1374 CPURISCVState *env = &cpu->env; 1375 1376 if (irq < IRQ_LOCAL_MAX) { 1377 switch (irq) { 1378 case IRQ_U_SOFT: 1379 case IRQ_S_SOFT: 1380 case IRQ_VS_SOFT: 1381 case IRQ_M_SOFT: 1382 case IRQ_U_TIMER: 1383 case IRQ_S_TIMER: 1384 case IRQ_VS_TIMER: 1385 case IRQ_M_TIMER: 1386 case IRQ_U_EXT: 1387 case IRQ_VS_EXT: 1388 case IRQ_M_EXT: 1389 if (kvm_enabled()) { 1390 kvm_riscv_set_irq(cpu, irq, level); 1391 } else { 1392 riscv_cpu_update_mip(env, 1 << irq, BOOL_TO_MASK(level)); 1393 } 1394 break; 1395 case IRQ_S_EXT: 1396 if (kvm_enabled()) { 1397 kvm_riscv_set_irq(cpu, irq, level); 1398 } else { 1399 env->external_seip = level; 1400 riscv_cpu_update_mip(env, 1 << irq, 1401 BOOL_TO_MASK(level | env->software_seip)); 1402 } 1403 break; 1404 default: 1405 g_assert_not_reached(); 1406 } 1407 } else if (irq < (IRQ_LOCAL_MAX + IRQ_LOCAL_GUEST_MAX)) { 1408 /* Require H-extension for handling guest local interrupts */ 1409 if (!riscv_has_ext(env, RVH)) { 1410 g_assert_not_reached(); 1411 } 1412 1413 /* Compute bit position in HGEIP CSR */ 1414 irq = irq - IRQ_LOCAL_MAX + 1; 1415 if (env->geilen < irq) { 1416 g_assert_not_reached(); 1417 } 1418 1419 /* Update HGEIP CSR */ 1420 env->hgeip &= ~((target_ulong)1 << irq); 1421 if (level) { 1422 env->hgeip |= (target_ulong)1 << irq; 1423 } 1424 1425 /* Update mip.SGEIP bit */ 1426 riscv_cpu_update_mip(env, MIP_SGEIP, 1427 BOOL_TO_MASK(!!(env->hgeie & env->hgeip))); 1428 } else { 1429 g_assert_not_reached(); 1430 } 1431 } 1432 1433 static void riscv_cpu_set_nmi(void *opaque, int irq, int level) 1434 { 1435 riscv_cpu_set_rnmi(RISCV_CPU(opaque), irq, level); 1436 } 1437 #endif /* CONFIG_USER_ONLY */ 1438 1439 static bool riscv_cpu_is_dynamic(Object *cpu_obj) 1440 { 1441 return object_dynamic_cast(cpu_obj, TYPE_RISCV_DYNAMIC_CPU) != NULL; 1442 } 1443 1444 static void riscv_cpu_post_init(Object *obj) 1445 { 1446 accel_cpu_instance_init(CPU(obj)); 1447 } 1448 1449 static void riscv_cpu_init(Object *obj) 1450 { 1451 RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(obj); 1452 RISCVCPU *cpu = RISCV_CPU(obj); 1453 CPURISCVState *env = &cpu->env; 1454 1455 env->misa_mxl = mcc->misa_mxl_max; 1456 1457 #ifndef CONFIG_USER_ONLY 1458 qdev_init_gpio_in(DEVICE(obj), riscv_cpu_set_irq, 1459 IRQ_LOCAL_MAX + IRQ_LOCAL_GUEST_MAX); 1460 qdev_init_gpio_in_named(DEVICE(cpu), riscv_cpu_set_nmi, 1461 "riscv.cpu.rnmi", RNMI_MAX); 1462 #endif /* CONFIG_USER_ONLY */ 1463 1464 general_user_opts = g_hash_table_new(g_str_hash, g_str_equal); 1465 1466 /* 1467 * The timer and performance counters extensions were supported 1468 * in QEMU before they were added as discrete extensions in the 1469 * ISA. To keep compatibility we'll always default them to 'true' 1470 * for all CPUs. Each accelerator will decide what to do when 1471 * users disable them. 1472 */ 1473 RISCV_CPU(obj)->cfg.ext_zicntr = true; 1474 RISCV_CPU(obj)->cfg.ext_zihpm = true; 1475 1476 /* Default values for non-bool cpu properties */ 1477 cpu->cfg.pmu_mask = MAKE_64BIT_MASK(3, 16); 1478 cpu->cfg.vlenb = 128 >> 3; 1479 cpu->cfg.elen = 64; 1480 cpu->cfg.cbom_blocksize = 64; 1481 cpu->cfg.cbop_blocksize = 64; 1482 cpu->cfg.cboz_blocksize = 64; 1483 cpu->env.vext_ver = VEXT_VERSION_1_00_0; 1484 } 1485 1486 static void riscv_bare_cpu_init(Object *obj) 1487 { 1488 RISCVCPU *cpu = RISCV_CPU(obj); 1489 1490 /* 1491 * Bare CPUs do not inherit the timer and performance 1492 * counters from the parent class (see riscv_cpu_init() 1493 * for info on why the parent enables them). 1494 * 1495 * Users have to explicitly enable these counters for 1496 * bare CPUs. 1497 */ 1498 cpu->cfg.ext_zicntr = false; 1499 cpu->cfg.ext_zihpm = false; 1500 1501 /* Set to QEMU's first supported priv version */ 1502 cpu->env.priv_ver = PRIV_VERSION_1_10_0; 1503 1504 /* 1505 * Support all available satp_mode settings. The default 1506 * value will be set to MBARE if the user doesn't set 1507 * satp_mode manually (see set_satp_mode_default()). 1508 */ 1509 #ifndef CONFIG_USER_ONLY 1510 set_satp_mode_max_supported(cpu, VM_1_10_SV64); 1511 #endif 1512 } 1513 1514 typedef struct misa_ext_info { 1515 const char *name; 1516 const char *description; 1517 } MISAExtInfo; 1518 1519 #define MISA_INFO_IDX(_bit) \ 1520 __builtin_ctz(_bit) 1521 1522 #define MISA_EXT_INFO(_bit, _propname, _descr) \ 1523 [MISA_INFO_IDX(_bit)] = {.name = _propname, .description = _descr} 1524 1525 static const MISAExtInfo misa_ext_info_arr[] = { 1526 MISA_EXT_INFO(RVA, "a", "Atomic instructions"), 1527 MISA_EXT_INFO(RVC, "c", "Compressed instructions"), 1528 MISA_EXT_INFO(RVD, "d", "Double-precision float point"), 1529 MISA_EXT_INFO(RVF, "f", "Single-precision float point"), 1530 MISA_EXT_INFO(RVI, "i", "Base integer instruction set"), 1531 MISA_EXT_INFO(RVE, "e", "Base integer instruction set (embedded)"), 1532 MISA_EXT_INFO(RVM, "m", "Integer multiplication and division"), 1533 MISA_EXT_INFO(RVS, "s", "Supervisor-level instructions"), 1534 MISA_EXT_INFO(RVU, "u", "User-level instructions"), 1535 MISA_EXT_INFO(RVH, "h", "Hypervisor"), 1536 MISA_EXT_INFO(RVV, "v", "Vector operations"), 1537 MISA_EXT_INFO(RVG, "g", "General purpose (IMAFD_Zicsr_Zifencei)"), 1538 MISA_EXT_INFO(RVB, "b", "Bit manipulation (Zba_Zbb_Zbs)") 1539 }; 1540 1541 static void riscv_cpu_validate_misa_mxl(RISCVCPUClass *mcc) 1542 { 1543 CPUClass *cc = CPU_CLASS(mcc); 1544 1545 /* Validate that MISA_MXL is set properly. */ 1546 switch (mcc->misa_mxl_max) { 1547 #ifdef TARGET_RISCV64 1548 case MXL_RV64: 1549 case MXL_RV128: 1550 cc->gdb_core_xml_file = "riscv-64bit-cpu.xml"; 1551 break; 1552 #endif 1553 case MXL_RV32: 1554 cc->gdb_core_xml_file = "riscv-32bit-cpu.xml"; 1555 break; 1556 default: 1557 g_assert_not_reached(); 1558 } 1559 } 1560 1561 static int riscv_validate_misa_info_idx(uint32_t bit) 1562 { 1563 int idx; 1564 1565 /* 1566 * Our lowest valid input (RVA) is 1 and 1567 * __builtin_ctz() is UB with zero. 1568 */ 1569 g_assert(bit != 0); 1570 idx = MISA_INFO_IDX(bit); 1571 1572 g_assert(idx < ARRAY_SIZE(misa_ext_info_arr)); 1573 return idx; 1574 } 1575 1576 const char *riscv_get_misa_ext_name(uint32_t bit) 1577 { 1578 int idx = riscv_validate_misa_info_idx(bit); 1579 const char *val = misa_ext_info_arr[idx].name; 1580 1581 g_assert(val != NULL); 1582 return val; 1583 } 1584 1585 const char *riscv_get_misa_ext_description(uint32_t bit) 1586 { 1587 int idx = riscv_validate_misa_info_idx(bit); 1588 const char *val = misa_ext_info_arr[idx].description; 1589 1590 g_assert(val != NULL); 1591 return val; 1592 } 1593 1594 #define MULTI_EXT_CFG_BOOL(_name, _prop, _defval) \ 1595 {.name = _name, .offset = CPU_CFG_OFFSET(_prop), \ 1596 .enabled = _defval} 1597 1598 const RISCVCPUMultiExtConfig riscv_cpu_extensions[] = { 1599 /* Defaults for standard extensions */ 1600 MULTI_EXT_CFG_BOOL("sscofpmf", ext_sscofpmf, false), 1601 MULTI_EXT_CFG_BOOL("smcntrpmf", ext_smcntrpmf, false), 1602 MULTI_EXT_CFG_BOOL("smcsrind", ext_smcsrind, false), 1603 MULTI_EXT_CFG_BOOL("smcdeleg", ext_smcdeleg, false), 1604 MULTI_EXT_CFG_BOOL("sscsrind", ext_sscsrind, false), 1605 MULTI_EXT_CFG_BOOL("ssccfg", ext_ssccfg, false), 1606 MULTI_EXT_CFG_BOOL("smctr", ext_smctr, false), 1607 MULTI_EXT_CFG_BOOL("ssctr", ext_ssctr, false), 1608 MULTI_EXT_CFG_BOOL("zifencei", ext_zifencei, true), 1609 MULTI_EXT_CFG_BOOL("zicfilp", ext_zicfilp, false), 1610 MULTI_EXT_CFG_BOOL("zicfiss", ext_zicfiss, false), 1611 MULTI_EXT_CFG_BOOL("zicsr", ext_zicsr, true), 1612 MULTI_EXT_CFG_BOOL("zihintntl", ext_zihintntl, true), 1613 MULTI_EXT_CFG_BOOL("zihintpause", ext_zihintpause, true), 1614 MULTI_EXT_CFG_BOOL("zimop", ext_zimop, false), 1615 MULTI_EXT_CFG_BOOL("zcmop", ext_zcmop, false), 1616 MULTI_EXT_CFG_BOOL("zacas", ext_zacas, false), 1617 MULTI_EXT_CFG_BOOL("zama16b", ext_zama16b, false), 1618 MULTI_EXT_CFG_BOOL("zabha", ext_zabha, false), 1619 MULTI_EXT_CFG_BOOL("zaamo", ext_zaamo, false), 1620 MULTI_EXT_CFG_BOOL("zalrsc", ext_zalrsc, false), 1621 MULTI_EXT_CFG_BOOL("zawrs", ext_zawrs, true), 1622 MULTI_EXT_CFG_BOOL("zfa", ext_zfa, true), 1623 MULTI_EXT_CFG_BOOL("zfbfmin", ext_zfbfmin, false), 1624 MULTI_EXT_CFG_BOOL("zfh", ext_zfh, false), 1625 MULTI_EXT_CFG_BOOL("zfhmin", ext_zfhmin, false), 1626 MULTI_EXT_CFG_BOOL("zve32f", ext_zve32f, false), 1627 MULTI_EXT_CFG_BOOL("zve32x", ext_zve32x, false), 1628 MULTI_EXT_CFG_BOOL("zve64f", ext_zve64f, false), 1629 MULTI_EXT_CFG_BOOL("zve64d", ext_zve64d, false), 1630 MULTI_EXT_CFG_BOOL("zve64x", ext_zve64x, false), 1631 MULTI_EXT_CFG_BOOL("zvfbfmin", ext_zvfbfmin, false), 1632 MULTI_EXT_CFG_BOOL("zvfbfwma", ext_zvfbfwma, false), 1633 MULTI_EXT_CFG_BOOL("zvfh", ext_zvfh, false), 1634 MULTI_EXT_CFG_BOOL("zvfhmin", ext_zvfhmin, false), 1635 MULTI_EXT_CFG_BOOL("sstc", ext_sstc, true), 1636 MULTI_EXT_CFG_BOOL("ssnpm", ext_ssnpm, false), 1637 MULTI_EXT_CFG_BOOL("sspm", ext_sspm, false), 1638 MULTI_EXT_CFG_BOOL("supm", ext_supm, false), 1639 1640 MULTI_EXT_CFG_BOOL("smaia", ext_smaia, false), 1641 MULTI_EXT_CFG_BOOL("smdbltrp", ext_smdbltrp, false), 1642 MULTI_EXT_CFG_BOOL("smepmp", ext_smepmp, false), 1643 MULTI_EXT_CFG_BOOL("smrnmi", ext_smrnmi, false), 1644 MULTI_EXT_CFG_BOOL("smmpm", ext_smmpm, false), 1645 MULTI_EXT_CFG_BOOL("smnpm", ext_smnpm, false), 1646 MULTI_EXT_CFG_BOOL("smstateen", ext_smstateen, false), 1647 MULTI_EXT_CFG_BOOL("ssaia", ext_ssaia, false), 1648 MULTI_EXT_CFG_BOOL("ssdbltrp", ext_ssdbltrp, false), 1649 MULTI_EXT_CFG_BOOL("svade", ext_svade, false), 1650 MULTI_EXT_CFG_BOOL("svadu", ext_svadu, true), 1651 MULTI_EXT_CFG_BOOL("svinval", ext_svinval, false), 1652 MULTI_EXT_CFG_BOOL("svnapot", ext_svnapot, false), 1653 MULTI_EXT_CFG_BOOL("svpbmt", ext_svpbmt, false), 1654 MULTI_EXT_CFG_BOOL("svvptc", ext_svvptc, true), 1655 1656 MULTI_EXT_CFG_BOOL("zicntr", ext_zicntr, true), 1657 MULTI_EXT_CFG_BOOL("zihpm", ext_zihpm, true), 1658 1659 MULTI_EXT_CFG_BOOL("zba", ext_zba, true), 1660 MULTI_EXT_CFG_BOOL("zbb", ext_zbb, true), 1661 MULTI_EXT_CFG_BOOL("zbc", ext_zbc, true), 1662 MULTI_EXT_CFG_BOOL("zbkb", ext_zbkb, false), 1663 MULTI_EXT_CFG_BOOL("zbkc", ext_zbkc, false), 1664 MULTI_EXT_CFG_BOOL("zbkx", ext_zbkx, false), 1665 MULTI_EXT_CFG_BOOL("zbs", ext_zbs, true), 1666 MULTI_EXT_CFG_BOOL("zk", ext_zk, false), 1667 MULTI_EXT_CFG_BOOL("zkn", ext_zkn, false), 1668 MULTI_EXT_CFG_BOOL("zknd", ext_zknd, false), 1669 MULTI_EXT_CFG_BOOL("zkne", ext_zkne, false), 1670 MULTI_EXT_CFG_BOOL("zknh", ext_zknh, false), 1671 MULTI_EXT_CFG_BOOL("zkr", ext_zkr, false), 1672 MULTI_EXT_CFG_BOOL("zks", ext_zks, false), 1673 MULTI_EXT_CFG_BOOL("zksed", ext_zksed, false), 1674 MULTI_EXT_CFG_BOOL("zksh", ext_zksh, false), 1675 MULTI_EXT_CFG_BOOL("zkt", ext_zkt, false), 1676 MULTI_EXT_CFG_BOOL("ztso", ext_ztso, false), 1677 1678 MULTI_EXT_CFG_BOOL("zdinx", ext_zdinx, false), 1679 MULTI_EXT_CFG_BOOL("zfinx", ext_zfinx, false), 1680 MULTI_EXT_CFG_BOOL("zhinx", ext_zhinx, false), 1681 MULTI_EXT_CFG_BOOL("zhinxmin", ext_zhinxmin, false), 1682 1683 MULTI_EXT_CFG_BOOL("zicbom", ext_zicbom, true), 1684 MULTI_EXT_CFG_BOOL("zicbop", ext_zicbop, true), 1685 MULTI_EXT_CFG_BOOL("zicboz", ext_zicboz, true), 1686 1687 MULTI_EXT_CFG_BOOL("zmmul", ext_zmmul, false), 1688 1689 MULTI_EXT_CFG_BOOL("zca", ext_zca, false), 1690 MULTI_EXT_CFG_BOOL("zcb", ext_zcb, false), 1691 MULTI_EXT_CFG_BOOL("zcd", ext_zcd, false), 1692 MULTI_EXT_CFG_BOOL("zce", ext_zce, false), 1693 MULTI_EXT_CFG_BOOL("zcf", ext_zcf, false), 1694 MULTI_EXT_CFG_BOOL("zcmp", ext_zcmp, false), 1695 MULTI_EXT_CFG_BOOL("zcmt", ext_zcmt, false), 1696 MULTI_EXT_CFG_BOOL("zicond", ext_zicond, false), 1697 1698 /* Vector cryptography extensions */ 1699 MULTI_EXT_CFG_BOOL("zvbb", ext_zvbb, false), 1700 MULTI_EXT_CFG_BOOL("zvbc", ext_zvbc, false), 1701 MULTI_EXT_CFG_BOOL("zvkb", ext_zvkb, false), 1702 MULTI_EXT_CFG_BOOL("zvkg", ext_zvkg, false), 1703 MULTI_EXT_CFG_BOOL("zvkned", ext_zvkned, false), 1704 MULTI_EXT_CFG_BOOL("zvknha", ext_zvknha, false), 1705 MULTI_EXT_CFG_BOOL("zvknhb", ext_zvknhb, false), 1706 MULTI_EXT_CFG_BOOL("zvksed", ext_zvksed, false), 1707 MULTI_EXT_CFG_BOOL("zvksh", ext_zvksh, false), 1708 MULTI_EXT_CFG_BOOL("zvkt", ext_zvkt, false), 1709 MULTI_EXT_CFG_BOOL("zvkn", ext_zvkn, false), 1710 MULTI_EXT_CFG_BOOL("zvknc", ext_zvknc, false), 1711 MULTI_EXT_CFG_BOOL("zvkng", ext_zvkng, false), 1712 MULTI_EXT_CFG_BOOL("zvks", ext_zvks, false), 1713 MULTI_EXT_CFG_BOOL("zvksc", ext_zvksc, false), 1714 MULTI_EXT_CFG_BOOL("zvksg", ext_zvksg, false), 1715 1716 { }, 1717 }; 1718 1719 const RISCVCPUMultiExtConfig riscv_cpu_vendor_exts[] = { 1720 MULTI_EXT_CFG_BOOL("xtheadba", ext_xtheadba, false), 1721 MULTI_EXT_CFG_BOOL("xtheadbb", ext_xtheadbb, false), 1722 MULTI_EXT_CFG_BOOL("xtheadbs", ext_xtheadbs, false), 1723 MULTI_EXT_CFG_BOOL("xtheadcmo", ext_xtheadcmo, false), 1724 MULTI_EXT_CFG_BOOL("xtheadcondmov", ext_xtheadcondmov, false), 1725 MULTI_EXT_CFG_BOOL("xtheadfmemidx", ext_xtheadfmemidx, false), 1726 MULTI_EXT_CFG_BOOL("xtheadfmv", ext_xtheadfmv, false), 1727 MULTI_EXT_CFG_BOOL("xtheadmac", ext_xtheadmac, false), 1728 MULTI_EXT_CFG_BOOL("xtheadmemidx", ext_xtheadmemidx, false), 1729 MULTI_EXT_CFG_BOOL("xtheadmempair", ext_xtheadmempair, false), 1730 MULTI_EXT_CFG_BOOL("xtheadsync", ext_xtheadsync, false), 1731 MULTI_EXT_CFG_BOOL("xventanacondops", ext_XVentanaCondOps, false), 1732 1733 { }, 1734 }; 1735 1736 /* These are experimental so mark with 'x-' */ 1737 const RISCVCPUMultiExtConfig riscv_cpu_experimental_exts[] = { 1738 MULTI_EXT_CFG_BOOL("x-svukte", ext_svukte, false), 1739 1740 { }, 1741 }; 1742 1743 /* 1744 * 'Named features' is the name we give to extensions that we 1745 * don't want to expose to users. They are either immutable 1746 * (always enabled/disable) or they'll vary depending on 1747 * the resulting CPU state. They have riscv,isa strings 1748 * and priv_ver like regular extensions. 1749 */ 1750 const RISCVCPUMultiExtConfig riscv_cpu_named_features[] = { 1751 MULTI_EXT_CFG_BOOL("zic64b", ext_zic64b, true), 1752 MULTI_EXT_CFG_BOOL("ssstateen", ext_ssstateen, true), 1753 MULTI_EXT_CFG_BOOL("sha", ext_sha, true), 1754 MULTI_EXT_CFG_BOOL("ziccrse", ext_ziccrse, true), 1755 1756 { }, 1757 }; 1758 1759 /* Deprecated entries marked for future removal */ 1760 const RISCVCPUMultiExtConfig riscv_cpu_deprecated_exts[] = { 1761 MULTI_EXT_CFG_BOOL("Zifencei", ext_zifencei, true), 1762 MULTI_EXT_CFG_BOOL("Zicsr", ext_zicsr, true), 1763 MULTI_EXT_CFG_BOOL("Zihintntl", ext_zihintntl, true), 1764 MULTI_EXT_CFG_BOOL("Zihintpause", ext_zihintpause, true), 1765 MULTI_EXT_CFG_BOOL("Zawrs", ext_zawrs, true), 1766 MULTI_EXT_CFG_BOOL("Zfa", ext_zfa, true), 1767 MULTI_EXT_CFG_BOOL("Zfh", ext_zfh, false), 1768 MULTI_EXT_CFG_BOOL("Zfhmin", ext_zfhmin, false), 1769 MULTI_EXT_CFG_BOOL("Zve32f", ext_zve32f, false), 1770 MULTI_EXT_CFG_BOOL("Zve64f", ext_zve64f, false), 1771 MULTI_EXT_CFG_BOOL("Zve64d", ext_zve64d, false), 1772 1773 { }, 1774 }; 1775 1776 static void cpu_set_prop_err(RISCVCPU *cpu, const char *propname, 1777 Error **errp) 1778 { 1779 g_autofree char *cpuname = riscv_cpu_get_name(cpu); 1780 error_setg(errp, "CPU '%s' does not allow changing the value of '%s'", 1781 cpuname, propname); 1782 } 1783 1784 static void prop_pmu_num_set(Object *obj, Visitor *v, const char *name, 1785 void *opaque, Error **errp) 1786 { 1787 RISCVCPU *cpu = RISCV_CPU(obj); 1788 uint8_t pmu_num, curr_pmu_num; 1789 uint32_t pmu_mask; 1790 1791 visit_type_uint8(v, name, &pmu_num, errp); 1792 1793 curr_pmu_num = ctpop32(cpu->cfg.pmu_mask); 1794 1795 if (pmu_num != curr_pmu_num && riscv_cpu_is_vendor(obj)) { 1796 cpu_set_prop_err(cpu, name, errp); 1797 error_append_hint(errp, "Current '%s' val: %u\n", 1798 name, curr_pmu_num); 1799 return; 1800 } 1801 1802 if (pmu_num > (RV_MAX_MHPMCOUNTERS - 3)) { 1803 error_setg(errp, "Number of counters exceeds maximum available"); 1804 return; 1805 } 1806 1807 if (pmu_num == 0) { 1808 pmu_mask = 0; 1809 } else { 1810 pmu_mask = MAKE_64BIT_MASK(3, pmu_num); 1811 } 1812 1813 warn_report("\"pmu-num\" property is deprecated; use \"pmu-mask\""); 1814 cpu->cfg.pmu_mask = pmu_mask; 1815 cpu_option_add_user_setting("pmu-mask", pmu_mask); 1816 } 1817 1818 static void prop_pmu_num_get(Object *obj, Visitor *v, const char *name, 1819 void *opaque, Error **errp) 1820 { 1821 RISCVCPU *cpu = RISCV_CPU(obj); 1822 uint8_t pmu_num = ctpop32(cpu->cfg.pmu_mask); 1823 1824 visit_type_uint8(v, name, &pmu_num, errp); 1825 } 1826 1827 static const PropertyInfo prop_pmu_num = { 1828 .type = "int8", 1829 .description = "pmu-num", 1830 .get = prop_pmu_num_get, 1831 .set = prop_pmu_num_set, 1832 }; 1833 1834 static void prop_pmu_mask_set(Object *obj, Visitor *v, const char *name, 1835 void *opaque, Error **errp) 1836 { 1837 RISCVCPU *cpu = RISCV_CPU(obj); 1838 uint32_t value; 1839 uint8_t pmu_num; 1840 1841 visit_type_uint32(v, name, &value, errp); 1842 1843 if (value != cpu->cfg.pmu_mask && riscv_cpu_is_vendor(obj)) { 1844 cpu_set_prop_err(cpu, name, errp); 1845 error_append_hint(errp, "Current '%s' val: %x\n", 1846 name, cpu->cfg.pmu_mask); 1847 return; 1848 } 1849 1850 pmu_num = ctpop32(value); 1851 1852 if (pmu_num > (RV_MAX_MHPMCOUNTERS - 3)) { 1853 error_setg(errp, "Number of counters exceeds maximum available"); 1854 return; 1855 } 1856 1857 cpu_option_add_user_setting(name, value); 1858 cpu->cfg.pmu_mask = value; 1859 } 1860 1861 static void prop_pmu_mask_get(Object *obj, Visitor *v, const char *name, 1862 void *opaque, Error **errp) 1863 { 1864 uint8_t pmu_mask = RISCV_CPU(obj)->cfg.pmu_mask; 1865 1866 visit_type_uint8(v, name, &pmu_mask, errp); 1867 } 1868 1869 static const PropertyInfo prop_pmu_mask = { 1870 .type = "int8", 1871 .description = "pmu-mask", 1872 .get = prop_pmu_mask_get, 1873 .set = prop_pmu_mask_set, 1874 }; 1875 1876 static void prop_mmu_set(Object *obj, Visitor *v, const char *name, 1877 void *opaque, Error **errp) 1878 { 1879 RISCVCPU *cpu = RISCV_CPU(obj); 1880 bool value; 1881 1882 visit_type_bool(v, name, &value, errp); 1883 1884 if (cpu->cfg.mmu != value && riscv_cpu_is_vendor(obj)) { 1885 cpu_set_prop_err(cpu, "mmu", errp); 1886 return; 1887 } 1888 1889 cpu_option_add_user_setting(name, value); 1890 cpu->cfg.mmu = value; 1891 } 1892 1893 static void prop_mmu_get(Object *obj, Visitor *v, const char *name, 1894 void *opaque, Error **errp) 1895 { 1896 bool value = RISCV_CPU(obj)->cfg.mmu; 1897 1898 visit_type_bool(v, name, &value, errp); 1899 } 1900 1901 static const PropertyInfo prop_mmu = { 1902 .type = "bool", 1903 .description = "mmu", 1904 .get = prop_mmu_get, 1905 .set = prop_mmu_set, 1906 }; 1907 1908 static void prop_pmp_set(Object *obj, Visitor *v, const char *name, 1909 void *opaque, Error **errp) 1910 { 1911 RISCVCPU *cpu = RISCV_CPU(obj); 1912 bool value; 1913 1914 visit_type_bool(v, name, &value, errp); 1915 1916 if (cpu->cfg.pmp != value && riscv_cpu_is_vendor(obj)) { 1917 cpu_set_prop_err(cpu, name, errp); 1918 return; 1919 } 1920 1921 cpu_option_add_user_setting(name, value); 1922 cpu->cfg.pmp = value; 1923 } 1924 1925 static void prop_pmp_get(Object *obj, Visitor *v, const char *name, 1926 void *opaque, Error **errp) 1927 { 1928 bool value = RISCV_CPU(obj)->cfg.pmp; 1929 1930 visit_type_bool(v, name, &value, errp); 1931 } 1932 1933 static const PropertyInfo prop_pmp = { 1934 .type = "bool", 1935 .description = "pmp", 1936 .get = prop_pmp_get, 1937 .set = prop_pmp_set, 1938 }; 1939 1940 static int priv_spec_from_str(const char *priv_spec_str) 1941 { 1942 int priv_version = -1; 1943 1944 if (!g_strcmp0(priv_spec_str, PRIV_VER_1_13_0_STR)) { 1945 priv_version = PRIV_VERSION_1_13_0; 1946 } else if (!g_strcmp0(priv_spec_str, PRIV_VER_1_12_0_STR)) { 1947 priv_version = PRIV_VERSION_1_12_0; 1948 } else if (!g_strcmp0(priv_spec_str, PRIV_VER_1_11_0_STR)) { 1949 priv_version = PRIV_VERSION_1_11_0; 1950 } else if (!g_strcmp0(priv_spec_str, PRIV_VER_1_10_0_STR)) { 1951 priv_version = PRIV_VERSION_1_10_0; 1952 } 1953 1954 return priv_version; 1955 } 1956 1957 const char *priv_spec_to_str(int priv_version) 1958 { 1959 switch (priv_version) { 1960 case PRIV_VERSION_1_10_0: 1961 return PRIV_VER_1_10_0_STR; 1962 case PRIV_VERSION_1_11_0: 1963 return PRIV_VER_1_11_0_STR; 1964 case PRIV_VERSION_1_12_0: 1965 return PRIV_VER_1_12_0_STR; 1966 case PRIV_VERSION_1_13_0: 1967 return PRIV_VER_1_13_0_STR; 1968 default: 1969 return NULL; 1970 } 1971 } 1972 1973 static void prop_priv_spec_set(Object *obj, Visitor *v, const char *name, 1974 void *opaque, Error **errp) 1975 { 1976 RISCVCPU *cpu = RISCV_CPU(obj); 1977 g_autofree char *value = NULL; 1978 int priv_version = -1; 1979 1980 visit_type_str(v, name, &value, errp); 1981 1982 priv_version = priv_spec_from_str(value); 1983 if (priv_version < 0) { 1984 error_setg(errp, "Unsupported privilege spec version '%s'", value); 1985 return; 1986 } 1987 1988 if (priv_version != cpu->env.priv_ver && riscv_cpu_is_vendor(obj)) { 1989 cpu_set_prop_err(cpu, name, errp); 1990 error_append_hint(errp, "Current '%s' val: %s\n", name, 1991 object_property_get_str(obj, name, NULL)); 1992 return; 1993 } 1994 1995 cpu_option_add_user_setting(name, priv_version); 1996 cpu->env.priv_ver = priv_version; 1997 } 1998 1999 static void prop_priv_spec_get(Object *obj, Visitor *v, const char *name, 2000 void *opaque, Error **errp) 2001 { 2002 RISCVCPU *cpu = RISCV_CPU(obj); 2003 const char *value = priv_spec_to_str(cpu->env.priv_ver); 2004 2005 visit_type_str(v, name, (char **)&value, errp); 2006 } 2007 2008 static const PropertyInfo prop_priv_spec = { 2009 .type = "str", 2010 .description = "priv_spec", 2011 /* FIXME enum? */ 2012 .get = prop_priv_spec_get, 2013 .set = prop_priv_spec_set, 2014 }; 2015 2016 static void prop_vext_spec_set(Object *obj, Visitor *v, const char *name, 2017 void *opaque, Error **errp) 2018 { 2019 RISCVCPU *cpu = RISCV_CPU(obj); 2020 g_autofree char *value = NULL; 2021 2022 visit_type_str(v, name, &value, errp); 2023 2024 if (g_strcmp0(value, VEXT_VER_1_00_0_STR) != 0) { 2025 error_setg(errp, "Unsupported vector spec version '%s'", value); 2026 return; 2027 } 2028 2029 cpu_option_add_user_setting(name, VEXT_VERSION_1_00_0); 2030 cpu->env.vext_ver = VEXT_VERSION_1_00_0; 2031 } 2032 2033 static void prop_vext_spec_get(Object *obj, Visitor *v, const char *name, 2034 void *opaque, Error **errp) 2035 { 2036 const char *value = VEXT_VER_1_00_0_STR; 2037 2038 visit_type_str(v, name, (char **)&value, errp); 2039 } 2040 2041 static const PropertyInfo prop_vext_spec = { 2042 .type = "str", 2043 .description = "vext_spec", 2044 /* FIXME enum? */ 2045 .get = prop_vext_spec_get, 2046 .set = prop_vext_spec_set, 2047 }; 2048 2049 static void prop_vlen_set(Object *obj, Visitor *v, const char *name, 2050 void *opaque, Error **errp) 2051 { 2052 RISCVCPU *cpu = RISCV_CPU(obj); 2053 uint16_t cpu_vlen = cpu->cfg.vlenb << 3; 2054 uint16_t value; 2055 2056 if (!visit_type_uint16(v, name, &value, errp)) { 2057 return; 2058 } 2059 2060 if (!is_power_of_2(value)) { 2061 error_setg(errp, "Vector extension VLEN must be power of 2"); 2062 return; 2063 } 2064 2065 if (value != cpu_vlen && riscv_cpu_is_vendor(obj)) { 2066 cpu_set_prop_err(cpu, name, errp); 2067 error_append_hint(errp, "Current '%s' val: %u\n", 2068 name, cpu_vlen); 2069 return; 2070 } 2071 2072 cpu_option_add_user_setting(name, value); 2073 cpu->cfg.vlenb = value >> 3; 2074 } 2075 2076 static void prop_vlen_get(Object *obj, Visitor *v, const char *name, 2077 void *opaque, Error **errp) 2078 { 2079 uint16_t value = RISCV_CPU(obj)->cfg.vlenb << 3; 2080 2081 visit_type_uint16(v, name, &value, errp); 2082 } 2083 2084 static const PropertyInfo prop_vlen = { 2085 .type = "uint16", 2086 .description = "vlen", 2087 .get = prop_vlen_get, 2088 .set = prop_vlen_set, 2089 }; 2090 2091 static void prop_elen_set(Object *obj, Visitor *v, const char *name, 2092 void *opaque, Error **errp) 2093 { 2094 RISCVCPU *cpu = RISCV_CPU(obj); 2095 uint16_t value; 2096 2097 if (!visit_type_uint16(v, name, &value, errp)) { 2098 return; 2099 } 2100 2101 if (!is_power_of_2(value)) { 2102 error_setg(errp, "Vector extension ELEN must be power of 2"); 2103 return; 2104 } 2105 2106 if (value != cpu->cfg.elen && riscv_cpu_is_vendor(obj)) { 2107 cpu_set_prop_err(cpu, name, errp); 2108 error_append_hint(errp, "Current '%s' val: %u\n", 2109 name, cpu->cfg.elen); 2110 return; 2111 } 2112 2113 cpu_option_add_user_setting(name, value); 2114 cpu->cfg.elen = value; 2115 } 2116 2117 static void prop_elen_get(Object *obj, Visitor *v, const char *name, 2118 void *opaque, Error **errp) 2119 { 2120 uint16_t value = RISCV_CPU(obj)->cfg.elen; 2121 2122 visit_type_uint16(v, name, &value, errp); 2123 } 2124 2125 static const PropertyInfo prop_elen = { 2126 .type = "uint16", 2127 .description = "elen", 2128 .get = prop_elen_get, 2129 .set = prop_elen_set, 2130 }; 2131 2132 static void prop_cbom_blksize_set(Object *obj, Visitor *v, const char *name, 2133 void *opaque, Error **errp) 2134 { 2135 RISCVCPU *cpu = RISCV_CPU(obj); 2136 uint16_t value; 2137 2138 if (!visit_type_uint16(v, name, &value, errp)) { 2139 return; 2140 } 2141 2142 if (value != cpu->cfg.cbom_blocksize && riscv_cpu_is_vendor(obj)) { 2143 cpu_set_prop_err(cpu, name, errp); 2144 error_append_hint(errp, "Current '%s' val: %u\n", 2145 name, cpu->cfg.cbom_blocksize); 2146 return; 2147 } 2148 2149 cpu_option_add_user_setting(name, value); 2150 cpu->cfg.cbom_blocksize = value; 2151 } 2152 2153 static void prop_cbom_blksize_get(Object *obj, Visitor *v, const char *name, 2154 void *opaque, Error **errp) 2155 { 2156 uint16_t value = RISCV_CPU(obj)->cfg.cbom_blocksize; 2157 2158 visit_type_uint16(v, name, &value, errp); 2159 } 2160 2161 static const PropertyInfo prop_cbom_blksize = { 2162 .type = "uint16", 2163 .description = "cbom_blocksize", 2164 .get = prop_cbom_blksize_get, 2165 .set = prop_cbom_blksize_set, 2166 }; 2167 2168 static void prop_cbop_blksize_set(Object *obj, Visitor *v, const char *name, 2169 void *opaque, Error **errp) 2170 { 2171 RISCVCPU *cpu = RISCV_CPU(obj); 2172 uint16_t value; 2173 2174 if (!visit_type_uint16(v, name, &value, errp)) { 2175 return; 2176 } 2177 2178 if (value != cpu->cfg.cbop_blocksize && riscv_cpu_is_vendor(obj)) { 2179 cpu_set_prop_err(cpu, name, errp); 2180 error_append_hint(errp, "Current '%s' val: %u\n", 2181 name, cpu->cfg.cbop_blocksize); 2182 return; 2183 } 2184 2185 cpu_option_add_user_setting(name, value); 2186 cpu->cfg.cbop_blocksize = value; 2187 } 2188 2189 static void prop_cbop_blksize_get(Object *obj, Visitor *v, const char *name, 2190 void *opaque, Error **errp) 2191 { 2192 uint16_t value = RISCV_CPU(obj)->cfg.cbop_blocksize; 2193 2194 visit_type_uint16(v, name, &value, errp); 2195 } 2196 2197 static const PropertyInfo prop_cbop_blksize = { 2198 .type = "uint16", 2199 .description = "cbop_blocksize", 2200 .get = prop_cbop_blksize_get, 2201 .set = prop_cbop_blksize_set, 2202 }; 2203 2204 static void prop_cboz_blksize_set(Object *obj, Visitor *v, const char *name, 2205 void *opaque, Error **errp) 2206 { 2207 RISCVCPU *cpu = RISCV_CPU(obj); 2208 uint16_t value; 2209 2210 if (!visit_type_uint16(v, name, &value, errp)) { 2211 return; 2212 } 2213 2214 if (value != cpu->cfg.cboz_blocksize && riscv_cpu_is_vendor(obj)) { 2215 cpu_set_prop_err(cpu, name, errp); 2216 error_append_hint(errp, "Current '%s' val: %u\n", 2217 name, cpu->cfg.cboz_blocksize); 2218 return; 2219 } 2220 2221 cpu_option_add_user_setting(name, value); 2222 cpu->cfg.cboz_blocksize = value; 2223 } 2224 2225 static void prop_cboz_blksize_get(Object *obj, Visitor *v, const char *name, 2226 void *opaque, Error **errp) 2227 { 2228 uint16_t value = RISCV_CPU(obj)->cfg.cboz_blocksize; 2229 2230 visit_type_uint16(v, name, &value, errp); 2231 } 2232 2233 static const PropertyInfo prop_cboz_blksize = { 2234 .type = "uint16", 2235 .description = "cboz_blocksize", 2236 .get = prop_cboz_blksize_get, 2237 .set = prop_cboz_blksize_set, 2238 }; 2239 2240 static void prop_mvendorid_set(Object *obj, Visitor *v, const char *name, 2241 void *opaque, Error **errp) 2242 { 2243 bool dynamic_cpu = riscv_cpu_is_dynamic(obj); 2244 RISCVCPU *cpu = RISCV_CPU(obj); 2245 uint32_t prev_val = cpu->cfg.mvendorid; 2246 uint32_t value; 2247 2248 if (!visit_type_uint32(v, name, &value, errp)) { 2249 return; 2250 } 2251 2252 if (!dynamic_cpu && prev_val != value) { 2253 error_setg(errp, "Unable to change %s mvendorid (0x%x)", 2254 object_get_typename(obj), prev_val); 2255 return; 2256 } 2257 2258 cpu->cfg.mvendorid = value; 2259 } 2260 2261 static void prop_mvendorid_get(Object *obj, Visitor *v, const char *name, 2262 void *opaque, Error **errp) 2263 { 2264 uint32_t value = RISCV_CPU(obj)->cfg.mvendorid; 2265 2266 visit_type_uint32(v, name, &value, errp); 2267 } 2268 2269 static const PropertyInfo prop_mvendorid = { 2270 .type = "uint32", 2271 .description = "mvendorid", 2272 .get = prop_mvendorid_get, 2273 .set = prop_mvendorid_set, 2274 }; 2275 2276 static void prop_mimpid_set(Object *obj, Visitor *v, const char *name, 2277 void *opaque, Error **errp) 2278 { 2279 bool dynamic_cpu = riscv_cpu_is_dynamic(obj); 2280 RISCVCPU *cpu = RISCV_CPU(obj); 2281 uint64_t prev_val = cpu->cfg.mimpid; 2282 uint64_t value; 2283 2284 if (!visit_type_uint64(v, name, &value, errp)) { 2285 return; 2286 } 2287 2288 if (!dynamic_cpu && prev_val != value) { 2289 error_setg(errp, "Unable to change %s mimpid (0x%" PRIu64 ")", 2290 object_get_typename(obj), prev_val); 2291 return; 2292 } 2293 2294 cpu->cfg.mimpid = value; 2295 } 2296 2297 static void prop_mimpid_get(Object *obj, Visitor *v, const char *name, 2298 void *opaque, Error **errp) 2299 { 2300 uint64_t value = RISCV_CPU(obj)->cfg.mimpid; 2301 2302 visit_type_uint64(v, name, &value, errp); 2303 } 2304 2305 static const PropertyInfo prop_mimpid = { 2306 .type = "uint64", 2307 .description = "mimpid", 2308 .get = prop_mimpid_get, 2309 .set = prop_mimpid_set, 2310 }; 2311 2312 static void prop_marchid_set(Object *obj, Visitor *v, const char *name, 2313 void *opaque, Error **errp) 2314 { 2315 bool dynamic_cpu = riscv_cpu_is_dynamic(obj); 2316 RISCVCPU *cpu = RISCV_CPU(obj); 2317 uint64_t prev_val = cpu->cfg.marchid; 2318 uint64_t value, invalid_val; 2319 uint32_t mxlen = 0; 2320 2321 if (!visit_type_uint64(v, name, &value, errp)) { 2322 return; 2323 } 2324 2325 if (!dynamic_cpu && prev_val != value) { 2326 error_setg(errp, "Unable to change %s marchid (0x%" PRIu64 ")", 2327 object_get_typename(obj), prev_val); 2328 return; 2329 } 2330 2331 switch (riscv_cpu_mxl(&cpu->env)) { 2332 case MXL_RV32: 2333 mxlen = 32; 2334 break; 2335 case MXL_RV64: 2336 case MXL_RV128: 2337 mxlen = 64; 2338 break; 2339 default: 2340 g_assert_not_reached(); 2341 } 2342 2343 invalid_val = 1LL << (mxlen - 1); 2344 2345 if (value == invalid_val) { 2346 error_setg(errp, "Unable to set marchid with MSB (%u) bit set " 2347 "and the remaining bits zero", mxlen); 2348 return; 2349 } 2350 2351 cpu->cfg.marchid = value; 2352 } 2353 2354 static void prop_marchid_get(Object *obj, Visitor *v, const char *name, 2355 void *opaque, Error **errp) 2356 { 2357 uint64_t value = RISCV_CPU(obj)->cfg.marchid; 2358 2359 visit_type_uint64(v, name, &value, errp); 2360 } 2361 2362 static const PropertyInfo prop_marchid = { 2363 .type = "uint64", 2364 .description = "marchid", 2365 .get = prop_marchid_get, 2366 .set = prop_marchid_set, 2367 }; 2368 2369 /* 2370 * RVA22U64 defines some 'named features' that are cache 2371 * related: Za64rs, Zic64b, Ziccif, Ziccrse, Ziccamoa 2372 * and Zicclsm. They are always implemented in TCG and 2373 * doesn't need to be manually enabled by the profile. 2374 */ 2375 static RISCVCPUProfile RVA22U64 = { 2376 .u_parent = NULL, 2377 .s_parent = NULL, 2378 .name = "rva22u64", 2379 .misa_ext = RVI | RVM | RVA | RVF | RVD | RVC | RVB | RVU, 2380 .priv_spec = RISCV_PROFILE_ATTR_UNUSED, 2381 .satp_mode = RISCV_PROFILE_ATTR_UNUSED, 2382 .ext_offsets = { 2383 CPU_CFG_OFFSET(ext_zicsr), CPU_CFG_OFFSET(ext_zihintpause), 2384 CPU_CFG_OFFSET(ext_zba), CPU_CFG_OFFSET(ext_zbb), 2385 CPU_CFG_OFFSET(ext_zbs), CPU_CFG_OFFSET(ext_zfhmin), 2386 CPU_CFG_OFFSET(ext_zkt), CPU_CFG_OFFSET(ext_zicntr), 2387 CPU_CFG_OFFSET(ext_zihpm), CPU_CFG_OFFSET(ext_zicbom), 2388 CPU_CFG_OFFSET(ext_zicbop), CPU_CFG_OFFSET(ext_zicboz), 2389 2390 /* mandatory named features for this profile */ 2391 CPU_CFG_OFFSET(ext_zic64b), 2392 2393 RISCV_PROFILE_EXT_LIST_END 2394 } 2395 }; 2396 2397 /* 2398 * As with RVA22U64, RVA22S64 also defines 'named features'. 2399 * 2400 * Cache related features that we consider enabled since we don't 2401 * implement cache: Ssccptr 2402 * 2403 * Other named features that we already implement: Sstvecd, Sstvala, 2404 * Sscounterenw 2405 * 2406 * The remaining features/extensions comes from RVA22U64. 2407 */ 2408 static RISCVCPUProfile RVA22S64 = { 2409 .u_parent = &RVA22U64, 2410 .s_parent = NULL, 2411 .name = "rva22s64", 2412 .misa_ext = RVS, 2413 .priv_spec = PRIV_VERSION_1_12_0, 2414 .satp_mode = VM_1_10_SV39, 2415 .ext_offsets = { 2416 /* rva22s64 exts */ 2417 CPU_CFG_OFFSET(ext_zifencei), CPU_CFG_OFFSET(ext_svpbmt), 2418 CPU_CFG_OFFSET(ext_svinval), CPU_CFG_OFFSET(ext_svade), 2419 2420 RISCV_PROFILE_EXT_LIST_END 2421 } 2422 }; 2423 2424 /* 2425 * All mandatory extensions from RVA22U64 are present 2426 * in RVA23U64 so set RVA22 as a parent. We need to 2427 * declare just the newly added mandatory extensions. 2428 */ 2429 static RISCVCPUProfile RVA23U64 = { 2430 .u_parent = &RVA22U64, 2431 .s_parent = NULL, 2432 .name = "rva23u64", 2433 .misa_ext = RVV, 2434 .priv_spec = RISCV_PROFILE_ATTR_UNUSED, 2435 .satp_mode = RISCV_PROFILE_ATTR_UNUSED, 2436 .ext_offsets = { 2437 CPU_CFG_OFFSET(ext_zvfhmin), CPU_CFG_OFFSET(ext_zvbb), 2438 CPU_CFG_OFFSET(ext_zvkt), CPU_CFG_OFFSET(ext_zihintntl), 2439 CPU_CFG_OFFSET(ext_zicond), CPU_CFG_OFFSET(ext_zimop), 2440 CPU_CFG_OFFSET(ext_zcmop), CPU_CFG_OFFSET(ext_zcb), 2441 CPU_CFG_OFFSET(ext_zfa), CPU_CFG_OFFSET(ext_zawrs), 2442 CPU_CFG_OFFSET(ext_supm), 2443 2444 RISCV_PROFILE_EXT_LIST_END 2445 } 2446 }; 2447 2448 /* 2449 * As with RVA23U64, RVA23S64 also defines 'named features'. 2450 * 2451 * Cache related features that we consider enabled since we don't 2452 * implement cache: Ssccptr 2453 * 2454 * Other named features that we already implement: Sstvecd, Sstvala, 2455 * Sscounterenw, Ssu64xl 2456 * 2457 * The remaining features/extensions comes from RVA23S64. 2458 */ 2459 static RISCVCPUProfile RVA23S64 = { 2460 .u_parent = &RVA23U64, 2461 .s_parent = &RVA22S64, 2462 .name = "rva23s64", 2463 .misa_ext = RVS, 2464 .priv_spec = PRIV_VERSION_1_13_0, 2465 .satp_mode = VM_1_10_SV39, 2466 .ext_offsets = { 2467 /* New in RVA23S64 */ 2468 CPU_CFG_OFFSET(ext_svnapot), CPU_CFG_OFFSET(ext_sstc), 2469 CPU_CFG_OFFSET(ext_sscofpmf), CPU_CFG_OFFSET(ext_ssnpm), 2470 2471 /* Named features: Sha */ 2472 CPU_CFG_OFFSET(ext_sha), 2473 2474 RISCV_PROFILE_EXT_LIST_END 2475 } 2476 }; 2477 2478 RISCVCPUProfile *riscv_profiles[] = { 2479 &RVA22U64, 2480 &RVA22S64, 2481 &RVA23U64, 2482 &RVA23S64, 2483 NULL, 2484 }; 2485 2486 static RISCVCPUImpliedExtsRule RVA_IMPLIED = { 2487 .is_misa = true, 2488 .ext = RVA, 2489 .implied_multi_exts = { 2490 CPU_CFG_OFFSET(ext_zalrsc), CPU_CFG_OFFSET(ext_zaamo), 2491 2492 RISCV_IMPLIED_EXTS_RULE_END 2493 }, 2494 }; 2495 2496 static RISCVCPUImpliedExtsRule RVD_IMPLIED = { 2497 .is_misa = true, 2498 .ext = RVD, 2499 .implied_misa_exts = RVF, 2500 .implied_multi_exts = { RISCV_IMPLIED_EXTS_RULE_END }, 2501 }; 2502 2503 static RISCVCPUImpliedExtsRule RVF_IMPLIED = { 2504 .is_misa = true, 2505 .ext = RVF, 2506 .implied_multi_exts = { 2507 CPU_CFG_OFFSET(ext_zicsr), 2508 2509 RISCV_IMPLIED_EXTS_RULE_END 2510 }, 2511 }; 2512 2513 static RISCVCPUImpliedExtsRule RVM_IMPLIED = { 2514 .is_misa = true, 2515 .ext = RVM, 2516 .implied_multi_exts = { 2517 CPU_CFG_OFFSET(ext_zmmul), 2518 2519 RISCV_IMPLIED_EXTS_RULE_END 2520 }, 2521 }; 2522 2523 static RISCVCPUImpliedExtsRule RVV_IMPLIED = { 2524 .is_misa = true, 2525 .ext = RVV, 2526 .implied_multi_exts = { 2527 CPU_CFG_OFFSET(ext_zve64d), 2528 2529 RISCV_IMPLIED_EXTS_RULE_END 2530 }, 2531 }; 2532 2533 static RISCVCPUImpliedExtsRule ZCB_IMPLIED = { 2534 .ext = CPU_CFG_OFFSET(ext_zcb), 2535 .implied_multi_exts = { 2536 CPU_CFG_OFFSET(ext_zca), 2537 2538 RISCV_IMPLIED_EXTS_RULE_END 2539 }, 2540 }; 2541 2542 static RISCVCPUImpliedExtsRule ZCD_IMPLIED = { 2543 .ext = CPU_CFG_OFFSET(ext_zcd), 2544 .implied_misa_exts = RVD, 2545 .implied_multi_exts = { 2546 CPU_CFG_OFFSET(ext_zca), 2547 2548 RISCV_IMPLIED_EXTS_RULE_END 2549 }, 2550 }; 2551 2552 static RISCVCPUImpliedExtsRule ZCE_IMPLIED = { 2553 .ext = CPU_CFG_OFFSET(ext_zce), 2554 .implied_multi_exts = { 2555 CPU_CFG_OFFSET(ext_zcb), CPU_CFG_OFFSET(ext_zcmp), 2556 CPU_CFG_OFFSET(ext_zcmt), 2557 2558 RISCV_IMPLIED_EXTS_RULE_END 2559 }, 2560 }; 2561 2562 static RISCVCPUImpliedExtsRule ZCF_IMPLIED = { 2563 .ext = CPU_CFG_OFFSET(ext_zcf), 2564 .implied_misa_exts = RVF, 2565 .implied_multi_exts = { 2566 CPU_CFG_OFFSET(ext_zca), 2567 2568 RISCV_IMPLIED_EXTS_RULE_END 2569 }, 2570 }; 2571 2572 static RISCVCPUImpliedExtsRule ZCMP_IMPLIED = { 2573 .ext = CPU_CFG_OFFSET(ext_zcmp), 2574 .implied_multi_exts = { 2575 CPU_CFG_OFFSET(ext_zca), 2576 2577 RISCV_IMPLIED_EXTS_RULE_END 2578 }, 2579 }; 2580 2581 static RISCVCPUImpliedExtsRule ZCMT_IMPLIED = { 2582 .ext = CPU_CFG_OFFSET(ext_zcmt), 2583 .implied_multi_exts = { 2584 CPU_CFG_OFFSET(ext_zca), CPU_CFG_OFFSET(ext_zicsr), 2585 2586 RISCV_IMPLIED_EXTS_RULE_END 2587 }, 2588 }; 2589 2590 static RISCVCPUImpliedExtsRule ZDINX_IMPLIED = { 2591 .ext = CPU_CFG_OFFSET(ext_zdinx), 2592 .implied_multi_exts = { 2593 CPU_CFG_OFFSET(ext_zfinx), 2594 2595 RISCV_IMPLIED_EXTS_RULE_END 2596 }, 2597 }; 2598 2599 static RISCVCPUImpliedExtsRule ZFA_IMPLIED = { 2600 .ext = CPU_CFG_OFFSET(ext_zfa), 2601 .implied_misa_exts = RVF, 2602 .implied_multi_exts = { RISCV_IMPLIED_EXTS_RULE_END }, 2603 }; 2604 2605 static RISCVCPUImpliedExtsRule ZFBFMIN_IMPLIED = { 2606 .ext = CPU_CFG_OFFSET(ext_zfbfmin), 2607 .implied_misa_exts = RVF, 2608 .implied_multi_exts = { RISCV_IMPLIED_EXTS_RULE_END }, 2609 }; 2610 2611 static RISCVCPUImpliedExtsRule ZFH_IMPLIED = { 2612 .ext = CPU_CFG_OFFSET(ext_zfh), 2613 .implied_multi_exts = { 2614 CPU_CFG_OFFSET(ext_zfhmin), 2615 2616 RISCV_IMPLIED_EXTS_RULE_END 2617 }, 2618 }; 2619 2620 static RISCVCPUImpliedExtsRule ZFHMIN_IMPLIED = { 2621 .ext = CPU_CFG_OFFSET(ext_zfhmin), 2622 .implied_misa_exts = RVF, 2623 .implied_multi_exts = { RISCV_IMPLIED_EXTS_RULE_END }, 2624 }; 2625 2626 static RISCVCPUImpliedExtsRule ZFINX_IMPLIED = { 2627 .ext = CPU_CFG_OFFSET(ext_zfinx), 2628 .implied_multi_exts = { 2629 CPU_CFG_OFFSET(ext_zicsr), 2630 2631 RISCV_IMPLIED_EXTS_RULE_END 2632 }, 2633 }; 2634 2635 static RISCVCPUImpliedExtsRule ZHINX_IMPLIED = { 2636 .ext = CPU_CFG_OFFSET(ext_zhinx), 2637 .implied_multi_exts = { 2638 CPU_CFG_OFFSET(ext_zhinxmin), 2639 2640 RISCV_IMPLIED_EXTS_RULE_END 2641 }, 2642 }; 2643 2644 static RISCVCPUImpliedExtsRule ZHINXMIN_IMPLIED = { 2645 .ext = CPU_CFG_OFFSET(ext_zhinxmin), 2646 .implied_multi_exts = { 2647 CPU_CFG_OFFSET(ext_zfinx), 2648 2649 RISCV_IMPLIED_EXTS_RULE_END 2650 }, 2651 }; 2652 2653 static RISCVCPUImpliedExtsRule ZICNTR_IMPLIED = { 2654 .ext = CPU_CFG_OFFSET(ext_zicntr), 2655 .implied_multi_exts = { 2656 CPU_CFG_OFFSET(ext_zicsr), 2657 2658 RISCV_IMPLIED_EXTS_RULE_END 2659 }, 2660 }; 2661 2662 static RISCVCPUImpliedExtsRule ZIHPM_IMPLIED = { 2663 .ext = CPU_CFG_OFFSET(ext_zihpm), 2664 .implied_multi_exts = { 2665 CPU_CFG_OFFSET(ext_zicsr), 2666 2667 RISCV_IMPLIED_EXTS_RULE_END 2668 }, 2669 }; 2670 2671 static RISCVCPUImpliedExtsRule ZK_IMPLIED = { 2672 .ext = CPU_CFG_OFFSET(ext_zk), 2673 .implied_multi_exts = { 2674 CPU_CFG_OFFSET(ext_zkn), CPU_CFG_OFFSET(ext_zkr), 2675 CPU_CFG_OFFSET(ext_zkt), 2676 2677 RISCV_IMPLIED_EXTS_RULE_END 2678 }, 2679 }; 2680 2681 static RISCVCPUImpliedExtsRule ZKN_IMPLIED = { 2682 .ext = CPU_CFG_OFFSET(ext_zkn), 2683 .implied_multi_exts = { 2684 CPU_CFG_OFFSET(ext_zbkb), CPU_CFG_OFFSET(ext_zbkc), 2685 CPU_CFG_OFFSET(ext_zbkx), CPU_CFG_OFFSET(ext_zkne), 2686 CPU_CFG_OFFSET(ext_zknd), CPU_CFG_OFFSET(ext_zknh), 2687 2688 RISCV_IMPLIED_EXTS_RULE_END 2689 }, 2690 }; 2691 2692 static RISCVCPUImpliedExtsRule ZKS_IMPLIED = { 2693 .ext = CPU_CFG_OFFSET(ext_zks), 2694 .implied_multi_exts = { 2695 CPU_CFG_OFFSET(ext_zbkb), CPU_CFG_OFFSET(ext_zbkc), 2696 CPU_CFG_OFFSET(ext_zbkx), CPU_CFG_OFFSET(ext_zksed), 2697 CPU_CFG_OFFSET(ext_zksh), 2698 2699 RISCV_IMPLIED_EXTS_RULE_END 2700 }, 2701 }; 2702 2703 static RISCVCPUImpliedExtsRule ZVBB_IMPLIED = { 2704 .ext = CPU_CFG_OFFSET(ext_zvbb), 2705 .implied_multi_exts = { 2706 CPU_CFG_OFFSET(ext_zvkb), 2707 2708 RISCV_IMPLIED_EXTS_RULE_END 2709 }, 2710 }; 2711 2712 static RISCVCPUImpliedExtsRule ZVE32F_IMPLIED = { 2713 .ext = CPU_CFG_OFFSET(ext_zve32f), 2714 .implied_misa_exts = RVF, 2715 .implied_multi_exts = { 2716 CPU_CFG_OFFSET(ext_zve32x), 2717 2718 RISCV_IMPLIED_EXTS_RULE_END 2719 }, 2720 }; 2721 2722 static RISCVCPUImpliedExtsRule ZVE32X_IMPLIED = { 2723 .ext = CPU_CFG_OFFSET(ext_zve32x), 2724 .implied_multi_exts = { 2725 CPU_CFG_OFFSET(ext_zicsr), 2726 2727 RISCV_IMPLIED_EXTS_RULE_END 2728 }, 2729 }; 2730 2731 static RISCVCPUImpliedExtsRule ZVE64D_IMPLIED = { 2732 .ext = CPU_CFG_OFFSET(ext_zve64d), 2733 .implied_misa_exts = RVD, 2734 .implied_multi_exts = { 2735 CPU_CFG_OFFSET(ext_zve64f), 2736 2737 RISCV_IMPLIED_EXTS_RULE_END 2738 }, 2739 }; 2740 2741 static RISCVCPUImpliedExtsRule ZVE64F_IMPLIED = { 2742 .ext = CPU_CFG_OFFSET(ext_zve64f), 2743 .implied_misa_exts = RVF, 2744 .implied_multi_exts = { 2745 CPU_CFG_OFFSET(ext_zve32f), CPU_CFG_OFFSET(ext_zve64x), 2746 2747 RISCV_IMPLIED_EXTS_RULE_END 2748 }, 2749 }; 2750 2751 static RISCVCPUImpliedExtsRule ZVE64X_IMPLIED = { 2752 .ext = CPU_CFG_OFFSET(ext_zve64x), 2753 .implied_multi_exts = { 2754 CPU_CFG_OFFSET(ext_zve32x), 2755 2756 RISCV_IMPLIED_EXTS_RULE_END 2757 }, 2758 }; 2759 2760 static RISCVCPUImpliedExtsRule ZVFBFMIN_IMPLIED = { 2761 .ext = CPU_CFG_OFFSET(ext_zvfbfmin), 2762 .implied_multi_exts = { 2763 CPU_CFG_OFFSET(ext_zve32f), 2764 2765 RISCV_IMPLIED_EXTS_RULE_END 2766 }, 2767 }; 2768 2769 static RISCVCPUImpliedExtsRule ZVFBFWMA_IMPLIED = { 2770 .ext = CPU_CFG_OFFSET(ext_zvfbfwma), 2771 .implied_multi_exts = { 2772 CPU_CFG_OFFSET(ext_zvfbfmin), CPU_CFG_OFFSET(ext_zfbfmin), 2773 2774 RISCV_IMPLIED_EXTS_RULE_END 2775 }, 2776 }; 2777 2778 static RISCVCPUImpliedExtsRule ZVFH_IMPLIED = { 2779 .ext = CPU_CFG_OFFSET(ext_zvfh), 2780 .implied_multi_exts = { 2781 CPU_CFG_OFFSET(ext_zvfhmin), CPU_CFG_OFFSET(ext_zfhmin), 2782 2783 RISCV_IMPLIED_EXTS_RULE_END 2784 }, 2785 }; 2786 2787 static RISCVCPUImpliedExtsRule ZVFHMIN_IMPLIED = { 2788 .ext = CPU_CFG_OFFSET(ext_zvfhmin), 2789 .implied_multi_exts = { 2790 CPU_CFG_OFFSET(ext_zve32f), 2791 2792 RISCV_IMPLIED_EXTS_RULE_END 2793 }, 2794 }; 2795 2796 static RISCVCPUImpliedExtsRule ZVKN_IMPLIED = { 2797 .ext = CPU_CFG_OFFSET(ext_zvkn), 2798 .implied_multi_exts = { 2799 CPU_CFG_OFFSET(ext_zvkned), CPU_CFG_OFFSET(ext_zvknhb), 2800 CPU_CFG_OFFSET(ext_zvkb), CPU_CFG_OFFSET(ext_zvkt), 2801 2802 RISCV_IMPLIED_EXTS_RULE_END 2803 }, 2804 }; 2805 2806 static RISCVCPUImpliedExtsRule ZVKNC_IMPLIED = { 2807 .ext = CPU_CFG_OFFSET(ext_zvknc), 2808 .implied_multi_exts = { 2809 CPU_CFG_OFFSET(ext_zvkn), CPU_CFG_OFFSET(ext_zvbc), 2810 2811 RISCV_IMPLIED_EXTS_RULE_END 2812 }, 2813 }; 2814 2815 static RISCVCPUImpliedExtsRule ZVKNG_IMPLIED = { 2816 .ext = CPU_CFG_OFFSET(ext_zvkng), 2817 .implied_multi_exts = { 2818 CPU_CFG_OFFSET(ext_zvkn), CPU_CFG_OFFSET(ext_zvkg), 2819 2820 RISCV_IMPLIED_EXTS_RULE_END 2821 }, 2822 }; 2823 2824 static RISCVCPUImpliedExtsRule ZVKNHB_IMPLIED = { 2825 .ext = CPU_CFG_OFFSET(ext_zvknhb), 2826 .implied_multi_exts = { 2827 CPU_CFG_OFFSET(ext_zve64x), 2828 2829 RISCV_IMPLIED_EXTS_RULE_END 2830 }, 2831 }; 2832 2833 static RISCVCPUImpliedExtsRule ZVKS_IMPLIED = { 2834 .ext = CPU_CFG_OFFSET(ext_zvks), 2835 .implied_multi_exts = { 2836 CPU_CFG_OFFSET(ext_zvksed), CPU_CFG_OFFSET(ext_zvksh), 2837 CPU_CFG_OFFSET(ext_zvkb), CPU_CFG_OFFSET(ext_zvkt), 2838 2839 RISCV_IMPLIED_EXTS_RULE_END 2840 }, 2841 }; 2842 2843 static RISCVCPUImpliedExtsRule ZVKSC_IMPLIED = { 2844 .ext = CPU_CFG_OFFSET(ext_zvksc), 2845 .implied_multi_exts = { 2846 CPU_CFG_OFFSET(ext_zvks), CPU_CFG_OFFSET(ext_zvbc), 2847 2848 RISCV_IMPLIED_EXTS_RULE_END 2849 }, 2850 }; 2851 2852 static RISCVCPUImpliedExtsRule ZVKSG_IMPLIED = { 2853 .ext = CPU_CFG_OFFSET(ext_zvksg), 2854 .implied_multi_exts = { 2855 CPU_CFG_OFFSET(ext_zvks), CPU_CFG_OFFSET(ext_zvkg), 2856 2857 RISCV_IMPLIED_EXTS_RULE_END 2858 }, 2859 }; 2860 2861 static RISCVCPUImpliedExtsRule SSCFG_IMPLIED = { 2862 .ext = CPU_CFG_OFFSET(ext_ssccfg), 2863 .implied_multi_exts = { 2864 CPU_CFG_OFFSET(ext_smcsrind), CPU_CFG_OFFSET(ext_sscsrind), 2865 CPU_CFG_OFFSET(ext_smcdeleg), 2866 2867 RISCV_IMPLIED_EXTS_RULE_END 2868 }, 2869 }; 2870 2871 static RISCVCPUImpliedExtsRule SUPM_IMPLIED = { 2872 .ext = CPU_CFG_OFFSET(ext_supm), 2873 .implied_multi_exts = { 2874 CPU_CFG_OFFSET(ext_ssnpm), CPU_CFG_OFFSET(ext_smnpm), 2875 2876 RISCV_IMPLIED_EXTS_RULE_END 2877 }, 2878 }; 2879 2880 static RISCVCPUImpliedExtsRule SSPM_IMPLIED = { 2881 .ext = CPU_CFG_OFFSET(ext_sspm), 2882 .implied_multi_exts = { 2883 CPU_CFG_OFFSET(ext_smnpm), 2884 2885 RISCV_IMPLIED_EXTS_RULE_END 2886 }, 2887 }; 2888 2889 static RISCVCPUImpliedExtsRule SMCTR_IMPLIED = { 2890 .ext = CPU_CFG_OFFSET(ext_smctr), 2891 .implied_misa_exts = RVS, 2892 .implied_multi_exts = { 2893 CPU_CFG_OFFSET(ext_sscsrind), 2894 2895 RISCV_IMPLIED_EXTS_RULE_END 2896 }, 2897 }; 2898 2899 static RISCVCPUImpliedExtsRule SSCTR_IMPLIED = { 2900 .ext = CPU_CFG_OFFSET(ext_ssctr), 2901 .implied_misa_exts = RVS, 2902 .implied_multi_exts = { 2903 CPU_CFG_OFFSET(ext_sscsrind), 2904 2905 RISCV_IMPLIED_EXTS_RULE_END 2906 }, 2907 }; 2908 2909 RISCVCPUImpliedExtsRule *riscv_misa_ext_implied_rules[] = { 2910 &RVA_IMPLIED, &RVD_IMPLIED, &RVF_IMPLIED, 2911 &RVM_IMPLIED, &RVV_IMPLIED, NULL 2912 }; 2913 2914 RISCVCPUImpliedExtsRule *riscv_multi_ext_implied_rules[] = { 2915 &ZCB_IMPLIED, &ZCD_IMPLIED, &ZCE_IMPLIED, 2916 &ZCF_IMPLIED, &ZCMP_IMPLIED, &ZCMT_IMPLIED, 2917 &ZDINX_IMPLIED, &ZFA_IMPLIED, &ZFBFMIN_IMPLIED, 2918 &ZFH_IMPLIED, &ZFHMIN_IMPLIED, &ZFINX_IMPLIED, 2919 &ZHINX_IMPLIED, &ZHINXMIN_IMPLIED, &ZICNTR_IMPLIED, 2920 &ZIHPM_IMPLIED, &ZK_IMPLIED, &ZKN_IMPLIED, 2921 &ZKS_IMPLIED, &ZVBB_IMPLIED, &ZVE32F_IMPLIED, 2922 &ZVE32X_IMPLIED, &ZVE64D_IMPLIED, &ZVE64F_IMPLIED, 2923 &ZVE64X_IMPLIED, &ZVFBFMIN_IMPLIED, &ZVFBFWMA_IMPLIED, 2924 &ZVFH_IMPLIED, &ZVFHMIN_IMPLIED, &ZVKN_IMPLIED, 2925 &ZVKNC_IMPLIED, &ZVKNG_IMPLIED, &ZVKNHB_IMPLIED, 2926 &ZVKS_IMPLIED, &ZVKSC_IMPLIED, &ZVKSG_IMPLIED, &SSCFG_IMPLIED, 2927 &SUPM_IMPLIED, &SSPM_IMPLIED, &SMCTR_IMPLIED, &SSCTR_IMPLIED, 2928 NULL 2929 }; 2930 2931 static const Property riscv_cpu_properties[] = { 2932 DEFINE_PROP_BOOL("debug", RISCVCPU, cfg.debug, true), 2933 2934 {.name = "pmu-mask", .info = &prop_pmu_mask}, 2935 {.name = "pmu-num", .info = &prop_pmu_num}, /* Deprecated */ 2936 2937 {.name = "mmu", .info = &prop_mmu}, 2938 {.name = "pmp", .info = &prop_pmp}, 2939 2940 {.name = "priv_spec", .info = &prop_priv_spec}, 2941 {.name = "vext_spec", .info = &prop_vext_spec}, 2942 2943 {.name = "vlen", .info = &prop_vlen}, 2944 {.name = "elen", .info = &prop_elen}, 2945 2946 {.name = "cbom_blocksize", .info = &prop_cbom_blksize}, 2947 {.name = "cbop_blocksize", .info = &prop_cbop_blksize}, 2948 {.name = "cboz_blocksize", .info = &prop_cboz_blksize}, 2949 2950 {.name = "mvendorid", .info = &prop_mvendorid}, 2951 {.name = "mimpid", .info = &prop_mimpid}, 2952 {.name = "marchid", .info = &prop_marchid}, 2953 2954 #ifndef CONFIG_USER_ONLY 2955 DEFINE_PROP_UINT64("resetvec", RISCVCPU, env.resetvec, DEFAULT_RSTVEC), 2956 DEFINE_PROP_UINT64("rnmi-interrupt-vector", RISCVCPU, env.rnmi_irqvec, 2957 DEFAULT_RNMI_IRQVEC), 2958 DEFINE_PROP_UINT64("rnmi-exception-vector", RISCVCPU, env.rnmi_excpvec, 2959 DEFAULT_RNMI_EXCPVEC), 2960 #endif 2961 2962 DEFINE_PROP_BOOL("short-isa-string", RISCVCPU, cfg.short_isa_string, false), 2963 2964 DEFINE_PROP_BOOL("rvv_ta_all_1s", RISCVCPU, cfg.rvv_ta_all_1s, false), 2965 DEFINE_PROP_BOOL("rvv_ma_all_1s", RISCVCPU, cfg.rvv_ma_all_1s, false), 2966 DEFINE_PROP_BOOL("rvv_vl_half_avl", RISCVCPU, cfg.rvv_vl_half_avl, false), 2967 2968 /* 2969 * write_misa() is marked as experimental for now so mark 2970 * it with -x and default to 'false'. 2971 */ 2972 DEFINE_PROP_BOOL("x-misa-w", RISCVCPU, cfg.misa_w, false), 2973 }; 2974 2975 #if defined(TARGET_RISCV64) 2976 static void rva22u64_profile_cpu_init(Object *obj) 2977 { 2978 rv64i_bare_cpu_init(obj); 2979 2980 RVA22U64.enabled = true; 2981 } 2982 2983 static void rva22s64_profile_cpu_init(Object *obj) 2984 { 2985 rv64i_bare_cpu_init(obj); 2986 2987 RVA22S64.enabled = true; 2988 } 2989 2990 static void rva23u64_profile_cpu_init(Object *obj) 2991 { 2992 rv64i_bare_cpu_init(obj); 2993 2994 RVA23U64.enabled = true; 2995 } 2996 2997 static void rva23s64_profile_cpu_init(Object *obj) 2998 { 2999 rv64i_bare_cpu_init(obj); 3000 3001 RVA23S64.enabled = true; 3002 } 3003 #endif 3004 3005 static const gchar *riscv_gdb_arch_name(CPUState *cs) 3006 { 3007 RISCVCPU *cpu = RISCV_CPU(cs); 3008 CPURISCVState *env = &cpu->env; 3009 3010 switch (riscv_cpu_mxl(env)) { 3011 case MXL_RV32: 3012 return "riscv:rv32"; 3013 case MXL_RV64: 3014 case MXL_RV128: 3015 return "riscv:rv64"; 3016 default: 3017 g_assert_not_reached(); 3018 } 3019 } 3020 3021 #ifndef CONFIG_USER_ONLY 3022 static int64_t riscv_get_arch_id(CPUState *cs) 3023 { 3024 RISCVCPU *cpu = RISCV_CPU(cs); 3025 3026 return cpu->env.mhartid; 3027 } 3028 3029 #include "hw/core/sysemu-cpu-ops.h" 3030 3031 static const struct SysemuCPUOps riscv_sysemu_ops = { 3032 .get_phys_page_debug = riscv_cpu_get_phys_page_debug, 3033 .write_elf64_note = riscv_cpu_write_elf64_note, 3034 .write_elf32_note = riscv_cpu_write_elf32_note, 3035 .legacy_vmsd = &vmstate_riscv_cpu, 3036 }; 3037 #endif 3038 3039 static void riscv_cpu_common_class_init(ObjectClass *c, void *data) 3040 { 3041 RISCVCPUClass *mcc = RISCV_CPU_CLASS(c); 3042 CPUClass *cc = CPU_CLASS(c); 3043 DeviceClass *dc = DEVICE_CLASS(c); 3044 ResettableClass *rc = RESETTABLE_CLASS(c); 3045 3046 device_class_set_parent_realize(dc, riscv_cpu_realize, 3047 &mcc->parent_realize); 3048 3049 resettable_class_set_parent_phases(rc, NULL, riscv_cpu_reset_hold, NULL, 3050 &mcc->parent_phases); 3051 3052 cc->class_by_name = riscv_cpu_class_by_name; 3053 cc->has_work = riscv_cpu_has_work; 3054 cc->mmu_index = riscv_cpu_mmu_index; 3055 cc->dump_state = riscv_cpu_dump_state; 3056 cc->set_pc = riscv_cpu_set_pc; 3057 cc->get_pc = riscv_cpu_get_pc; 3058 cc->gdb_read_register = riscv_cpu_gdb_read_register; 3059 cc->gdb_write_register = riscv_cpu_gdb_write_register; 3060 cc->gdb_stop_before_watchpoint = true; 3061 cc->disas_set_info = riscv_cpu_disas_set_info; 3062 #ifndef CONFIG_USER_ONLY 3063 cc->sysemu_ops = &riscv_sysemu_ops; 3064 cc->get_arch_id = riscv_get_arch_id; 3065 #endif 3066 cc->gdb_arch_name = riscv_gdb_arch_name; 3067 3068 device_class_set_props(dc, riscv_cpu_properties); 3069 } 3070 3071 static void riscv_cpu_class_init(ObjectClass *c, void *data) 3072 { 3073 RISCVCPUClass *mcc = RISCV_CPU_CLASS(c); 3074 3075 mcc->misa_mxl_max = (RISCVMXL)GPOINTER_TO_UINT(data); 3076 riscv_cpu_validate_misa_mxl(mcc); 3077 } 3078 3079 static void riscv_isa_string_ext(RISCVCPU *cpu, char **isa_str, 3080 int max_str_len) 3081 { 3082 const RISCVIsaExtData *edata; 3083 char *old = *isa_str; 3084 char *new = *isa_str; 3085 3086 for (edata = isa_edata_arr; edata && edata->name; edata++) { 3087 if (isa_ext_is_enabled(cpu, edata->ext_enable_offset)) { 3088 new = g_strconcat(old, "_", edata->name, NULL); 3089 g_free(old); 3090 old = new; 3091 } 3092 } 3093 3094 *isa_str = new; 3095 } 3096 3097 char *riscv_isa_string(RISCVCPU *cpu) 3098 { 3099 RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(cpu); 3100 int i; 3101 const size_t maxlen = sizeof("rv128") + sizeof(riscv_single_letter_exts); 3102 char *isa_str = g_new(char, maxlen); 3103 int xlen = riscv_cpu_max_xlen(mcc); 3104 char *p = isa_str + snprintf(isa_str, maxlen, "rv%d", xlen); 3105 3106 for (i = 0; i < sizeof(riscv_single_letter_exts) - 1; i++) { 3107 if (cpu->env.misa_ext & RV(riscv_single_letter_exts[i])) { 3108 *p++ = qemu_tolower(riscv_single_letter_exts[i]); 3109 } 3110 } 3111 *p = '\0'; 3112 if (!cpu->cfg.short_isa_string) { 3113 riscv_isa_string_ext(cpu, &isa_str, maxlen); 3114 } 3115 return isa_str; 3116 } 3117 3118 #ifndef CONFIG_USER_ONLY 3119 static char **riscv_isa_extensions_list(RISCVCPU *cpu, int *count) 3120 { 3121 int maxlen = ARRAY_SIZE(riscv_single_letter_exts) + ARRAY_SIZE(isa_edata_arr); 3122 char **extensions = g_new(char *, maxlen); 3123 3124 for (int i = 0; i < sizeof(riscv_single_letter_exts) - 1; i++) { 3125 if (cpu->env.misa_ext & RV(riscv_single_letter_exts[i])) { 3126 extensions[*count] = g_new(char, 2); 3127 snprintf(extensions[*count], 2, "%c", 3128 qemu_tolower(riscv_single_letter_exts[i])); 3129 (*count)++; 3130 } 3131 } 3132 3133 for (const RISCVIsaExtData *edata = isa_edata_arr; edata->name; edata++) { 3134 if (isa_ext_is_enabled(cpu, edata->ext_enable_offset)) { 3135 extensions[*count] = g_strdup(edata->name); 3136 (*count)++; 3137 } 3138 } 3139 3140 return extensions; 3141 } 3142 3143 void riscv_isa_write_fdt(RISCVCPU *cpu, void *fdt, char *nodename) 3144 { 3145 RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(cpu); 3146 const size_t maxlen = sizeof("rv128i"); 3147 g_autofree char *isa_base = g_new(char, maxlen); 3148 g_autofree char *riscv_isa; 3149 char **isa_extensions; 3150 int count = 0; 3151 int xlen = riscv_cpu_max_xlen(mcc); 3152 3153 riscv_isa = riscv_isa_string(cpu); 3154 qemu_fdt_setprop_string(fdt, nodename, "riscv,isa", riscv_isa); 3155 3156 snprintf(isa_base, maxlen, "rv%di", xlen); 3157 qemu_fdt_setprop_string(fdt, nodename, "riscv,isa-base", isa_base); 3158 3159 isa_extensions = riscv_isa_extensions_list(cpu, &count); 3160 qemu_fdt_setprop_string_array(fdt, nodename, "riscv,isa-extensions", 3161 isa_extensions, count); 3162 3163 for (int i = 0; i < count; i++) { 3164 g_free(isa_extensions[i]); 3165 } 3166 3167 g_free(isa_extensions); 3168 } 3169 #endif 3170 3171 #define DEFINE_DYNAMIC_CPU(type_name, misa_mxl_max, initfn) \ 3172 { \ 3173 .name = (type_name), \ 3174 .parent = TYPE_RISCV_DYNAMIC_CPU, \ 3175 .instance_init = (initfn), \ 3176 .class_init = riscv_cpu_class_init, \ 3177 .class_data = GUINT_TO_POINTER(misa_mxl_max) \ 3178 } 3179 3180 #define DEFINE_VENDOR_CPU(type_name, misa_mxl_max, initfn) \ 3181 { \ 3182 .name = (type_name), \ 3183 .parent = TYPE_RISCV_VENDOR_CPU, \ 3184 .instance_init = (initfn), \ 3185 .class_init = riscv_cpu_class_init, \ 3186 .class_data = GUINT_TO_POINTER(misa_mxl_max) \ 3187 } 3188 3189 #define DEFINE_BARE_CPU(type_name, misa_mxl_max, initfn) \ 3190 { \ 3191 .name = (type_name), \ 3192 .parent = TYPE_RISCV_BARE_CPU, \ 3193 .instance_init = (initfn), \ 3194 .class_init = riscv_cpu_class_init, \ 3195 .class_data = GUINT_TO_POINTER(misa_mxl_max) \ 3196 } 3197 3198 #define DEFINE_PROFILE_CPU(type_name, misa_mxl_max, initfn) \ 3199 { \ 3200 .name = (type_name), \ 3201 .parent = TYPE_RISCV_BARE_CPU, \ 3202 .instance_init = (initfn), \ 3203 .class_init = riscv_cpu_class_init, \ 3204 .class_data = GUINT_TO_POINTER(misa_mxl_max) \ 3205 } 3206 3207 static const TypeInfo riscv_cpu_type_infos[] = { 3208 { 3209 .name = TYPE_RISCV_CPU, 3210 .parent = TYPE_CPU, 3211 .instance_size = sizeof(RISCVCPU), 3212 .instance_align = __alignof(RISCVCPU), 3213 .instance_init = riscv_cpu_init, 3214 .instance_post_init = riscv_cpu_post_init, 3215 .abstract = true, 3216 .class_size = sizeof(RISCVCPUClass), 3217 .class_init = riscv_cpu_common_class_init, 3218 }, 3219 { 3220 .name = TYPE_RISCV_DYNAMIC_CPU, 3221 .parent = TYPE_RISCV_CPU, 3222 .abstract = true, 3223 }, 3224 { 3225 .name = TYPE_RISCV_VENDOR_CPU, 3226 .parent = TYPE_RISCV_CPU, 3227 .abstract = true, 3228 }, 3229 { 3230 .name = TYPE_RISCV_BARE_CPU, 3231 .parent = TYPE_RISCV_CPU, 3232 .instance_init = riscv_bare_cpu_init, 3233 .abstract = true, 3234 }, 3235 #if defined(TARGET_RISCV32) 3236 DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_MAX, MXL_RV32, riscv_max_cpu_init), 3237 #elif defined(TARGET_RISCV64) 3238 DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_MAX, MXL_RV64, riscv_max_cpu_init), 3239 #endif 3240 3241 #if defined(TARGET_RISCV32) || \ 3242 (defined(TARGET_RISCV64) && !defined(CONFIG_USER_ONLY)) 3243 DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_BASE32, MXL_RV32, rv32_base_cpu_init), 3244 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_IBEX, MXL_RV32, rv32_ibex_cpu_init), 3245 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_SIFIVE_E31, MXL_RV32, rv32_sifive_e_cpu_init), 3246 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_SIFIVE_E34, MXL_RV32, rv32_imafcu_nommu_cpu_init), 3247 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_SIFIVE_U34, MXL_RV32, rv32_sifive_u_cpu_init), 3248 DEFINE_BARE_CPU(TYPE_RISCV_CPU_RV32I, MXL_RV32, rv32i_bare_cpu_init), 3249 DEFINE_BARE_CPU(TYPE_RISCV_CPU_RV32E, MXL_RV32, rv32e_bare_cpu_init), 3250 #endif 3251 3252 #if (defined(TARGET_RISCV64) && !defined(CONFIG_USER_ONLY)) 3253 DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_MAX32, MXL_RV32, riscv_max_cpu_init), 3254 #endif 3255 3256 #if defined(TARGET_RISCV64) 3257 DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_BASE64, MXL_RV64, rv64_base_cpu_init), 3258 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_SIFIVE_E51, MXL_RV64, rv64_sifive_e_cpu_init), 3259 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_SIFIVE_U54, MXL_RV64, rv64_sifive_u_cpu_init), 3260 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_SHAKTI_C, MXL_RV64, rv64_sifive_u_cpu_init), 3261 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_THEAD_C906, MXL_RV64, rv64_thead_c906_cpu_init), 3262 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_TT_ASCALON, MXL_RV64, rv64_tt_ascalon_cpu_init), 3263 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_VEYRON_V1, MXL_RV64, rv64_veyron_v1_cpu_init), 3264 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_XIANGSHAN_NANHU, 3265 MXL_RV64, rv64_xiangshan_nanhu_cpu_init), 3266 #ifdef CONFIG_TCG 3267 DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_BASE128, MXL_RV128, rv128_base_cpu_init), 3268 #endif /* CONFIG_TCG */ 3269 DEFINE_BARE_CPU(TYPE_RISCV_CPU_RV64I, MXL_RV64, rv64i_bare_cpu_init), 3270 DEFINE_BARE_CPU(TYPE_RISCV_CPU_RV64E, MXL_RV64, rv64e_bare_cpu_init), 3271 DEFINE_PROFILE_CPU(TYPE_RISCV_CPU_RVA22U64, MXL_RV64, rva22u64_profile_cpu_init), 3272 DEFINE_PROFILE_CPU(TYPE_RISCV_CPU_RVA22S64, MXL_RV64, rva22s64_profile_cpu_init), 3273 DEFINE_PROFILE_CPU(TYPE_RISCV_CPU_RVA23U64, MXL_RV64, rva23u64_profile_cpu_init), 3274 DEFINE_PROFILE_CPU(TYPE_RISCV_CPU_RVA23S64, MXL_RV64, rva23s64_profile_cpu_init), 3275 #endif /* TARGET_RISCV64 */ 3276 }; 3277 3278 DEFINE_TYPES(riscv_cpu_type_infos) 3279