From 9d04b1b4e6289a86d87be8afee101f1483716e43 Mon Sep 17 00:00:00 2001
From: Gabe Black <gabe.black@gmail.com>
Date: Sun, 17 Jan 2021 22:46:36 -0800
Subject: [PATCH] arm,kern: Stop using the getArgument function for kernel
 events.

This change plumbs through an ABI to use with the GuestABI mechanism so
that the ISA switched getArgument function is no longer used.

Change-Id: I0d394dcfd7ad6fa745b6ef2aa62973167108f0c3
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/39320
Reviewed-by: Bobby R. Bruce <bbruce@ucdavis.edu>
Reviewed-by: Giacomo Travaglini <giacomo.travaglini@arm.com>
Maintainer: Giacomo Travaglini <giacomo.travaglini@arm.com>
Tested-by: kokoro <noreply+kokoro@google.com>
---
 src/arch/arm/freebsd/fs_workload.cc |  3 +--
 src/arch/arm/fs_workload.hh         | 30 +++++++++++++++++++++++++++++
 src/arch/arm/linux/fs_workload.cc   | 21 ++++++++------------
 src/kern/freebsd/events.cc          |  7 +------
 src/kern/freebsd/events.hh          | 17 +++++++++++-----
 src/kern/linux/events.cc            |  7 +------
 src/kern/linux/events.hh            | 16 ++++++++++-----
 7 files changed, 64 insertions(+), 37 deletions(-)

diff --git a/src/arch/arm/freebsd/fs_workload.cc b/src/arch/arm/freebsd/fs_workload.cc
index cc0151bb65..7cd7a03665 100644
--- a/src/arch/arm/freebsd/fs_workload.cc
+++ b/src/arch/arm/freebsd/fs_workload.cc
@@ -68,8 +68,7 @@ FsFreebsd::FsFreebsd(const Params &p) : ArmISA::FsWorkload(p),
             "oops_exit", "Kernel oops in guest");
     }
 
-    skipUDelay = addKernelFuncEvent<SkipUDelay<ArmISA::SkipFunc>>(
-        "DELAY", "DELAY", 1000, 0);
+    skipUDelay = addSkipFunc<SkipUDelay>("DELAY", "DELAY", 1000, 0);
 }
 
 void
diff --git a/src/arch/arm/fs_workload.hh b/src/arch/arm/fs_workload.hh
index 4461670475..d7f17389ca 100644
--- a/src/arch/arm/fs_workload.hh
+++ b/src/arch/arm/fs_workload.hh
@@ -44,6 +44,8 @@
 #include <memory>
 #include <vector>
 
+#include "arch/arm/aapcs32.hh"
+#include "arch/arm/aapcs64.hh"
 #include "kern/linux/events.hh"
 #include "params/ArmFsWorkload.hh"
 #include "sim/kernel_workload.hh"
@@ -86,6 +88,34 @@ class FsWorkload : public KernelWorkload
      */
     Loader::ObjectFile *getBootLoader(Loader::ObjectFile *const obj);
 
+    template <template <class ABI, class Base> class FuncEvent,
+             typename... Args>
+    PCEvent *
+    addSkipFunc(Args... args)
+    {
+        if (getArch() == Loader::Arm64) {
+            return addKernelFuncEvent<FuncEvent<Aapcs64, SkipFunc>>(
+                    std::forward<Args>(args)...);
+        } else {
+            return addKernelFuncEvent<FuncEvent<Aapcs32, SkipFunc>>(
+                    std::forward<Args>(args)...);
+        }
+    }
+
+    template <template <class ABI, class Base> class FuncEvent,
+             typename... Args>
+    PCEvent *
+    addSkipFuncOrPanic(Args... args)
+    {
+        if (getArch() == Loader::Arm64) {
+            return addKernelFuncEventOrPanic<FuncEvent<Aapcs64, SkipFunc>>(
+                    std::forward<Args>(args)...);
+        } else {
+            return addKernelFuncEventOrPanic<FuncEvent<Aapcs32, SkipFunc>>(
+                    std::forward<Args>(args)...);
+        }
+    }
+
   public:
     typedef ArmFsWorkloadParams Params;
     const Params &
diff --git a/src/arch/arm/linux/fs_workload.cc b/src/arch/arm/linux/fs_workload.cc
index b296b68081..3c29298194 100644
--- a/src/arch/arm/linux/fs_workload.cc
+++ b/src/arch/arm/linux/fs_workload.cc
@@ -230,28 +230,23 @@ FsLinux::startup()
 
     // With ARM udelay() is #defined to __udelay
     // newer kernels use __loop_udelay and __loop_const_udelay symbols
-    skipUDelay = addKernelFuncEvent<SkipUDelay<SkipFunc>>(
+    skipUDelay = addSkipFunc<SkipUDelay>(
         "__loop_udelay", "__udelay", 1000, 0);
-    if (!skipUDelay)
-        skipUDelay = addKernelFuncEventOrPanic<SkipUDelay<SkipFunc>>(
-         "__udelay", "__udelay", 1000, 0);
+    if (!skipUDelay) {
+        skipUDelay = addSkipFuncOrPanic<SkipUDelay>(
+                "__udelay", "__udelay", 1000, 0);
+    }
 
     // constant arguments to udelay() have some precomputation done ahead of
     // time. Constant comes from code.
-    skipConstUDelay = addKernelFuncEvent<SkipUDelay<SkipFunc>>(
+    skipConstUDelay = addSkipFunc<SkipUDelay>(
         "__loop_const_udelay", "__const_udelay", 1000, 107374);
     if (!skipConstUDelay) {
-        skipConstUDelay = addKernelFuncEventOrPanic<SkipUDelay<SkipFunc>>(
+        skipConstUDelay = addSkipFuncOrPanic<SkipUDelay>(
             "__const_udelay", "__const_udelay", 1000, 107374);
     }
 
-    if (getArch() == Loader::Arm64) {
-        debugPrintk = addKernelFuncEvent<
-            DebugPrintk<SkipFuncLinux64>>("dprintk");
-    } else {
-        debugPrintk = addKernelFuncEvent<
-            DebugPrintk<SkipFuncLinux32>>("dprintk");
-    }
+    debugPrintk = addSkipFunc<DebugPrintk>("dprintk");
 }
 
 void
diff --git a/src/kern/freebsd/events.cc b/src/kern/freebsd/events.cc
index 0c4c613291..e6b66fa68a 100644
--- a/src/kern/freebsd/events.cc
+++ b/src/kern/freebsd/events.cc
@@ -45,13 +45,8 @@ namespace FreeBSD
 {
 
 void
-onUDelay(ThreadContext *tc, uint64_t div, uint64_t mul)
+onUDelay(ThreadContext *tc, uint64_t div, uint64_t mul, uint64_t time)
 {
-    int arg_num = 0;
-
-    // Get the time in native size
-    uint64_t time = TheISA::getArgument(tc, arg_num,  (uint16_t)-1, false);
-
     // convert parameter to ns
     if (div)
         time /= div;
diff --git a/src/kern/freebsd/events.hh b/src/kern/freebsd/events.hh
index 79894b649c..ebf6128be6 100644
--- a/src/kern/freebsd/events.hh
+++ b/src/kern/freebsd/events.hh
@@ -34,18 +34,19 @@
 #define __KERN_FREEBSD_EVENTS_HH__
 
 #include "kern/system_events.hh"
+#include "sim/guest_abi.hh"
 
 namespace FreeBSD
 {
 
-void onUDelay(ThreadContext *tc, uint64_t div, uint64_t mul);
+void onUDelay(ThreadContext *tc, uint64_t div, uint64_t mul, uint64_t time);
 
 /** A class to skip udelay() and related calls in the kernel.
- * This class has two additional parameters that take the argument to udelay and
- * manipulated it to come up with ns and eventually ticks to quiesce for.
+ * This class has two additional parameters that take the argument to udelay
+ * and manipulated it to come up with ns and eventually ticks to quiesce for.
  * See descriptions of argDivToNs and argMultToNs below.
  */
-template <typename Base>
+template <typename ABI, typename Base>
 class SkipUDelay : public Base
 {
   private:
@@ -69,7 +70,13 @@ class SkipUDelay : public Base
     void
     process(ThreadContext *tc) override
     {
-        onUDelay(tc, argDivToNs, argMultToNs);
+        // Use Addr since it's handled specially and will act as a natively
+        // sized data type.
+        std::function<void(ThreadContext *, Addr)> call_udelay =
+            [this](ThreadContext *tc, Addr time) {
+            onUDelay(tc, argDivToNs, argMultToNs, time);
+        };
+        invokeSimcall<ABI>(tc, call_udelay);
         Base::process(tc);
     }
 };
diff --git a/src/kern/linux/events.cc b/src/kern/linux/events.cc
index db487e822d..8ae76b33b5 100644
--- a/src/kern/linux/events.cc
+++ b/src/kern/linux/events.cc
@@ -78,13 +78,8 @@ KernelPanic::process(ThreadContext *tc)
 }
 
 void
-onUDelay(ThreadContext *tc, uint64_t div, uint64_t mul)
+onUDelay(ThreadContext *tc, uint64_t div, uint64_t mul, uint64_t time)
 {
-    int arg_num = 0;
-
-    // Get the time in native size
-    uint64_t time = TheISA::getArgument(tc, arg_num, (uint16_t)-1, false);
-
     // convert parameter to ns
     if (div)
         time /= div;
diff --git a/src/kern/linux/events.hh b/src/kern/linux/events.hh
index 2ca97a43bb..8785345d32 100644
--- a/src/kern/linux/events.hh
+++ b/src/kern/linux/events.hh
@@ -56,7 +56,7 @@ class ThreadContext;
 namespace Linux
 {
 
-template <typename Base>
+template <typename ABI, typename Base>
 class DebugPrintk : public Base
 {
   public:
@@ -71,7 +71,7 @@ class DebugPrintk : public Base
                     PrintkVarArgs args) -> int {
                 return printk(str, tc, format_ptr, args);
             };
-            invokeSimcall<typename Base::ABI>(tc, func);
+            invokeSimcall<ABI>(tc, func);
             DPRINTFN("%s", str);
         }
         Base::process(tc);
@@ -120,7 +120,7 @@ class KernelPanic : public PCEvent
     void process(ThreadContext *tc) override;
 };
 
-void onUDelay(ThreadContext *tc, uint64_t div, uint64_t mul);
+void onUDelay(ThreadContext *tc, uint64_t div, uint64_t mul, uint64_t time);
 
 /**
  * A class to skip udelay() and related calls in the kernel.
@@ -128,7 +128,7 @@ void onUDelay(ThreadContext *tc, uint64_t div, uint64_t mul);
  * and manipulated it to come up with ns and eventually ticks to quiesce for.
  * See descriptions of argDivToNs and argMultToNs below.
  */
-template <typename Base>
+template <typename ABI, typename Base>
 class SkipUDelay : public Base
 {
   private:
@@ -156,7 +156,13 @@ class SkipUDelay : public Base
     void
     process(ThreadContext *tc) override
     {
-        onUDelay(tc, argDivToNs, argMultToNs);
+        // Use Addr since it's handled specially and will act as a natively
+        // sized data type.
+        std::function<void(ThreadContext *, Addr)> call_udelay =
+            [this](ThreadContext *tc, Addr time) {
+            onUDelay(tc, argDivToNs, argMultToNs, time);
+        };
+        invokeSimcall<ABI>(tc, call_udelay);
         Base::process(tc);
     }
 };