projects / gem5.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Merge with head, hopefully the last time for this batch.
[gem5.git] / src / arch / arm / isa / insts / m5ops.isa
diff --git a/src/arch/arm/isa/insts/m5ops.isa b/src/arch/arm/isa/insts/m5ops.isa
index 8521cbc979fb5c5947b36f9caac0d38f63bcfbb2..a32bf6dfc3d923599581badeb3aa25032644e06a 100644 (file)
--- a/src/arch/arm/isa/insts/m5ops.isa
+++ b/src/arch/arm/isa/insts/m5ops.isa
@@ -39,13 +39,22 @@
 
 let {{
     header_output = ""
-    decoder_output = ""
-    exec_output = ""
+    decoder_output = '''
+    uint64_t join32to64(uint32_t r1, uint32_t r0)
+    {
+        uint64_t r = r1;
+        r <<= 32;
+        r |= r0;
+        return r;
+    }
+    '''
+    exec_output = '''
+    uint64_t join32to64(uint32_t r1, uint32_t r0);
+    '''
+
 
     armCode = '''
-#if FULL_SYSTEM
     PseudoInst::arm(xc->tcBase());
-#endif
     '''
     armIop = InstObjParams("arm", "Arm", "PredOp",
                            { "code": armCode,
@@ -56,9 +65,7 @@ let {{
     exec_output += PredOpExecute.subst(armIop)
 
     quiesceCode = '''
-#if FULL_SYSTEM
-    PseudoInst::quiesceNs(xc->tcBase(), R0);
-#endif
+    PseudoInst::quiesce(xc->tcBase());
     '''
     quiesceIop = InstObjParams("quiesce", "Quiesce", "PredOp",
                            { "code": quiesceCode,
@@ -69,9 +76,7 @@ let {{
     exec_output += QuiescePredOpExecute.subst(quiesceIop)
 
     quiesceNsCode = '''
-#if FULL_SYSTEM
-    PseudoInst::quiesceNs(xc->tcBase(), R0);
-#endif
+    PseudoInst::quiesceNs(xc->tcBase(), join32to64(R1, R0));
     '''
 
     quiesceNsIop = InstObjParams("quiesceNs", "QuiesceNs", "PredOp",
@@ -83,9 +88,7 @@ let {{
     exec_output += QuiescePredOpExecute.subst(quiesceNsIop)
 
     quiesceCyclesCode = '''
-#if FULL_SYSTEM
-    PseudoInst::quiesceCycles(xc->tcBase(), R0);
-#endif
+    PseudoInst::quiesceCycles(xc->tcBase(), join32to64(R1, R0));
     '''
 
     quiesceCyclesIop = InstObjParams("quiesceCycles", "QuiesceCycles", "PredOp",
@@ -97,9 +100,9 @@ let {{
     exec_output += QuiescePredOpExecute.subst(quiesceCyclesIop)
 
     quiesceTimeCode = '''
-#if FULL_SYSTEM
-    R0 = PseudoInst::quiesceTime(xc->tcBase());
-#endif
+    uint64_t qt_val = PseudoInst::quiesceTime(xc->tcBase());
+    R0 = bits(qt_val, 31, 0);
+    R1 = bits(qt_val, 63, 32);
     '''
 
     quiesceTimeIop = InstObjParams("quiesceTime", "QuiesceTime", "PredOp",
@@ -110,18 +113,28 @@ let {{
     decoder_output += BasicConstructor.subst(quiesceTimeIop)
     exec_output += PredOpExecute.subst(quiesceTimeIop)
 
+    rpnsCode = '''
+    uint64_t rpns_val = PseudoInst::rpns(xc->tcBase());
+    R0 = bits(rpns_val, 31, 0);
+    R1 = bits(rpns_val, 63, 32);
+    '''
+
     rpnsIop = InstObjParams("rpns", "Rpns", "PredOp",
-                           { "code": "R0 = PseudoInst::rpns(xc->tcBase());",
+                           { "code": rpnsCode,
                              "predicate_test": predicateTest },
                              ["IsNonSpeculative", "IsUnverifiable"])
     header_output += BasicDeclare.subst(rpnsIop)
     decoder_output += BasicConstructor.subst(rpnsIop)
     exec_output += PredOpExecute.subst(rpnsIop)
 
+    wakeCpuCode = '''
+    PseudoInst::wakeCPU(xc->tcBase(), join32to64(R1,R0));
+    '''
+
     wakeCPUIop = InstObjParams("wakeCPU", "WakeCPU", "PredOp",
-                           { "code": "PseudoInst::wakeCPU(xc->tcBase(), R0);",
-                             "predicate_test": predicateTest },
-                             ["IsNonSpeculative", "IsUnverifiable"])
+                   { "code": wakeCpuCode,
+                     "predicate_test": predicateTest },
+                     ["IsNonSpeculative", "IsUnverifiable"])
     header_output += BasicDeclare.subst(wakeCPUIop)
     decoder_output += BasicConstructor.subst(wakeCPUIop)
     exec_output += PredOpExecute.subst(wakeCPUIop)
@@ -153,18 +166,19 @@ let {{
     decoder_output += BasicConstructor.subst(deprecated_exitIop)
     exec_output += PredOpExecute.subst(deprecated_exitIop)
 
+    m5exit_code = '''
+        PseudoInst::m5exit(xc->tcBase(), join32to64(R1, R0));
+    '''
     m5exitIop = InstObjParams("m5exit", "M5exit", "PredOp",
-                           { "code": "PseudoInst::m5exit(xc->tcBase(), R0)",
-                             "predicate_test": predicateTest },
-                             ["No_OpClass", "IsNonSpeculative"])
+                                   { "code": m5exit_code,
+                                     "predicate_test": predicateTest },
+                                     ["No_OpClass", "IsNonSpeculative"])
     header_output += BasicDeclare.subst(m5exitIop)
     decoder_output += BasicConstructor.subst(m5exitIop)
     exec_output += PredOpExecute.subst(m5exitIop)
 
     loadsymbolCode = '''
-#if FULL_SYSTEM
     PseudoInst::loadsymbol(xc->tcBase());
-#endif
     '''
 
     loadsymbolIop = InstObjParams("loadsymbol", "Loadsymbol", "PredOp",
@@ -176,63 +190,93 @@ let {{
     exec_output += PredOpExecute.subst(loadsymbolIop)
 
     initparamCode = '''
-#if FULL_SYSTEM
-    Rt = xc->tcBase()->getCpuPtr()->system->init_param;
-#endif
+    uint64_t ip_val  = PseudoInst::initParam(xc->tcBase());
+    R0 = bits(ip_val, 31, 0);
+    R1 = bits(ip_val, 63, 32);
     '''
 
     initparamIop = InstObjParams("initparam", "Initparam", "PredOp",
                            { "code": initparamCode,
-                             "predicate_test": predicateTest })
+                             "predicate_test": predicateTest },
+                             ["IsNonSpeculative"])
     header_output += BasicDeclare.subst(initparamIop)
     decoder_output += BasicConstructor.subst(initparamIop)
     exec_output += PredOpExecute.subst(initparamIop)
 
+    resetstats_code = '''
+    PseudoInst::resetstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
+    '''
+
     resetstatsIop = InstObjParams("resetstats", "Resetstats", "PredOp",
-                           { "code": "PseudoInst::resetstats(xc->tcBase(), R0, R1);",
+                           { "code": resetstats_code,
                              "predicate_test": predicateTest },
                              ["IsNonSpeculative"])
     header_output += BasicDeclare.subst(resetstatsIop)
     decoder_output += BasicConstructor.subst(resetstatsIop)
     exec_output += PredOpExecute.subst(resetstatsIop)
 
+    dumpstats_code = '''
+    PseudoInst::dumpstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
+    '''
     dumpstatsIop = InstObjParams("dumpstats", "Dumpstats", "PredOp",
-                           { "code": "PseudoInst::dumpstats(xc->tcBase(), R0, R1);",
+                           { "code": dumpstats_code,
                              "predicate_test": predicateTest },
                              ["IsNonSpeculative"])
     header_output += BasicDeclare.subst(dumpstatsIop)
     decoder_output += BasicConstructor.subst(dumpstatsIop)
     exec_output += PredOpExecute.subst(dumpstatsIop)
 
+    dumpresetstats_code = '''
+    PseudoInst::dumpresetstats(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
+    '''
     dumpresetstatsIop = InstObjParams("dumpresetstats", "Dumpresetstats", "PredOp",
-                           { "code": "PseudoInst::dumpresetstats(xc->tcBase(), R0, R1);",
+                           { "code": dumpresetstats_code,
                              "predicate_test": predicateTest },
                              ["IsNonSpeculative"])
     header_output += BasicDeclare.subst(dumpresetstatsIop)
     decoder_output += BasicConstructor.subst(dumpresetstatsIop)
     exec_output += PredOpExecute.subst(dumpresetstatsIop)
 
+    m5checkpoint_code = '''
+    PseudoInst::m5checkpoint(xc->tcBase(), join32to64(R1, R0), join32to64(R3, R2));
+    '''
     m5checkpointIop = InstObjParams("m5checkpoint", "M5checkpoint", "PredOp",
-                           { "code": "PseudoInst::m5checkpoint(xc->tcBase(), R0, R1);",
+                           { "code": m5checkpoint_code,
                              "predicate_test": predicateTest },
-                             ["IsNonSpeculative"])
+                             ["IsNonSpeculative", "IsUnverifiable"])
     header_output += BasicDeclare.subst(m5checkpointIop)
     decoder_output += BasicConstructor.subst(m5checkpointIop)
     exec_output += PredOpExecute.subst(m5checkpointIop)
 
     m5readfileCode = '''
-#if FULL_SYSTEM
-    R0 = PseudoInst::readfile(xc->tcBase(), R0, R1, R2);
-#endif
+    int n = 4;
+    uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false);
+    R0 = PseudoInst::readfile(xc->tcBase(), R0, join32to64(R3,R2), offset);
     '''
     m5readfileIop = InstObjParams("m5readfile", "M5readfile", "PredOp",
                            { "code": m5readfileCode,
                              "predicate_test": predicateTest },
-                             ["IsNonSpeculative"])
+                             ["IsNonSpeculative", "IsUnverifiable"])
     header_output += BasicDeclare.subst(m5readfileIop)
     decoder_output += BasicConstructor.subst(m5readfileIop)
     exec_output += PredOpExecute.subst(m5readfileIop)
 
+    m5writefileCode = '''
+    int n = 4;
+    uint64_t offset = getArgument(xc->tcBase(), n, sizeof(uint64_t), false);
+    n = 6;
+    Addr filenameAddr = getArgument(xc->tcBase(), n, sizeof(Addr), false);
+    R0 = PseudoInst::writefile(xc->tcBase(), R0, join32to64(R3,R2), offset,
+                                filenameAddr);
+    '''
+    m5writefileIop = InstObjParams("m5writefile", "M5writefile", "PredOp",
+                           { "code": m5writefileCode,
+                             "predicate_test": predicateTest },
+                             ["IsNonSpeculative"])
+    header_output += BasicDeclare.subst(m5writefileIop)
+    decoder_output += BasicConstructor.subst(m5writefileIop)
+    exec_output += PredOpExecute.subst(m5writefileIop)
+
     m5breakIop = InstObjParams("m5break", "M5break", "PredOp",
                            { "code": "PseudoInst::debugbreak(xc->tcBase());",
                              "predicate_test": predicateTest },
@@ -250,9 +294,7 @@ let {{
     exec_output += PredOpExecute.subst(m5switchcpuIop)
 
     m5addsymbolCode = '''
-#if FULL_SYSTEM
-    PseudoInst::addsymbol(xc->tcBase(), R0, R1);
-#endif
+    PseudoInst::addsymbol(xc->tcBase(), join32to64(R1, R0), R2);
     '''
     m5addsymbolIop = InstObjParams("m5addsymbol", "M5addsymbol", "PredOp",
                            { "code": m5addsymbolCode,
@@ -272,4 +314,30 @@ let {{
     decoder_output += BasicConstructor.subst(m5panicIop)
     exec_output += PredOpExecute.subst(m5panicIop)
 
+    m5workbeginCode = '''PseudoInst::workbegin(
+                          xc->tcBase(),
+                          join32to64(R1, R0),
+                          join32to64(R3, R2)
+                      );'''
+    m5workbeginIop = InstObjParams("m5workbegin", "M5workbegin", "PredOp",
+                     { "code": m5workbeginCode,
+                       "predicate_test": predicateTest },
+                       ["IsNonSpeculative"])
+    header_output += BasicDeclare.subst(m5workbeginIop)
+    decoder_output += BasicConstructor.subst(m5workbeginIop)
+    exec_output += PredOpExecute.subst(m5workbeginIop)
+
+    m5workendCode = '''PseudoInst::workend(
+                        xc->tcBase(),
+                        join32to64(R1, R0),
+                        join32to64(R3, R2)
+                    );'''
+    m5workendIop = InstObjParams("m5workend", "M5workend", "PredOp",
+                     { "code": m5workendCode,
+                       "predicate_test": predicateTest },
+                       ["IsNonSpeculative"])
+    header_output += BasicDeclare.subst(m5workendIop)
+    decoder_output += BasicConstructor.subst(m5workendIop)
+    exec_output += PredOpExecute.subst(m5workendIop)
+
 }};