Hydrogenisation of binops

src/code-stubs-hydrogen.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 824 matching lines @@
       : graph()->GetConstantUndefined();
 }
 
 
 Handle<Code> CompareNilICStub::GenerateCode(Isolate* isolate) {
   return DoGenerateCode(isolate, this);
 }
 
 
 template <>
+HValue* CodeStubGraphBuilder<BinaryOpStub>::BuildCodeInitializedStub() {
+  BinaryOpStub* stub = casted_stub();
+  HValue* left = GetParameter(0);
+  HValue* right = GetParameter(1);
+
+  Handle<Type> left_type = stub->GetLeftType(isolate());
+  Handle<Type> right_type = stub->GetRightType(isolate());
+  Handle<Type> result_type = stub->GetResultType(isolate());
+
+  ASSERT(!left_type->Is(Type::None()) && !right_type->Is(Type::None()) &&
+         (stub->HasSideEffects(isolate()) || !result_type->Is(Type::None())));
+
+  HValue* res = NULL;

[Michael Starzinger, 2013/09/27 08:36:11]

nit: s/res/result/

+  if (stub->operation() == Token::ADD &&
+      (left_type->Maybe(Type::String()) || right_type->Maybe(Type::String())) &&
+      !left_type->Is(Type::String()) && !right_type->Is(Type::String())) {
+    // For the generic add stub a fast case for String add is performance
+    // critical.
+    if (left_type->Maybe(Type::String())) {
+      IfBuilder left_string(this);
+      left_string.IfNot<HIsSmiAndBranch>(left);
+      left_string.AndIf<HIsStringAndBranch>(left);
+      left_string.Then();
+      Push(Add<HStringAdd>(left, right, STRING_ADD_CHECK_RIGHT));
+      left_string.Else();
+      Push(AddInstruction(BuildBinaryOperation(stub->operation(),
+          left, right, left_type, right_type, result_type,
+          stub->fixed_right_arg(), true)));
+      left_string.End();
+      res = Pop();
+    } else {
+      IfBuilder right_string(this);
+      right_string.IfNot<HIsSmiAndBranch>(right);
+      right_string.AndIf<HIsStringAndBranch>(right);
+      right_string.Then();
+      Push(Add<HStringAdd>(left, right, STRING_ADD_CHECK_LEFT));
+      right_string.Else();
+      Push(AddInstruction(BuildBinaryOperation(stub->operation(),
+          left, right, left_type, right_type, result_type,
+          stub->fixed_right_arg(), true)));
+      right_string.End();
+      res = Pop();
+    }
+  } else {
+    res = AddInstruction(BuildBinaryOperation(stub->operation(),
+        left, right, left_type, right_type, result_type,
+        stub->fixed_right_arg(), true));
+  }
+
+  // If we encounter a generic argument, the number conversion is
+  // observable, thus we cannot afford to bail out after the fact.
+  if (!stub->HasSideEffects(isolate())) {
+    if (result_type->Is(Type::Smi())) {
+      if (stub->operation() == Token::SHR) {
+        // TODO(olivf) Replace this by a SmiTagU Instruction.
+        // 0x40000000: this number would convert to negative when interpreting
+        // the register as signed value;
+        IfBuilder if_of(this);
+        if_of.IfNot<HCompareNumericAndBranch>(res,
+            Add<HConstant>(static_cast<int>(0x40000000)), Token::EQ_STRICT);
+        if_of.Then();
+        if_of.ElseDeopt("UInt->Smi oveflow");
+        if_of.End();
+      }
+    }
+    res = EnforceNumberType(res, result_type);
+  }
+
+  // Reuse the double box if we are allowed to (i.e. chained binops).
+  if (stub->CanReuseDoubleBox()) {
+    HValue* reuse = (stub->mode() == OVERWRITE_LEFT) ? left : right;
+    IfBuilder if_heap_number(this);
+    if_heap_number.IfNot<HIsSmiAndBranch>(reuse);
+    if_heap_number.Then();
+    HValue* res_val = Add<HForceRepresentation>(res, Representation::Double());
+    HObjectAccess access = HObjectAccess::ForHeapNumberValue();
+    Add<HStoreNamedField>(reuse, access, res_val);
+    Push(reuse);
+    if_heap_number.Else();
+    Push(res);
+    if_heap_number.End();
+    res = Pop();
+  }
+
+  return res;
+}
+
+
+Handle<Code> BinaryOpStub::GenerateCode(Isolate* isolate) {
+  return DoGenerateCode(isolate, this);
+}
+
+
+template <>
 HValue* CodeStubGraphBuilder<ToBooleanStub>::BuildCodeInitializedStub() {
   ToBooleanStub* stub = casted_stub();
 
   IfBuilder if_true(this);
   if_true.If<HBranch>(GetParameter(0), stub->GetTypes());
   if_true.Then();
   if_true.Return(graph()->GetConstant1());
   if_true.Else();
   if_true.End();
   return graph()->GetConstant0();
@@ skipping 272 matching lines @@
   return js_function;
 }
 
 
 Handle<Code> FastNewClosureStub::GenerateCode(Isolate* isolate) {
   return DoGenerateCode(isolate, this);
 }
 
 
 } }  // namespace v8::internal