A64: Synchronize with r15358.

src/a64/lithium-a64.cc

 // Copyright 2013 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 536 matching lines @@
 LOperand* LChunkBuilder::FixedTemp(DoubleRegister reg) {
   LUnallocated* operand = ToUnallocated(reg);
   ASSERT(operand->HasFixedPolicy());
   return operand;
 }
 
 
 LPlatformChunk* LChunkBuilder::Build() {
   ASSERT(is_unused());
   chunk_ = new(zone_) LPlatformChunk(info_, graph_);
-  HPhase phase("L_Building chunk", chunk_);
+  LPhase phase("L_Building chunk", chunk_);
   status_ = BUILDING;
   const ZoneList<HBasicBlock*>* blocks = graph_->blocks();
   for (int i = 0; i < blocks->length(); i++) {
     DoBasicBlock(blocks->at(i));
     if (is_aborted()) return NULL;
   }
   status_ = DONE;
   return chunk_;
 }
 
@@ skipping 302 matching lines @@
 LInstruction* LChunkBuilder::DoAllocate(HAllocate* instr) {
   info()->MarkAsDeferredCalling();
   LOperand* size = UseRegisterOrConstant(instr->size());
   LOperand* temp1 = TempRegister();
   LOperand* temp2 = TempRegister();
   LAllocate* result = new(zone()) LAllocate(size, temp1, temp2);
   return AssignPointerMap(DefineAsRegister(result));
 }
 
 
+LInstruction* LChunkBuilder::DoAllocateObject(HAllocateObject* instr) {
+  info()->MarkAsDeferredCalling();
+  LAllocateObject* result =
+      new(zone()) LAllocateObject(TempRegister(), TempRegister());
+  return AssignPointerMap(DefineAsRegister(result));
+}
+
+
 LInstruction* LChunkBuilder::DoApplyArguments(HApplyArguments* instr) {
   LOperand* function = UseFixed(instr->function(), x1);
   LOperand* receiver = UseFixed(instr->receiver(), x0);
   LOperand* length = UseFixed(instr->length(), x2);
   LOperand* elements = UseFixed(instr->elements(), x3);
   LApplyArguments* result = new(zone()) LApplyArguments(function,
                                                         receiver,
                                                         length,
                                                         elements);
   return MarkAsCall(DefineFixed(result, x0), instr, CAN_DEOPTIMIZE_EAGERLY);
@@ skipping 68 matching lines @@
 
   if (value->EmitAtUses()) {
     // TODO(all): Handle this case with CheckElideControlInstruction once
     // we've done the rebase.
     HBasicBlock* successor = HConstant::cast(value)->BooleanValue()
         ? instr->FirstSuccessor()
         : instr->SecondSuccessor();
     return new(zone()) LGoto(successor->block_id());
   }
 
-  Representation rep = value->representation();
+  Representation r = value->representation();
   HType type = value->type();
 
-  if (rep.IsTagged() && !type.IsSmi() && !type.IsBoolean()) {
-    ToBooleanStub::Types expected = instr->expected_input_types();
-    LOperand* temp1 = NULL;
-    LOperand* temp2 = NULL;
-
-    if (expected.NeedsMap() || expected.IsEmpty()) {
-      temp1 = TempRegister();
-      temp2 = TempRegister();
+  if (r.IsInteger32() || r.IsSmi() || r.IsDouble()) {
+    // These representations have simple checks that cannot deoptimize.
+    return new(zone()) LBranch(UseRegister(value), NULL, NULL);
+  } else {
+    ASSERT(r.IsTagged());
+    if (type.IsBoolean() || type.IsSmi() || type.IsJSArray() ||
+        type.IsHeapNumber()) {
+      // These types have simple checks that cannot deoptimize.
+      return new(zone()) LBranch(UseRegister(value), NULL, NULL);
     }
 
-    // Tagged values that are not known smis or booleans require a
-    // deoptimization environment.
-    return AssignEnvironment(
-        new(zone()) LBranch(UseRegister(value), temp1, temp2));
-  } else {
-    return new(zone()) LBranch(UseRegister(value), NULL, NULL);
+    if (type.IsString()) {
+      // This type cannot deoptimize, but needs a scratch register.
+      return new(zone()) LBranch(UseRegister(value), TempRegister(), NULL);
+    }
+
+    ToBooleanStub::Types expected = instr->expected_input_types();
+    bool needs_temps = expected.NeedsMap() || expected.IsEmpty();
+    LOperand* temp1 = needs_temps ? TempRegister() : NULL;
+    LOperand* temp2 = needs_temps ? TempRegister() : NULL;
+
+    if (expected.IsGeneric() || expected.IsEmpty()) {
+      // The generic case cannot deoptimize because it already supports every
+      // possible input type.
+      ASSERT(needs_temps);
+      return new(zone()) LBranch(UseRegister(value), temp1, temp2);
+    } else {
+      return AssignEnvironment(
+          new(zone()) LBranch(UseRegister(value), temp1, temp2));
+    }
   }
 }
 
 
 LInstruction* LChunkBuilder::DoCallConstantFunction(
     HCallConstantFunction* instr) {
   argument_count_ -= instr->argument_count();
   return MarkAsCall(DefineFixed(new(zone()) LCallConstantFunction, x0), instr);
 }
 
@@ skipping 188 matching lines @@
 
 
 LInstruction* LChunkBuilder::DoCheckMaps(HCheckMaps* instr) {
   LOperand* value = UseRegister(instr->value());
   LOperand* temp = TempRegister();
   LInstruction* result = new(zone()) LCheckMaps(value, temp);
   return AssignEnvironment(result);
 }
 
 
-LInstruction* LChunkBuilder::DoCheckNonSmi(HCheckNonSmi* instr) {
-  // TODO(all): On newer v8 versions, this hydrogen instruction has been renamed
-  // into HCheckHeapObject but still translate into LCheckNonSmi.
+LInstruction* LChunkBuilder::DoCheckHeapObject(HCheckHeapObject* instr) {
   LOperand* value = UseRegisterAtStart(instr->value());
   return AssignEnvironment(new(zone()) LCheckNonSmi(value));
 }
 
 
 LInstruction* LChunkBuilder::DoCheckPrototypeMaps(HCheckPrototypeMaps* instr) {
   // TODO(jbramley): The scratch registers are not needed if
   // instr->CanOmitPrototypeChecks(). Can we safely test that here?
   LOperand* temp1 = TempRegister();
   LOperand* temp2 = TempRegister();
@@ skipping 1271 matching lines @@
 LInstruction* LChunkBuilder::DoWrapReceiver(HWrapReceiver* instr) {
   LOperand* receiver = UseRegister(instr->receiver());
   LOperand* function = UseRegisterAtStart(instr->function());
   LOperand* temp = TempRegister();
   LWrapReceiver* result = new(zone()) LWrapReceiver(receiver, function, temp);
   return AssignEnvironment(DefineAsRegister(result));
 }
 
 
 } }  // namespace v8::internal