2018-03-02 20:31:10 +08:00
|
|
|
/*
|
|
|
|
* QEMU RISC-V CPU
|
|
|
|
*
|
|
|
|
* Copyright (c) 2016-2017 Sagar Karandikar, sagark@eecs.berkeley.edu
|
|
|
|
* Copyright (c) 2017-2018 SiFive, Inc.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms and conditions of the GNU General Public License,
|
|
|
|
* version 2 or later, as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along with
|
|
|
|
* this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef RISCV_CPU_H
|
|
|
|
#define RISCV_CPU_H
|
|
|
|
|
2019-07-09 23:20:52 +08:00
|
|
|
#include "hw/core/cpu.h"
|
2020-07-01 23:24:52 +08:00
|
|
|
#include "hw/registerfields.h"
|
2018-03-02 20:31:10 +08:00
|
|
|
#include "exec/cpu-defs.h"
|
2019-08-09 00:29:41 +08:00
|
|
|
#include "fpu/softfloat-types.h"
|
2020-09-04 04:43:22 +08:00
|
|
|
#include "qom/object.h"
|
2018-03-02 20:31:10 +08:00
|
|
|
|
2019-03-23 02:51:19 +08:00
|
|
|
#define TCG_GUEST_DEFAULT_MO 0
|
|
|
|
|
2018-03-02 20:31:10 +08:00
|
|
|
#define TYPE_RISCV_CPU "riscv-cpu"
|
|
|
|
|
|
|
|
#define RISCV_CPU_TYPE_SUFFIX "-" TYPE_RISCV_CPU
|
|
|
|
#define RISCV_CPU_TYPE_NAME(name) (name RISCV_CPU_TYPE_SUFFIX)
|
2018-02-07 18:40:25 +08:00
|
|
|
#define CPU_RESOLVING_TYPE TYPE_RISCV_CPU
|
2018-03-02 20:31:10 +08:00
|
|
|
|
|
|
|
#define TYPE_RISCV_CPU_ANY RISCV_CPU_TYPE_NAME("any")
|
2019-04-20 10:24:09 +08:00
|
|
|
#define TYPE_RISCV_CPU_BASE32 RISCV_CPU_TYPE_NAME("rv32")
|
|
|
|
#define TYPE_RISCV_CPU_BASE64 RISCV_CPU_TYPE_NAME("rv64")
|
2020-04-24 01:50:09 +08:00
|
|
|
#define TYPE_RISCV_CPU_IBEX RISCV_CPU_TYPE_NAME("lowrisc-ibex")
|
2021-04-02 02:14:54 +08:00
|
|
|
#define TYPE_RISCV_CPU_SHAKTI_C RISCV_CPU_TYPE_NAME("shakti-c")
|
2018-03-02 20:31:10 +08:00
|
|
|
#define TYPE_RISCV_CPU_SIFIVE_E31 RISCV_CPU_TYPE_NAME("sifive-e31")
|
2020-03-14 03:34:29 +08:00
|
|
|
#define TYPE_RISCV_CPU_SIFIVE_E34 RISCV_CPU_TYPE_NAME("sifive-e34")
|
2018-03-02 20:31:10 +08:00
|
|
|
#define TYPE_RISCV_CPU_SIFIVE_E51 RISCV_CPU_TYPE_NAME("sifive-e51")
|
|
|
|
#define TYPE_RISCV_CPU_SIFIVE_U34 RISCV_CPU_TYPE_NAME("sifive-u34")
|
|
|
|
#define TYPE_RISCV_CPU_SIFIVE_U54 RISCV_CPU_TYPE_NAME("sifive-u54")
|
|
|
|
|
2020-12-17 02:22:29 +08:00
|
|
|
#if defined(TARGET_RISCV32)
|
|
|
|
# define TYPE_RISCV_CPU_BASE TYPE_RISCV_CPU_BASE32
|
|
|
|
#elif defined(TARGET_RISCV64)
|
|
|
|
# define TYPE_RISCV_CPU_BASE TYPE_RISCV_CPU_BASE64
|
|
|
|
#endif
|
|
|
|
|
2018-03-02 20:31:10 +08:00
|
|
|
#define RV32 ((target_ulong)1 << (TARGET_LONG_BITS - 2))
|
|
|
|
#define RV64 ((target_ulong)2 << (TARGET_LONG_BITS - 2))
|
|
|
|
|
|
|
|
#define RV(x) ((target_ulong)1 << (x - 'A'))
|
|
|
|
|
|
|
|
#define RVI RV('I')
|
2018-03-05 08:28:00 +08:00
|
|
|
#define RVE RV('E') /* E and I are mutually exclusive */
|
2018-03-02 20:31:10 +08:00
|
|
|
#define RVM RV('M')
|
|
|
|
#define RVA RV('A')
|
|
|
|
#define RVF RV('F')
|
|
|
|
#define RVD RV('D')
|
2020-07-01 23:24:49 +08:00
|
|
|
#define RVV RV('V')
|
2018-03-02 20:31:10 +08:00
|
|
|
#define RVC RV('C')
|
|
|
|
#define RVS RV('S')
|
|
|
|
#define RVU RV('U')
|
2020-02-01 09:01:41 +08:00
|
|
|
#define RVH RV('H')
|
2021-05-06 00:06:03 +08:00
|
|
|
#define RVB RV('B')
|
2018-03-02 20:31:10 +08:00
|
|
|
|
|
|
|
/* S extension denotes that Supervisor mode exists, however it is possible
|
|
|
|
to have a core that support S mode but does not have an MMU and there
|
|
|
|
is currently no bit in misa to indicate whether an MMU exists or not
|
2019-01-05 07:24:14 +08:00
|
|
|
so a cpu features bitfield is required, likewise for optional PMP support */
|
2018-03-02 20:31:10 +08:00
|
|
|
enum {
|
2019-01-05 07:24:14 +08:00
|
|
|
RISCV_FEATURE_MMU,
|
2019-01-15 07:59:00 +08:00
|
|
|
RISCV_FEATURE_PMP,
|
2021-04-19 14:16:44 +08:00
|
|
|
RISCV_FEATURE_EPMP,
|
2019-01-15 07:59:00 +08:00
|
|
|
RISCV_FEATURE_MISA
|
2018-03-02 20:31:10 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
#define PRIV_VERSION_1_10_0 0x00011000
|
2019-06-18 09:31:05 +08:00
|
|
|
#define PRIV_VERSION_1_11_0 0x00011100
|
2018-03-02 20:31:10 +08:00
|
|
|
|
2021-05-06 00:06:18 +08:00
|
|
|
#define BEXT_VERSION_0_93_0 0x00009300
|
2020-07-01 23:24:50 +08:00
|
|
|
#define VEXT_VERSION_0_07_1 0x00000701
|
|
|
|
|
2020-10-14 18:17:28 +08:00
|
|
|
enum {
|
|
|
|
TRANSLATE_SUCCESS,
|
|
|
|
TRANSLATE_FAIL,
|
|
|
|
TRANSLATE_PMP_FAIL,
|
|
|
|
TRANSLATE_G_STAGE_FAIL
|
|
|
|
};
|
|
|
|
|
2018-03-02 20:31:10 +08:00
|
|
|
#define MMU_USER_IDX 3
|
|
|
|
|
|
|
|
#define MAX_RISCV_PMPS (16)
|
|
|
|
|
|
|
|
typedef struct CPURISCVState CPURISCVState;
|
|
|
|
|
2021-05-17 04:53:33 +08:00
|
|
|
#if !defined(CONFIG_USER_ONLY)
|
2018-03-02 20:31:10 +08:00
|
|
|
#include "pmp.h"
|
2021-05-17 04:53:33 +08:00
|
|
|
#endif
|
2018-03-02 20:31:10 +08:00
|
|
|
|
2020-07-01 23:25:49 +08:00
|
|
|
#define RV_VLEN_MAX 256
|
2020-07-01 23:24:49 +08:00
|
|
|
|
2020-07-01 23:24:52 +08:00
|
|
|
FIELD(VTYPE, VLMUL, 0, 2)
|
|
|
|
FIELD(VTYPE, VSEW, 2, 3)
|
|
|
|
FIELD(VTYPE, VEDIV, 5, 2)
|
|
|
|
FIELD(VTYPE, RESERVED, 7, sizeof(target_ulong) * 8 - 9)
|
2020-07-10 18:48:18 +08:00
|
|
|
FIELD(VTYPE, VILL, sizeof(target_ulong) * 8 - 1, 1)
|
2020-07-01 23:24:52 +08:00
|
|
|
|
2018-03-02 20:31:10 +08:00
|
|
|
struct CPURISCVState {
|
|
|
|
target_ulong gpr[32];
|
|
|
|
uint64_t fpr[32]; /* assume both F and D extensions */
|
2020-07-01 23:24:49 +08:00
|
|
|
|
|
|
|
/* vector coprocessor state. */
|
|
|
|
uint64_t vreg[32 * RV_VLEN_MAX / 64] QEMU_ALIGNED(16);
|
|
|
|
target_ulong vxrm;
|
|
|
|
target_ulong vxsat;
|
|
|
|
target_ulong vl;
|
|
|
|
target_ulong vstart;
|
|
|
|
target_ulong vtype;
|
|
|
|
|
2018-03-02 20:31:10 +08:00
|
|
|
target_ulong pc;
|
|
|
|
target_ulong load_res;
|
|
|
|
target_ulong load_val;
|
|
|
|
|
|
|
|
target_ulong frm;
|
|
|
|
|
|
|
|
target_ulong badaddr;
|
2020-02-01 09:02:56 +08:00
|
|
|
target_ulong guest_phys_fault_addr;
|
2018-03-02 20:31:10 +08:00
|
|
|
|
|
|
|
target_ulong priv_ver;
|
2021-05-06 00:06:18 +08:00
|
|
|
target_ulong bext_ver;
|
2020-07-01 23:24:50 +08:00
|
|
|
target_ulong vext_ver;
|
2018-03-02 20:31:10 +08:00
|
|
|
target_ulong misa;
|
2019-01-15 07:59:00 +08:00
|
|
|
target_ulong misa_mask;
|
2018-03-02 20:31:10 +08:00
|
|
|
|
|
|
|
uint32_t features;
|
|
|
|
|
2019-03-16 09:20:46 +08:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
|
|
|
uint32_t elf_flags;
|
|
|
|
#endif
|
|
|
|
|
2018-03-02 20:31:10 +08:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
target_ulong priv;
|
2020-02-01 09:01:51 +08:00
|
|
|
/* This contains QEMU specific information about the virt state. */
|
|
|
|
target_ulong virt;
|
2018-03-02 20:31:10 +08:00
|
|
|
target_ulong resetvec;
|
|
|
|
|
|
|
|
target_ulong mhartid;
|
2020-10-26 19:55:25 +08:00
|
|
|
/*
|
|
|
|
* For RV32 this is 32-bit mstatus and 32-bit mstatush.
|
|
|
|
* For RV64 this is a 64-bit mstatus.
|
|
|
|
*/
|
|
|
|
uint64_t mstatus;
|
2018-04-09 05:25:25 +08:00
|
|
|
|
2020-02-01 09:01:38 +08:00
|
|
|
target_ulong mip;
|
2020-02-01 09:02:12 +08:00
|
|
|
|
2019-03-16 09:20:20 +08:00
|
|
|
uint32_t miclaim;
|
2018-04-09 05:25:25 +08:00
|
|
|
|
2018-03-02 20:31:10 +08:00
|
|
|
target_ulong mie;
|
|
|
|
target_ulong mideleg;
|
|
|
|
|
|
|
|
target_ulong satp; /* since: priv-1.10.0 */
|
2021-03-20 03:45:29 +08:00
|
|
|
target_ulong stval;
|
2018-03-02 20:31:10 +08:00
|
|
|
target_ulong medeleg;
|
|
|
|
|
|
|
|
target_ulong stvec;
|
|
|
|
target_ulong sepc;
|
|
|
|
target_ulong scause;
|
|
|
|
|
|
|
|
target_ulong mtvec;
|
|
|
|
target_ulong mepc;
|
|
|
|
target_ulong mcause;
|
|
|
|
target_ulong mtval; /* since: priv-1.10.0 */
|
|
|
|
|
2020-02-01 09:01:43 +08:00
|
|
|
/* Hypervisor CSRs */
|
|
|
|
target_ulong hstatus;
|
|
|
|
target_ulong hedeleg;
|
|
|
|
target_ulong hideleg;
|
|
|
|
target_ulong hcounteren;
|
|
|
|
target_ulong htval;
|
|
|
|
target_ulong htinst;
|
|
|
|
target_ulong hgatp;
|
2020-02-02 21:42:16 +08:00
|
|
|
uint64_t htimedelta;
|
2020-02-01 09:01:43 +08:00
|
|
|
|
|
|
|
/* Virtual CSRs */
|
2020-10-26 19:55:25 +08:00
|
|
|
/*
|
|
|
|
* For RV32 this is 32-bit vsstatus and 32-bit vsstatush.
|
|
|
|
* For RV64 this is a 64-bit vsstatus.
|
|
|
|
*/
|
|
|
|
uint64_t vsstatus;
|
2020-02-01 09:01:43 +08:00
|
|
|
target_ulong vstvec;
|
|
|
|
target_ulong vsscratch;
|
|
|
|
target_ulong vsepc;
|
|
|
|
target_ulong vscause;
|
|
|
|
target_ulong vstval;
|
|
|
|
target_ulong vsatp;
|
|
|
|
|
|
|
|
target_ulong mtval2;
|
|
|
|
target_ulong mtinst;
|
|
|
|
|
2020-02-01 09:02:12 +08:00
|
|
|
/* HS Backup CSRs */
|
|
|
|
target_ulong stvec_hs;
|
|
|
|
target_ulong sscratch_hs;
|
|
|
|
target_ulong sepc_hs;
|
|
|
|
target_ulong scause_hs;
|
|
|
|
target_ulong stval_hs;
|
|
|
|
target_ulong satp_hs;
|
2020-10-26 19:55:25 +08:00
|
|
|
uint64_t mstatus_hs;
|
2020-02-01 09:02:12 +08:00
|
|
|
|
2021-03-19 22:14:59 +08:00
|
|
|
/* Signals whether the current exception occurred with two-stage address
|
|
|
|
translation active. */
|
|
|
|
bool two_stage_lookup;
|
|
|
|
|
2018-04-09 07:33:05 +08:00
|
|
|
target_ulong scounteren;
|
|
|
|
target_ulong mcounteren;
|
2018-03-02 20:31:10 +08:00
|
|
|
|
|
|
|
target_ulong sscratch;
|
|
|
|
target_ulong mscratch;
|
|
|
|
|
|
|
|
/* temporary htif regs */
|
|
|
|
uint64_t mfromhost;
|
|
|
|
uint64_t mtohost;
|
|
|
|
uint64_t timecmp;
|
|
|
|
|
|
|
|
/* physical memory protection */
|
|
|
|
pmp_table_t pmp_state;
|
2021-04-19 14:16:53 +08:00
|
|
|
target_ulong mseccfg;
|
2019-03-15 18:26:58 +08:00
|
|
|
|
2020-02-02 21:42:16 +08:00
|
|
|
/* machine specific rdtime callback */
|
2020-09-01 09:39:10 +08:00
|
|
|
uint64_t (*rdtime_fn)(uint32_t);
|
|
|
|
uint32_t rdtime_fn_arg;
|
2020-02-02 21:42:16 +08:00
|
|
|
|
2019-03-15 18:26:58 +08:00
|
|
|
/* True if in debugger mode. */
|
|
|
|
bool debugger;
|
2018-03-02 20:31:10 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
float_status fp_status;
|
|
|
|
|
|
|
|
/* Fields from here on are preserved across CPU reset. */
|
|
|
|
QEMUTimer *timer; /* Internal timer */
|
|
|
|
};
|
|
|
|
|
2020-09-01 05:07:37 +08:00
|
|
|
OBJECT_DECLARE_TYPE(RISCVCPU, RISCVCPUClass,
|
qom: Remove module_obj_name parameter from OBJECT_DECLARE* macros
One of the goals of having less boilerplate on QOM declarations
is to avoid human error. Requiring an extra argument that is
never used is an opportunity for mistakes.
Remove the unused argument from OBJECT_DECLARE_TYPE and
OBJECT_DECLARE_SIMPLE_TYPE.
Coccinelle patch used to convert all users of the macros:
@@
declarer name OBJECT_DECLARE_TYPE;
identifier InstanceType, ClassType, lowercase, UPPERCASE;
@@
OBJECT_DECLARE_TYPE(InstanceType, ClassType,
- lowercase,
UPPERCASE);
@@
declarer name OBJECT_DECLARE_SIMPLE_TYPE;
identifier InstanceType, lowercase, UPPERCASE;
@@
OBJECT_DECLARE_SIMPLE_TYPE(InstanceType,
- lowercase,
UPPERCASE);
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: Cédric Le Goater <clg@kaod.org>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Acked-by: Igor Mammedov <imammedo@redhat.com>
Acked-by: Paul Durrant <paul@xen.org>
Acked-by: Thomas Huth <thuth@redhat.com>
Message-Id: <20200916182519.415636-4-ehabkost@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-09-17 02:25:17 +08:00
|
|
|
RISCV_CPU)
|
2018-03-02 20:31:10 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* RISCVCPUClass:
|
|
|
|
* @parent_realize: The parent class' realize handler.
|
|
|
|
* @parent_reset: The parent class' reset handler.
|
|
|
|
*
|
|
|
|
* A RISCV CPU model.
|
|
|
|
*/
|
2020-09-04 04:43:22 +08:00
|
|
|
struct RISCVCPUClass {
|
2018-03-02 20:31:10 +08:00
|
|
|
/*< private >*/
|
|
|
|
CPUClass parent_class;
|
|
|
|
/*< public >*/
|
|
|
|
DeviceRealize parent_realize;
|
cpu: Use DeviceClass reset instead of a special CPUClass reset
The CPUClass has a 'reset' method. This is a legacy from when
TYPE_CPU used not to inherit from TYPE_DEVICE. We don't need it any
more, as we can simply use the TYPE_DEVICE reset. The 'cpu_reset()'
function is kept as the API which most places use to reset a CPU; it
is now a wrapper which calls device_cold_reset() and then the
tracepoint function.
This change should not cause CPU objects to be reset more often
than they are at the moment, because:
* nobody is directly calling device_cold_reset() or
qdev_reset_all() on CPU objects
* no CPU object is on a qbus, so they will not be reset either
by somebody calling qbus_reset_all()/bus_cold_reset(), or
by the main "reset sysbus and everything in the qbus tree"
reset that most devices are reset by
Note that this does not change the need for each machine or whatever
to use qemu_register_reset() to arrange to call cpu_reset() -- that
is necessary because CPU objects are not on any qbus, so they don't
get reset when the qbus tree rooted at the sysbus bus is reset, and
this isn't being changed here.
All the changes to the files under target/ were made using the
included Coccinelle script, except:
(1) the deletion of the now-inaccurate and not terribly useful
"CPUClass::reset" comments was done with a perl one-liner afterwards:
perl -n -i -e '/ CPUClass::reset/ or print' target/*/*.c
(2) this bit of the s390 change was done by hand, because the
Coccinelle script is not sophisticated enough to handle the
parent_reset call being inside another function:
| @@ -96,8 +96,9 @@ static void s390_cpu_reset(CPUState *s, cpu_reset_type type)
| S390CPU *cpu = S390_CPU(s);
| S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
| CPUS390XState *env = &cpu->env;
|+ DeviceState *dev = DEVICE(s);
|
|- scc->parent_reset(s);
|+ scc->parent_reset(dev);
| cpu->env.sigp_order = 0;
| s390_cpu_set_state(S390_CPU_STATE_STOPPED, cpu);
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Message-Id: <20200303100511.5498-1-peter.maydell@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-03-03 18:05:11 +08:00
|
|
|
DeviceReset parent_reset;
|
2020-09-04 04:43:22 +08:00
|
|
|
};
|
2018-03-02 20:31:10 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* RISCVCPU:
|
|
|
|
* @env: #CPURISCVState
|
|
|
|
*
|
|
|
|
* A RISCV CPU.
|
|
|
|
*/
|
2020-09-04 04:43:22 +08:00
|
|
|
struct RISCVCPU {
|
2018-03-02 20:31:10 +08:00
|
|
|
/*< private >*/
|
|
|
|
CPUState parent_obj;
|
|
|
|
/*< public >*/
|
2019-03-23 08:16:06 +08:00
|
|
|
CPUNegativeOffsetState neg;
|
2018-03-02 20:31:10 +08:00
|
|
|
CPURISCVState env;
|
2019-04-20 10:24:01 +08:00
|
|
|
|
2021-01-16 13:41:22 +08:00
|
|
|
char *dyn_csr_xml;
|
|
|
|
|
2019-04-20 10:24:01 +08:00
|
|
|
/* Configuration Settings */
|
|
|
|
struct {
|
2019-05-07 06:49:53 +08:00
|
|
|
bool ext_i;
|
|
|
|
bool ext_e;
|
|
|
|
bool ext_g;
|
|
|
|
bool ext_m;
|
|
|
|
bool ext_a;
|
|
|
|
bool ext_f;
|
|
|
|
bool ext_d;
|
|
|
|
bool ext_c;
|
2021-05-06 00:06:17 +08:00
|
|
|
bool ext_b;
|
2019-05-07 06:49:53 +08:00
|
|
|
bool ext_s;
|
|
|
|
bool ext_u;
|
2020-02-01 09:03:11 +08:00
|
|
|
bool ext_h;
|
2020-07-01 23:25:49 +08:00
|
|
|
bool ext_v;
|
2019-06-18 09:31:22 +08:00
|
|
|
bool ext_counters;
|
2019-06-24 16:59:05 +08:00
|
|
|
bool ext_ifencei;
|
2019-06-24 16:59:51 +08:00
|
|
|
bool ext_icsr;
|
2019-05-07 06:49:53 +08:00
|
|
|
|
2019-04-20 10:24:01 +08:00
|
|
|
char *priv_spec;
|
|
|
|
char *user_spec;
|
2021-05-06 00:06:18 +08:00
|
|
|
char *bext_spec;
|
2020-07-01 23:25:49 +08:00
|
|
|
char *vext_spec;
|
2020-07-01 23:24:50 +08:00
|
|
|
uint16_t vlen;
|
|
|
|
uint16_t elen;
|
2019-04-20 10:24:01 +08:00
|
|
|
bool mmu;
|
|
|
|
bool pmp;
|
2021-04-19 14:17:25 +08:00
|
|
|
bool epmp;
|
2020-09-01 09:38:56 +08:00
|
|
|
uint64_t resetvec;
|
2019-04-20 10:24:01 +08:00
|
|
|
} cfg;
|
2020-09-04 04:43:22 +08:00
|
|
|
};
|
2018-03-02 20:31:10 +08:00
|
|
|
|
|
|
|
static inline int riscv_has_ext(CPURISCVState *env, target_ulong ext)
|
|
|
|
{
|
|
|
|
return (env->misa & ext) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool riscv_feature(CPURISCVState *env, int feature)
|
|
|
|
{
|
|
|
|
return env->features & (1ULL << feature);
|
|
|
|
}
|
|
|
|
|
|
|
|
#include "cpu_user.h"
|
|
|
|
#include "cpu_bits.h"
|
|
|
|
|
|
|
|
extern const char * const riscv_int_regnames[];
|
|
|
|
extern const char * const riscv_fpr_regnames[];
|
|
|
|
|
2020-08-14 11:58:19 +08:00
|
|
|
const char *riscv_cpu_get_trap_name(target_ulong cause, bool async);
|
2018-03-02 20:31:10 +08:00
|
|
|
void riscv_cpu_do_interrupt(CPUState *cpu);
|
2021-02-01 20:44:58 +08:00
|
|
|
int riscv_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs,
|
|
|
|
int cpuid, void *opaque);
|
|
|
|
int riscv_cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cs,
|
|
|
|
int cpuid, void *opaque);
|
2020-03-17 01:21:41 +08:00
|
|
|
int riscv_cpu_gdb_read_register(CPUState *cpu, GByteArray *buf, int reg);
|
2018-03-02 20:31:10 +08:00
|
|
|
int riscv_cpu_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg);
|
2019-07-31 07:35:24 +08:00
|
|
|
bool riscv_cpu_fp_enabled(CPURISCVState *env);
|
2020-02-01 09:01:51 +08:00
|
|
|
bool riscv_cpu_virt_enabled(CPURISCVState *env);
|
|
|
|
void riscv_cpu_set_virt_enabled(CPURISCVState *env, bool enable);
|
2020-02-01 09:01:54 +08:00
|
|
|
bool riscv_cpu_force_hs_excep_enabled(CPURISCVState *env);
|
|
|
|
void riscv_cpu_set_force_hs_excep(CPURISCVState *env, bool enable);
|
2020-11-04 12:43:29 +08:00
|
|
|
bool riscv_cpu_two_stage_lookup(int mmu_idx);
|
2018-03-02 20:31:10 +08:00
|
|
|
int riscv_cpu_mmu_index(CPURISCVState *env, bool ifetch);
|
|
|
|
hwaddr riscv_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);
|
|
|
|
void riscv_cpu_do_unaligned_access(CPUState *cs, vaddr addr,
|
|
|
|
MMUAccessType access_type, int mmu_idx,
|
|
|
|
uintptr_t retaddr);
|
2019-04-02 18:12:38 +08:00
|
|
|
bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size,
|
|
|
|
MMUAccessType access_type, int mmu_idx,
|
|
|
|
bool probe, uintptr_t retaddr);
|
2019-10-09 04:51:52 +08:00
|
|
|
void riscv_cpu_do_transaction_failed(CPUState *cs, hwaddr physaddr,
|
|
|
|
vaddr addr, unsigned size,
|
|
|
|
MMUAccessType access_type,
|
|
|
|
int mmu_idx, MemTxAttrs attrs,
|
|
|
|
MemTxResult response, uintptr_t retaddr);
|
2018-03-02 20:31:10 +08:00
|
|
|
char *riscv_isa_string(RISCVCPU *cpu);
|
2019-04-18 03:17:57 +08:00
|
|
|
void riscv_cpu_list(void);
|
2018-03-02 20:31:10 +08:00
|
|
|
|
|
|
|
#define cpu_list riscv_cpu_list
|
|
|
|
#define cpu_mmu_index riscv_cpu_mmu_index
|
|
|
|
|
2018-04-09 05:25:25 +08:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2021-09-12 00:54:28 +08:00
|
|
|
bool riscv_cpu_exec_interrupt(CPUState *cs, int interrupt_request);
|
2020-02-01 09:02:12 +08:00
|
|
|
void riscv_cpu_swap_hypervisor_regs(CPURISCVState *env);
|
2019-03-16 09:20:20 +08:00
|
|
|
int riscv_cpu_claim_interrupts(RISCVCPU *cpu, uint32_t interrupts);
|
2018-04-09 05:25:25 +08:00
|
|
|
uint32_t riscv_cpu_update_mip(RISCVCPU *cpu, uint32_t mask, uint32_t value);
|
|
|
|
#define BOOL_TO_MASK(x) (-!!(x)) /* helper for riscv_cpu_update_mip value */
|
2020-09-01 09:39:10 +08:00
|
|
|
void riscv_cpu_set_rdtime_fn(CPURISCVState *env, uint64_t (*fn)(uint32_t),
|
|
|
|
uint32_t arg);
|
2018-04-09 05:25:25 +08:00
|
|
|
#endif
|
2019-01-15 07:58:23 +08:00
|
|
|
void riscv_cpu_set_mode(CPURISCVState *env, target_ulong newpriv);
|
2018-03-02 20:31:10 +08:00
|
|
|
|
|
|
|
void riscv_translate_init(void);
|
2019-01-15 07:58:23 +08:00
|
|
|
void QEMU_NORETURN riscv_raise_exception(CPURISCVState *env,
|
|
|
|
uint32_t exception, uintptr_t pc);
|
2018-03-02 20:31:10 +08:00
|
|
|
|
2019-01-15 07:58:23 +08:00
|
|
|
target_ulong riscv_cpu_get_fflags(CPURISCVState *env);
|
|
|
|
void riscv_cpu_set_fflags(CPURISCVState *env, target_ulong);
|
2018-03-02 20:31:10 +08:00
|
|
|
|
2020-11-04 12:43:23 +08:00
|
|
|
#define TB_FLAGS_MMU_MASK 7
|
|
|
|
#define TB_FLAGS_PRIV_MMU_MASK 3
|
|
|
|
#define TB_FLAGS_PRIV_HYP_ACCESS_MASK (1 << 2)
|
2019-01-15 07:57:50 +08:00
|
|
|
#define TB_FLAGS_MSTATUS_FS MSTATUS_FS
|
2018-03-02 20:31:10 +08:00
|
|
|
|
2020-07-01 23:24:52 +08:00
|
|
|
typedef CPURISCVState CPUArchState;
|
|
|
|
typedef RISCVCPU ArchCPU;
|
|
|
|
#include "exec/cpu-all.h"
|
|
|
|
|
|
|
|
FIELD(TB_FLAGS, VL_EQ_VLMAX, 2, 1)
|
|
|
|
FIELD(TB_FLAGS, LMUL, 3, 2)
|
|
|
|
FIELD(TB_FLAGS, SEW, 5, 3)
|
|
|
|
FIELD(TB_FLAGS, VILL, 8, 1)
|
2020-11-04 12:43:31 +08:00
|
|
|
/* Is a Hypervisor instruction load/store allowed? */
|
|
|
|
FIELD(TB_FLAGS, HLSX, 9, 1)
|
2020-07-01 23:24:52 +08:00
|
|
|
|
2020-12-17 02:22:51 +08:00
|
|
|
bool riscv_cpu_is_32bit(CPURISCVState *env);
|
|
|
|
|
2020-07-01 23:24:52 +08:00
|
|
|
/*
|
|
|
|
* A simplification for VLMAX
|
|
|
|
* = (1 << LMUL) * VLEN / (8 * (1 << SEW))
|
|
|
|
* = (VLEN << LMUL) / (8 << SEW)
|
|
|
|
* = (VLEN << LMUL) >> (SEW + 3)
|
|
|
|
* = VLEN >> (SEW + 3 - LMUL)
|
|
|
|
*/
|
|
|
|
static inline uint32_t vext_get_vlmax(RISCVCPU *cpu, target_ulong vtype)
|
|
|
|
{
|
|
|
|
uint8_t sew, lmul;
|
|
|
|
|
|
|
|
sew = FIELD_EX64(vtype, VTYPE, VSEW);
|
|
|
|
lmul = FIELD_EX64(vtype, VTYPE, VLMUL);
|
|
|
|
return cpu->cfg.vlen >> (sew + 3 - lmul);
|
|
|
|
}
|
|
|
|
|
2018-03-02 20:31:10 +08:00
|
|
|
static inline void cpu_get_tb_cpu_state(CPURISCVState *env, target_ulong *pc,
|
2020-07-01 23:24:52 +08:00
|
|
|
target_ulong *cs_base, uint32_t *pflags)
|
2018-03-02 20:31:10 +08:00
|
|
|
{
|
2020-07-01 23:24:52 +08:00
|
|
|
uint32_t flags = 0;
|
|
|
|
|
2018-03-02 20:31:10 +08:00
|
|
|
*pc = env->pc;
|
|
|
|
*cs_base = 0;
|
2020-07-01 23:24:52 +08:00
|
|
|
|
|
|
|
if (riscv_has_ext(env, RVV)) {
|
|
|
|
uint32_t vlmax = vext_get_vlmax(env_archcpu(env), env->vtype);
|
|
|
|
bool vl_eq_vlmax = (env->vstart == 0) && (vlmax == env->vl);
|
|
|
|
flags = FIELD_DP32(flags, TB_FLAGS, VILL,
|
|
|
|
FIELD_EX64(env->vtype, VTYPE, VILL));
|
|
|
|
flags = FIELD_DP32(flags, TB_FLAGS, SEW,
|
|
|
|
FIELD_EX64(env->vtype, VTYPE, VSEW));
|
|
|
|
flags = FIELD_DP32(flags, TB_FLAGS, LMUL,
|
|
|
|
FIELD_EX64(env->vtype, VTYPE, VLMUL));
|
|
|
|
flags = FIELD_DP32(flags, TB_FLAGS, VL_EQ_VLMAX, vl_eq_vlmax);
|
|
|
|
} else {
|
|
|
|
flags = FIELD_DP32(flags, TB_FLAGS, VILL, 1);
|
|
|
|
}
|
|
|
|
|
2018-03-02 20:31:10 +08:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
2020-07-01 23:24:52 +08:00
|
|
|
flags |= TB_FLAGS_MSTATUS_FS;
|
2018-03-02 20:31:10 +08:00
|
|
|
#else
|
2020-07-01 23:24:52 +08:00
|
|
|
flags |= cpu_mmu_index(env, 0);
|
2020-02-01 09:02:41 +08:00
|
|
|
if (riscv_cpu_fp_enabled(env)) {
|
2020-07-01 23:24:52 +08:00
|
|
|
flags |= env->mstatus & MSTATUS_FS;
|
2020-02-01 09:02:41 +08:00
|
|
|
}
|
2020-11-04 12:43:31 +08:00
|
|
|
|
|
|
|
if (riscv_has_ext(env, RVH)) {
|
|
|
|
if (env->priv == PRV_M ||
|
|
|
|
(env->priv == PRV_S && !riscv_cpu_virt_enabled(env)) ||
|
|
|
|
(env->priv == PRV_U && !riscv_cpu_virt_enabled(env) &&
|
|
|
|
get_field(env->hstatus, HSTATUS_HU))) {
|
|
|
|
flags = FIELD_DP32(flags, TB_FLAGS, HLSX, 1);
|
|
|
|
}
|
|
|
|
}
|
2018-03-02 20:31:10 +08:00
|
|
|
#endif
|
2020-11-04 12:43:31 +08:00
|
|
|
|
2020-07-01 23:24:52 +08:00
|
|
|
*pflags = flags;
|
2018-03-02 20:31:10 +08:00
|
|
|
}
|
|
|
|
|
2021-04-01 23:18:07 +08:00
|
|
|
RISCVException riscv_csrrw(CPURISCVState *env, int csrno,
|
|
|
|
target_ulong *ret_value,
|
|
|
|
target_ulong new_value, target_ulong write_mask);
|
|
|
|
RISCVException riscv_csrrw_debug(CPURISCVState *env, int csrno,
|
|
|
|
target_ulong *ret_value,
|
|
|
|
target_ulong new_value,
|
|
|
|
target_ulong write_mask);
|
2019-01-05 07:23:55 +08:00
|
|
|
|
2019-01-15 07:58:23 +08:00
|
|
|
static inline void riscv_csr_write(CPURISCVState *env, int csrno,
|
|
|
|
target_ulong val)
|
2019-01-05 07:23:55 +08:00
|
|
|
{
|
|
|
|
riscv_csrrw(env, csrno, NULL, val, MAKE_64BIT_MASK(0, TARGET_LONG_BITS));
|
|
|
|
}
|
|
|
|
|
2019-01-15 07:58:23 +08:00
|
|
|
static inline target_ulong riscv_csr_read(CPURISCVState *env, int csrno)
|
2019-01-05 07:23:55 +08:00
|
|
|
{
|
|
|
|
target_ulong val = 0;
|
|
|
|
riscv_csrrw(env, csrno, &val, 0, 0);
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2021-04-01 23:17:39 +08:00
|
|
|
typedef RISCVException (*riscv_csr_predicate_fn)(CPURISCVState *env,
|
|
|
|
int csrno);
|
2021-04-01 23:17:57 +08:00
|
|
|
typedef RISCVException (*riscv_csr_read_fn)(CPURISCVState *env, int csrno,
|
|
|
|
target_ulong *ret_value);
|
|
|
|
typedef RISCVException (*riscv_csr_write_fn)(CPURISCVState *env, int csrno,
|
|
|
|
target_ulong new_value);
|
|
|
|
typedef RISCVException (*riscv_csr_op_fn)(CPURISCVState *env, int csrno,
|
|
|
|
target_ulong *ret_value,
|
|
|
|
target_ulong new_value,
|
|
|
|
target_ulong write_mask);
|
2019-01-05 07:23:55 +08:00
|
|
|
|
|
|
|
typedef struct {
|
2021-01-12 12:52:02 +08:00
|
|
|
const char *name;
|
2019-01-05 07:24:14 +08:00
|
|
|
riscv_csr_predicate_fn predicate;
|
2019-01-05 07:23:55 +08:00
|
|
|
riscv_csr_read_fn read;
|
|
|
|
riscv_csr_write_fn write;
|
|
|
|
riscv_csr_op_fn op;
|
|
|
|
} riscv_csr_operations;
|
|
|
|
|
2021-01-12 12:52:01 +08:00
|
|
|
/* CSR function table constants */
|
|
|
|
enum {
|
|
|
|
CSR_TABLE_SIZE = 0x1000
|
|
|
|
};
|
|
|
|
|
|
|
|
/* CSR function table */
|
2021-01-19 10:52:03 +08:00
|
|
|
extern riscv_csr_operations csr_ops[CSR_TABLE_SIZE];
|
2021-01-12 12:52:01 +08:00
|
|
|
|
2019-01-05 07:23:55 +08:00
|
|
|
void riscv_get_csr_ops(int csrno, riscv_csr_operations *ops);
|
|
|
|
void riscv_set_csr_ops(int csrno, riscv_csr_operations *ops);
|
2018-03-02 20:31:10 +08:00
|
|
|
|
2019-03-15 18:26:59 +08:00
|
|
|
void riscv_cpu_register_gdb_regs_for_features(CPUState *cs);
|
|
|
|
|
2018-03-02 20:31:10 +08:00
|
|
|
#endif /* RISCV_CPU_H */
|