A64: Synchronize with r19001.

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 415 matching lines @@
   }
 }
 
 
 void LCodeGen::DoCallFunction(LCallFunction* instr) {
   ASSERT(ToRegister(instr->context()).is(cp));
   ASSERT(ToRegister(instr->function()).Is(x1));
   ASSERT(ToRegister(instr->result()).Is(x0));
 
   int arity = instr->arity();
-  CallFunctionStub stub(arity, NO_CALL_FUNCTION_FLAGS);
-  if (instr->hydrogen()->IsTailCall()) {
-    if (NeedsEagerFrame()) {
-      __ Mov(masm()->StackPointer(), fp);
-    }
-    __ Jump(stub.GetCode(isolate()), RelocInfo::CODE_TARGET);
-  } else {
-    CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
-  }
+  CallFunctionStub stub(arity, instr->hydrogen()->function_flags());
+  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
 }
 
 
 void LCodeGen::DoCallNew(LCallNew* instr) {
   ASSERT(ToRegister(instr->context()).is(cp));
   ASSERT(instr->IsMarkedAsCall());
   ASSERT(ToRegister(instr->constructor()).is(x1));
 
   __ Mov(x0, instr->arity());
   // No cell in x2 for construct type feedback in optimized code.
@@ skipping 2261 matching lines @@
 void LCodeGen::DoDummy(LDummy* instr) {
   // Nothing to see here, move on!
 }
 
 
 void LCodeGen::DoDummyUse(LDummyUse* instr) {
   // Nothing to see here, move on!
 }
 
 
-void LCodeGen::DoElementsKind(LElementsKind* instr) {
-  Register result = ToRegister(instr->result());
-  Register input = ToRegister(instr->value());
-
-  // Load map into result.
-  __ Ldr(result, FieldMemOperand(input, HeapObject::kMapOffset));
-
-  // Load the map's "bit field 2" into result.
-  ASSERT((Map::kElementsKindBitCount + Map::kElementsKindShift) <= kByteSize);
-  __ Ldrb(result.W(), FieldMemOperand(result, Map::kBitField2Offset));
-
-  // Retrieve elements_kind from bit field 2.
-  __ Ubfx(result.W(), result.W(), Map::kElementsKindShift,
-          Map::kElementsKindBitCount);
-}
-
-
 void LCodeGen::DoFunctionLiteral(LFunctionLiteral* instr) {
   ASSERT(ToRegister(instr->context()).is(cp));
   // FunctionLiteral instruction is marked as call, we can trash any register.
   ASSERT(instr->IsMarkedAsCall());
 
   // Use the fast case closure allocation code that allocates in new
   // space for nested functions that don't need literals cloning.
   bool pretenure = instr->hydrogen()->pretenure();
   if (!pretenure && instr->hydrogen()->has_no_literals()) {
     FastNewClosureStub stub(instr->hydrogen()->language_mode(),
@@ skipping 2300 matching lines @@
     return;
   }
 
   Handle<Map> transition = instr->transition();
 
   if (FLAG_track_heap_object_fields && representation.IsHeapObject()) {
     Register value = ToRegister(instr->value());
     if (!instr->hydrogen()->value()->type().IsHeapObject()) {
       DeoptimizeIfSmi(value, instr->environment());
     }
-  } else if (FLAG_track_double_fields && representation.IsDouble()) {
+  } else if (representation.IsDouble()) {
     ASSERT(transition.is_null());
     ASSERT(access.IsInobject());
     ASSERT(!instr->hydrogen()->NeedsWriteBarrier());
     FPRegister value = ToDoubleRegister(instr->value());
     __ Str(value, FieldMemOperand(object, offset));
     return;
   }
 
   if (!transition.is_null()) {
     // Store the new map value.
@@ skipping 361 matching lines @@
   __ Push(x1, x0);
   CallRuntime(Runtime::kAllocateInNewSpace, 1, instr);
   __ Pop(x1);
 
   __ Bind(&allocated);
   // Copy the content into the newly allocated memory.
   __ CopyFields(x0, x1, CPURegList(x10, x11, x12), size / kPointerSize);
 }
 
 
-void LCodeGen::DoThrow(LThrow* instr) {
-  ASSERT(ToRegister(instr->context()).is(cp));
-  Register value = ToRegister(instr->value());
-  __ Push(value);
-  CallRuntime(Runtime::kThrow, 1, instr);
-
-  if (FLAG_debug_code) {
-    __ Unreachable();
-  }
-}
-
-
 void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {
   Register object = ToRegister(instr->object());
   Register temp1 = ToRegister(instr->temp1());
 
   Handle<Map> from_map = instr->original_map();
   Handle<Map> to_map = instr->transitioned_map();
   ElementsKind from_kind = instr->from_kind();
   ElementsKind to_kind = instr->to_kind();
 
   Label not_applicable;
@@ skipping 153 matching lines @@
       !instr->hydrogen()->value()->range()->IsInSmiRange() ||
       instr->hydrogen()->value()->range()->upper() == kMaxInt) {
     // The Range class can't express upper bounds in the (kMaxInt, kMaxUint32]
     // interval, so we treat kMaxInt as a sentinel for this entire interval.
     DeoptimizeIfNegative(value.W(), instr->environment());
   }
   __ SmiTag(result, value);
 }
 
 
-void LCodeGen::DoValueOf(LValueOf* instr) {
-  Register input = ToRegister(instr->value());
-  Register result = ToRegister(instr->result());
-  Register scratch = ToRegister(instr->temp());
-  Label done;
-
-  ASSERT(input.Is(result));
-
-  if (!instr->hydrogen()->value()->IsHeapObject()) {
-    // If the object is a smi return it.
-    __ JumpIfSmi(input, &done);
-  }
-
-  // If the object is not a value type, return the object, otherwise
-  // return the value.
-  __ JumpIfNotObjectType(input, scratch, scratch, JS_VALUE_TYPE, &done);
-  __ Ldr(result, FieldMemOperand(input, JSValue::kValueOffset));
-
-  __ Bind(&done);
-}
-
-
 void LCodeGen::DoCheckMapValue(LCheckMapValue* instr) {
   Register object = ToRegister(instr->value());
   Register map = ToRegister(instr->map());
   Register temp = ToRegister(instr->temp());
   __ Ldr(temp, FieldMemOperand(object, HeapObject::kMapOffset));
   __ Cmp(map, temp);
   DeoptimizeIf(ne, instr->environment());
 }
 
 
 void LCodeGen::DoWrapReceiver(LWrapReceiver* instr) {
   Register receiver = ToRegister(instr->receiver());
   Register function = ToRegister(instr->function());
   Register result = ToRegister(instr->result());
 
   // If the receiver is null or undefined, we have to pass the global object as
   // a receiver to normal functions. Values have to be passed unchanged to
   // builtins and strict-mode functions.
   Label global_object, done, deopt;
 
-  __ Ldr(result, FieldMemOperand(function,
-                               JSFunction::kSharedFunctionInfoOffset));
+  if (!instr->hydrogen()->known_function()) {
+    __ Ldr(result, FieldMemOperand(function,
+                                   JSFunction::kSharedFunctionInfoOffset));
 
-  // CompilerHints is an int32 field. See objects.h.
-  __ Ldr(result.W(),
-         FieldMemOperand(result, SharedFunctionInfo::kCompilerHintsOffset));
+    // CompilerHints is an int32 field. See objects.h.
+    __ Ldr(result.W(),
+           FieldMemOperand(result, SharedFunctionInfo::kCompilerHintsOffset));
 
-  // Do not transform the receiver to object for strict mode functions.
-  __ Tbnz(result, SharedFunctionInfo::kStrictModeFunction, &done);
+    // Do not transform the receiver to object for strict mode functions.
+    __ Tbnz(result, SharedFunctionInfo::kStrictModeFunction, &done);
 
-  // Do not transform the receiver to object for builtins.
-  __ Tbnz(result, SharedFunctionInfo::kNative, &done);
+    // Do not transform the receiver to object for builtins.
+    __ Tbnz(result, SharedFunctionInfo::kNative, &done);
+  }
 
   // Normal function. Replace undefined or null with global receiver.
   __ JumpIfRoot(receiver, Heap::kNullValueRootIndex, &global_object);
   __ JumpIfRoot(receiver, Heap::kUndefinedValueRootIndex, &global_object);
 
   // Deoptimize if the receiver is not a JS object.
   __ JumpIfSmi(receiver, &deopt);
   __ CompareObjectType(receiver, result, result, FIRST_SPEC_OBJECT_TYPE);
   __ B(ge, &done);
   // Otherwise, fall through to deopt.
@@ skipping 35 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