Changeset 84413 in webkit for trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h

Timestamp:

Apr 20, 2011, 1:47:53 PM (14 years ago)

Author:

[email protected]

Message:

Bug 59022 - DFG JIT - Optimize branch-on-relational-compare

Reviewed by Oliver Hunt.

If a relational compare (< or <=) is immediately followed by a branch,
we can combine the two, avoiding generation of a boolean into a register.

• assembler/MacroAssemblerX86Common.h:

(JSC::MacroAssemblerX86Common::branch32):
(JSC::MacroAssemblerX86Common::invert):
(JSC::MacroAssemblerX86Common::commute):

• dfg/DFGNode.h:

(JSC::DFG::Node::adjustedRefCount):

• dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compilePeepHoleBranch):
(JSC::DFG::SpeculativeJIT::compile):

• dfg/DFGSpeculativeJIT.h:

(JSC::DFG::SpeculativeJIT::isJSConstantWithInt32Value):
(JSC::DFG::SpeculativeJIT::detectPeepHoleBranch):

File:

• trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h

@@ -819 +819 @@
     }
     
+    Jump branch32(RelationalCondition cond, TrustedImm32 left, RegisterID right)
+    {
+        if (((cond == Equal) || (cond == NotEqual)) && !left.m_value)
+            m_assembler.testl_rr(right, right);
+        else
+            m_assembler.cmpl_ir(left.m_value, right);
+        return Jump(m_assembler.jCC(x86Condition(commute(cond))));
+    }
+    
     Jump branch32(RelationalCondition cond, RegisterID left, Address right)
     {
@@ -1159 +1168 @@
         m_assembler.setCC_r(x86Condition(cond), dest);
         m_assembler.movzbl_rr(dest, dest);
+    }
+
+    // Invert a relational condition, e.g. == becomes !=, < becomes >=, etc.
+    static RelationalCondition invert(RelationalCondition cond)
+    {
+        return static_cast<RelationalCondition>(cond ^ 1);
+    }
+
+    // Commute a relational condition, returns a new condition that will produce
+    // the same results given the same inputs but with their positions exchanged.
+    static RelationalCondition commute(RelationalCondition cond)
+    {
+        // Equality is commutative!
+        if (cond == Equal || cond == NotEqual)
+            return cond;
+
+        // Based on the values of x86 condition codes, remap > with < and >= with <=
+        if (cond >= LessThan) {
+            ASSERT(cond == LessThan || cond == LessThanOrEqual || cond == GreaterThan || cond == GreaterThanOrEqual);
+            return static_cast<RelationalCondition>(X86Assembler::ConditionL + X86Assembler::ConditionG - cond);
+        }
+
+        // As above, for unsigned conditions.
+        ASSERT(cond == Below || cond == BelowOrEqual || cond == Above || cond == AboveOrEqual);
+        return static_cast<RelationalCondition>(X86Assembler::ConditionB + X86Assembler::ConditionA - cond);
     }