A64: Synchronize with r17441.

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 398 matching lines @@
 
 
 void LCodeGen::CallCodeGeneric(Handle<Code> code,
                                RelocInfo::Mode mode,
                                LInstruction* instr,
                                SafepointMode safepoint_mode) {
   EnsureSpaceForLazyDeopt(Deoptimizer::patch_size());
   ASSERT(instr != NULL);
 
   Assembler::BlockConstPoolScope scope(masm_);
-  LPointerMap* pointers = instr->pointer_map();
-  RecordPosition(pointers->position());
   __ Call(code, mode);
   RecordSafepointWithLazyDeopt(instr, safepoint_mode);
 
   if ((code->kind() == Code::BINARY_OP_IC) ||
       (code->kind() == Code::COMPARE_IC)) {
     // Signal that we don't inline smi code before these stubs in the
     // optimizing code generator.
     InlineSmiCheckInfo::EmitNotInlined(masm());
   }
 }
@@ skipping 70 matching lines @@
 
   ASSERT(ToRegister(instr->result()).is(x0));
 }
 
 
 void LCodeGen::CallRuntime(const Runtime::Function* function,
                            int num_arguments,
                            LInstruction* instr,
                            SaveFPRegsMode save_doubles) {
   ASSERT(instr != NULL);
-  LPointerMap* pointers = instr->pointer_map();
-  ASSERT(pointers != NULL);
-  RecordPosition(pointers->position());
 
   __ CallRuntime(function, num_arguments, save_doubles);
 
   RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
 }
 
 
 void LCodeGen::CallRuntimeFromDeferred(Runtime::FunctionId id,
                                        int argc,
                                        LInstruction* instr) {
   __ CallRuntimeSaveDoubles(id);
   RecordSafepointWithRegisters(
       instr->pointer_map(), argc, Safepoint::kNoLazyDeopt);
 }
 
 
-void LCodeGen::RecordPosition(int position) {
+void LCodeGen::RecordAndWritePosition(int position) {
   if (position == RelocInfo::kNoPosition) return;
   masm()->positions_recorder()->RecordPosition(position);
+  masm()->positions_recorder()->WriteRecordedPositions();
 }
 
 
-void LCodeGen::RecordAndUpdatePosition(int position) {
-  if (position >= 0 && position != old_position_) {
-    masm()->positions_recorder()->RecordPosition(position);
-    old_position_ = position;
-  }
-}
-
-
 void LCodeGen::RecordSafepointWithLazyDeopt(LInstruction* instr,
                                             SafepointMode safepoint_mode) {
   if (safepoint_mode == RECORD_SIMPLE_SAFEPOINT) {
     RecordSafepoint(instr->pointer_map(), Safepoint::kLazyDeopt);
   } else {
     ASSERT(safepoint_mode == RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
     RecordSafepointWithRegisters(
         instr->pointer_map(), 0, Safepoint::kLazyDeopt);
   }
 }
@@ skipping 24 matching lines @@
   }
 }
 
 void LCodeGen::RecordSafepoint(LPointerMap* pointers,
                                Safepoint::DeoptMode deopt_mode) {
   RecordSafepoint(pointers, Safepoint::kSimple, 0, deopt_mode);
 }
 
 
 void LCodeGen::RecordSafepoint(Safepoint::DeoptMode deopt_mode) {
-  LPointerMap empty_pointers(RelocInfo::kNoPosition, zone());
+  LPointerMap empty_pointers(zone());
   RecordSafepoint(&empty_pointers, deopt_mode);
 }
 
 
 void LCodeGen::RecordSafepointWithRegisters(LPointerMap* pointers,
                                             int arguments,
                                             Safepoint::DeoptMode deopt_mode) {
   RecordSafepoint(pointers, Safepoint::kWithRegisters, arguments, deopt_mode);
 }
 
@@ skipping 42 matching lines @@
       int receiver_offset = scope()->num_parameters() * kPointerSize;
       __ LoadRoot(x10, Heap::kUndefinedValueRootIndex);
       __ Poke(x10, receiver_offset);
       __ Bind(&ok);
     }
   }
 
   ASSERT(__ StackPointer().Is(jssp));
   info()->set_prologue_offset(masm_->pc_offset());
   if (NeedsEagerFrame()) {
-    if (info()->IsStub()) {
-      // TODO(jbramley): Does x1 contain a JSFunction here, or does it already
-      // have the special STUB smi?
-      __ Mov(x10, Operand(Smi::FromInt(StackFrame::STUB)));
-      // Compiled stubs don't age, and so they don't need the predictable code
-      // ageing sequence.
-      __ Push(lr, fp, cp, x10);
-      __ Add(fp, jssp, 2 * kPointerSize);
-    } else {
-      // This call emits the following sequence in a way that can be patched for
-      // code ageing support:
-      //  Push(lr, fp, cp, x1);
-      //  Add(fp, jssp, 2 * kPointerSize);
-      __ EmitFrameSetupForCodeAgePatching();
-    }
+    __ Prologue(info()->IsStub() ? BUILD_STUB_FRAME : BUILD_FUNCTION_FRAME);
     frame_is_built_ = true;
     info_->AddNoFrameRange(0, masm_->pc_offset());
   }
 
   // Reserve space for the stack slots needed by the code.
   int slots = GetStackSlotCount();
   if (slots > 0) {
     __ Claim(slots, kPointerSize);
   }
 
@@ skipping 73 matching lines @@
   __ Claim(slots);
 }
 
 
 bool LCodeGen::GenerateDeferredCode() {
   ASSERT(is_generating());
   if (deferred_.length() > 0) {
     for (int i = 0; !is_aborted() && (i < deferred_.length()); i++) {
       LDeferredCode* code = deferred_[i];
 
-      int pos = instructions_->at(code->instruction_index())->position();
-      RecordAndUpdatePosition(pos);
+      HValue* value =
+          instructions_->at(code->instruction_index())->hydrogen_value();
+      RecordAndWritePosition(value->position());
 
       Comment(";;; <@%d,#%d> "
               "-------------------- Deferred %s --------------------",
               code->instruction_index(),
               code->instr()->hydrogen_value()->id(),
               code->instr()->Mnemonic());
 
       __ Bind(code->entry());
 
       if (NeedsDeferredFrame()) {
@@ skipping 423 matching lines @@
 }
 
 
 Condition LCodeGen::TokenToCondition(Token::Value op, bool is_unsigned) {
   Condition cond = nv;
   switch (op) {
     case Token::EQ:
     case Token::EQ_STRICT:
       cond = eq;
       break;
+    case Token::NE:
+    case Token::NE_STRICT:
+      cond = ne;
+      break;
     case Token::LT:
       cond = is_unsigned ? lo : lt;
       break;
     case Token::GT:
       cond = is_unsigned ? hi : gt;
       break;
     case Token::LTE:
       cond = is_unsigned ? ls : le;
       break;
     case Token::GTE:
@@ skipping 281 matching lines @@
   __ Cbz(length, &invoke);
   __ Bind(&loop);
   __ Ldr(scratch, MemOperand(elements, length, LSL, kPointerSizeLog2));
   __ Push(scratch);
   __ Subs(length, length, 1);
   __ B(ne, &loop);
 
   __ Bind(&invoke);
   ASSERT(instr->HasPointerMap());
   LPointerMap* pointers = instr->pointer_map();
-  RecordPosition(pointers->position());
   SafepointGenerator safepoint_generator(this, pointers, Safepoint::kLazyDeopt);
   // The number of arguments is stored in argc (receiver) which is x0, as
   // expected by InvokeFunction.
   ParameterCount actual(argc);
   __ InvokeFunction(function, actual, CALL_FUNCTION,
                     safepoint_generator, CALL_AS_METHOD);
   __ Ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
 }
 
 
@@ skipping 306 matching lines @@
       formal_parameter_count == SharedFunctionInfo::kDontAdaptArgumentsSentinel;
   bool can_invoke_directly =
       dont_adapt_arguments || formal_parameter_count == arity;
 
   // The function interface relies on the following register assignments.
   ASSERT(function_reg.Is(x1) || function_reg.IsNone());
   Register arity_reg = x0;
   Register call_kind_reg = x5;
 
   LPointerMap* pointers = instr->pointer_map();
-  RecordPosition(pointers->position());
 
   // If necessary, load the function object.
   if (function_reg.IsNone()) {
     function_reg = x1;
-    __ LoadHeapObject(function_reg, function);
+    __ LoadObject(function_reg, function);
   }
 
   if (FLAG_debug_code) {
     Label is_not_smi;
     // Try to confirm that function_reg (x1) is a tagged pointer.
     __ JumpIfNotSmi(function_reg, &is_not_smi);
     __ Abort(kExpectedFunctionObject);
     __ Bind(&is_not_smi);
   }
 
@@ skipping 1094 matching lines @@
 
   __ Bind(&return_false);
   __ LoadRoot(result, Heap::kFalseValueRootIndex);
 
   // Here result is either true or false.
   __ Bind(deferred->exit());
   __ Bind(&done);
 }
 
 
-void LCodeGen::DoInstanceSize(LInstanceSize* instr) {
-  Register object = ToRegister(instr->object());
-  Register result = ToRegister(instr->result());
-  __ Ldr(result, FieldMemOperand(object, HeapObject::kMapOffset));
-  __ Ldrb(result, FieldMemOperand(result, Map::kInstanceSizeOffset));
-}
-
-
 void LCodeGen::DoDeferredInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
   Register result = ToRegister(instr->result());
   ASSERT(result.Is(x0));  // InstanceofStub returns its result in x0.
   InstanceofStub::Flags flags = InstanceofStub::kNoFlags;
   flags = static_cast<InstanceofStub::Flags>(
       flags | InstanceofStub::kArgsInRegisters);
   flags = static_cast<InstanceofStub::Flags>(
       flags | InstanceofStub::kReturnTrueFalseObject);
   flags = static_cast<InstanceofStub::Flags>(
       flags | InstanceofStub::kCallSiteInlineCheck);
 
   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
 
   // Prepare InstanceofStub arguments.
   ASSERT(ToRegister(instr->value()).Is(InstanceofStub::left()));
-  __ LoadHeapObject(InstanceofStub::right(), instr->function());
+  __ LoadObject(InstanceofStub::right(), instr->function());
 
   InstanceofStub stub(flags);
   CallCodeGeneric(stub.GetCode(isolate()),
                   RelocInfo::CODE_TARGET,
                   instr,
                   RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
   LEnvironment* env = instr->GetDeferredLazyDeoptimizationEnvironment();
   safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
 
   // Put the result value into the result register slot.
@@ skipping 25 matching lines @@
 
 
 void LCodeGen::DoInvokeFunction(LInvokeFunction* instr) {
   // The function is required to be in x1.
   ASSERT(ToRegister(instr->function()).is(x1));
   ASSERT(instr->HasPointerMap());
 
   Handle<JSFunction> known_function = instr->hydrogen()->known_function();
   if (known_function.is_null()) {
     LPointerMap* pointers = instr->pointer_map();
-    RecordPosition(pointers->position());
     SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
     ParameterCount count(instr->arity());
     __ InvokeFunction(x1, count, CALL_FUNCTION, generator, CALL_AS_METHOD);
     __ Ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
   } else {
     CallKnownFunction(known_function,
                       instr->hydrogen()->formal_parameter_count(),
                       instr->arity(),
                       instr,
                       CALL_AS_METHOD,
@@ skipping 2117 matching lines @@
   DoubleRegister dbl_scratch1 = double_scratch();
 
   Label done;
 
   // Load heap object map.
   __ Ldr(scratch1, FieldMemOperand(input, HeapObject::kMapOffset));
 
   if (instr->truncating()) {
     Register output = ToRegister(instr->result());
     Register scratch2 = ToRegister(temp2);
-    Label undefined;
+    Label check_bools, undefined;
 
     // If it's not a heap number, jump to undefined check.
-    __ JumpIfNotRoot(scratch1, Heap::kHeapNumberMapRootIndex, &undefined);
+    __ JumpIfNotRoot(scratch1, Heap::kHeapNumberMapRootIndex, &check_bools);
 
     // A heap number: load value and convert to int32 using truncating function.
     __ Ldr(dbl_scratch1, FieldMemOperand(input, HeapNumber::kValueOffset));
     __ ECMA262ToInt32(output, dbl_scratch1, scratch1, scratch2);
     __ B(&done);
 
+    __ Bind(&check_bools);
+
+    TODO_UNIMPLEMENTED("LTaggedToI: Truncate booleans to 0 or 1.");
+
     // Check for undefined. Undefined is converted to zero for truncating
     // conversions.
     __ Bind(&undefined);
 
     DeoptimizeIfNotRoot(input, Heap::kUndefinedValueRootIndex,
                         instr->environment());
     __ Mov(output, 0);
   } else {
     Register output = ToRegister32(instr->result());
 
@@ skipping 75 matching lines @@
 
 void LCodeGen::DoRegExpLiteral(LRegExpLiteral* instr) {
   Label materialized;
   // Registers will be used as follows:
   // x7 = literals array.
   // x1 = regexp literal.
   // x0 = regexp literal clone.
   // x10-x12 are used as temporaries.
   int literal_offset =
       FixedArray::OffsetOfElementAt(instr->hydrogen()->literal_index());
-  __ LoadHeapObject(x7, instr->hydrogen()->literals());
+  __ LoadObject(x7, instr->hydrogen()->literals());
   __ Ldr(x1, FieldMemOperand(x7, literal_offset));
   __ JumpIfNotRoot(x1, Heap::kUndefinedValueRootIndex, &materialized);
 
   // Create regexp literal using runtime function
   // Result will be in x0.
   __ Mov(x12, Operand(Smi::FromInt(instr->hydrogen()->literal_index())));
   __ Mov(x11, Operand(instr->hydrogen()->pattern()));
   __ Mov(x10, Operand(instr->hydrogen()->flags()));
   __ Push(x7, x12, x11, x10);
   CallRuntime(Runtime::kMaterializeRegExpLiteral, 4, instr);
@@ skipping 59 matching lines @@
         instr->pointer_map(), 0, Safepoint::kNoLazyDeopt);
   }
   __ Bind(&not_applicable);
 }
 
 
 void LCodeGen::DoTrapAllocationMemento(LTrapAllocationMemento* instr) {
   Register object = ToRegister(instr->object());
   Register temp1 = ToRegister(instr->temp1());
   Register temp2 = ToRegister(instr->temp2());
-  __ TestJSArrayForAllocationMemento(object, temp1, temp2);
-  DeoptimizeIf(eq, instr->environment());
+
+  Label no_memento_found;
+  __ JumpIfJSArrayHasAllocationMemento(object, temp1, temp2, &no_memento_found);
+  Deoptimize(instr->environment());
+  __ Bind(&no_memento_found);
 }
 
 
 void LCodeGen::DoTruncateDoubleToIntOrSmi(LTruncateDoubleToIntOrSmi* instr) {
   DoubleRegister input = ToDoubleRegister(instr->value());
   Register result = ToRegister(instr->result());
   __ ECMA262ToInt32(result, input,
                     ToRegister(instr->temp1()),
                     ToRegister(instr->temp2()),
                     instr->tag_result()
@@ skipping 95 matching lines @@
     __ B(false_label);
   }
 }
 
 
 void LCodeGen::DoUint32ToDouble(LUint32ToDouble* instr) {
   __ Ucvtf(ToDoubleRegister(instr->result()), ToRegister32(instr->value()));
 }
 
 
+void LCodeGen::DoUint32ToSmi(LUint32ToSmi* instr) {
+  Register value = ToRegister(instr->value());
+  Register result = ToRegister(instr->result());
+
+  if (!instr->hydrogen()->value()->HasRange() ||
+      !instr->hydrogen()->value()->range()->IsInSmiRange()) {
+    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.
@@ skipping 89 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