arch-arm: Add initial support for SVE contiguous loads/stores

[gem5.git] / src / arch / sparc / process.hh

diff --git a/src/arch/sparc/process.hh b/src/arch/sparc/process.hh
index c177f20a5465b8fd7889f230289cd7ff702bda3c..eeb267116382f79fa42bac07c39d20e2bcfd1a70 100644 (file)
--- a/src/arch/sparc/process.hh
+++ b/src/arch/sparc/process.hh
@@ -24,56 +24,140 @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Gabe Black
+ *          Ali Saidi
  */
 
 #ifndef __SPARC_PROCESS_HH__
 #define __SPARC_PROCESS_HH__
 
+#include <memory>
 #include <string>
 #include <vector>
+
+#include "arch/sparc/isa_traits.hh"
+#include "base/loader/object_file.hh"
+#include "mem/page_table.hh"
+#include "sim/byteswap.hh"
 #include "sim/process.hh"
 
-class ObjectFile;
-class System;
+class SparcProcess : public Process
+{
+  protected:
+
+    const Addr StackBias;
 
-typedef struct
+    // The locations of the fill and spill handlers
+    Addr fillStart, spillStart;
+
+    SparcProcess(ProcessParams * params, ObjectFile *objFile,
+                 Addr _StackBias);
+
+    void initState();
+
+    template<class IntType>
+    void argsInit(int pageSize);
+
+  public:
+
+    // Handles traps which request services from the operating system
+    virtual void handleTrap(int trapNum, ThreadContext *tc, Fault *fault);
+
+    Addr readFillStart() { return fillStart; }
+    Addr readSpillStart() { return spillStart; }
+
+    virtual void flushWindows(ThreadContext *tc) = 0;
+    void setSyscallReturn(ThreadContext *tc, SyscallReturn return_value);
+};
+
+class Sparc32Process : public SparcProcess
 {
-    int64_t a_type;
-    union {
-        int64_t a_val;
-        Addr    a_ptr;
-        Addr    a_fcn;
-    };
-} m5_auxv_t;
-
-class SparcLiveProcess : public LiveProcess
+  protected:
+
+    Sparc32Process(ProcessParams * params, ObjectFile *objFile)
+        : SparcProcess(params, objFile, 0)
+    {
+        Addr brk_point = objFile->dataBase() + objFile->dataSize() +
+                         objFile->bssSize();
+        brk_point = roundUp(brk_point, SparcISA::PageBytes);
+
+        // Reserve 8M for main stack.
+        Addr max_stack_size = 8 * 1024 * 1024;
+
+        // Set up stack. On SPARC Linux, stack goes from the top of memory
+        // downward, less the hole for the kernel address space.
+        Addr stack_base = 0xf0000000ULL;
+
+        // Set pointer for next thread stack.
+        Addr next_thread_stack_base = stack_base - max_stack_size;
+
+        // Set up region for mmaps.
+        Addr mmap_end = 0x70000000;
+
+        memState = std::make_shared<MemState>(brk_point, stack_base,
+                                              max_stack_size,
+                                              next_thread_stack_base,
+                                              mmap_end);
+    }
+
+    void initState();
+
+  public:
+
+    void argsInit(int intSize, int pageSize);
+
+    void flushWindows(ThreadContext *tc);
+
+    RegVal getSyscallArg(ThreadContext *tc, int &i);
+    /// Explicitly import the otherwise hidden getSyscallArg
+    using Process::getSyscallArg;
+
+    void setSyscallArg(ThreadContext *tc, int i, RegVal val);
+};
+
+class Sparc64Process : public SparcProcess
 {
   protected:
 
-    static const Addr StackBias = 2047;
+    Sparc64Process(ProcessParams * params, ObjectFile *objFile)
+        : SparcProcess(params, objFile, 2047)
+    {
+        Addr brk_point = objFile->dataBase() + objFile->dataSize() +
+                         objFile->bssSize();
+        brk_point = roundUp(brk_point, SparcISA::PageBytes);
+
+        Addr max_stack_size = 8 * 1024 * 1024;
 
-    std::vector<m5_auxv_t> auxv;
+        // Set up stack. On SPARC Linux, stack goes from the top of memory
+        // downward, less the hole for the kernel address space.
+        Addr stack_base = 0x80000000000ULL;
 
-    SparcLiveProcess(const std::string &nm, ObjectFile *objFile,
-                System *_system, int stdin_fd, int stdout_fd, int stderr_fd,
-                std::vector<std::string> &argv,
-                std::vector<std::string> &envp);
+        // Set pointer for next thread stack.  Reserve 8M for main stack.
+        Addr next_thread_stack_base = stack_base - max_stack_size;
 
-    void startup();
+        // Set up region for mmaps.
+        Addr mmap_end = 0xfffff80000000000ULL;
+
+        memState = std::make_shared<MemState>(brk_point, stack_base,
+                                              max_stack_size,
+                                              next_thread_stack_base,
+                                              mmap_end);
+    }
+
+    void initState();
 
   public:
-    // this function is used to create the LiveProcess object, since
-    // we can't tell which subclass of LiveProcess to use until we
-    // open and look at the object file.
-    static SparcLiveProcess *create(const std::string &nm,
-                               System *_system,
-                               int stdin_fd, int stdout_fd, int stderr_fd,
-                               std::string executable,
-                               std::vector<std::string> &argv,
-                               std::vector<std::string> &envp);
 
     void argsInit(int intSize, int pageSize);
 
+    void flushWindows(ThreadContext *tc);
+
+    RegVal getSyscallArg(ThreadContext *tc, int &i);
+    /// Explicitly import the otherwise hidden getSyscallArg
+    using Process::getSyscallArg;
+
+    void setSyscallArg(ThreadContext *tc, int i, RegVal val);
 };
 
 #endif // __SPARC_PROCESS_HH__