Gabe Black has uploaded this change for review. (
https://gem5-review.googlesource.com/c/public/gem5/+/49110 )
Change subject: cpu: Implement (get|set)Reg(Flat|) for SimpleThread.
......................................................................
cpu: Implement (get|set)Reg(Flat|) for SimpleThread.
Change-Id: Iddda31746606865d746df98e9e6d5adfa7266745
---
M src/cpu/simple_thread.hh
1 file changed, 301 insertions(+), 0 deletions(-)
diff --git a/src/cpu/simple_thread.hh b/src/cpu/simple_thread.hh
index 97bd21a..650a4be 100644
--- a/src/cpu/simple_thread.hh
+++ b/src/cpu/simple_thread.hh
@@ -129,6 +129,18 @@
data.data() + (idx << _regShift));
}
+ void
+ get(size_t idx, void *val) const
+ {
+ std::memcpy(val, data.data() + (idx << _regShift), _regBytes);
+ }
+
+ void
+ set(size_t idx, const void *val)
+ {
+ std::memcpy(data.data() + (idx << _regShift), val, _regBytes);
+ }
+
void clear() { std::fill(data.begin(), data.end(), 0); }
};
@@ -518,6 +530,295 @@
}
RegVal
+ getReg(const RegId &arch_reg) const override
+ {
+ const RegId reg = flattenRegId(arch_reg);
+
+ const RegClassType type = reg.classValue();
+ const RegIndex idx = reg.index();
+ const RegIndex arch_idx = arch_reg.index();
+
+ RegVal val;
+ switch (type) {
+ case IntRegClass:
+ assert(idx < intRegs.size());
+ val = intRegs.reg(idx);
+ DPRINTF(IntRegs, "Reading int reg %d (%d) as %#x.\n",
+ arch_idx, idx, val);
+ return val;
+ case FloatRegClass:
+ assert(idx < floatRegs.size());
+ val = floatRegs.reg(idx);
+ DPRINTF(FloatRegs, "Reading float reg %d (%d) as %#x.\n",
+ arch_idx, idx, val);
+ return val;
+ case CCRegClass:
+ assert(idx < ccRegs.size());
+ val = ccRegs.reg(idx);
+ DPRINTF(CCRegs, "Reading cc reg %d (%d) as %#x.\n",
+ arch_idx, idx, val);
+ return val;
+ default:
+ panic("Unsupported register class type %d.", type);
+ }
+ }
+
+ RegVal
+ getRegFlat(const RegId ®) const override
+ {
+ const RegClassType type = reg.classValue();
+ const RegIndex idx = reg.index();
+
+ RegVal val;
+ switch (type) {
+ case IntRegClass:
+ assert(idx < intRegs.size());
+ val = intRegs.reg(idx);
+ DPRINTF(IntRegs, "Reading int reg %d as %#x.\n", idx, val);
+ return val;
+ case FloatRegClass:
+ assert(idx < floatRegs.size());
+ val = floatRegs.reg(idx);
+ DPRINTF(FloatRegs, "Reading float reg %d as %#x.\n", idx, val);
+ return val;
+ case CCRegClass:
+ assert(idx < ccRegs.size());
+ val = ccRegs.reg(idx);
+ DPRINTF(CCRegs, "Reading cc reg %d as %#x.\n", idx, val);
+ return val;
+ default:
+ panic("Unsupported register class type %d.", type);
+ }
+ }
+
+ void
+ getReg(const RegId &arch_reg, void *val) const override
+ {
+ const RegId reg = flattenRegId(arch_reg);
+
+ const RegClassType type = reg.classValue();
+ const RegIndex idx = reg.index();
+ const RegIndex arch_idx = arch_reg.index();
+
+ switch (type) {
+ case IntRegClass:
+ *(RegVal *)val = getRegFlat(reg);
+ break;
+ case FloatRegClass:
+ *(RegVal *)val = getRegFlat(reg);
+ break;
+ case VecRegClass:
+ vecRegs.get(idx, val);
+ DPRINTF(VecRegs, "Reading vector register %d (%d) as %s.\n",
+ arch_idx, idx, *(TheISA::VecRegContainer *)val);
+ break;
+ case VecPredRegClass:
+ vecPredRegs.get(idx, val);
+ DPRINTF(VecPredRegs, "Reading predicate register %d (%d)
as %s.\n",
+ arch_idx, idx, *(TheISA::VecRegContainer *)val);
+ break;
+ case CCRegClass:
+ *(RegVal *)val = getRegFlat(reg);
+ break;
+ case VecElemClass:
+ {
+ auto ret = vecRegs.reg<TheISA::VecRegContainer>(idx).
+ as<TheISA::VecElem>();
+ const TheISA::VecElem &elem = ret[reg.elemIndex()];
+ DPRINTF(VecRegs, "Reading element %d of vector register "
+ "%d (%d) as %s.\n",
+ reg.elemIndex(), arch_idx, idx, elem);
+ memcpy(val, &elem, sizeof(elem));
+ }
+ break;
+ default:
+ panic("Unrecognized register class type %d.", type);
+ }
+ }
+
+ void
+ getRegFlat(const RegId ®, void *val) const override
+ {
+ const RegClassType type = reg.classValue();
+ const RegIndex idx = reg.index();
+
+ switch (type) {
+ case IntRegClass:
+ *(RegVal *)val = getRegFlat(reg);
+ break;
+ case FloatRegClass:
+ *(RegVal *)val = getRegFlat(reg);
+ break;
+ case VecRegClass:
+ vecRegs.get(idx, val);
+ DPRINTF(VecRegs, "Reading vector register %d as %s.\n",
+ idx, *(TheISA::VecRegContainer *)val);
+ break;
+ case VecPredRegClass:
+ vecPredRegs.get(idx, val);
+ DPRINTF(VecPredRegs, "Reading predicate register %d as %s.\n",
+ idx, *(TheISA::VecRegContainer *)val);
+ break;
+ case CCRegClass:
+ *(RegVal *)val = getRegFlat(reg);
+ break;
+ case VecElemClass:
+ {
+ auto ret = vecRegs.reg<TheISA::VecRegContainer>(idx).
+ as<TheISA::VecElem>();
+ const TheISA::VecElem &elem = ret[reg.elemIndex()];
+ DPRINTF(VecRegs,
+ "Reading element %d of vector register %d
as %s.\n",
+ reg.elemIndex(), idx, elem);
+ memcpy(val, &elem, sizeof(elem));
+ }
+ break;
+ default:
+ panic("Unrecognized register class type %d.", type);
+ }
+ }
+
+ void
+ setReg(const RegId &arch_reg, RegVal val) override
+ {
+ const RegId reg = flattenRegId(arch_reg);
+
+ const RegClassType type = reg.classValue();
+ const RegIndex idx = reg.index();
+ const RegIndex arch_idx = arch_reg.index();
+
+ switch (type) {
+ case IntRegClass:
+ DPRINTF(IntRegs, "Setting int register %d (%d) to %#x.\n",
+ arch_idx, idx, val);
+ intRegs.reg(idx) = val;
+ break;
+ case FloatRegClass:
+ DPRINTF(FloatRegs, "Setting float register %d (%d) to %#x.\n",
+ arch_idx, idx, val);
+ floatRegs.reg(idx) = val;
+ break;
+ case CCRegClass:
+ DPRINTF(CCRegs, "Setting cc register %d (%d) to %#x.\n",
+ arch_idx, idx, val);
+ ccRegs.reg(idx) = val;
+ break;
+ default:
+ panic("Unsupported register class type %d.", type);
+ }
+ }
+
+ void
+ setRegFlat(const RegId ®, RegVal val) override
+ {
+ const RegClassType type = reg.classValue();
+ const RegIndex idx = reg.index();
+
+ switch (type) {
+ case IntRegClass:
+ DPRINTF(IntRegs, "Setting int register %d to %#x.\n", idx,
val);
+ intRegs.reg(idx) = val;
+ break;
+ case FloatRegClass:
+ DPRINTF(FloatRegs, "Setting float register %d to %#x.\n",
+ idx, val);
+ floatRegs.reg(idx) = val;
+ break;
+ case CCRegClass:
+ DPRINTF(CCRegs, "Setting cc register %d to %#x.\n", idx, val);
+ ccRegs.reg(idx) = val;
+ break;
+ default:
+ panic("Unsupported register class type %d.", type);
+ }
+ }
+
+ void
+ setReg(const RegId &arch_reg, const void *val) override
+ {
+ const RegId reg = flattenRegId(arch_reg);
+
+ const RegClassType type = reg.classValue();
+ const RegIndex idx = reg.index();
+ const RegIndex arch_idx = arch_reg.index();
+
+ switch (type) {
+ case IntRegClass:
+ setRegFlat(reg, *(RegVal *)val);
+ break;
+ case FloatRegClass:
+ setRegFlat(reg, *(RegVal *)val);
+ break;
+ case VecRegClass:
+ DPRINTF(VecRegs, "Setting vector register %d (%d) to %s.\n",
+ idx, *(TheISA::VecRegContainer *)val);
+ vecRegs.set(idx, val);
+ break;
+ case VecPredRegClass:
+ DPRINTF(VecPredRegs, "Setting predicate register %d (%d)
to %s.\n",
+ idx, *(TheISA::VecRegContainer *)val);
+ vecPredRegs.set(idx, val);
+ break;
+ case CCRegClass:
+ setRegFlat(reg, *(RegVal *)val);
+ break;
+ case VecElemClass:
+ {
+ const auto &elem = *(const TheISA::VecElem *)val;
+ DPRINTF(VecRegs, "Setting element %d of vector register "
+ "%d (%d) to %s.\n",
+ reg.elemIndex(), arch_idx, idx, elem);
+ vecRegs.reg<TheISA::VecRegContainer>(idx).
+ as<TheISA::VecElem>()[reg.elemIndex()] = elem;
+ }
+ break;
+ default:
+ panic("Unrecognized register class type %d.", type);
+ }
+ }
+
+ void
+ setRegFlat(const RegId ®, const void *val) override
+ {
+ const RegClassType type = reg.classValue();
+ const RegIndex idx = reg.index();
+
+ switch (type) {
+ case IntRegClass:
+ setRegFlat(reg, *(RegVal *)val);
+ break;
+ case FloatRegClass:
+ setRegFlat(reg, *(RegVal *)val);
+ break;
+ case VecRegClass:
+ DPRINTF(VecRegs, "Setting vector register %d to %s.\n",
+ idx, *(TheISA::VecRegContainer *)val);
+ vecRegs.set(idx, val);
+ break;
+ case VecPredRegClass:
+ DPRINTF(VecPredRegs, "Setting predicate register %d to %s.\n",
+ idx, *(TheISA::VecRegContainer *)val);
+ vecPredRegs.set(idx, val);
+ break;
+ case CCRegClass:
+ setRegFlat(reg, *(RegVal *)val);
+ break;
+ case VecElemClass:
+ {
+ const auto &elem = *(const TheISA::VecElem *)val;
+ DPRINTF(VecRegs,
+ "Setting element %d of vector register %d
to %s.\n",
+ reg.elemIndex(), idx, elem);
+ vecRegs.reg<TheISA::VecRegContainer>(idx).
+ as<TheISA::VecElem>()[reg.elemIndex()] = elem;
+ }
+ break;
+ default:
+ panic("Unrecognized register class type %d.", type);
+ }
+ }
+
+ RegVal
readIntRegFlat(RegIndex idx) const override
{
return intRegs.reg(idx);
--
To view, visit https://gem5-review.googlesource.com/c/public/gem5/+/49110
To unsubscribe, or for help writing mail filters, visit
https://gem5-review.googlesource.com/settings
Gerrit-Project: public/gem5
Gerrit-Branch: develop
Gerrit-Change-Id: Iddda31746606865d746df98e9e6d5adfa7266745
Gerrit-Change-Number: 49110
Gerrit-PatchSet: 1
Gerrit-Owner: Gabe Black <gabe.bl...@gmail.com>
Gerrit-MessageType: newchange
_______________________________________________
gem5-dev mailing list -- gem5-dev@gem5.org
To unsubscribe send an email to gem5-dev-le...@gem5.org
%(web_page_url)slistinfo%(cgiext)s/%(_internal_name)s
