Cleanup MacroAssembler in preparation for becoming a template

Move some of the used types and functions into the class name space.

Change-Id: I2da72714d796a202ae9181c7a18745a94d95d925
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

1 files changed, 74 insertions, 53 deletions

diff --git a/src/3rdparty/masm/assembler/MacroAssembler.h b/src/3rdparty/masm/assembler/MacroAssembler.h
index e122e2f3ae..1fbca4c55b 100644
--- a/src/3rdparty/masm/assembler/MacroAssembler.h
+++ b/src/3rdparty/masm/assembler/MacroAssembler.h
@@ -70,6 +70,27 @@ namespace JSC {
 
 class MacroAssembler : public MacroAssemblerBase {
 public:
+    using DoubleCondition = typename MacroAssemblerBase::DoubleCondition;
+    using ResultCondition = typename MacroAssemblerBase::ResultCondition;
+    using RelationalCondition = typename MacroAssemblerBase::RelationalCondition;
+    using RegisterID = typename MacroAssemblerBase::RegisterID;
+    using Address = typename MacroAssemblerBase::Address;
+    using ExtendedAddress = typename MacroAssemblerBase::ExtendedAddress;
+    using BaseIndex = typename MacroAssemblerBase::BaseIndex;
+    using ImplicitAddress = typename MacroAssemblerBase::ImplicitAddress;
+    using AbsoluteAddress = typename MacroAssemblerBase::AbsoluteAddress;
+    using TrustedImm32 = typename MacroAssemblerBase::TrustedImm32;
+    using TrustedImm64 = typename MacroAssemblerBase::TrustedImm64;
+    using TrustedImmPtr = typename MacroAssemblerBase::TrustedImmPtr;
+    using Imm32 = typename MacroAssemblerBase::Imm32;
+    using Imm64 = typename MacroAssemblerBase::Imm64;
+    using ImmPtr = typename MacroAssemblerBase::ImmPtr;
+    using Label = typename MacroAssemblerBase::Label;
+    using DataLabelPtr = typename MacroAssemblerBase::DataLabelPtr;
+    using DataLabel32 = typename MacroAssemblerBase::DataLabel32;
+    using DataLabelCompact = typename MacroAssemblerBase::DataLabelCompact;
+    using Jump = typename MacroAssemblerBase::Jump;
+    using PatchableJump = typename MacroAssemblerBase::PatchableJump;
 
     using MacroAssemblerBase::pop;
     using MacroAssemblerBase::jump;
@@ -100,41 +121,41 @@ public:
     static DoubleCondition invert(DoubleCondition cond)
     {
         switch (cond) {
-        case DoubleEqual:
-            return DoubleNotEqualOrUnordered;
-        case DoubleNotEqual:
-            return DoubleEqualOrUnordered;
-        case DoubleGreaterThan:
-            return DoubleLessThanOrEqualOrUnordered;
-        case DoubleGreaterThanOrEqual:
-            return DoubleLessThanOrUnordered;
-        case DoubleLessThan:
-            return DoubleGreaterThanOrEqualOrUnordered;
-        case DoubleLessThanOrEqual:
-            return DoubleGreaterThanOrUnordered;
-        case DoubleEqualOrUnordered:
-            return DoubleNotEqual;
-        case DoubleNotEqualOrUnordered:
-            return DoubleEqual;
-        case DoubleGreaterThanOrUnordered:
-            return DoubleLessThanOrEqual;
-        case DoubleGreaterThanOrEqualOrUnordered:
-            return DoubleLessThan;
-        case DoubleLessThanOrUnordered:
-            return DoubleGreaterThanOrEqual;
-        case DoubleLessThanOrEqualOrUnordered:
-            return DoubleGreaterThan;
+        case DoubleCondition::DoubleEqual:
+            return DoubleCondition::DoubleNotEqualOrUnordered;
+        case DoubleCondition::DoubleNotEqual:
+            return DoubleCondition::DoubleEqualOrUnordered;
+        case DoubleCondition::DoubleGreaterThan:
+            return DoubleCondition::DoubleLessThanOrEqualOrUnordered;
+        case DoubleCondition::DoubleGreaterThanOrEqual:
+            return DoubleCondition::DoubleLessThanOrUnordered;
+        case DoubleCondition::DoubleLessThan:
+            return DoubleCondition::DoubleGreaterThanOrEqualOrUnordered;
+        case DoubleCondition::DoubleLessThanOrEqual:
+            return DoubleCondition::DoubleGreaterThanOrUnordered;
+        case DoubleCondition::DoubleEqualOrUnordered:
+            return DoubleCondition::DoubleNotEqual;
+        case DoubleCondition::DoubleNotEqualOrUnordered:
+            return DoubleCondition::DoubleEqual;
+        case DoubleCondition::DoubleGreaterThanOrUnordered:
+            return DoubleCondition::DoubleLessThanOrEqual;
+        case DoubleCondition::DoubleGreaterThanOrEqualOrUnordered:
+            return DoubleCondition::DoubleLessThan;
+        case DoubleCondition::DoubleLessThanOrUnordered:
+            return DoubleCondition::DoubleGreaterThanOrEqual;
+        case DoubleCondition::DoubleLessThanOrEqualOrUnordered:
+            return DoubleCondition::DoubleGreaterThan;
         default:
             RELEASE_ASSERT_NOT_REACHED();
-            return DoubleEqual; // make compiler happy
+            return DoubleCondition::DoubleEqual; // make compiler happy
         }
     }
     
     static bool isInvertible(ResultCondition cond)
     {
         switch (cond) {
-        case Zero:
-        case NonZero:
+        case ResultCondition::Zero:
+        case ResultCondition::NonZero:
             return true;
         default:
             return false;
@@ -144,13 +165,13 @@ public:
     static ResultCondition invert(ResultCondition cond)
     {
         switch (cond) {
-        case Zero:
-            return NonZero;
-        case NonZero:
-            return Zero;
+        case ResultCondition::Zero:
+            return ResultCondition::NonZero;
+        case ResultCondition::NonZero:
+            return ResultCondition::Zero;
         default:
             RELEASE_ASSERT_NOT_REACHED();
-            return Zero; // Make compiler happy for release builds.
+            return ResultCondition::Zero; // Make compiler happy for release builds.
         }
     }
 #endif
@@ -159,17 +180,17 @@ public:
     // described in terms of other macro assembly methods.
     void pop()
     {
-        addPtr(TrustedImm32(sizeof(void*)), stackPointerRegister);
+        addPtr(TrustedImm32(sizeof(void*)), MacroAssemblerBase::stackPointerRegister);
     }
     
     void peek(RegisterID dest, int index = 0)
     {
-        loadPtr(Address(stackPointerRegister, (index * sizeof(void*))), dest);
+        loadPtr(Address(MacroAssemblerBase::stackPointerRegister, (index * sizeof(void*))), dest);
     }
 
     Address addressForPoke(int index)
     {
-        return Address(stackPointerRegister, (index * sizeof(void*)));
+        return Address(MacroAssemblerBase::stackPointerRegister, (index * sizeof(void*)));
     }
     
     void poke(RegisterID src, int index = 0)
@@ -190,7 +211,7 @@ public:
 #if CPU(X86_64) || CPU(ARM64)
     void peek64(RegisterID dest, int index = 0)
     {
-        load64(Address(stackPointerRegister, (index * sizeof(void*))), dest);
+        load64(Address(MacroAssemblerBase::stackPointerRegister, (index * sizeof(void*))), dest);
     }
 
     void poke(TrustedImm64 value, int index = 0)
@@ -296,27 +317,27 @@ public:
     static RelationalCondition commute(RelationalCondition condition)
     {
         switch (condition) {
-        case Above:
-            return Below;
-        case AboveOrEqual:
-            return BelowOrEqual;
-        case Below:
-            return Above;
-        case BelowOrEqual:
-            return AboveOrEqual;
-        case GreaterThan:
-            return LessThan;
-        case GreaterThanOrEqual:
-            return LessThanOrEqual;
-        case LessThan:
-            return GreaterThan;
-        case LessThanOrEqual:
-            return GreaterThanOrEqual;
+        case RelationalCondition::Above:
+            return RelationalCondition::Below;
+        case RelationalCondition::AboveOrEqual:
+            return RelationalCondition::BelowOrEqual;
+        case RelationalCondition::Below:
+            return RelationalCondition::Above;
+        case RelationalCondition::BelowOrEqual:
+            return RelationalCondition::AboveOrEqual;
+        case RelationalCondition::GreaterThan:
+            return RelationalCondition::LessThan;
+        case RelationalCondition::GreaterThanOrEqual:
+            return RelationalCondition::LessThanOrEqual;
+        case RelationalCondition::LessThan:
+            return RelationalCondition::GreaterThan;
+        case RelationalCondition::LessThanOrEqual:
+            return RelationalCondition::GreaterThanOrEqual;
         default:
             break;
         }
 
-        ASSERT(condition == Equal || condition == NotEqual);
+        ASSERT(condition == RelationalCondition::Equal || condition == RelationalCondition::NotEqual);
         return condition;
     }