cpu, arch: fix the type used for the request flags

Change-Id: I183b9942929c873c3272ce6d1abd4ebc472c7132
Reviewed-by: Andreas Sandberg <andreas.sandberg@arm.com>

diff --git a/src/arch/arm/isa.cc b/src/arch/arm/isa.cc
index fabbe07569a8722473d6747311c93acd1fd2e817..2ae0bd7dcf54276d8ad98e79d100f982b1deee43 100644 (file)
--- a/src/arch/arm/isa.cc
+++ b/src/arch/arm/isa.cc
@@ -1465,7 +1465,7 @@ ISA::setMiscReg(int misc_reg, const MiscReg &val, ThreadContext *tc)
           case MISCREG_ATS1HR:
           case MISCREG_ATS1HW:
             {
-              unsigned flags = 0;
+              Request::Flags flags = 0;
               BaseTLB::Mode mode = BaseTLB::Read;
               TLB::ArmTranslationType tranType = TLB::NormalTran;
               Fault fault;
@@ -1710,7 +1710,7 @@ ISA::setMiscReg(int misc_reg, const MiscReg &val, ThreadContext *tc)
           case MISCREG_AT_S1E3W_Xt:
             {
                 RequestPtr req = new Request;
-                unsigned flags = 0;
+                Request::Flags flags = 0;
                 BaseTLB::Mode mode = BaseTLB::Read;
                 TLB::ArmTranslationType tranType = TLB::NormalTran;
                 Fault fault;

diff --git a/src/arch/arm/tlb.cc b/src/arch/arm/tlb.cc
index a19a609b7c84a4bbfe62e4f7ff9b9f1ed9a009eb..6658657aaf539ccd67ed9ebb82a85a5f014bb5cc 100644 (file)
--- a/src/arch/arm/tlb.cc
+++ b/src/arch/arm/tlb.cc
@@ -64,6 +64,7 @@
 #include "debug/TLB.hh"
 #include "debug/TLBVerbose.hh"
 #include "mem/page_table.hh"
+#include "mem/request.hh"
 #include "params/ArmTLB.hh"
 #include "sim/full_system.hh"
 #include "sim/process.hh"
@@ -555,7 +556,7 @@ TLB::translateSe(RequestPtr req, ThreadContext *tc, Mode mode,
         vaddr = purifyTaggedAddr(vaddr_tainted, tc, aarch64EL, ttbcr);
     else
         vaddr = vaddr_tainted;
-    uint32_t flags = req->getFlags();
+    Request::Flags flags = req->getFlags();
 
     bool is_fetch = (mode == Execute);
     bool is_write = (mode == Write);
@@ -588,7 +589,7 @@ Fault
 TLB::checkPermissions(TlbEntry *te, RequestPtr req, Mode mode)
 {
     Addr vaddr = req->getVaddr(); // 32-bit don't have to purify
-    uint32_t flags = req->getFlags();
+    Request::Flags flags = req->getFlags();
     bool is_fetch  = (mode == Execute);
     bool is_write  = (mode == Write);
     bool is_priv   = isPriv && !(flags & UserMode);
@@ -760,7 +761,7 @@ TLB::checkPermissions64(TlbEntry *te, RequestPtr req, Mode mode,
     Addr vaddr_tainted = req->getVaddr();
     Addr vaddr = purifyTaggedAddr(vaddr_tainted, tc, aarch64EL, ttbcr);
 
-    uint32_t flags = req->getFlags();
+    Request::Flags flags = req->getFlags();
     bool is_fetch  = (mode == Execute);
     bool is_write  = (mode == Write);
     bool is_priv M5_VAR_USED  = isPriv && !(flags & UserMode);
@@ -967,7 +968,7 @@ TLB::translateFs(RequestPtr req, ThreadContext *tc, Mode mode,
         vaddr = purifyTaggedAddr(vaddr_tainted, tc, aarch64EL, ttbcr);
     else
         vaddr = vaddr_tainted;
-    uint32_t flags = req->getFlags();
+    Request::Flags flags = req->getFlags();
 
     bool is_fetch  = (mode == Execute);
     bool is_write  = (mode == Write);
@@ -981,7 +982,7 @@ TLB::translateFs(RequestPtr req, ThreadContext *tc, Mode mode,
             isPriv, flags & UserMode, isSecure, tranType & S1S2NsTran);
 
     DPRINTF(TLB, "translateFs addr %#x, mode %d, st2 %d, scr %#x sctlr %#x "
-                 "flags %#x tranType 0x%x\n", vaddr_tainted, mode, isStage2,
+                 "flags %#lx tranType 0x%x\n", vaddr_tainted, mode, isStage2,
                  scr, sctlr, flags, tranType);
 
     if ((req->isInstFetch() && (!sctlr.i)) ||

diff --git a/src/arch/generic/memhelpers.hh b/src/arch/generic/memhelpers.hh
index b12e7b0b16e0b0be438ac6c2037b9f463d9c306a..f1c1d33221313cc14f008ed7789a09463311fbc0 100644 (file)
--- a/src/arch/generic/memhelpers.hh
+++ b/src/arch/generic/memhelpers.hh
@@ -54,7 +54,7 @@
 template <class XC, class MemT>
 Fault
 initiateMemRead(XC *xc, Trace::InstRecord *traceData, Addr addr,
-                MemT &mem, unsigned flags)
+                MemT &mem, Request::Flags flags)
 {
     return xc->initiateMemRead(addr, sizeof(MemT), flags);
 }
@@ -73,7 +73,7 @@ getMem(PacketPtr pkt, MemT &mem, Trace::InstRecord *traceData)
 template <class XC, class MemT>
 Fault
 readMemAtomic(XC *xc, Trace::InstRecord *traceData, Addr addr, MemT &mem,
-        unsigned flags)
+              Request::Flags flags)
 {
     memset(&mem, 0, sizeof(mem));
     Fault fault = xc->readMem(addr, (uint8_t *)&mem, sizeof(MemT), flags);
@@ -89,7 +89,7 @@ readMemAtomic(XC *xc, Trace::InstRecord *traceData, Addr addr, MemT &mem,
 template <class XC, class MemT>
 Fault
 writeMemTiming(XC *xc, Trace::InstRecord *traceData, MemT mem, Addr addr,
-        unsigned flags, uint64_t *res)
+               Request::Flags flags, uint64_t *res)
 {
     if (traceData) {
         traceData->setData(mem);
@@ -102,7 +102,7 @@ writeMemTiming(XC *xc, Trace::InstRecord *traceData, MemT mem, Addr addr,
 template <class XC, class MemT>
 Fault
 writeMemAtomic(XC *xc, Trace::InstRecord *traceData, const MemT &mem,
-        Addr addr, unsigned flags, uint64_t *res)
+               Addr addr, Request::Flags flags, uint64_t *res)
 {
     if (traceData) {
         traceData->setData(mem);

diff --git a/src/arch/x86/memhelpers.hh b/src/arch/x86/memhelpers.hh
index b13207ec47ae514b21e6d6b8a96f947a17308758..416dfe3c18cadab5bc9d00e2e6a62dc3123d37c1 100644 (file)
--- a/src/arch/x86/memhelpers.hh
+++ b/src/arch/x86/memhelpers.hh
@@ -45,7 +45,7 @@ namespace X86ISA
 template <class XC>
 Fault
 initiateMemRead(XC *xc, Trace::InstRecord *traceData, Addr addr,
-                unsigned dataSize, unsigned flags)
+                unsigned dataSize, Request::Flags flags)
 {
     return xc->initiateMemRead(addr, dataSize, flags);
 }
@@ -100,7 +100,7 @@ getMem(PacketPtr pkt, std::array<uint64_t, N> &mem, unsigned dataSize,
 template <class XC>
 Fault
 readMemAtomic(XC *xc, Trace::InstRecord *traceData, Addr addr, uint64_t &mem,
-        unsigned dataSize, unsigned flags)
+              unsigned dataSize, Request::Flags flags)
 {
     memset(&mem, 0, sizeof(mem));
     Fault fault = xc->readMem(addr, (uint8_t *)&mem, dataSize, flags);
@@ -142,7 +142,8 @@ readMemAtomic(XC *xc, Trace::InstRecord *traceData, Addr addr,
 template <class XC>
 Fault
 writeMemTiming(XC *xc, Trace::InstRecord *traceData, uint64_t mem,
-        unsigned dataSize, Addr addr, unsigned flags, uint64_t *res)
+               unsigned dataSize, Addr addr, Request::Flags flags,
+               uint64_t *res)
 {
     if (traceData) {
         traceData->setData(mem);
@@ -176,7 +177,8 @@ writeMemTiming(XC *xc, Trace::InstRecord *traceData,
 template <class XC>
 Fault
 writeMemAtomic(XC *xc, Trace::InstRecord *traceData, uint64_t mem,
-        unsigned dataSize, Addr addr, unsigned flags, uint64_t *res)
+               unsigned dataSize, Addr addr, Request::Flags flags,
+               uint64_t *res)
 {
     if (traceData) {
         traceData->setData(mem);

diff --git a/src/arch/x86/tlb.cc b/src/arch/x86/tlb.cc
index d0e77bc9b49ba1e14ca030ea741e58151961d26e..be43cb06e44e0feccde81e552e151bd9290e6e30 100644 (file)
--- a/src/arch/x86/tlb.cc
+++ b/src/arch/x86/tlb.cc
@@ -273,7 +273,7 @@ Fault
 TLB::translate(RequestPtr req, ThreadContext *tc, Translation *translation,
         Mode mode, bool &delayedResponse, bool timing)
 {
-    uint32_t flags = req->getFlags();
+    Request::Flags flags = req->getFlags();
     int seg = flags & SegmentFlagMask;
     bool storeCheck = flags & (StoreCheck << FlagShift);
 

diff --git a/src/cpu/base_dyn_inst.hh b/src/cpu/base_dyn_inst.hh
index e846f679018a9df5bf1b0b4631abdcf80fcf5f8d..6d9a5325332387808e395b1d688fe432b037d28f 100644 (file)
--- a/src/cpu/base_dyn_inst.hh
+++ b/src/cpu/base_dyn_inst.hh
@@ -65,6 +65,7 @@
 #include "cpu/static_inst.hh"
 #include "cpu/translation.hh"
 #include "mem/packet.hh"
+#include "mem/request.hh"
 #include "sim/byteswap.hh"
 #include "sim/system.hh"
 
@@ -313,10 +314,10 @@ class BaseDynInst : public ExecContext, public RefCounted
         cpu->demapPage(vaddr, asn);
     }
 
-    Fault initiateMemRead(Addr addr, unsigned size, unsigned flags);
+    Fault initiateMemRead(Addr addr, unsigned size, Request::Flags flags);
 
-    Fault writeMem(uint8_t *data, unsigned size,
-                   Addr addr, unsigned flags, uint64_t *res);
+    Fault writeMem(uint8_t *data, unsigned size, Addr addr,
+                   Request::Flags flags, uint64_t *res);
 
     /** Splits a request in two if it crosses a dcache block. */
     void splitRequest(RequestPtr req, RequestPtr &sreqLow,
@@ -873,7 +874,8 @@ class BaseDynInst : public ExecContext, public RefCounted
 
 template<class Impl>
 Fault
-BaseDynInst<Impl>::initiateMemRead(Addr addr, unsigned size, unsigned flags)
+BaseDynInst<Impl>::initiateMemRead(Addr addr, unsigned size,
+                                   Request::Flags flags)
 {
     instFlags[ReqMade] = true;
     Request *req = NULL;
@@ -925,8 +927,8 @@ BaseDynInst<Impl>::initiateMemRead(Addr addr, unsigned size, unsigned flags)
 
 template<class Impl>
 Fault
-BaseDynInst<Impl>::writeMem(uint8_t *data, unsigned size,
-                            Addr addr, unsigned flags, uint64_t *res)
+BaseDynInst<Impl>::writeMem(uint8_t *data, unsigned size, Addr addr,
+                            Request::Flags flags, uint64_t *res)
 {
     if (traceData)
         traceData->setMem(addr, size, flags);

diff --git a/src/cpu/checker/cpu.cc b/src/cpu/checker/cpu.cc
index 4d5919cdf88dbec16008f87252553f093b2a643a..9aae8b812ec36e0725dd9c8d7546defe3aa71706 100644 (file)
--- a/src/cpu/checker/cpu.cc
+++ b/src/cpu/checker/cpu.cc
@@ -139,7 +139,8 @@ CheckerCPU::unserialize(CheckpointIn &cp)
 }
 
 Fault
-CheckerCPU::readMem(Addr addr, uint8_t *data, unsigned size, unsigned flags)
+CheckerCPU::readMem(Addr addr, uint8_t *data, unsigned size,
+                    Request::Flags flags)
 {
     Fault fault = NoFault;
     int fullSize = size;
@@ -225,7 +226,7 @@ CheckerCPU::readMem(Addr addr, uint8_t *data, unsigned size, unsigned flags)
 
 Fault
 CheckerCPU::writeMem(uint8_t *data, unsigned size,
-                     Addr addr, unsigned flags, uint64_t *res)
+                     Addr addr, Request::Flags flags, uint64_t *res)
 {
     Fault fault = NoFault;
     bool checked_flags = false;

diff --git a/src/cpu/checker/cpu.hh b/src/cpu/checker/cpu.hh
index 93ab9defd4e46f9b8fcc993be56d7ac0d7b1f5ba..21ff9c7f74b9039b9b20fc258417e0fa7de13f8b 100644 (file)
--- a/src/cpu/checker/cpu.hh
+++ b/src/cpu/checker/cpu.hh
@@ -57,6 +57,7 @@
 #include "cpu/simple_thread.hh"
 #include "cpu/static_inst.hh"
 #include "debug/Checker.hh"
+#include "mem/request.hh"
 #include "params/CheckerCPU.hh"
 #include "sim/eventq.hh"
 
@@ -374,9 +375,9 @@ class CheckerCPU : public BaseCPU, public ExecContext
     }
 
     Fault readMem(Addr addr, uint8_t *data, unsigned size,
-                  unsigned flags) override;
-    Fault writeMem(uint8_t *data, unsigned size,
-                   Addr addr, unsigned flags, uint64_t *res) override;
+                  Request::Flags flags) override;
+    Fault writeMem(uint8_t *data, unsigned size, Addr addr,
+                   Request::Flags flags, uint64_t *res) override;
 
     unsigned int readStCondFailures() const override {
         return thread->readStCondFailures();

diff --git a/src/cpu/exec_context.hh b/src/cpu/exec_context.hh
index 951c9c2b3e14d0c6f0ccda935d3c6cfd9d865348..dd718b56a85f8374ed6a689a9f0fbfc095ee64d8 100644 (file)
--- a/src/cpu/exec_context.hh
+++ b/src/cpu/exec_context.hh
@@ -51,6 +51,7 @@
 #include "cpu/base.hh"
 #include "cpu/static_inst_fwd.hh"
 #include "cpu/translation.hh"
+#include "mem/request.hh"
 
 /**
  * The ExecContext is an abstract base class the provides the
@@ -182,7 +183,7 @@ class ExecContext {
      * should never be called).
      */
     virtual Fault readMem(Addr addr, uint8_t *data, unsigned int size,
-                          unsigned int flags)
+                          Request::Flags flags)
     {
         panic("ExecContext::readMem() should be overridden\n");
     }
@@ -195,7 +196,7 @@ class ExecContext {
      * should never be called).
      */
     virtual Fault initiateMemRead(Addr addr, unsigned int size,
-                                  unsigned int flags)
+                                  Request::Flags flags)
     {
         panic("ExecContext::initiateMemRead() should be overridden\n");
     }
@@ -205,7 +206,7 @@ class ExecContext {
      * For timing-mode contexts, initiate a timing memory write operation.
      */
     virtual Fault writeMem(uint8_t *data, unsigned int size, Addr addr,
-                           unsigned int flags, uint64_t *res) = 0;
+                           Request::Flags flags, uint64_t *res) = 0;
 
     /**
      * Sets the number of consecutive store conditional failures.

diff --git a/src/cpu/minor/exec_context.hh b/src/cpu/minor/exec_context.hh
index a5d646b6c497d684298470cecd9441feacd19798..4a56c01fe56312312b2593a0e9e3eec2229276d7 100644 (file)
--- a/src/cpu/minor/exec_context.hh
+++ b/src/cpu/minor/exec_context.hh
@@ -58,6 +58,7 @@
 #include "cpu/minor/pipeline.hh"
 #include "cpu/base.hh"
 #include "cpu/simple_thread.hh"
+#include "mem/request.hh"
 #include "debug/MinorExecute.hh"
 
 namespace Minor
@@ -103,7 +104,7 @@ class ExecContext : public ::ExecContext
     }
 
     Fault
-    initiateMemRead(Addr addr, unsigned int size, unsigned int flags)
+    initiateMemRead(Addr addr, unsigned int size, Request::Flags flags)
     {
         execute.getLSQ().pushRequest(inst, true /* load */, nullptr,
             size, addr, flags, NULL);
@@ -112,7 +113,7 @@ class ExecContext : public ::ExecContext
 
     Fault
     writeMem(uint8_t *data, unsigned int size, Addr addr,
-        unsigned int flags, uint64_t *res)
+             Request::Flags flags, uint64_t *res)
     {
         execute.getLSQ().pushRequest(inst, false /* store */, data,
             size, addr, flags, res);

diff --git a/src/cpu/minor/lsq.cc b/src/cpu/minor/lsq.cc
index 5995a52c26064bde811e94125b610d1b568953ed..476f9d4746a8f89a0db7e3092ebe52600ced2e16 100644 (file)
--- a/src/cpu/minor/lsq.cc
+++ b/src/cpu/minor/lsq.cc
@@ -1471,7 +1471,8 @@ LSQ::needsToTick()
 
 void
 LSQ::pushRequest(MinorDynInstPtr inst, bool isLoad, uint8_t *data,
-    unsigned int size, Addr addr, unsigned int flags, uint64_t *res)
+                 unsigned int size, Addr addr, Request::Flags flags,
+                 uint64_t *res)
 {
     bool needs_burst = transferNeedsBurst(addr, size, lineWidth);
     LSQRequestPtr request;

diff --git a/src/cpu/minor/lsq.hh b/src/cpu/minor/lsq.hh
index e0b72177c382afdc62ea3eef58ccaeaaf0ab78e1..1a9094806d6b157dd8756a7605af793c7e781bbe 100644 (file)
--- a/src/cpu/minor/lsq.hh
+++ b/src/cpu/minor/lsq.hh
@@ -712,7 +712,8 @@ class LSQ : public Named
     /** Single interface for readMem/writeMem to issue requests into
      *  the LSQ */
     void pushRequest(MinorDynInstPtr inst, bool isLoad, uint8_t *data,
-        unsigned int size, Addr addr, unsigned int flags, uint64_t *res);
+                     unsigned int size, Addr addr, Request::Flags flags,
+                     uint64_t *res);
 
     /** Push a predicate failed-representing request into the queues just
      *  to maintain commit order */

diff --git a/src/cpu/simple/atomic.cc b/src/cpu/simple/atomic.cc
index a8e97f14cbefc2695fa3ad3783ff3d0e03f75d49..8dd81ae0b4c579d6d0dd85eab0f7d07b45b7f480 100644 (file)
--- a/src/cpu/simple/atomic.cc
+++ b/src/cpu/simple/atomic.cc
@@ -334,8 +334,8 @@ AtomicSimpleCPU::AtomicCPUDPort::recvFunctionalSnoop(PacketPtr pkt)
 }
 
 Fault
-AtomicSimpleCPU::readMem(Addr addr, uint8_t * data,
-                         unsigned size, unsigned flags)
+AtomicSimpleCPU::readMem(Addr addr, uint8_t * data, unsigned size,
+                         Request::Flags flags)
 {
     SimpleExecContext& t_info = *threadInfo[curThread];
     SimpleThread* thread = t_info.thread;
@@ -422,15 +422,16 @@ AtomicSimpleCPU::readMem(Addr addr, uint8_t * data,
 }
 
 Fault
-AtomicSimpleCPU::initiateMemRead(Addr addr, unsigned size, unsigned flags)
+AtomicSimpleCPU::initiateMemRead(Addr addr, unsigned size,
+                                 Request::Flags flags)
 {
     panic("initiateMemRead() is for timing accesses, and should "
           "never be called on AtomicSimpleCPU.\n");
 }
 
 Fault
-AtomicSimpleCPU::writeMem(uint8_t *data, unsigned size,
-                          Addr addr, unsigned flags, uint64_t *res)
+AtomicSimpleCPU::writeMem(uint8_t *data, unsigned size, Addr addr,
+                          Request::Flags flags, uint64_t *res)
 {
     SimpleExecContext& t_info = *threadInfo[curThread];
     SimpleThread* thread = t_info.thread;

diff --git a/src/cpu/simple/atomic.hh b/src/cpu/simple/atomic.hh
index 098ecd759db23aa8579d226dc694c026aac370b4..cdc1890de5468d4fd9e6e243d0557368fe38135c 100644 (file)
--- a/src/cpu/simple/atomic.hh
+++ b/src/cpu/simple/atomic.hh
@@ -45,6 +45,7 @@
 
 #include "cpu/simple/base.hh"
 #include "cpu/simple/exec_context.hh"
+#include "mem/request.hh"
 #include "params/AtomicSimpleCPU.hh"
 #include "sim/probe/probe.hh"
 
@@ -202,12 +203,13 @@ class AtomicSimpleCPU : public BaseSimpleCPU
     void suspendContext(ThreadID thread_num) override;
 
     Fault readMem(Addr addr, uint8_t *data, unsigned size,
-                  unsigned flags) override;
+                  Request::Flags flags) override;
 
-    Fault initiateMemRead(Addr addr, unsigned size, unsigned flags) override;
+    Fault initiateMemRead(Addr addr, unsigned size,
+                          Request::Flags flags) override;
 
     Fault writeMem(uint8_t *data, unsigned size,
-                   Addr addr, unsigned flags, uint64_t *res) override;
+                   Addr addr, Request::Flags flags, uint64_t *res) override;
 
     void regProbePoints() override;
 

diff --git a/src/cpu/simple/base.hh b/src/cpu/simple/base.hh
index 9164a2960b66e69a319bc2c805c3589434cee509..15ab2aba4accb69d4cdc466c474c2939db8b90a5 100644 (file)
--- a/src/cpu/simple/base.hh
+++ b/src/cpu/simple/base.hh
@@ -143,12 +143,13 @@ class BaseSimpleCPU : public BaseCPU
     void startup() override;
 
     virtual Fault readMem(Addr addr, uint8_t* data, unsigned size,
-                          unsigned flags) = 0;
+                          Request::Flags flags) = 0;
 
-    virtual Fault initiateMemRead(Addr addr, unsigned size, unsigned flags) = 0;
+    virtual Fault initiateMemRead(Addr addr, unsigned size,
+                                  Request::Flags flags) = 0;
 
     virtual Fault writeMem(uint8_t* data, unsigned size, Addr addr,
-                           unsigned flags, uint64_t* res) = 0;
+                           Request::Flags flags, uint64_t* res) = 0;
 
     void countInst();
     Counter totalInsts() const override;

diff --git a/src/cpu/simple/exec_context.hh b/src/cpu/simple/exec_context.hh
index f9d80d0d51447087539fb2b4c7aac330e4d41455..430790c094fa5a11223486434a269ba9286bb158 100644 (file)
--- a/src/cpu/simple/exec_context.hh
+++ b/src/cpu/simple/exec_context.hh
@@ -53,6 +53,7 @@
 #include "cpu/simple/base.hh"
 #include "cpu/static_inst_fwd.hh"
 #include "cpu/translation.hh"
+#include "mem/request.hh"
 
 class BaseSimpleCPU;
 
@@ -286,19 +287,19 @@ class SimpleExecContext : public ExecContext {
     { panic("BaseSimpleCPU::getEA() not implemented\n"); }
 
     Fault readMem(Addr addr, uint8_t *data, unsigned int size,
-                  unsigned int flags) override
+                  Request::Flags flags) override
     {
         return cpu->readMem(addr, data, size, flags);
     }
 
     Fault initiateMemRead(Addr addr, unsigned int size,
-                          unsigned int flags) override
+                          Request::Flags flags) override
     {
         return cpu->initiateMemRead(addr, size, flags);
     }
 
     Fault writeMem(uint8_t *data, unsigned int size, Addr addr,
-                   unsigned int flags, uint64_t *res) override
+                   Request::Flags flags, uint64_t *res) override
     {
         return cpu->writeMem(data, size, addr, flags, res);
     }

diff --git a/src/cpu/simple/timing.cc b/src/cpu/simple/timing.cc
index 515d6b23c56286ad15e0b56a6dee32bd35849fef..65fea15ee6a2cc29842e8641a7119e9c17e40cc4 100644 (file)
--- a/src/cpu/simple/timing.cc
+++ b/src/cpu/simple/timing.cc
@@ -409,14 +409,15 @@ TimingSimpleCPU::buildSplitPacket(PacketPtr &pkt1, PacketPtr &pkt2,
 
 Fault
 TimingSimpleCPU::readMem(Addr addr, uint8_t *data,
-                         unsigned size, unsigned flags)
+                         unsigned size, Request::Flags flags)
 {
     panic("readMem() is for atomic accesses, and should "
           "never be called on TimingSimpleCPU.\n");
 }
 
 Fault
-TimingSimpleCPU::initiateMemRead(Addr addr, unsigned size, unsigned flags)
+TimingSimpleCPU::initiateMemRead(Addr addr, unsigned size,
+                                 Request::Flags flags)
 {
     SimpleExecContext &t_info = *threadInfo[curThread];
     SimpleThread* thread = t_info.thread;
@@ -489,7 +490,7 @@ TimingSimpleCPU::handleWritePacket()
 
 Fault
 TimingSimpleCPU::writeMem(uint8_t *data, unsigned size,
-                          Addr addr, unsigned flags, uint64_t *res)
+                          Addr addr, Request::Flags flags, uint64_t *res)
 {
     SimpleExecContext &t_info = *threadInfo[curThread];
     SimpleThread* thread = t_info.thread;

diff --git a/src/cpu/simple/timing.hh b/src/cpu/simple/timing.hh
index 035f05158894ac6d165fffcece50d916be3161bd..eebf884ca55edc4d9dd9dab789b7ce3f93c24083 100644 (file)
--- a/src/cpu/simple/timing.hh
+++ b/src/cpu/simple/timing.hh
@@ -279,12 +279,13 @@ class TimingSimpleCPU : public BaseSimpleCPU
     void suspendContext(ThreadID thread_num) override;
 
     Fault readMem(Addr addr, uint8_t *data, unsigned size,
-                  unsigned flags) override;
+                  Request::Flags flags) override;
 
-    Fault initiateMemRead(Addr addr, unsigned size, unsigned flags) override;
+    Fault initiateMemRead(Addr addr, unsigned size,
+                          Request::Flags flags) override;
 
     Fault writeMem(uint8_t *data, unsigned size,
-                   Addr addr, unsigned flags, uint64_t *res) override;
+                   Addr addr, Request::Flags flags, uint64_t *res) override;
 
     void fetch();
     void sendFetch(const Fault &fault, RequestPtr req, ThreadContext *tc);