JavaScriptCore-1218.tar.gz

[apple/javascriptcore.git] / bytecode / Operands.h

diff --git a/bytecode/Operands.h b/bytecode/Operands.h
index a05159f8129f2a1d6fd89438a6503b46f2ba53b8..e7b3e241fb4f13beb1b566ade73932d869df6d28 100644 (file)
--- a/bytecode/Operands.h
+++ b/bytecode/Operands.h
@@ -28,7 +28,7 @@
 
 #include "CallFrame.h"
 #include "JSObject.h"
 
 #include "CallFrame.h"
 #include "JSObject.h"

-#include "ScopeChain.h"
+#include <wtf/PrintStream.h>

 #include <wtf/Vector.h>
 
 namespace JSC {
 #include <wtf/Vector.h>
 
 namespace JSC {


@@ -43,9 +43,11 @@ template<typename T> struct OperandValueTraits;
 template<typename T>
 struct OperandValueTraits {
     static T defaultValue() { return T(); }
 template<typename T>
 struct OperandValueTraits {
     static T defaultValue() { return T(); }

-    static void dump(const T& value, FILE* out) { value.dump(out); }
+    static void dump(const T& value, PrintStream& out) { value.dump(out); }

 };
 
 };
 

+enum OperandKind { ArgumentOperand, LocalOperand };
+

 template<typename T, typename Traits = OperandValueTraits<T> >
 class Operands {
 public:
 template<typename T, typename Traits = OperandValueTraits<T> >
 class Operands {
 public:


@@ -66,6 +68,28 @@ public:
     T& local(size_t idx) { return m_locals[idx]; }
     const T& local(size_t idx) const { return m_locals[idx]; }
     
     T& local(size_t idx) { return m_locals[idx]; }
     const T& local(size_t idx) const { return m_locals[idx]; }
     

+    template<OperandKind operandKind>
+    size_t sizeFor() const
+    {
+        if (operandKind == ArgumentOperand)
+            return numberOfArguments();
+        return numberOfLocals();
+    }
+    template<OperandKind operandKind>
+    T& atFor(size_t idx)
+    {
+        if (operandKind == ArgumentOperand)
+            return argument(idx);
+        return local(idx);
+    }
+    template<OperandKind operandKind>
+    const T& atFor(size_t idx) const
+    {
+        if (operandKind == ArgumentOperand)
+            return argument(idx);
+        return local(idx);
+    }
+    

     void ensureLocals(size_t size)
     {
         if (size <= m_locals.size())
     void ensureLocals(size_t size)
     {
         if (size <= m_locals.size())


@@ -115,6 +139,13 @@ public:
     
     const T& operand(int operand) const { return const_cast<const T&>(const_cast<Operands*>(this)->operand(operand)); }
     
     
     const T& operand(int operand) const { return const_cast<const T&>(const_cast<Operands*>(this)->operand(operand)); }
     

+    bool hasOperand(int operand) const
+    {
+        if (operandIsArgument(operand))
+            return true;
+        return static_cast<size_t>(operand) < numberOfLocals();
+    }
+    

     void setOperand(int operand, const T& value)
     {
         if (operandIsArgument(operand)) {
     void setOperand(int operand, const T& value)
     {
         if (operandIsArgument(operand)) {


@@ -126,6 +157,49 @@ public:
         setLocal(operand, value);
     }
     
         setLocal(operand, value);
     }
     

+    size_t size() const { return numberOfArguments() + numberOfLocals(); }
+    const T& at(size_t index) const
+    {
+        if (index < numberOfArguments())
+            return m_arguments[index];
+        return m_locals[index - numberOfArguments()];
+    }
+    T& at(size_t index)
+    {
+        if (index < numberOfArguments())
+            return m_arguments[index];
+        return m_locals[index - numberOfArguments()];
+    }
+    const T& operator[](size_t index) const { return at(index); }
+    T& operator[](size_t index) { return at(index); }
+
+    bool isArgument(size_t index) const { return index < numberOfArguments(); }
+    bool isVariable(size_t index) const { return !isArgument(index); }
+    int argumentForIndex(size_t index) const
+    {
+        return index;
+    }
+    int variableForIndex(size_t index) const
+    {
+        return index - m_arguments.size();
+    }
+    int operandForIndex(size_t index) const
+    {
+        if (index < numberOfArguments())
+            return argumentToOperand(index);
+        return index - numberOfArguments();
+    }
+    
+    void setOperandFirstTime(int operand, const T& value)
+    {
+        if (operandIsArgument(operand)) {
+            setArgumentFirstTime(operandToArgument(operand), value);
+            return;
+        }
+        
+        setLocalFirstTime(operand, value);
+    }
+    

     void clear()
     {
         for (size_t i = 0; i < m_arguments.size(); ++i)
     void clear()
     {
         for (size_t i = 0; i < m_arguments.size(); ++i)


@@ -140,17 +214,19 @@ private:
 };
 
 template<typename T, typename Traits>
 };
 
 template<typename T, typename Traits>

-void dumpOperands(Operands<T, Traits>& operands, FILE* out)
+void dumpOperands(const Operands<T, Traits>& operands, PrintStream& out)

 {
 {

-    for (size_t argument = 0; argument < operands.numberOfArguments(); ++argument) {
-        if (argument)
-            fprintf(out, " ");
+    for (size_t argument = operands.numberOfArguments(); argument--;) {
+        if (argument != operands.numberOfArguments() - 1)
+            out.printf(" ");
+        out.print("arg", argument, ":");

         Traits::dump(operands.argument(argument), out);
     }
         Traits::dump(operands.argument(argument), out);
     }

-    fprintf(out, " : ");
+    out.printf(" : ");

     for (size_t local = 0; local < operands.numberOfLocals(); ++local) {
         if (local)
     for (size_t local = 0; local < operands.numberOfLocals(); ++local) {
         if (local)

-            fprintf(out, " ");
+            out.printf(" ");
+        out.print("r", local, ":");

         Traits::dump(operands.local(local), out);
     }
 }
         Traits::dump(operands.local(local), out);
     }
 }