A64: Synchronize with r18084.

src/a64/full-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 1608 matching lines @@
     __ Push(x10);
   } else {
     VisitForStackValue(expression);
   }
 }
 
 
 void FullCodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
   Comment cmnt(masm_, "[ ObjectLiteral");
 
-  int depth = 1;
-  expr->BuildConstantProperties(isolate(), &depth);
+  expr->BuildConstantProperties(isolate());
   Handle<FixedArray> constant_properties = expr->constant_properties();
   __ Ldr(x3, MemOperand(fp,  JavaScriptFrameConstants::kFunctionOffset));
   __ Ldr(x3, FieldMemOperand(x3, JSFunction::kLiteralsOffset));
   __ Mov(x2, Operand(Smi::FromInt(expr->literal_index())));
   __ Mov(x1, Operand(constant_properties));
   int flags = expr->fast_elements()
       ? ObjectLiteral::kFastElements
       : ObjectLiteral::kNoFlags;
   flags |= expr->has_function()
       ? ObjectLiteral::kHasFunction
       : ObjectLiteral::kNoFlags;
   __ Mov(x0, Operand(Smi::FromInt(flags)));
   int properties_count = constant_properties->length() / 2;
   const int max_cloned_properties =
       FastCloneShallowObjectStub::kMaximumClonedProperties;
   if ((FLAG_track_double_fields && expr->may_store_doubles()) ||
-      (depth > 1) || Serializer::enabled() ||
+      (expr->depth() > 1) || Serializer::enabled() ||
       (flags != ObjectLiteral::kFastElements) ||
       (properties_count > max_cloned_properties)) {
     __ Push(x3, x2, x1, x0);
     __ CallRuntime(Runtime::kCreateObjectLiteral, 4);
   } else {
     FastCloneShallowObjectStub stub(properties_count);
     __ CallStub(&stub);
   }
 
   // If result_saved is true the result is on top of the stack.  If
@@ skipping 99 matching lines @@
     context()->PlugTOS();
   } else {
     context()->Plug(x0);
   }
 }
 
 
 void FullCodeGenerator::VisitArrayLiteral(ArrayLiteral* expr) {
   Comment cmnt(masm_, "[ ArrayLiteral");
 
-  int depth = 1;
-  expr->BuildConstantElements(isolate(), &depth);
+  expr->BuildConstantElements(isolate());
+  int flags = (expr->depth() == 1) ? ArrayLiteral::kShallowElements
+                                   : ArrayLiteral::kNoFlags;
+
   ZoneList<Expression*>* subexprs = expr->values();
   int length = subexprs->length();
   Handle<FixedArray> constant_elements = expr->constant_elements();
   ASSERT_EQ(2, constant_elements->length());
   ElementsKind constant_elements_kind =
       static_cast<ElementsKind>(Smi::cast(constant_elements->get(0))->value());
   bool has_fast_elements = IsFastObjectElementsKind(constant_elements_kind);
   Handle<FixedArrayBase> constant_elements_values(
       FixedArrayBase::cast(constant_elements->get(1)));
 
   __ Ldr(x3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
   __ Ldr(x3, FieldMemOperand(x3, JSFunction::kLiteralsOffset));
   // TODO(jbramley): Can these Operand constructors be implicit?
   __ Mov(x2, Operand(Smi::FromInt(expr->literal_index())));
   __ Mov(x1, Operand(constant_elements));
   if (has_fast_elements && constant_elements_values->map() ==
       isolate()->heap()->fixed_cow_array_map()) {
     FastCloneShallowArrayStub stub(
         FastCloneShallowArrayStub::COPY_ON_WRITE_ELEMENTS,
         DONT_TRACK_ALLOCATION_SITE,
         length);
     __ CallStub(&stub);
     __ IncrementCounter(
         isolate()->counters()->cow_arrays_created_stub(), 1, x10, x11);
-  } else if ((depth > 1) || Serializer::enabled() ||
+  } else if ((expr->depth() > 1) || Serializer::enabled() ||
              length > FastCloneShallowArrayStub::kMaximumClonedLength) {
-    __ Push(x3, x2, x1);
-    __ CallRuntime(Runtime::kCreateArrayLiteral, 3);
+    __ Mov(x0, Operand(Smi::FromInt(flags)));
+    __ Push(x3, x2, x1, x0);
+    __ CallRuntime(Runtime::kCreateArrayLiteral, 4);
   } else {
     ASSERT(IsFastSmiOrObjectElementsKind(constant_elements_kind) ||
            FLAG_smi_only_arrays);
     FastCloneShallowArrayStub::Mode mode =
         FastCloneShallowArrayStub::CLONE_ANY_ELEMENTS;
     AllocationSiteMode allocation_site_mode = FLAG_track_allocation_sites
         ? TRACK_ALLOCATION_SITE : DONT_TRACK_ALLOCATION_SITE;
 
     if (has_fast_elements) {
       mode = FastCloneShallowArrayStub::CLONE_ELEMENTS;
@@ skipping 1297 matching lines @@
     VisitForStackValue(args->at(2));
     __ CallRuntime(Runtime::kLog, 2);
   }
 
   // Finally, we're expected to leave a value on the top of the stack.
   __ LoadRoot(x0, Heap::kUndefinedValueRootIndex);
   context()->Plug(x0);
 }
 
 
-void FullCodeGenerator::EmitRandomHeapNumber(CallRuntime* expr) {
-  ASSERT(expr->arguments()->length() == 0);
-  Label slow_allocate_heapnumber;
-  Label heapnumber_allocated;
-  Register heap_num = x19;  // Callee-saved register.
-
-  __ LoadRoot(x5, Heap::kHeapNumberMapRootIndex);
-  __ AllocateHeapNumber(heap_num, &slow_allocate_heapnumber, x10, x11, x5);
-  __ B(&heapnumber_allocated);
-
-  __ Bind(&slow_allocate_heapnumber);
-  // Call the runtime to allocate the heap number.
-  __ CallRuntime(Runtime::kNumberAlloc, 0);
-  __ Mov(heap_num, x0);
-
-  __ Bind(&heapnumber_allocated);
-
-  // Get 32 random bits.
-  __ Ldr(x0,
-         ContextMemOperand(context_register(), Context::GLOBAL_OBJECT_INDEX));
-  __ Ldr(x0, FieldMemOperand(x0, GlobalObject::kNativeContextOffset));
-  __ CallCFunction(ExternalReference::random_uint32_function(isolate()), 1);
-
-  // Interpret the 32 random bits as a 0.32 fixed point number, and convert to
-  // a double in the range 0.0 <= number < 1.0.
-  __ Ucvtf(d0, x0, 32);
-  __ Str(d0, FieldMemOperand(heap_num, HeapNumber::kValueOffset));
-  __ Mov(x0, heap_num);
-
-  context()->Plug(x0);
-}
-
-
 void FullCodeGenerator::EmitSubString(CallRuntime* expr) {
   // Load the arguments on the stack and call the stub.
   SubStringStub stub;
   ZoneList<Expression*>* args = expr->arguments();
   ASSERT(args->length() == 3);
   VisitForStackValue(args->at(0));
   VisitForStackValue(args->at(1));
   VisitForStackValue(args->at(2));
   __ CallStub(&stub);
   context()->Plug(x0);
@@ skipping 1900 matching lines @@
   return previous_;
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64