misc: Remove the "fault" parameter from syscall functions.

This parameter was never set or used, just plumbed everywhere,
occasionally with a dummy value. This change removes all of that
plumbing.

Change-Id: I9bc31ffd1fbc4952c5d3096f7f21eab30102300b
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/33277
Tested-by: kokoro <noreply+kokoro@google.com>
Reviewed-by: Andreas Sandberg <andreas.sandberg@arm.com>
Maintainer: Andreas Sandberg <andreas.sandberg@arm.com>

diff --git a/src/arch/arm/fastmodel/iris/thread_context.hh b/src/arch/arm/fastmodel/iris/thread_context.hh
index 363e1d7066130bb257ed9f5c16117c7d9d4cb226..dc5396952ccd07e2537b9806c336b3026901efae 100644 (file)
--- a/src/arch/arm/fastmodel/iris/thread_context.hh
+++ b/src/arch/arm/fastmodel/iris/thread_context.hh
@@ -445,7 +445,7 @@ class ThreadContext : public ::ThreadContext
     }
 
     void
-    syscall(Fault *fault) override
+    syscall() override
     {
         panic("%s not implemented.", __FUNCTION__);
     }

diff --git a/src/arch/arm/faults.cc b/src/arch/arm/faults.cc
index 5b865ecab007a6eec6b938fe620a38d71ab46dfc..56e1814c6c72186315323e9cadf406f689fee4d9 100644 (file)
--- a/src/arch/arm/faults.cc
+++ b/src/arch/arm/faults.cc
@@ -865,8 +865,7 @@ SupervisorCall::invoke(ThreadContext *tc, const StaticInstPtr &inst)
 
     // As of now, there isn't a 32 bit thumb version of this instruction.
     assert(!machInst.bigThumb);
-    Fault fault;
-    tc->syscall(&fault);
+    tc->syscall();
 
     // Advance the PC since that won't happen automatically.
     PCState pc = tc->pcState();

diff --git a/src/arch/arm/freebsd/process.cc b/src/arch/arm/freebsd/process.cc
index d8a7d6836e1370e0ff4aeff34e470a42bc78569c..4bf6bcca6568a2ece66b9ec85f109b24f0925321 100644 (file)
--- a/src/arch/arm/freebsd/process.cc
+++ b/src/arch/arm/freebsd/process.cc
@@ -175,15 +175,15 @@ ArmFreebsdProcess64::initState()
 }
 
 void
-ArmFreebsdProcess32::syscall(ThreadContext *tc, Fault *fault)
+ArmFreebsdProcess32::syscall(ThreadContext *tc)
 {
-    ArmProcess32::syscall(tc, fault);
-    syscallDescs32.get(tc->readIntReg(INTREG_R7))->doSyscall(tc, fault);
+    ArmProcess32::syscall(tc);
+    syscallDescs32.get(tc->readIntReg(INTREG_R7))->doSyscall(tc);
 }
 
 void
-ArmFreebsdProcess64::syscall(ThreadContext *tc, Fault *fault)
+ArmFreebsdProcess64::syscall(ThreadContext *tc)
 {
-    ArmProcess64::syscall(tc, fault);
-    syscallDescs64.get(tc->readIntReg(INTREG_X8))->doSyscall(tc, fault);
+    ArmProcess64::syscall(tc);
+    syscallDescs64.get(tc->readIntReg(INTREG_X8))->doSyscall(tc);
 }

diff --git a/src/arch/arm/freebsd/process.hh b/src/arch/arm/freebsd/process.hh
index d52512a01495e68303eb9291ea63c343a9726d33..b64a3a06bf675b9692afb8fac06c19e6a3c7381c 100644 (file)
--- a/src/arch/arm/freebsd/process.hh
+++ b/src/arch/arm/freebsd/process.hh
@@ -82,7 +82,7 @@ class ArmFreebsdProcess32 : public ArmProcess32, public ArmFreebsdProcessBits
 
     void initState() override;
 
-    void syscall(ThreadContext *tc, Fault *fault) override;
+    void syscall(ThreadContext *tc) override;
 
     /// A page to hold "kernel" provided functions. The name might be wrong.
     static const Addr commPage;
@@ -100,7 +100,7 @@ class ArmFreebsdProcess64 : public ArmProcess64, public ArmFreebsdProcessBits
                         ::Loader::Arch _arch);
 
     void initState() override;
-    void syscall(ThreadContext *tc, Fault *fault) override;
+    void syscall(ThreadContext *tc) override;
 
     struct SyscallABI : public ArmProcess64::SyscallABI,
                         public ArmFreebsdProcessBits::SyscallABI

diff --git a/src/arch/arm/linux/process.cc b/src/arch/arm/linux/process.cc
index 65f1cd15e29d9fa73964e5421aeb4bc209603fbe..c190167227ebbdf6b0c32d19933142b9b77997b8 100644 (file)
--- a/src/arch/arm/linux/process.cc
+++ b/src/arch/arm/linux/process.cc
@@ -912,9 +912,9 @@ ArmLinuxProcess64::initState()
 }
 
 void
-ArmLinuxProcess32::syscall(ThreadContext *tc, Fault *fault)
+ArmLinuxProcess32::syscall(ThreadContext *tc)
 {
-    ArmProcess32::syscall(tc, fault);
+    ArmProcess32::syscall(tc);
 
     int num = tc->readIntReg(INTREG_R7);
     SyscallDesc *desc = syscallDescs32Low.get(num, false);
@@ -922,13 +922,13 @@ ArmLinuxProcess32::syscall(ThreadContext *tc, Fault *fault)
         desc = syscallDescs32Low.get(num, false);
     if (!desc)
         desc = privSyscallDescs32.get(num);
-    desc->doSyscall(tc, fault);
+    desc->doSyscall(tc);
 }
 
 void
-ArmLinuxProcess64::syscall(ThreadContext *tc, Fault *fault)
+ArmLinuxProcess64::syscall(ThreadContext *tc)
 {
-    ArmProcess64::syscall(tc, fault);
+    ArmProcess64::syscall(tc);
 
     int num = tc->readIntReg(INTREG_X8);
     SyscallDesc *desc = syscallDescs64Low.get(num, false);
@@ -936,5 +936,5 @@ ArmLinuxProcess64::syscall(ThreadContext *tc, Fault *fault)
         desc = syscallDescs64Low.get(num, false);
     if (!desc)
         desc = privSyscallDescs64.get(num);
-    desc->doSyscall(tc, fault);
+    desc->doSyscall(tc);
 }

diff --git a/src/arch/arm/linux/process.hh b/src/arch/arm/linux/process.hh
index 0c15c2802e578e354d97e77025660a0eecf7c801..21c2a293c97386ccf4c383fe3d1584d2ba5c22a7 100644 (file)
--- a/src/arch/arm/linux/process.hh
+++ b/src/arch/arm/linux/process.hh
@@ -82,7 +82,7 @@ class ArmLinuxProcess32 : public ArmProcess32, public ArmLinuxProcessBits
 
     void initState() override;
 
-    void syscall(ThreadContext *tc, Fault *fault) override;
+    void syscall(ThreadContext *tc) override;
 
     /// A page to hold "kernel" provided functions. The name might be wrong.
     static const Addr commPage;
@@ -100,7 +100,7 @@ class ArmLinuxProcess64 : public ArmProcess64, public ArmLinuxProcessBits
                       ::Loader::Arch _arch);
 
     void initState() override;
-    void syscall(ThreadContext *tc, Fault *fault) override;
+    void syscall(ThreadContext *tc) override;
 
     struct SyscallABI : public ArmProcess64::SyscallABI,
                         public ArmLinuxProcessBits::SyscallABI

diff --git a/src/arch/mips/isa/decoder.isa b/src/arch/mips/isa/decoder.isa
index 19a14999cd5a6dbd80feb022b494b4ec3c9cee96..6e19f85d81b9c20091299344e4a58519710e0d6b 100644 (file)
--- a/src/arch/mips/isa/decoder.isa
+++ b/src/arch/mips/isa/decoder.isa
@@ -159,7 +159,7 @@ decode OPCODE_HI default Unknown::unknown() {
                     0x2: movz({{ Rd = (Rt == 0) ? Rs : Rd; }});
                     0x3: movn({{ Rd = (Rt != 0) ? Rs : Rd; }});
                     0x4: decode FullSystemInt {
-                        0: syscall_se({{ xc->syscall(&fault); }},
+                        0: syscall_se({{ xc->syscall(); }},
                                 IsSerializeAfter, IsNonSpeculative);
                       default: syscall({{ fault = std::make_shared<SystemCallFault>(); }});
                     }

diff --git a/src/arch/mips/linux/process.cc b/src/arch/mips/linux/process.cc
index 600d05363e7c12bdcff68aa9e1aac5ebf9100a01..3bc88dfea1fc125c179d7be66da24d5dc3177b77 100644 (file)
--- a/src/arch/mips/linux/process.cc
+++ b/src/arch/mips/linux/process.cc
@@ -476,8 +476,8 @@ MipsLinuxProcess::MipsLinuxProcess(ProcessParams * params,
 {}
 
 void
-MipsLinuxProcess::syscall(ThreadContext *tc, Fault *fault)
+MipsLinuxProcess::syscall(ThreadContext *tc)
 {
-    MipsProcess::syscall(tc, fault);
-    syscallDescs.get(tc->readIntReg(2))->doSyscall(tc, fault);
+    MipsProcess::syscall(tc);
+    syscallDescs.get(tc->readIntReg(2))->doSyscall(tc);
 }

diff --git a/src/arch/mips/linux/process.hh b/src/arch/mips/linux/process.hh
index ddf2a11c5e545a523474f795017f8e63ed103f18..981526ca9789d1d8438e8b937353f38dc1b81212 100644 (file)
--- a/src/arch/mips/linux/process.hh
+++ b/src/arch/mips/linux/process.hh
@@ -47,7 +47,7 @@ class MipsLinuxProcess : public MipsProcess
     /// ID of the thread group leader for the process
     uint64_t __tgid;
 
-    void syscall(ThreadContext *tc, Fault *fault) override;
+    void syscall(ThreadContext *tc) override;
 
     /// Syscall descriptors, indexed by call number.
     static SyscallDescTable<SyscallABI> syscallDescs;

diff --git a/src/arch/power/isa/decoder.isa b/src/arch/power/isa/decoder.isa
index ce9cbbabfc52c833187067d5e6735ffdd59d772f..2e88aea7f2bdd10a1f81e7f5e12ae01ade252fbe 100644 (file)
--- a/src/arch/power/isa/decoder.isa
+++ b/src/arch/power/isa/decoder.isa
@@ -515,7 +515,7 @@ decode OPCODE default Unknown::unknown() {
         55: stfdu({{ Mem_df = Fs; }});
     }
 
-    17: IntOp::sc({{ xc->syscall(&fault); }},
+    17: IntOp::sc({{ xc->syscall(); }},
                   [ IsSyscall, IsNonSpeculative, IsSerializeAfter ]);
 
     format FloatArithOp {

diff --git a/src/arch/power/linux/process.cc b/src/arch/power/linux/process.cc
index fd07947e9d8b78f4f77df74a91b4f84fb9f8f2d5..633c3a76be4b52a8d1faf6da748c325d4ab26903 100644 (file)
--- a/src/arch/power/linux/process.cc
+++ b/src/arch/power/linux/process.cc
@@ -451,8 +451,8 @@ PowerLinuxProcess::initState()
 }
 
 void
-PowerLinuxProcess::syscall(ThreadContext *tc, Fault *fault)
+PowerLinuxProcess::syscall(ThreadContext *tc)
 {
-    PowerProcess::syscall(tc, fault);
-    syscallDescs.get(tc->readIntReg(0))->doSyscall(tc, fault);
+    PowerProcess::syscall(tc);
+    syscallDescs.get(tc->readIntReg(0))->doSyscall(tc);
 }

diff --git a/src/arch/power/linux/process.hh b/src/arch/power/linux/process.hh
index a81edfb9d47d982c2fab85c37a44f69dcf2049b2..2c7883de82bf0a690b2ec8c24b7aa6147b2c3f83 100644 (file)
--- a/src/arch/power/linux/process.hh
+++ b/src/arch/power/linux/process.hh
@@ -42,7 +42,7 @@ class PowerLinuxProcess : public PowerProcess
 
     void initState() override;
 
-    void syscall(ThreadContext *tc, Fault *fault) override;
+    void syscall(ThreadContext *tc) override;
 
     /// Syscall descriptors, indexed by call number.
     static SyscallDescTable<SyscallABI> syscallDescs;

diff --git a/src/arch/riscv/faults.cc b/src/arch/riscv/faults.cc
index 2ef8df44b9c91464fba6c9771de20ea95186296d..7a1c7bd8c426025df5dc2784901e75e5f4ca9202 100644 (file)
--- a/src/arch/riscv/faults.cc
+++ b/src/arch/riscv/faults.cc
@@ -194,8 +194,7 @@ BreakpointFault::invokeSE(ThreadContext *tc, const StaticInstPtr &inst)
 void
 SyscallFault::invokeSE(ThreadContext *tc, const StaticInstPtr &inst)
 {
-    Fault *fault = NoFault;
-    tc->syscall(fault);
+    tc->syscall();
 }
 
 } // namespace RiscvISA

diff --git a/src/arch/riscv/linux/process.cc b/src/arch/riscv/linux/process.cc
index fa6bf01881f98d9a6e7cc3bd723fb7aead2a8256..094097f16bbb3684452b97e2990e7151a8cf8987 100644 (file)
--- a/src/arch/riscv/linux/process.cc
+++ b/src/arch/riscv/linux/process.cc
@@ -781,10 +781,10 @@ RiscvLinuxProcess64::RiscvLinuxProcess64(ProcessParams * params,
 {}
 
 void
-RiscvLinuxProcess64::syscall(ThreadContext *tc, Fault *fault)
+RiscvLinuxProcess64::syscall(ThreadContext *tc)
 {
-    RiscvProcess64::syscall(tc, fault);
-    syscallDescs.get(tc->readIntReg(SyscallNumReg))->doSyscall(tc, fault);
+    RiscvProcess64::syscall(tc);
+    syscallDescs.get(tc->readIntReg(SyscallNumReg))->doSyscall(tc);
 }
 
 RiscvLinuxProcess32::RiscvLinuxProcess32(ProcessParams * params,
@@ -792,8 +792,8 @@ RiscvLinuxProcess32::RiscvLinuxProcess32(ProcessParams * params,
 {}
 
 void
-RiscvLinuxProcess32::syscall(ThreadContext *tc, Fault *fault)
+RiscvLinuxProcess32::syscall(ThreadContext *tc)
 {
-    RiscvProcess32::syscall(tc, fault);
-    syscallDescs.get(tc->readIntReg(SyscallNumReg))->doSyscall(tc, fault);
+    RiscvProcess32::syscall(tc);
+    syscallDescs.get(tc->readIntReg(SyscallNumReg))->doSyscall(tc);
 }

diff --git a/src/arch/riscv/linux/process.hh b/src/arch/riscv/linux/process.hh
index b553bef4f783b8645a753e8e60ec2a2dbc3b2d1b..8844273cd1800688ef3f0881838c094a7588f0e1 100644 (file)
--- a/src/arch/riscv/linux/process.hh
+++ b/src/arch/riscv/linux/process.hh
@@ -50,7 +50,7 @@ class RiscvLinuxProcess64 : public RiscvProcess64
     /// ID of the thread group leader for the process
     uint64_t __tgid;
 
-    void syscall(ThreadContext *tc, Fault *fault) override;
+    void syscall(ThreadContext *tc) override;
 
     /// Syscall descriptors, indexed by call number.
     static SyscallDescTable<SyscallABI> syscallDescs;
@@ -68,7 +68,7 @@ class RiscvLinuxProcess32 : public RiscvProcess32
     /// ID of the thread group leader for the process
     uint64_t __tgid;
 
-    void syscall(ThreadContext *tc, Fault *fault) override;
+    void syscall(ThreadContext *tc) override;
 
     /// Array of syscall descriptors, indexed by call number.
     static SyscallDescTable<SyscallABI> syscallDescs;

diff --git a/src/arch/sparc/faults.cc b/src/arch/sparc/faults.cc
index 4197613803a6db0c0e5f88847df490a71206eecf..34a0d52b24b7b474bdc058a870e796a0ffd114e7 100644 (file)
--- a/src/arch/sparc/faults.cc
+++ b/src/arch/sparc/faults.cc
@@ -815,8 +815,7 @@ TrapInstruction::invoke(ThreadContext *tc, const StaticInstPtr &inst)
     SparcProcess *sp = dynamic_cast<SparcProcess *>(p);
     assert(sp);
 
-    Fault fault;
-    sp->handleTrap(_n, tc, &fault);
+    sp->handleTrap(_n, tc);
 
     // We need to explicitly advance the pc, since that's not done for us
     // on a faulting instruction

diff --git a/src/arch/sparc/linux/process.cc b/src/arch/sparc/linux/process.cc
index 2988223483f99c5225e047b72890a4607712d2bc..79bbaeed2acdff5af9187bd5130d1387739a4861 100644 (file)
--- a/src/arch/sparc/linux/process.cc
+++ b/src/arch/sparc/linux/process.cc
@@ -81,21 +81,21 @@ Sparc32LinuxProcess::Sparc32LinuxProcess(ProcessParams * params,
 {}
 
 void
-Sparc32LinuxProcess::syscall(ThreadContext *tc, Fault *fault)
+Sparc32LinuxProcess::syscall(ThreadContext *tc)
 {
-    Sparc32Process::syscall(tc, fault);
-    syscall32Descs.get(tc->readIntReg(1))->doSyscall(tc, fault);
+    Sparc32Process::syscall(tc);
+    syscall32Descs.get(tc->readIntReg(1))->doSyscall(tc);
 }
 
 void
-Sparc32LinuxProcess::handleTrap(int trapNum, ThreadContext *tc, Fault *fault)
+Sparc32LinuxProcess::handleTrap(int trapNum, ThreadContext *tc)
 {
     switch (trapNum) {
       case 0x10: //Linux 32 bit syscall trap
-        tc->syscall(fault);
+        tc->syscall();
         break;
       default:
-        SparcProcess::handleTrap(trapNum, tc, fault);
+        SparcProcess::handleTrap(trapNum, tc);
     }
 }
 
@@ -105,10 +105,10 @@ Sparc64LinuxProcess::Sparc64LinuxProcess(ProcessParams * params,
 {}
 
 void
-Sparc64LinuxProcess::syscall(ThreadContext *tc, Fault *fault)
+Sparc64LinuxProcess::syscall(ThreadContext *tc)
 {
-    Sparc64Process::syscall(tc, fault);
-    syscallDescs.get(tc->readIntReg(1))->doSyscall(tc, fault);
+    Sparc64Process::syscall(tc);
+    syscallDescs.get(tc->readIntReg(1))->doSyscall(tc);
 }
 
 void
@@ -124,12 +124,12 @@ Sparc64LinuxProcess::setContext(ThreadContext *tc)
 }
 
 void
-Sparc64LinuxProcess::handleTrap(int trapNum, ThreadContext *tc, Fault *fault)
+Sparc64LinuxProcess::handleTrap(int trapNum, ThreadContext *tc)
 {
     switch (trapNum) {
       // case 0x10: // Linux 32 bit syscall trap
       case 0x6d: // Linux 64 bit syscall trap
-        tc->syscall(fault);
+        tc->syscall();
         break;
       case 0x6e: // Linux 64 bit getcontext trap
         getContext(tc);
@@ -138,6 +138,6 @@ Sparc64LinuxProcess::handleTrap(int trapNum, ThreadContext *tc, Fault *fault)
         setContext(tc);
         break;
       default:
-        SparcProcess::handleTrap(trapNum, tc, fault);
+        SparcProcess::handleTrap(trapNum, tc);
     }
 }

diff --git a/src/arch/sparc/linux/process.hh b/src/arch/sparc/linux/process.hh
index 99c9547894bf604de882bf1ef7071e24fad9ce18..0cea430c5596cfb9390534f42f2d74a21e41c017 100644 (file)
--- a/src/arch/sparc/linux/process.hh
+++ b/src/arch/sparc/linux/process.hh
@@ -56,9 +56,9 @@ class Sparc32LinuxProcess : public SparcLinuxProcess, public Sparc32Process
     /// Constructor.
     Sparc32LinuxProcess(ProcessParams * params, ::Loader::ObjectFile *objFile);
 
-    void syscall(ThreadContext *tc, Fault *fault) override;
+    void syscall(ThreadContext *tc) override;
 
-    void handleTrap(int trapNum, ThreadContext *tc, Fault *fault) override;
+    void handleTrap(int trapNum, ThreadContext *tc) override;
 };
 
 /// A process with emulated 32 bit SPARC/Linux syscalls.
@@ -68,12 +68,12 @@ class Sparc64LinuxProcess : public SparcLinuxProcess, public Sparc64Process
     /// Constructor.
     Sparc64LinuxProcess(ProcessParams * params, ::Loader::ObjectFile *objFile);
 
-    void syscall(ThreadContext *tc, Fault *fault) override;
+    void syscall(ThreadContext *tc) override;
 
     void getContext(ThreadContext *tc);
     void setContext(ThreadContext *tc);
 
-    void handleTrap(int trapNum, ThreadContext *tc, Fault *fault) override;
+    void handleTrap(int trapNum, ThreadContext *tc) override;
 };
 
 SyscallReturn getresuidFunc(SyscallDesc *desc, ThreadContext *tc,

diff --git a/src/arch/sparc/process.cc b/src/arch/sparc/process.cc
index ca0df08e62b6cca3f8414e496443100e7d8e3687..d28189cdbc9bdec592b6f842fc4e64168f177d95 100644 (file)
--- a/src/arch/sparc/process.cc
+++ b/src/arch/sparc/process.cc
@@ -66,7 +66,7 @@ SparcProcess::SparcProcess(ProcessParams *params,
 }
 
 void
-SparcProcess::handleTrap(int trapNum, ThreadContext *tc, Fault *fault)
+SparcProcess::handleTrap(int trapNum, ThreadContext *tc)
 {
     PCState pc = tc->pcState();
     switch (trapNum) {

diff --git a/src/arch/sparc/process.hh b/src/arch/sparc/process.hh
index bf992240217dc05063e5d410223fbfa50abc362f..68b607f1437431fd02ea6759ac1b9b62104e1cd9 100644 (file)
--- a/src/arch/sparc/process.hh
+++ b/src/arch/sparc/process.hh
@@ -61,7 +61,7 @@ class SparcProcess : public Process
   public:
 
     // Handles traps which request services from the operating system
-    virtual void handleTrap(int trapNum, ThreadContext *tc, Fault *fault);
+    virtual void handleTrap(int trapNum, ThreadContext *tc);
 
     Addr readFillStart() { return fillStart; }
     Addr readSpillStart() { return spillStart; }

diff --git a/src/arch/sparc/solaris/process.cc b/src/arch/sparc/solaris/process.cc
index 63f1a0fa77c73a589266859eb57819fa0c098b6c..88fb1927f1802aca05e2336eb88b9930f15beda0 100644 (file)
--- a/src/arch/sparc/solaris/process.cc
+++ b/src/arch/sparc/solaris/process.cc
@@ -350,8 +350,8 @@ SparcSolarisProcess::SparcSolarisProcess(ProcessParams *params,
 {}
 
 void
-SparcSolarisProcess::syscall(ThreadContext *tc, Fault *fault)
+SparcSolarisProcess::syscall(ThreadContext *tc)
 {
-    Sparc64Process::syscall(tc, fault);
-    syscallDescs.get(tc->readIntReg(1))->doSyscall(tc, fault);
+    Sparc64Process::syscall(tc);
+    syscallDescs.get(tc->readIntReg(1))->doSyscall(tc);
 }

diff --git a/src/arch/sparc/solaris/process.hh b/src/arch/sparc/solaris/process.hh
index 2f218bb567c78f4a1a7eeec42c0c21c656e53df7..0c71d4a7d2d5cea843a923b5af3ddc6aedfbbf8c 100644 (file)
--- a/src/arch/sparc/solaris/process.hh
+++ b/src/arch/sparc/solaris/process.hh
@@ -46,7 +46,7 @@ class SparcSolarisProcess : public Sparc64Process
     /// The target system's hostname.
     static const char *hostname;
 
-    void syscall(ThreadContext *tc, Fault *fault) override;
+    void syscall(ThreadContext *tc) override;
 
      /// Array of syscall descriptors, indexed by call number.
     static SyscallDescTable<Sparc64Process::SyscallABI> syscallDescs;

diff --git a/src/arch/x86/isa/decoder/one_byte_opcodes.isa b/src/arch/x86/isa/decoder/one_byte_opcodes.isa
index e09b34a83b0f18986f47f45bead13589e04e8414..b1b6218be09a54f252dce3131b8e22f0dfedb902 100644 (file)
--- a/src/arch/x86/isa/decoder/one_byte_opcodes.isa
+++ b/src/arch/x86/isa/decoder/one_byte_opcodes.isa
@@ -398,7 +398,7 @@
                         // will sign extend it, and there's no easy way to
                         // specify only checking the first byte.
                         0xffffffffffffff80:
-                            SyscallInst::int80('xc->syscall(&fault)',
+                            SyscallInst::int80('xc->syscall()',
                                                IsSyscall, IsNonSpeculative,
                                                IsSerializeAfter);
                     }

diff --git a/src/arch/x86/isa/decoder/two_byte_opcodes.isa b/src/arch/x86/isa/decoder/two_byte_opcodes.isa
index c147d08e4b0e14a99b780d3093472cdb650d1563..0dec25b93034621813f7707eae6f87b4e19f19bb 100644 (file)
--- a/src/arch/x86/isa/decoder/two_byte_opcodes.isa
+++ b/src/arch/x86/isa/decoder/two_byte_opcodes.isa
@@ -237,7 +237,7 @@
                 }
             }
             0x05: decode FullSystemInt {
-                0: SyscallInst::syscall('xc->syscall(&fault)',
+                0: SyscallInst::syscall('xc->syscall()',
                                         IsSyscall, IsNonSpeculative,
                                         IsSerializeAfter);
                 default: decode MODE_MODE {
@@ -431,7 +431,7 @@
             0x2: Inst::RDMSR();
             0x3: rdpmc();
             0x4: decode FullSystemInt {
-                0: SyscallInst::sysenter('xc->syscall(&fault)',
+                0: SyscallInst::sysenter('xc->syscall()',
                                          IsSyscall, IsNonSpeculative,
                                          IsSerializeAfter);
                 default: sysenter();

diff --git a/src/arch/x86/linux/process.cc b/src/arch/x86/linux/process.cc
index 9460a4b0682c70041e4e9ebe42a5a2bbe06023d0..68a9841f747403991605f5e459f752496efdc084 100644 (file)
--- a/src/arch/x86/linux/process.cc
+++ b/src/arch/x86/linux/process.cc
@@ -566,10 +566,10 @@ static SyscallDescTable<X86_64LinuxProcess::SyscallABI> syscallDescs64 = {
 };
 
 void
-X86_64LinuxProcess::syscall(ThreadContext *tc, Fault *fault)
+X86_64LinuxProcess::syscall(ThreadContext *tc)
 {
-    X86_64Process::syscall(tc, fault);
-    syscallDescs64.get(tc->readIntReg(INTREG_RAX))->doSyscall(tc, fault);
+    X86_64Process::syscall(tc);
+    syscallDescs64.get(tc->readIntReg(INTREG_RAX))->doSyscall(tc);
 }
 
 void
@@ -915,9 +915,9 @@ static SyscallDescTable<I386LinuxProcess::SyscallABI> syscallDescs32 = {
 };
 
 void
-I386LinuxProcess::syscall(ThreadContext *tc, Fault *fault)
+I386LinuxProcess::syscall(ThreadContext *tc)
 {
-    I386Process::syscall(tc, fault);
+    I386Process::syscall(tc);
     PCState pc = tc->pcState();
     Addr eip = pc.pc();
     if (eip >= vsyscallPage.base &&
@@ -925,7 +925,7 @@ I386LinuxProcess::syscall(ThreadContext *tc, Fault *fault)
         pc.npc(vsyscallPage.base + vsyscallPage.vsysexitOffset);
         tc->pcState(pc);
     }
-    syscallDescs32.get(tc->readIntReg(INTREG_RAX))->doSyscall(tc, fault);
+    syscallDescs32.get(tc->readIntReg(INTREG_RAX))->doSyscall(tc);
 }
 
 void

diff --git a/src/arch/x86/linux/process.hh b/src/arch/x86/linux/process.hh
index c2fff8bf88670d6915fa1d07023b7b4462716d3a..06b669235d0b67a5c320f6c2340df7372005d313 100644 (file)
--- a/src/arch/x86/linux/process.hh
+++ b/src/arch/x86/linux/process.hh
@@ -53,7 +53,7 @@ class X86_64LinuxProcess : public X86_64Process
 {
   public:
     using X86_64Process::X86_64Process;
-    void syscall(ThreadContext *tc, Fault *fault) override;
+    void syscall(ThreadContext *tc) override;
     void clone(ThreadContext *old_tc, ThreadContext *new_tc, Process *process,
                RegVal flags) override;
 
@@ -67,7 +67,7 @@ class I386LinuxProcess : public I386Process
 {
   public:
     using I386Process::I386Process;
-    void syscall(ThreadContext *tc, Fault *fault) override;
+    void syscall(ThreadContext *tc) override;
     void clone(ThreadContext *old_tc, ThreadContext *new_tc, Process *process,
                RegVal flags) override;
 

diff --git a/src/cpu/checker/cpu.hh b/src/cpu/checker/cpu.hh
index 3c040648a78dbbd6ec65cdc03dd40dbbf653cd77..7d1807e27321f94610037ed030cd2cafb6a23e73 100644 (file)
--- a/src/cpu/checker/cpu.hh
+++ b/src/cpu/checker/cpu.hh
@@ -577,7 +577,7 @@ class CheckerCPU : public BaseCPU, public ExecContext
     void wakeup(ThreadID tid) override { }
     // Assume that the normal CPU's call to syscall was successful.
     // The checker's state would have already been updated by the syscall.
-    void syscall(Fault *fault) override { }
+    void syscall() override { }
 
     void
     handleError()

diff --git a/src/cpu/checker/thread_context.hh b/src/cpu/checker/thread_context.hh
index 06cb3b9a065e5a3e0b1e343e8f12be4802876924..e98b3a2213dec2051718fc513709c5614ccdfaa3 100644 (file)
--- a/src/cpu/checker/thread_context.hh
+++ b/src/cpu/checker/thread_context.hh
@@ -172,11 +172,7 @@ class CheckerThreadContext : public ThreadContext
     }
 
     /** Executes a syscall in SE mode. */
-    void
-    syscall(Fault *fault) override
-    {
-        return actualTC->syscall(fault);
-    }
+    void syscall() override { return actualTC->syscall(); }
 
     Status status() const override { return actualTC->status(); }
 

diff --git a/src/cpu/exec_context.hh b/src/cpu/exec_context.hh
index 29daced4f50c74dde150510c4e269367d1a47aef..418019199b92d623d74589747cdb78a6ea3db8e6 100644 (file)
--- a/src/cpu/exec_context.hh
+++ b/src/cpu/exec_context.hh
@@ -303,7 +303,7 @@ class ExecContext {
     /**
      * Executes a syscall.
      */
-    virtual void syscall(Fault *fault) = 0;
+    virtual void syscall() = 0;
 
     /** @} */
 

diff --git a/src/cpu/minor/exec_context.hh b/src/cpu/minor/exec_context.hh
index a0b1d181bdfdbbde0b0c63d0b1206b52e15f8b20..e65fdfb14a0e03d036ae5d5cb19dcecc70faad6e 100644 (file)
--- a/src/cpu/minor/exec_context.hh
+++ b/src/cpu/minor/exec_context.hh
@@ -379,11 +379,7 @@ class ExecContext : public ::ExecContext
         return thread.setMiscReg(reg.index(), val);
     }
 
-    void
-    syscall(Fault *fault) override
-    {
-        thread.syscall(fault);
-    }
+    void syscall() override { thread.syscall(); }
 
     ThreadContext *tcBase() const override { return thread.getTC(); }
 

diff --git a/src/cpu/o3/cpu.cc b/src/cpu/o3/cpu.cc
index d9114903a349c4613d79ce43e31c411337261c31..d0a387cfcb77e666211957f504681214ce19e80c 100644 (file)
--- a/src/cpu/o3/cpu.cc
+++ b/src/cpu/o3/cpu.cc
@@ -915,7 +915,7 @@ FullO3CPU<Impl>::trap(const Fault &fault, ThreadID tid,
 
 template <class Impl>
 void
-FullO3CPU<Impl>::syscall(ThreadID tid, Fault *fault)
+FullO3CPU<Impl>::syscall(ThreadID tid)
 {
     DPRINTF(O3CPU, "[tid:%i] Executing syscall().\n\n", tid);
 
@@ -926,7 +926,7 @@ FullO3CPU<Impl>::syscall(ThreadID tid, Fault *fault)
     ++(this->thread[tid]->funcExeInst);
 
     // Execute the actual syscall.
-    this->thread[tid]->syscall(fault);
+    this->thread[tid]->syscall();
 
     // Decrease funcExeInst by one as the normal commit will handle
     // incrementing it.

diff --git a/src/cpu/o3/cpu.hh b/src/cpu/o3/cpu.hh
index c3d911b97cf139e4c50fd5a359c6786d244f4434..cc0e2cd066db25fd8a8929646b390f416a11c488 100644 (file)
--- a/src/cpu/o3/cpu.hh
+++ b/src/cpu/o3/cpu.hh
@@ -280,7 +280,7 @@ class FullO3CPU : public BaseO3CPU
     /** Executes a syscall.
      * @todo: Determine if this needs to be virtual.
      */
-    void syscall(ThreadID tid, Fault *fault);
+    void syscall(ThreadID tid);
 
     /** Starts draining the CPU's pipeline of all instructions in
      * order to stop all memory accesses. */

diff --git a/src/cpu/o3/dyn_inst.hh b/src/cpu/o3/dyn_inst.hh
index d5f142c0c6b8f2906f3a3ffd147c0104b74b7df6..5f2a5886bb0d885a3e168e8f0280bad4e7645dd1 100644 (file)
--- a/src/cpu/o3/dyn_inst.hh
+++ b/src/cpu/o3/dyn_inst.hh
@@ -249,7 +249,7 @@ class BaseO3DynInst : public BaseDynInst<Impl>
     void trap(const Fault &fault);
 
     /** Emulates a syscall. */
-    void syscall(Fault *fault) override;
+    void syscall() override;
 
   public:
 

diff --git a/src/cpu/o3/dyn_inst_impl.hh b/src/cpu/o3/dyn_inst_impl.hh
index 597bd1d553cb36b29f2e1dfb150ad9e9a2a04610..8a6a434a055571ea426bcb30eaa05b6fe8ca1280 100644 (file)
--- a/src/cpu/o3/dyn_inst_impl.hh
+++ b/src/cpu/o3/dyn_inst_impl.hh
@@ -189,13 +189,13 @@ BaseO3DynInst<Impl>::trap(const Fault &fault)
 
 template <class Impl>
 void
-BaseO3DynInst<Impl>::syscall(Fault *fault)
+BaseO3DynInst<Impl>::syscall()
 {
     // HACK: check CPU's nextPC before and after syscall. If it
     // changes, update this instruction's nextPC because the syscall
     // must have changed the nextPC.
     TheISA::PCState curPC = this->cpu->pcState(this->threadNumber);
-    this->cpu->syscall(this->threadNumber, fault);
+    this->cpu->syscall(this->threadNumber);
     TheISA::PCState newPC = this->cpu->pcState(this->threadNumber);
     if (!(curPC == newPC)) {
         this->pcState(newPC);

diff --git a/src/cpu/o3/thread_context.hh b/src/cpu/o3/thread_context.hh
index f710613f71b7e6dc8964dfa8c8e423c67d5d45a3..e3e11fe18a0a18f1a7dfb44823bf3da7dc7660c2 100644 (file)
--- a/src/cpu/o3/thread_context.hh
+++ b/src/cpu/o3/thread_context.hh
@@ -421,9 +421,9 @@ class O3ThreadContext : public ThreadContext
 
     /** Executes a syscall in SE mode. */
     void
-    syscall(Fault *fault) override
+    syscall() override
     {
-        return cpu->syscall(thread->threadId(), fault);
+        return cpu->syscall(thread->threadId());
     }
 
     /** Reads the funcExeInst counter. */

diff --git a/src/cpu/o3/thread_state.hh b/src/cpu/o3/thread_state.hh
index 757671a84c5a4516aac8aacd6e8367d77cdd4842..6420da99a42c31542d21151122da8c1f24c3745c 100644 (file)
--- a/src/cpu/o3/thread_state.hh
+++ b/src/cpu/o3/thread_state.hh
@@ -127,10 +127,7 @@ struct O3ThreadState : public ThreadState {
     ThreadContext *getTC() { return tc; }
 
     /** Handles the syscall. */
-    void syscall(Fault *fault)
-    {
-        process->syscall(tc, fault);
-    }
+    void syscall() { process->syscall(tc); }
 };
 
 #endif // __CPU_O3_THREAD_STATE_HH__

diff --git a/src/cpu/simple/exec_context.hh b/src/cpu/simple/exec_context.hh
index e7c59c035e04dc058c4efb99b15605dfab6ade27..5214211ba22d836f7e165729a50119dbb1d7b3e8 100644 (file)
--- a/src/cpu/simple/exec_context.hh
+++ b/src/cpu/simple/exec_context.hh
@@ -494,11 +494,7 @@ class SimpleExecContext : public ExecContext {
     /**
      * Executes a syscall specified by the callnum.
      */
-    void
-    syscall(Fault *fault) override
-    {
-        thread->syscall(fault);
-    }
+    void syscall() override { thread->syscall(); }
 
     /** Returns a pointer to the ThreadContext. */
     ThreadContext *tcBase() const override { return thread->getTC(); }

diff --git a/src/cpu/simple_thread.hh b/src/cpu/simple_thread.hh
index 8a2f22794c20edfb62bd7c7b236a235495501c2a..2c785736b34a0d5d68c8ee2b2aeac7b3539c0c83 100644 (file)
--- a/src/cpu/simple_thread.hh
+++ b/src/cpu/simple_thread.hh
@@ -576,11 +576,7 @@ class SimpleThread : public ThreadState, public ThreadContext
         return ThreadState::readFuncExeInst();
     }
 
-    void
-    syscall(Fault *fault) override
-    {
-        process->syscall(this, fault);
-    }
+    void syscall() override { process->syscall(this); }
 
     RegVal readIntRegFlat(RegIndex idx) const override { return intRegs[idx]; }
     void

diff --git a/src/cpu/thread_context.hh b/src/cpu/thread_context.hh
index 8ca2c5059ac23065f2ec616492c9a1662bdf9bcd..6662502f0cdecb295505ec0e9ab15dd07e595ef3 100644 (file)
--- a/src/cpu/thread_context.hh
+++ b/src/cpu/thread_context.hh
@@ -293,7 +293,7 @@ class ThreadContext : public PCEventScope
     // Same with st cond failures.
     virtual Counter readFuncExeInst() const = 0;
 
-    virtual void syscall(Fault *fault) = 0;
+    virtual void syscall() = 0;
 
     // This function exits the thread context in the CPU and returns
     // 1 if the CPU has no more active threads (meaning it's OK to exit);

diff --git a/src/sim/process.hh b/src/sim/process.hh
index 0add01ab928946ba969d49c2e4510b6eb3549cfd..449e0a5aa4add54fb642c333cbeb7e1c577eec8a 100644 (file)
--- a/src/sim/process.hh
+++ b/src/sim/process.hh
@@ -75,7 +75,7 @@ class Process : public SimObject
     void initState() override;
     DrainState drain() override;
 
-    virtual void syscall(ThreadContext *tc, Fault *fault) { numSyscalls++; }
+    virtual void syscall(ThreadContext *tc) { numSyscalls++; }
 
     inline uint64_t uid() { return _uid; }
     inline uint64_t euid() { return _euid; }

diff --git a/src/sim/pseudo_inst.cc b/src/sim/pseudo_inst.cc
index 4cbe87ccb59b1fe912a34d1ae2a97e74f4bb927c..7335fda4e7e22bf471e3fb87c0fbbdc197bcb3bc 100644 (file)
--- a/src/sim/pseudo_inst.cc
+++ b/src/sim/pseudo_inst.cc
@@ -479,8 +479,7 @@ void
 m5Syscall(ThreadContext *tc)
 {
     DPRINTF(PseudoInst, "PseudoInst::m5Syscall()\n");
-    Fault fault;
-    tc->syscall(&fault);
+    tc->syscall();
 }
 
 void

diff --git a/src/sim/syscall_desc.cc b/src/sim/syscall_desc.cc
index d2e27497473ce8b1c733ed3471bbca726cd984f8..26587172877e769d5a3340f265ca0257b91cf231 100644 (file)
--- a/src/sim/syscall_desc.cc
+++ b/src/sim/syscall_desc.cc
@@ -35,7 +35,7 @@
 class ThreadContext;
 
 void
-SyscallDesc::doSyscall(ThreadContext *tc, Fault *fault)
+SyscallDesc::doSyscall(ThreadContext *tc)
 {
     DPRINTF_SYSCALL(Base, "Calling %s...\n", dumper(name(), tc));
 

diff --git a/src/sim/syscall_desc.hh b/src/sim/syscall_desc.hh
index 53e3ccd03606847449e5e3422640df3ceb665dfc..2fd24345124521349cbd9467766d2b9cbae6b11b 100644 (file)
--- a/src/sim/syscall_desc.hh
+++ b/src/sim/syscall_desc.hh
@@ -71,7 +71,7 @@ class SyscallDesc {
      * to add filters for behaviors or apply checks for all system calls.
      * @param tc Handle for owning ThreadContext to pass information
      */
-    void doSyscall(ThreadContext *tc, Fault *fault);
+    void doSyscall(ThreadContext *tc);
 
     std::string name() const { return _name; }
     int num() const { return _num; }