sim: Rename GuestABI's Position to State.

This type can hold any generic state related to locating return types
and arguments in addition to simple position information. To make that
clearer, this change renames the Position type to State.

Change-Id: I50ff2ec61c3eba0e9505c66ce32e27b515bd4b27
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/24107
Tested-by: kokoro <noreply+kokoro@google.com>
Reviewed-by: Bobby R. Bruce <bbruce@ucdavis.edu>
Maintainer: Gabe Black <gabeblack@google.com>

diff --git a/src/arch/arm/aapcs64.hh b/src/arch/arm/aapcs64.hh
index 16edcb3899b1e85ca88a2e77a56f571874444edf..9d7623a058f89bd98f7fe74ac78e7dbce40c7a09 100644 (file)
--- a/src/arch/arm/aapcs64.hh
+++ b/src/arch/arm/aapcs64.hh
@@ -44,7 +44,7 @@ class ThreadContext;
 
 struct Aapcs64
 {
-    struct Position
+    struct State
     {
         int ngrn=0; // Next general purpose register number.
         int nsrn=0; // Next SIMD and floating point register number.
@@ -55,7 +55,7 @@ struct Aapcs64
         // The maximum allowed SIMD and floating point register number.
         static const int MAX_SRN = 7;
 
-        explicit Position(const ThreadContext *tc) :
+        explicit State(const ThreadContext *tc) :
             nsaa(tc->readIntReg(ArmISA::INTREG_SPX))
         {}
     };
@@ -161,7 +161,7 @@ struct Aapcs64ArgumentBase
 {
     template <typename T>
     static T
-    loadFromStack(ThreadContext *tc, Aapcs64::Position &position)
+    loadFromStack(ThreadContext *tc, Aapcs64::State &state)
     {
         // The alignment is the larger of 8 or the natural alignment of T.
         size_t align = std::max<size_t>(8, alignof(T));
@@ -169,14 +169,14 @@ struct Aapcs64ArgumentBase
         size_t size = roundUp(sizeof(T), 8);
 
         // Align the stack.
-        position.nsaa = roundUp(position.nsaa, align);
+        state.nsaa = roundUp(state.nsaa, align);
 
         // Extract the value from it.
-        TypedBufferArg<T> val(position.nsaa);
+        TypedBufferArg<T> val(state.nsaa);
         val.copyIn(tc->getVirtProxy());
 
         // Move the nsaa past this argument.
-        position.nsaa += size;
+        state.nsaa += size;
 
         // Return the value we extracted.
         return gtoh(*val, ArmISA::byteOrder(tc));
@@ -195,14 +195,14 @@ struct Argument<Aapcs64, Float, typename std::enable_if<
     public Aapcs64ArgumentBase
 {
     static Float
-    get(ThreadContext *tc, Aapcs64::Position &position)
+    get(ThreadContext *tc, Aapcs64::State &state)
     {
-        if (position.nsrn <= position.MAX_SRN) {
-            RegId id(VecRegClass, position.nsrn++);
+        if (state.nsrn <= state.MAX_SRN) {
+            RegId id(VecRegClass, state.nsrn++);
             return tc->readVecReg(id).laneView<Float, 0>();
         }
 
-        return loadFromStack<Float>(tc, position);
+        return loadFromStack<Float>(tc, state);
     }
 };
 
@@ -232,25 +232,25 @@ struct Argument<Aapcs64, Integer, typename std::enable_if<
     std::is_integral<Integer>::value>::type> : public Aapcs64ArgumentBase
 {
     static Integer
-    get(ThreadContext *tc, Aapcs64::Position &position)
+    get(ThreadContext *tc, Aapcs64::State &state)
     {
-        if (sizeof(Integer) <= 8 && position.ngrn <= position.MAX_GRN)
-            return tc->readIntReg(position.ngrn++);
+        if (sizeof(Integer) <= 8 && state.ngrn <= state.MAX_GRN)
+            return tc->readIntReg(state.ngrn++);
 
-        if (alignof(Integer) == 16 && (position.ngrn % 2))
-            position.ngrn++;
+        if (alignof(Integer) == 16 && (state.ngrn % 2))
+            state.ngrn++;
 
-        if (sizeof(Integer) == 16 && position.ngrn + 1 <= position.MAX_GRN) {
-            Integer low = tc->readIntReg(position.ngrn++);
-            Integer high = tc->readIntReg(position.ngrn++);
+        if (sizeof(Integer) == 16 && state.ngrn + 1 <= state.MAX_GRN) {
+            Integer low = tc->readIntReg(state.ngrn++);
+            Integer high = tc->readIntReg(state.ngrn++);
             high = high << 64;
             return high | low;
         }
 
         // Max out ngrn since we've effectively saturated it.
-        position.ngrn = position.MAX_GRN + 1;
+        state.ngrn = state.MAX_GRN + 1;
 
-        return loadFromStack<Integer>(tc, position);
+        return loadFromStack<Integer>(tc, state);
     }
 };
 
@@ -287,22 +287,22 @@ struct Argument<Aapcs64, HA, typename std::enable_if<
     IsAapcs64Hxa<HA>::value>::type> : public Aapcs64ArgumentBase
 {
     static HA
-    get(ThreadContext *tc, Aapcs64::Position &position)
+    get(ThreadContext *tc, Aapcs64::State &state)
     {
         using Elem = typename Aapcs64ArrayType<HA>::Type;
         constexpr size_t Count = sizeof(HA) / sizeof(Elem);
 
-        if (position.nsrn + Count - 1 <= position.MAX_SRN) {
+        if (state.nsrn + Count - 1 <= state.MAX_SRN) {
             HA ha;
             for (int i = 0; i < Count; i++)
-                ha[i] = Argument<Aapcs64, Elem>::get(tc, position);
+                ha[i] = Argument<Aapcs64, Elem>::get(tc, state);
             return ha;
         }
 
         // Max out the nsrn since we effectively exhausted it.
-        position.nsrn = position.MAX_SRN + 1;
+        state.nsrn = state.MAX_SRN + 1;
 
-        return loadFromStack<HA>(tc, position);
+        return loadFromStack<HA>(tc, state);
     }
 };
 
@@ -332,13 +332,13 @@ struct Argument<Aapcs64, Composite, typename std::enable_if<
     >::type> : public Aapcs64ArgumentBase
 {
     static Composite
-    get(ThreadContext *tc, Aapcs64::Position &position)
+    get(ThreadContext *tc, Aapcs64::State &state)
     {
         if (sizeof(Composite) > 16) {
             // Composite values larger than 16 which aren't HFAs or HVAs are
             // kept in a buffer, and the argument is actually a pointer to that
             // buffer.
-            Addr addr = Argument<Aapcs64, Addr>::get(tc, position);
+            Addr addr = Argument<Aapcs64, Addr>::get(tc, state);
             TypedBufferArg<Composite> composite(addr);
             composite.copyIn(tc->getVirtProxy());
             return gtoh(*composite, ArmISA::byteOrder(tc));
@@ -353,10 +353,10 @@ struct Argument<Aapcs64, Composite, typename std::enable_if<
         const int regs = (bytes + chunk_size - 1) / chunk_size;
 
         // Can it fit in GPRs?
-        if (position.ngrn + regs - 1 <= position.MAX_GRN) {
+        if (state.ngrn + regs - 1 <= state.MAX_GRN) {
             alignas(alignof(Composite)) uint8_t buf[bytes];
             for (int i = 0; i < regs; i++) {
-                Chunk val = tc->readIntReg(position.ngrn++);
+                Chunk val = tc->readIntReg(state.ngrn++);
                 val = htog(val, ArmISA::byteOrder(tc));
                 size_t to_copy = std::min<size_t>(bytes, chunk_size);
                 memcpy(buf + i * chunk_size, &val, to_copy);
@@ -366,9 +366,9 @@ struct Argument<Aapcs64, Composite, typename std::enable_if<
         }
 
         // Max out the ngrn since we effectively exhausted it.
-        position.ngrn = position.MAX_GRN;
+        state.ngrn = state.MAX_GRN;
 
-        return loadFromStack<Composite>(tc, position);
+        return loadFromStack<Composite>(tc, state);
     }
 };
 

diff --git a/src/arch/arm/process.hh b/src/arch/arm/process.hh
index 08100fcd46c75233b019b0e5b7372bfa91ce0ed6..3d0e3493735f4daf766b86144d015d967429a2f8 100644 (file)
--- a/src/arch/arm/process.hh
+++ b/src/arch/arm/process.hh
@@ -101,15 +101,15 @@ struct Argument<ABI, Arg,
         ABI::template IsWide<Arg>::value>::type>
 {
     static Arg
-    get(ThreadContext *tc, typename ABI::Position &position)
+    get(ThreadContext *tc, typename ABI::State &state)
     {
         // 64 bit arguments are passed starting in an even register.
-        if (position % 2)
-            position++;
-        panic_if(position + 1 >= ABI::ArgumentRegs.size(),
+        if (state % 2)
+            state++;
+        panic_if(state + 1 >= ABI::ArgumentRegs.size(),
                 "Ran out of syscall argument registers.");
-        auto low = ABI::ArgumentRegs[position++];
-        auto high = ABI::ArgumentRegs[position++];
+        auto low = ABI::ArgumentRegs[state++];
+        auto high = ABI::ArgumentRegs[state++];
         return (Arg)ABI::mergeRegs(tc, low, high);
     }
 };

diff --git a/src/arch/sparc/process.hh b/src/arch/sparc/process.hh
index 79e3e41fb3610eb2b2a3b89b7d8ff4ada68889db..785417ca73b701f7da6d2a6e0c2ef74ba6988d45 100644 (file)
--- a/src/arch/sparc/process.hh
+++ b/src/arch/sparc/process.hh
@@ -166,12 +166,12 @@ struct Argument<Sparc32Process::SyscallABI, Arg,
     using ABI = Sparc32Process::SyscallABI;
 
     static Arg
-    get(ThreadContext *tc, typename ABI::Position &position)
+    get(ThreadContext *tc, typename ABI::State &state)
     {
-        panic_if(position + 1 >= ABI::ArgumentRegs.size(),
+        panic_if(state + 1 >= ABI::ArgumentRegs.size(),
                 "Ran out of syscall argument registers.");
-        auto high = ABI::ArgumentRegs[position++];
-        auto low = ABI::ArgumentRegs[position++];
+        auto high = ABI::ArgumentRegs[state++];
+        auto low = ABI::ArgumentRegs[state++];
         return (Arg)ABI::mergeRegs(tc, low, high);
     }
 };

diff --git a/src/arch/x86/linux/process.hh b/src/arch/x86/linux/process.hh
index a236a9e1227056198b225bebeb5f9fb9bf307175..c3bd4ebb9d3d08b44e457d2d739dd8106ddf98fe 100644 (file)
--- a/src/arch/x86/linux/process.hh
+++ b/src/arch/x86/linux/process.hh
@@ -91,12 +91,12 @@ struct Argument<X86ISA::I386LinuxProcess::SyscallABI, Arg,
     using ABI = X86ISA::I386LinuxProcess::SyscallABI;
 
     static Arg
-    get(ThreadContext *tc, typename ABI::Position &position)
+    get(ThreadContext *tc, typename ABI::State &state)
     {
-        panic_if(position + 1 >= ABI::ArgumentRegs.size(),
+        panic_if(state + 1 >= ABI::ArgumentRegs.size(),
                 "Ran out of syscall argument registers.");
-        auto low = ABI::ArgumentRegs[position++];
-        auto high = ABI::ArgumentRegs[position++];
+        auto low = ABI::ArgumentRegs[state++];
+        auto high = ABI::ArgumentRegs[state++];
         return (Arg)ABI::mergeRegs(tc, low, high);
     }
 };

diff --git a/src/arch/x86/pseudo_inst_abi.hh b/src/arch/x86/pseudo_inst_abi.hh
index 5ac5efe42f0b5f3a394280682d83b8f8ba935451..36e40db83d989fe73fc6e0a69d948cf7fc92b333 100644 (file)
--- a/src/arch/x86/pseudo_inst_abi.hh
+++ b/src/arch/x86/pseudo_inst_abi.hh
@@ -40,7 +40,7 @@
 
 struct X86PseudoInstABI
 {
-    using Position = int;
+    using State = int;
 };
 
 namespace GuestABI
@@ -63,12 +63,12 @@ template <>
 struct Argument<X86PseudoInstABI, uint64_t>
 {
     static uint64_t
-    get(ThreadContext *tc, X86PseudoInstABI::Position &position)
+    get(ThreadContext *tc, X86PseudoInstABI::State &state)
     {
         // The first 6 integer arguments are passed in registers, the rest
         // are passed on the stack.
 
-        panic_if(position >= 6, "Too many psuedo inst arguments.");
+        panic_if(state >= 6, "Too many psuedo inst arguments.");
 
         using namespace X86ISA;
 
@@ -77,7 +77,7 @@ struct Argument<X86PseudoInstABI, uint64_t>
             INTREG_RCX, INTREG_R8, INTREG_R9
         };
 
-        return tc->readIntReg(int_reg_map[position++]);
+        return tc->readIntReg(int_reg_map[state++]);
     }
 };
 

diff --git a/src/sim/guest_abi.hh b/src/sim/guest_abi.hh
index 310fc00d04abd3a0a4a6bcd952098b80f057bc40..704155b4e523dd4b431225f6cb094e67419c4e02 100644 (file)
--- a/src/sim/guest_abi.hh
+++ b/src/sim/guest_abi.hh
@@ -47,11 +47,11 @@ Ret
 invokeSimcall(ThreadContext *tc,
               std::function<Ret(ThreadContext *, Args...)> target)
 {
-    // Default construct a Position to track consumed resources. Built in
+    // Default construct a State to track consumed resources. Built in
     // types will be zero initialized.
-    auto position = GuestABI::initializePosition<ABI>(tc);
-    GuestABI::prepareForFunction<ABI, Ret, Args...>(tc, position);
-    return GuestABI::callFrom<ABI, Ret, Args...>(tc, position, target);
+    auto state = GuestABI::initializeState<ABI>(tc);
+    GuestABI::prepareForFunction<ABI, Ret, Args...>(tc, state);
+    return GuestABI::callFrom<ABI, Ret, Args...>(tc, state, target);
 }
 
 template <typename ABI, typename Ret, typename ...Args>
@@ -67,11 +67,11 @@ void
 invokeSimcall(ThreadContext *tc,
               std::function<void(ThreadContext *, Args...)> target)
 {
-    // Default construct a Position to track consumed resources. Built in
+    // Default construct a State to track consumed resources. Built in
     // types will be zero initialized.
-    auto position = GuestABI::initializePosition<ABI>(tc);
-    GuestABI::prepareForArguments<ABI, Args...>(tc, position);
-    GuestABI::callFrom<ABI, Args...>(tc, position, target);
+    auto state = GuestABI::initializeState<ABI>(tc);
+    GuestABI::prepareForArguments<ABI, Args...>(tc, state);
+    GuestABI::callFrom<ABI, Args...>(tc, state, target);
 }
 
 template <typename ABI, typename ...Args>
@@ -93,12 +93,12 @@ dumpSimcall(std::string name, ThreadContext *tc,
             std::function<Ret(ThreadContext *, Args...)> target=
             std::function<Ret(ThreadContext *, Args...)>())
 {
-    auto position = GuestABI::initializePosition<ABI>(tc);
+    auto state = GuestABI::initializeState<ABI>(tc);
     std::ostringstream ss;
 
-    GuestABI::prepareForFunction<ABI, Ret, Args...>(tc, position);
+    GuestABI::prepareForFunction<ABI, Ret, Args...>(tc, state);
     ss << name;
-    GuestABI::dumpArgsFrom<ABI, Ret, Args...>(0, ss, tc, position);
+    GuestABI::dumpArgsFrom<ABI, Ret, Args...>(0, ss, tc, state);
     return ss.str();
 }
 

diff --git a/src/sim/guest_abi.test.cc b/src/sim/guest_abi.test.cc
index 9ac7defc2ef40841848fa1aed3c151046025ac1d..6b5d0607bd9f7aeba05a4de3a678ad215dca9063 100644 (file)
--- a/src/sim/guest_abi.test.cc
+++ b/src/sim/guest_abi.test.cc
@@ -63,13 +63,13 @@ const double ThreadContext::DefaultFloatResult = 0.0;
 // registers.
 struct TestABI_1D
 {
-    using Position = int;
+    using State = int;
 };
 
 // ABI anchor for an ABI which uses the prepare() hook.
 struct TestABI_Prepare
 {
-    using Position = int;
+    using State = int;
 };
 
 // ABI anchor for an ABI which has 2D progress. Conceptually, this could be
@@ -77,15 +77,15 @@ struct TestABI_Prepare
 // registers.
 struct TestABI_2D
 {
-    using Position = std::pair<int, int>;
+    using State = std::pair<int, int>;
 };
 
 struct TestABI_TcInit
 {
-    struct Position
+    struct State
     {
         int pos;
-        Position(const ThreadContext *tc) : pos(tc->intOffset) {}
+        State(const ThreadContext *tc) : pos(tc->intOffset) {}
     };
 };
 
@@ -98,9 +98,9 @@ template <>
 struct Argument<TestABI_1D, int>
 {
     static int
-    get(ThreadContext *tc, TestABI_1D::Position &position)
+    get(ThreadContext *tc, TestABI_1D::State &state)
     {
-        return tc->ints[position++];
+        return tc->ints[state++];
     }
 };
 
@@ -109,9 +109,9 @@ struct Argument<TestABI_1D, Arg,
     typename std::enable_if<std::is_floating_point<Arg>::value>::type>
 {
     static Arg
-    get(ThreadContext *tc, TestABI_1D::Position &position)
+    get(ThreadContext *tc, TestABI_1D::State &state)
     {
-        return tc->floats[position++];
+        return tc->floats[state++];
     }
 };
 
@@ -143,15 +143,15 @@ template <>
 struct Argument<TestABI_Prepare, int>
 {
     static int
-    get(ThreadContext *tc, TestABI_Prepare::Position &position)
+    get(ThreadContext *tc, TestABI_Prepare::State &state)
     {
-        return tc->ints[--position];
+        return tc->ints[--state];
     }
 
     static void
-    prepare(ThreadContext *tc, TestABI_Prepare::Position &position)
+    prepare(ThreadContext *tc, TestABI_Prepare::State &state)
     {
-        position++;
+        state++;
     }
 };
 
@@ -160,9 +160,9 @@ struct Result<TestABI_Prepare, Ret>
 {
     static void store(ThreadContext *tc, const Ret &ret) {}
     static void
-    prepare(ThreadContext *tc, TestABI_Prepare::Position &position)
+    prepare(ThreadContext *tc, TestABI_Prepare::State &state)
     {
-        position++;
+        state++;
     }
 };
 
@@ -173,9 +173,9 @@ template <>
 struct Argument<TestABI_2D, int>
 {
     static int
-    get(ThreadContext *tc, TestABI_2D::Position &position)
+    get(ThreadContext *tc, TestABI_2D::State &state)
     {
-        return tc->ints[position.first++];
+        return tc->ints[state.first++];
     }
 };
 
@@ -184,9 +184,9 @@ struct Argument<TestABI_2D, Arg,
     typename std::enable_if<std::is_floating_point<Arg>::value>::type>
 {
     static Arg
-    get(ThreadContext *tc, TestABI_2D::Position &position)
+    get(ThreadContext *tc, TestABI_2D::State &state)
     {
-        return tc->floats[position.second++];
+        return tc->floats[state.second++];
     }
 };
 
@@ -216,9 +216,9 @@ template <>
 struct Argument<TestABI_TcInit, int>
 {
     static int
-    get(ThreadContext *tc, TestABI_TcInit::Position &position)
+    get(ThreadContext *tc, TestABI_TcInit::State &state)
     {
-        return tc->ints[position.pos++];
+        return tc->ints[state.pos++];
     }
 };
 

diff --git a/src/sim/guest_abi/definition.hh b/src/sim/guest_abi/definition.hh
index b43a482d0363e9794c6c1ff9a5c6144deb4a6e49..becdb3c85950a7013d95d3053f5b7fb689b7ccea 100644 (file)
--- a/src/sim/guest_abi/definition.hh
+++ b/src/sim/guest_abi/definition.hh
@@ -36,9 +36,9 @@ namespace GuestABI
 /*
  * To implement an ABI, a subclass needs to implement a system of
  * specializations of these two templates Result and Argument, and define a
- * "Position" type.
+ * "State" type.
  *
- * The Position type carries information about, for instance, how many
+ * The State type carries information about, for instance, how many
  * integer registers have been consumed gathering earlier arguments. It
  * may contain multiple elements if there are multiple dimensions to track,
  * for instance the number of integer and floating point registers used so far.
@@ -60,7 +60,7 @@ struct Result
   private:
     /*
      * Store result "ret" into the state accessible through tc. Optionally
-     * accept "position" in case it holds some signature wide information.
+     * accept "state" in case it holds some signature wide information.
      *
      * Note that the declaration below is only to document the expected
      * signature and is private so it won't be used by accident.
@@ -69,7 +69,7 @@ struct Result
      */
     static void store(ThreadContext *tc, const Ret &ret);
     static void store(ThreadContext *tc, const Ret &ret,
-                      typename ABI::Position &position);
+                      typename ABI::State &state);
 
     /*
      * Prepare for a result of type Ret. This might mean, for instance,
@@ -77,7 +77,7 @@ struct Result
      *
      * This method can be excluded if no preparation is necessary.
      */
-    static void prepare(ThreadContext *tc, typename ABI::Position &position);
+    static void prepare(ThreadContext *tc, typename ABI::State &state);
 };
 
 /*
@@ -93,13 +93,13 @@ struct Argument
 {
     /*
      * Retrieve an argument of type Arg from the state accessible through tc,
-     * assuming the state represented by "position" has already been used.
-     * Also update position to account for this argument as well.
+     * assuming the state represented by "state" has already been used.
+     * Also update state to account for this argument as well.
      *
      * Like Result::store above, the declaration below is only to document
      * the expected method signature.
      */
-    static Arg get(ThreadContext *tc, typename ABI::Position &position);
+    static Arg get(ThreadContext *tc, typename ABI::State &state);
 
     /*
      * Prepare for an argument of type Arg. This might mean, for instance,
@@ -107,7 +107,7 @@ struct Argument
      *
      * This method can be excluded if no preparation is necessary.
      */
-    static void allocate(ThreadContext *tc, typename ABI::Position &position);
+    static void allocate(ThreadContext *tc, typename ABI::State &state);
 };
 
 } // namespace GuestABI

diff --git a/src/sim/guest_abi/dispatch.hh b/src/sim/guest_abi/dispatch.hh
index eb703a5fd4f27560cb48d16c84f37e38a917c623..62cbf291d2db18686667a261e1ed324edf0ac199 100644 (file)
--- a/src/sim/guest_abi/dispatch.hh
+++ b/src/sim/guest_abi/dispatch.hh
@@ -54,18 +54,18 @@ namespace GuestABI
 // result.
 template <typename ABI, typename Ret>
 static typename std::enable_if<!std::is_void<Ret>::value, Ret>::type
-callFrom(ThreadContext *tc, typename ABI::Position &position,
+callFrom(ThreadContext *tc, typename ABI::State &state,
         std::function<Ret(ThreadContext *)> target)
 {
     Ret ret = target(tc);
-    storeResult<ABI, Ret>(tc, ret, position);
+    storeResult<ABI, Ret>(tc, ret, state);
     return ret;
 }
 
 // With no arguments to gather and nothing to return, call the target function.
 template <typename ABI>
 static void
-callFrom(ThreadContext *tc, typename ABI::Position &position,
+callFrom(ThreadContext *tc, typename ABI::State &state,
         std::function<void(ThreadContext *)> target)
 {
     target(tc);
@@ -75,11 +75,11 @@ callFrom(ThreadContext *tc, typename ABI::Position &position,
 // case above.
 template <typename ABI, typename Ret, typename NextArg, typename ...Args>
 static typename std::enable_if<!std::is_void<Ret>::value, Ret>::type
-callFrom(ThreadContext *tc, typename ABI::Position &position,
+callFrom(ThreadContext *tc, typename ABI::State &state,
         std::function<Ret(ThreadContext *, NextArg, Args...)> target)
 {
     // Extract the next argument from the thread context.
-    NextArg next = getArgument<ABI, NextArg>(tc, position);
+    NextArg next = getArgument<ABI, NextArg>(tc, state);
 
     // Build a partial function which adds the next argument to the call.
     std::function<Ret(ThreadContext *, Args...)> partial =
@@ -88,18 +88,18 @@ callFrom(ThreadContext *tc, typename ABI::Position &position,
         };
 
     // Recursively handle any remaining arguments.
-    return callFrom<ABI, Ret, Args...>(tc, position, partial);
+    return callFrom<ABI, Ret, Args...>(tc, state, partial);
 }
 
 // Recursively gather arguments for target from tc until we get to the base
 // case above. This version is for functions that don't return anything.
 template <typename ABI, typename NextArg, typename ...Args>
 static void
-callFrom(ThreadContext *tc, typename ABI::Position &position,
+callFrom(ThreadContext *tc, typename ABI::State &state,
         std::function<void(ThreadContext *, NextArg, Args...)> target)
 {
     // Extract the next argument from the thread context.
-    NextArg next = getArgument<ABI, NextArg>(tc, position);
+    NextArg next = getArgument<ABI, NextArg>(tc, state);
 
     // Build a partial function which adds the next argument to the call.
     std::function<void(ThreadContext *, Args...)> partial =
@@ -108,7 +108,7 @@ callFrom(ThreadContext *tc, typename ABI::Position &position,
         };
 
     // Recursively handle any remaining arguments.
-    callFrom<ABI, Args...>(tc, position, partial);
+    callFrom<ABI, Args...>(tc, state, partial);
 }
 
 
@@ -122,7 +122,7 @@ callFrom(ThreadContext *tc, typename ABI::Position &position,
 template <typename ABI, typename Ret>
 static void
 dumpArgsFrom(int count, std::ostream &os, ThreadContext *tc,
-             typename ABI::Position &position)
+             typename ABI::State &state)
 {
     os << ")";
 }
@@ -133,20 +133,20 @@ dumpArgsFrom(int count, std::ostream &os, ThreadContext *tc,
 template <typename ABI, typename Ret, typename NextArg, typename ...Args>
 static void
 dumpArgsFrom(int count, std::ostream &os, ThreadContext *tc,
-             typename ABI::Position &position)
+             typename ABI::State &state)
 {
     // Either open the parenthesis or add a comma, depending on where we are
     // in the argument list.
     os << (count ? ", " : "(");
 
     // Extract the next argument from the thread context.
-    NextArg next = getArgument<ABI, NextArg>(tc, position);
+    NextArg next = getArgument<ABI, NextArg>(tc, state);
 
     // Add this argument to the list.
     os << next;
 
     // Recursively handle any remaining arguments.
-    dumpArgsFrom<ABI, Ret, Args...>(count + 1, os, tc, position);
+    dumpArgsFrom<ABI, Ret, Args...>(count + 1, os, tc, state);
 }
 
 } // namespace GuestABI

diff --git a/src/sim/guest_abi/layout.hh b/src/sim/guest_abi/layout.hh
index ecc3a0826b39ce739fcb8b386a3e1714bce92c8c..d5df3a7c45b78d19fccf2e23a813a0d8c7fadf6b 100644 (file)
--- a/src/sim/guest_abi/layout.hh
+++ b/src/sim/guest_abi/layout.hh
@@ -38,36 +38,36 @@ namespace GuestABI
 {
 
 /*
- * Position may need to be initialized based on the ThreadContext, for instance
+ * State may need to be initialized based on the ThreadContext, for instance
  * to find out where the stack pointer is initially.
  */
 template <typename ABI, typename Enabled=void>
-struct PositionInitializer
+struct StateInitializer
 {
-    static typename ABI::Position
+    static typename ABI::State
     init(const ThreadContext *tc)
     {
-        return typename ABI::Position();
+        return typename ABI::State();
     }
 };
 
 template <typename ABI>
-struct PositionInitializer<ABI, typename std::enable_if<
-    std::is_constructible<typename ABI::Position, const ThreadContext *>::value
+struct StateInitializer<ABI, typename std::enable_if<
+    std::is_constructible<typename ABI::State, const ThreadContext *>::value
     >::type>
 {
-    static typename ABI::Position
+    static typename ABI::State
     init(const ThreadContext *tc)
     {
-        return typename ABI::Position(tc);
+        return typename ABI::State(tc);
     }
 };
 
 template <typename ABI>
-static typename ABI::Position
-initializePosition(const ThreadContext *tc)
+static typename ABI::State
+initializeState(const ThreadContext *tc)
 {
-    return PositionInitializer<ABI>::init(tc);
+    return StateInitializer<ABI>::init(tc);
 }
 
 /*
@@ -81,7 +81,7 @@ template <typename ABI, template <class ...> class Role,
 struct Preparer
 {
     static void
-    prepare(ThreadContext *tc, typename ABI::Position &position)
+    prepare(ThreadContext *tc, typename ABI::State &state)
     {}
 };
 
@@ -94,52 +94,52 @@ template <typename ABI, template <class ...> class Role, typename Type>
 struct Preparer<ABI, Role, Type, decltype((void)&Role<ABI, Type>::prepare)>
 {
     static void
-    prepare(ThreadContext *tc, typename ABI::Position &position)
+    prepare(ThreadContext *tc, typename ABI::State &state)
     {
-        Role<ABI, Type>::prepare(tc, position);
+        Role<ABI, Type>::prepare(tc, state);
     }
 };
 
 template <typename ABI, typename Ret, typename Enabled=void>
 static void
-prepareForResult(ThreadContext *tc, typename ABI::Position &position)
+prepareForResult(ThreadContext *tc, typename ABI::State &state)
 {
-    Preparer<ABI, Result, Ret>::prepare(tc, position);
+    Preparer<ABI, Result, Ret>::prepare(tc, state);
 }
 
 template <typename ABI>
 static void
-prepareForArguments(ThreadContext *tc, typename ABI::Position &position)
+prepareForArguments(ThreadContext *tc, typename ABI::State &state)
 {
     return;
 }
 
 template <typename ABI, typename NextArg, typename ...Args>
 static void
-prepareForArguments(ThreadContext *tc, typename ABI::Position &position)
+prepareForArguments(ThreadContext *tc, typename ABI::State &state)
 {
-    Preparer<ABI, Argument, NextArg>::prepare(tc, position);
-    prepareForArguments<ABI, Args...>(tc, position);
+    Preparer<ABI, Argument, NextArg>::prepare(tc, state);
+    prepareForArguments<ABI, Args...>(tc, state);
 }
 
 template <typename ABI, typename Ret, typename ...Args>
 static void
-prepareForFunction(ThreadContext *tc, typename ABI::Position &position)
+prepareForFunction(ThreadContext *tc, typename ABI::State &state)
 {
-    prepareForResult<ABI, Ret>(tc, position);
-    prepareForArguments<ABI, Args...>(tc, position);
+    prepareForResult<ABI, Ret>(tc, state);
+    prepareForArguments<ABI, Args...>(tc, state);
 }
 
 /*
  * This struct template provides a way to call the Result store method and
- * optionally pass it the position.
+ * optionally pass it the state.
  */
 
 template <typename ABI, typename Ret, typename Enabled=void>
 struct ResultStorer
 {
     static void
-    store(ThreadContext *tc, const Ret &ret, typename ABI::Position &position)
+    store(ThreadContext *tc, const Ret &ret, typename ABI::State &state)
     {
         Result<ABI, Ret>::store(tc, ret);
     }
@@ -153,14 +153,13 @@ std::false_type foo(void (*)(ThreadContext *, const Ret &ret));
 
 template <typename ABI, typename Ret>
 struct ResultStorer<ABI, Ret, typename std::enable_if<
-    std::is_same<void (*)(ThreadContext *, const Ret &,
-                          typename ABI::Position &),
+    std::is_same<void (*)(ThreadContext *, const Ret &, typename ABI::State &),
                  decltype(&Result<ABI, Ret>::store)>::value>::type>
 {
     static void
-    store(ThreadContext *tc, const Ret &ret, typename ABI::Position &position)
+    store(ThreadContext *tc, const Ret &ret, typename ABI::State &state)
     {
-        Result<ABI, Ret>::store(tc, ret, position);
+        Result<ABI, Ret>::store(tc, ret, state);
     }
 };
 
@@ -170,17 +169,16 @@ struct ResultStorer<ABI, Ret, typename std::enable_if<
 
 template <typename ABI, typename Ret>
 static void
-storeResult(ThreadContext *tc, const Ret &ret,
-            typename ABI::Position &position)
+storeResult(ThreadContext *tc, const Ret &ret, typename ABI::State &state)
 {
-    ResultStorer<ABI, Ret>::store(tc, ret, position);
+    ResultStorer<ABI, Ret>::store(tc, ret, state);
 }
 
 template <typename ABI, typename Arg>
 static Arg
-getArgument(ThreadContext *tc, typename ABI::Position &position)
+getArgument(ThreadContext *tc, typename ABI::State &state)
 {
-    return Argument<ABI, Arg>::get(tc, position);
+    return Argument<ABI, Arg>::get(tc, state);
 }
 
 } // namespace GuestABI

diff --git a/src/sim/guest_abi/varargs.hh b/src/sim/guest_abi/varargs.hh
index c350a8128d078ea40d97b9e49ed07b75af6ca89b..41e3c623f91f487253be5813a3dcd678f66c088f 100644 (file)
--- a/src/sim/guest_abi/varargs.hh
+++ b/src/sim/guest_abi/varargs.hh
@@ -114,7 +114,7 @@ class VarArgsImpl<ABI, Base, First, Types...> :
     void
     _getImpl(First &first) override
     {
-        first = Argument<ABI, First>::get(this->tc, this->position);
+        first = Argument<ABI, First>::get(this->tc, this->state);
     }
 };
 
@@ -125,14 +125,14 @@ class VarArgsImpl<ABI, Base> : public Base
   protected:
     // Declare state to pass to the Argument<>::get methods.
     ThreadContext *tc;
-    typename ABI::Position position;
+    typename ABI::State state;
 
     // Give the "using" statement in our subclass something to refer to.
     void _getImpl();
 
   public:
-    VarArgsImpl(ThreadContext *_tc, const typename ABI::Position &_pos) :
-        tc(_tc), position(_pos)
+    VarArgsImpl(ThreadContext *_tc, const typename ABI::State &_state) :
+        tc(_tc), state(_state)
     {}
 };
 
@@ -184,11 +184,11 @@ template <typename ABI, typename ...Types>
 struct Argument<ABI, VarArgs<Types...>>
 {
     static VarArgs<Types...>
-    get(ThreadContext *tc, typename ABI::Position &position)
+    get(ThreadContext *tc, typename ABI::State &state)
     {
         using Base = VarArgsBase<Types...>;
         using Impl = VarArgsImpl<ABI, Base, Types...>;
-        return VarArgs<Types...>(new Impl(tc, position));
+        return VarArgs<Types...>(new Impl(tc, state));
     }
 };
 

diff --git a/src/sim/pseudo_inst.hh b/src/sim/pseudo_inst.hh
index 9be742e96103f0687259b148355ab8d598290f99..fbf997a9c16f8f877247f27a4d492339cc79d096 100644 (file)
--- a/src/sim/pseudo_inst.hh
+++ b/src/sim/pseudo_inst.hh
@@ -53,7 +53,7 @@ class ThreadContext;
 
 struct PseudoInstABI
 {
-    using Position = int;
+    using State = int;
 };
 
 namespace GuestABI
@@ -73,11 +73,11 @@ template <>
 struct Argument<PseudoInstABI, uint64_t>
 {
     static uint64_t
-    get(ThreadContext *tc, PseudoInstABI::Position &position)
+    get(ThreadContext *tc, PseudoInstABI::State &state)
     {
-        uint64_t result = TheISA::getArgument(tc, position, sizeof(uint64_t),
-                                              false);
-        position++;
+        uint64_t result =
+            TheISA::getArgument(tc, state, sizeof(uint64_t), false);
+        state++;
         return result;
     }
 };

diff --git a/src/sim/syscall_abi.hh b/src/sim/syscall_abi.hh
index f6eade50e94d9911d1470b8cad7de2ebcc9dbe41..533dece47c9b92e94e902939c64b24586a3c03e2 100644 (file)
--- a/src/sim/syscall_abi.hh
+++ b/src/sim/syscall_abi.hh
@@ -49,7 +49,7 @@ struct IsConforming<Addr> : public std::true_type {};
 
 struct GenericSyscallABI
 {
-    using Position = int;
+    using State = int;
 };
 
 struct GenericSyscallABI64 : public GenericSyscallABI
@@ -100,11 +100,11 @@ struct Argument<ABI, Arg,
         std::is_integral<Arg>::value>::type>
 {
     static Arg
-    get(ThreadContext *tc, typename ABI::Position &position)
+    get(ThreadContext *tc, typename ABI::State &state)
     {
-        panic_if(position >= ABI::ArgumentRegs.size(),
+        panic_if(state >= ABI::ArgumentRegs.size(),
                 "Ran out of syscall argument registers.");
-        return tc->readIntReg(ABI::ArgumentRegs[position++]);
+        return tc->readIntReg(ABI::ArgumentRegs[state++]);
     }
 };
 
@@ -115,11 +115,11 @@ struct Argument<ABI, Arg,
     typename std::enable_if<!ABI::template IsWide<Arg>::value>::type>
 {
     static Arg
-    get(ThreadContext *tc, typename ABI::Position &position)
+    get(ThreadContext *tc, typename ABI::State &state)
     {
-        panic_if(position >= ABI::ArgumentRegs.size(),
+        panic_if(state >= ABI::ArgumentRegs.size(),
                 "Ran out of syscall argument registers.");
-        return bits(tc->readIntReg(ABI::ArgumentRegs[position++]), 31, 0);
+        return bits(tc->readIntReg(ABI::ArgumentRegs[state++]), 31, 0);
     }
 };