Start rewriting live analysis

Signed-off-by: Ádám László Kulcsár <[email protected]>

Author: kulcsaradam

src/interpreter/ByteCode.cpp

@@ -17,6 +17,7 @@
 #ifndef __WalrusByteCode__
 #define __WalrusByteCode__
 
+#include "Walrus.h"
 #if !defined(NDEBUG)
 #include <cinttypes>
 #include "runtime/Module.h"
@@ -932,6 +933,12 @@ class ByteCode {
 
     Opcode opcode() const;
     size_t getSize() const;
+    std::vector<Walrus::ByteCodeStackOffset> getByteCodeStackOffsets(FunctionType* funcType) const;
+    void setByteCodeOffset(size_t index, Walrus::ByteCodeStackOffset offset, Walrus::ByteCodeStackOffset original);
+    void dump() const
+    {
+        return;
+    }
 
 protected:
     friend class Interpreter;
@@ -964,6 +971,8 @@ class ByteCodeOffset2 : public ByteCode {
 
     ByteCodeStackOffset stackOffset1() const { return m_stackOffset1; }
     ByteCodeStackOffset stackOffset2() const { return m_stackOffset2; }
+    void setStackOffset1(Walrus::ByteCodeStackOffset o) { m_stackOffset1 = o; }
+    void setStackOffset2(Walrus::ByteCodeStackOffset o) { m_stackOffset2 = o; }
 
 protected:
     ByteCodeStackOffset m_stackOffset1;
@@ -982,6 +991,7 @@ class ByteCodeOffset3 : public ByteCode {
     ByteCodeStackOffset stackOffset1() const { return m_stackOffsets[0]; }
     ByteCodeStackOffset stackOffset2() const { return m_stackOffsets[1]; }
     ByteCodeStackOffset stackOffset3() const { return m_stackOffsets[2]; }
+    void setStackOffset(uint8_t index, Walrus::ByteCodeStackOffset o) { m_stackOffsets[index] = o; }
 
 protected:
     ByteCodeStackOffset m_stackOffsets[3];
@@ -997,6 +1007,7 @@ class ByteCodeOffsetValue : public ByteCode {
     }
 
     ByteCodeStackOffset stackOffset() const { return m_stackOffset; }
+    void setStackOffset(ByteCodeStackOffset o) { m_stackOffset = o; }
     uint32_t uint32Value() const { return m_value; }
     int32_t int32Value() const { return static_cast<int32_t>(m_value); }
 
@@ -1016,7 +1027,9 @@ class ByteCodeOffset2Value : public ByteCode {
     }
 
     ByteCodeStackOffset stackOffset1() const { return m_stackOffset1; }
+    void setStackOffset1(ByteCodeStackOffset o) { m_stackOffset1 = o; }
     ByteCodeStackOffset stackOffset2() const { return m_stackOffset2; }
+    void setStackOffset2(ByteCodeStackOffset o) { m_stackOffset2 = o; }
     uint32_t uint32Value() const { return m_value; }
     int32_t int32Value() const { return static_cast<int32_t>(m_value); }
 
@@ -1041,7 +1054,9 @@ class ByteCodeOffset2ValueMemIdx : public ByteCode {
     uint16_t memIndex() const { return m_memIndex; }
     uint16_t alignment() const { return m_alignment; }
     ByteCodeStackOffset stackOffset1() const { return m_stackOffset1; }
+    void setStackOffset1(ByteCodeStackOffset o) { m_stackOffset1 = o; }
     ByteCodeStackOffset stackOffset2() const { return m_stackOffset2; }
+    void setStackOffset2(ByteCodeStackOffset o) { m_stackOffset2 = o; }
     uint32_t uint32Value() const { return m_value; }
     int32_t int32Value() const { return static_cast<int32_t>(m_value); }
 
@@ -1066,6 +1081,7 @@ class ByteCodeOffset4 : public ByteCode {
     ByteCodeStackOffset src1Offset() const { return m_stackOffsets[1]; }
     ByteCodeStackOffset src2Offset() const { return m_stackOffsets[2]; }
     ByteCodeStackOffset dstOffset() const { return m_stackOffsets[3]; }
+    void setStackOffset(size_t index, ByteCodeStackOffset o) { m_stackOffsets[index] = o; }
 
 protected:
     ByteCodeStackOffset m_stackOffsets[4];
@@ -1235,6 +1251,7 @@ class BinaryOperation : public ByteCodeOffset3 {
     const ByteCodeStackOffset* srcOffset() const { return stackOffsets(); }
     ByteCodeStackOffset dstOffset() const { return stackOffset3(); }
     void setDstOffset(ByteCodeStackOffset o) { m_stackOffsets[2] = o; }
+    void setSrcOffsset(ByteCodeStackOffset o, size_t index) { m_stackOffsets[index] = o; }
 #if !defined(NDEBUG)
     void dump(size_t pos)
     {
@@ -1394,6 +1411,11 @@ class Call : public ByteCode {
         return reinterpret_cast<ByteCodeStackOffset*>(reinterpret_cast<size_t>(this) + sizeof(Call));
     }
 
+    void setStackOffset(size_t index, ByteCodeStackOffset o)
+    {
+        reinterpret_cast<ByteCodeStackOffset*>(reinterpret_cast<size_t>(this) + sizeof(Call))[index] = o;
+    }
+
     uint16_t parameterOffsetsSize() const
     {
         return m_parameterOffsetsSize;
@@ -1444,13 +1466,21 @@ class CallIndirect : public ByteCode {
     }
 
     ByteCodeStackOffset calleeOffset() const { return m_calleeOffset; }
+    void setCalleeOffset(ByteCodeStackOffset o) { m_calleeOffset = o; }
     uint32_t tableIndex() const { return m_tableIndex; }
     FunctionType* functionType() const { return m_functionType; }
     ByteCodeStackOffset* stackOffsets() const
     {
         return reinterpret_cast<ByteCodeStackOffset*>(reinterpret_cast<size_t>(this) + sizeof(CallIndirect));
     }
 
+    void setStackOffset(size_t index, ByteCodeStackOffset o)
+    {
+        (reinterpret_cast<ByteCodeStackOffset*>(reinterpret_cast<size_t>(this) + sizeof(CallIndirect)))[index] = o;
+
+        // *(reinterpret_cast<ByteCodeStackOffset*>(reinterpret_cast<size_t>(this) + sizeof(Call) + index * sizeof(ByteCodeStackOffset))) = o;
+    }
+
     uint16_t parameterOffsetsSize() const
     {
         return m_parameterOffsetsSize;
@@ -1761,11 +1791,15 @@ class Select : public ByteCode {
     }
 
     ByteCodeStackOffset condOffset() const { return m_condOffset; }
+    void setCondOffset(ByteCodeStackOffset o) { m_condOffset = o; }
     uint16_t valueSize() const { return m_valueSize; }
     bool isFloat() const { return m_isFloat != 0; }
     ByteCodeStackOffset src0Offset() const { return m_src0Offset; }
+    void setSrc0Offset(ByteCodeStackOffset o) { m_src0Offset = o; }
     ByteCodeStackOffset src1Offset() const { return m_src1Offset; }
+    void setSrc1Offset(ByteCodeStackOffset o) { m_src1Offset = o; }
     ByteCodeStackOffset dstOffset() const { return m_dstOffset; }
+    void setDstOffset(ByteCodeStackOffset o) { m_dstOffset = o; }
 
 #if !defined(NDEBUG)
     void dump(size_t pos)
@@ -1798,6 +1832,7 @@ class BrTable : public ByteCode {
     }
 
     ByteCodeStackOffset condOffset() const { return m_condOffset; }
+    void setCondOffset(ByteCodeStackOffset o) { m_condOffset = o; }
     int32_t defaultOffset() const { return m_defaultOffset; }
     static inline size_t offsetOfDefault() { return offsetof(BrTable, m_defaultOffset); }
 
@@ -1871,6 +1906,10 @@ class MemoryInit : public ByteCode {
     {
         return m_srcOffsets;
     }
+    void setStackOffset(size_t index, ByteCodeStackOffset o)
+    {
+        m_srcOffsets[index] = o;
+    }
 
     uint16_t memIndex() const { return m_memIndex; }
 
@@ -3110,6 +3149,10 @@ class TableCopy : public ByteCode {
     {
         return m_srcOffsets;
     }
+    void setStackOffset(size_t index, ByteCodeStackOffset o)
+    {
+        m_srcOffsets[index] = o;
+    }
 
 #if !defined(NDEBUG)
     void dump(size_t pos)
@@ -3174,6 +3217,11 @@ class TableInit : public ByteCode {
     {
         return m_srcOffsets;
     }
+    void setStackOffset(size_t index, ByteCodeStackOffset o)
+    {
+        m_srcOffsets[index] = o;
+    }
+
 #if !defined(NDEBUG)
     void dump(size_t pos)
     {
@@ -3391,6 +3439,10 @@ class Throw : public ByteCode {
     {
         return reinterpret_cast<ByteCodeStackOffset*>(reinterpret_cast<size_t>(this) + sizeof(Throw));
     }
+    void setDataOffset(size_t index, ByteCodeStackOffset o)
+    {
+        reinterpret_cast<ByteCodeStackOffset*>(reinterpret_cast<size_t>(this) + sizeof(Throw))[index] = o;
+    }
 
     uint32_t offsetsSize() const
     {
@@ -3466,6 +3518,11 @@ class End : public ByteCode {
         return reinterpret_cast<ByteCodeStackOffset*>(reinterpret_cast<size_t>(this) + sizeof(End));
     }
 
+    void setResultOffset(size_t index, ByteCodeStackOffset o)
+    {
+        reinterpret_cast<ByteCodeStackOffset*>(reinterpret_cast<size_t>(this) + sizeof(End))[index] = o;
+    }
+
     uint32_t offsetsSize() const
     {
         return m_offsetsSize;

src/interpreter/ByteCode.h

@@ -98,7 +98,7 @@ void JITArg::set(Operand* operand)
     Instruction* instr = VARIABLE_GET_IMM(*operand);
 
 #if (defined SLJIT_32BIT_ARCHITECTURE && SLJIT_32BIT_ARCHITECTURE)
-    ASSERT(instr->opcode() == ByteCode::Const32Opcode);
+    //    ASSERT(instr->opcode() == ByteCode::Const32Opcode);
 
     this->argw = static_cast<sljit_s32>(reinterpret_cast<Const32*>(instr->byteCode())->value());
 #else /* !SLJIT_32BIT_ARCHITECTURE */