A64: Synchronize with r16849.

src/a64/lithium-codegen-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 2048 matching lines @@
 
   if (instr->hydrogen()->CanOmitMapChecks()) {
     ASSERT(instr->value() == NULL);
     ASSERT(instr->temp() == NULL);
     return;
   }
 
   Register object = ToRegister(instr->value());
   Register map_reg = ToRegister(instr->temp());
 
-  SmallMapList* map_set = instr->hydrogen()->map_set();
   __ Ldr(map_reg, FieldMemOperand(object, HeapObject::kMapOffset));
 
   DeferredCheckMaps* deferred = NULL;
   if (instr->hydrogen()->has_migration_target()) {
     deferred = new(zone()) DeferredCheckMaps(this, instr, object);
     __ Bind(deferred->check_maps());
   }
 
+  UniqueSet<Map> map_set = instr->hydrogen()->map_set();
   Label success;
-  for (int i = 0; i < map_set->length(); i++) {
-    Handle<Map> map = map_set->at(i);
+  for (int i = 0; i < map_set.size(); i++) {
+    Handle<Map> map = map_set.at(i).handle();
     __ CompareMap(map_reg, map, &success);
     __ B(eq, &success);
   }
 
   // We didn't match a map.
   if (instr->hydrogen()->has_migration_target()) {
     __ B(deferred->entry());
   } else {
     Deoptimize(instr->environment());
   }
@@ skipping 349 matching lines @@
     if (!it.value()->IsReturn()) {
       __ Mov(result, cp);
       return;
     }
   }
 }
 
 
 void LCodeGen::DoCheckValue(LCheckValue* instr) {
   Register reg = ToRegister(instr->value());
-  Handle<HeapObject> object = instr->hydrogen()->object();
+  Handle<HeapObject> object = instr->hydrogen()->object().handle();
   AllowDeferredHandleDereference smi_check;
   if (isolate()->heap()->InNewSpace(*object)) {
     Register temp = ToRegister(instr->temp());
     Handle<Cell> cell = isolate()->factory()->NewCell(object);
     __ Mov(temp, Operand(Handle<Object>(cell)));
     __ Ldr(temp, FieldMemOperand(temp, Cell::kValueOffset));
     __ Cmp(reg, temp);
   } else {
     __ Cmp(reg, Operand(object));
   }
@@ skipping 646 matching lines @@
 
   // Check the marker in the calling frame.
   __ Bind(&check_frame_marker);
   __ Ldr(temp1, MemOperand(temp1, StandardFrameConstants::kMarkerOffset));
 
   EmitCompareAndBranch(
       instr, eq, temp1, Operand(Smi::FromInt(StackFrame::CONSTRUCT)));
 }
 
 
-void LCodeGen::DoIsNumberAndBranch(LIsNumberAndBranch* instr) {
-  Representation r = instr->hydrogen()->value()->representation();
-  if (r.IsSmiOrInteger32() || r.IsDouble()) {
-    __ B(instr->TrueLabel(chunk_));
-  } else {
-    ASSERT(r.IsTagged());
-    Register value = ToRegister(instr->value());
-    HType type = instr->hydrogen()->value()->type();
-    if (type.IsTaggedNumber()) {
-      __ B(instr->TrueLabel(chunk_));
-    }
-    __ JumpIfSmi(value, instr->TrueLabel(chunk_));
-
-    EmitBranchIfHeapNumber(instr, value);
-  }
-}
-
-
 void LCodeGen::DoIsObjectAndBranch(LIsObjectAndBranch* instr) {
   Label* is_object = instr->TrueLabel(chunk_);
   Label* is_not_object = instr->FalseLabel(chunk_);
   Register value = ToRegister(instr->value());
   Register map = ToRegister(instr->temp1());
   Register scratch = ToRegister(instr->temp2());
 
   __ JumpIfSmi(value, is_not_object);
   __ JumpIfRoot(value, Heap::kNullValueRootIndex, is_object);
 
@@ skipping 413 matching lines @@
   ASSERT(ToRegister(instr->object()).is(x0));
   __ Mov(x2, Operand(instr->name()));
 
   Handle<Code> ic = isolate()->builtins()->LoadIC_Initialize();
   CallCode(ic, RelocInfo::CODE_TARGET, instr);
 
   ASSERT(ToRegister(instr->result()).is(x0));
 }
 
 
+void LCodeGen::DoLoadRoot(LLoadRoot* instr) {
+  Register result = ToRegister(instr->result());
+  __ LoadRoot(result, instr->index());
+}
+
+
 void LCodeGen::DoMapEnumLength(LMapEnumLength* instr) {
   Register result = ToRegister(instr->result());
   Register map = ToRegister(instr->value());
   __ EnumLengthSmi(result, map);
 }
 
 
 void LCodeGen::DoMathAbs(LMathAbs* instr) {
   Representation r = instr->hydrogen()->value()->representation();
   if (r.IsDouble()) {
@@ skipping 2036 matching lines @@
   __ Bind(&out_of_object);
   __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
   // Index is equal to negated out of object property index plus 1.
   __ Sub(result, result, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ Bind(&done);
 }
 
 } }  // namespace v8::internal