A64: Synchronize with r17104.

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 283 matching lines @@
     stub->InitializeInterfaceDescriptor(isolate, descriptor);
   }
 
   // If we are uninitialized we can use a light-weight stub to enter
   // the runtime that is significantly faster than using the standard
   // stub-failure deopt mechanism.
   if (stub->IsUninitialized() && descriptor->has_miss_handler()) {
     ASSERT(descriptor->stack_parameter_count_ == NULL);
     return stub->GenerateLightweightMissCode(isolate);
   }
+  ElapsedTimer timer;
+  if (FLAG_profile_hydrogen_code_stub_compilation) {
+    timer.Start();
+  }
   CodeStubGraphBuilder<Stub> builder(isolate, stub);
   LChunk* chunk = OptimizeGraph(builder.CreateGraph());
-  return chunk->Codegen();
+  Handle<Code> code = chunk->Codegen();
+  if (FLAG_profile_hydrogen_code_stub_compilation) {
+    double ms = timer.Elapsed().InMillisecondsF();
+    PrintF("[Lazy compilation of %s took %0.3f ms]\n", *stub->GetName(), ms);
+  }
+  return code;
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<ToNumberStub>::BuildCodeStub() {
   HValue* value = GetParameter(0);
 
   // Check if the parameter is already a SMI or heap number.
   IfBuilder if_number(this);
   if_number.If<HIsSmiAndBranch>(value);
@@ skipping 518 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* result = NULL;
+  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();
+      result = 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();
+      result = Pop();
+    }
+  } else {
+    result = 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>(result,
+            Add<HConstant>(static_cast<int>(SmiValuesAre32Bits()
+                ? 0x80000000 : 0x40000000)), Token::EQ_STRICT);
+        if_of.Then();
+        if_of.ElseDeopt("UInt->Smi oveflow");
+        if_of.End();
+      }
+    }
+    result = EnforceNumberType(result, 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>(result,
+                                                Representation::Double());
+    HObjectAccess access = HObjectAccess::ForHeapNumberValue();
+    Add<HStoreNamedField>(reuse, access, res_val);
+    Push(reuse);
+    if_heap_number.Else();
+    Push(result);
+    if_heap_number.End();
+    result = Pop();
+  }
+
+  return result;
+}
+
+
+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