A64: Hook up --deopt-every-n-times to all Deoptimize methods

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 948 matching lines @@
       chunk()->inlined_closures();
 
   for (int i = 0, length = inlined_closures->length(); i < length; i++) {
     DefineDeoptimizationLiteral(inlined_closures->at(i));
   }
 
   inlined_function_count_ = deoptimization_literals_.length();
 }
 
 
-bool LCodeGen::DeoptimizeHeader(LEnvironment* environment) {
+Deoptimizer::BailoutType LCodeGen::DeoptimizeHeader(
+    LEnvironment* environment,
+    Deoptimizer::BailoutType* override_bailout_type) {
   RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);
   ASSERT(environment->HasBeenRegistered());
   ASSERT(info()->IsOptimizing() || info()->IsStub());
   int id = environment->deoptimization_index();
-  Deoptimizer::BailoutType bailout_type = info()->IsStub() ? Deoptimizer::LAZY
-                                                           : Deoptimizer::EAGER;
+  Deoptimizer::BailoutType bailout_type =
+      info()->IsStub() ? Deoptimizer::LAZY : Deoptimizer::EAGER;
+  if (override_bailout_type) bailout_type = *override_bailout_type;
   Address entry =
       Deoptimizer::GetDeoptimizationEntry(isolate(), id, bailout_type);
 
   if (entry == NULL) {
     Abort(kBailoutWasNotPrepared);
-    return false;
+    return bailout_type;
   }
 
   if (FLAG_deopt_every_n_times != 0 && !info()->IsStub()) {
     Label not_zero;
     ExternalReference count = ExternalReference::stress_deopt_count(isolate());
 
     __ Push(x0, x1);
     __ Mov(x0, Operand(count));
     __ Ldr(w1, MemOperand(x0));
     __ Subs(x1, x1, 1);
     __ B(gt, &not_zero);
     __ Mov(w1, FLAG_deopt_every_n_times);
     __ Str(w1, MemOperand(x0));
     __ Pop(x0, x1);
     ASSERT(frame_is_built_);
     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
     __ Unreachable();
 
     __ Bind(&not_zero);
     __ Str(w1, MemOperand(x0));
     __ Pop(x0, x1);
   }
 
-  return true;
+  return bailout_type;
 }
 
 
 void LCodeGen::Deoptimize(LEnvironment* environment,
                           Deoptimizer::BailoutType bailout_type) {
-  if (!DeoptimizeHeader(environment)) return;
-
   ASSERT(environment->HasBeenRegistered());
   ASSERT(info()->IsOptimizing() || info()->IsStub());
   int id = environment->deoptimization_index();
   Address entry =
       Deoptimizer::GetDeoptimizationEntry(isolate(), id, bailout_type);
 
   if (info()->ShouldTrapOnDeopt()) {
     __ Debug("trap_on_deopt", __LINE__, BREAK);
   }
 
@@ skipping 12 matching lines @@
                                               bailout_type,
                                               !frame_is_built_);
       deopt_jump_table_.Add(table_entry, zone());
     }
     __ B(&deopt_jump_table_.last().label);
   }
 }
 
 
 void LCodeGen::Deoptimize(LEnvironment* environment) {
-  Deoptimizer::BailoutType bailout_type = info()->IsStub() ? Deoptimizer::LAZY
-                                                           : Deoptimizer::EAGER;
+  Deoptimizer::BailoutType bailout_type = DeoptimizeHeader(environment, NULL);
   Deoptimize(environment, bailout_type);
 }
 
 
 void LCodeGen::DeoptimizeIf(Condition cond, LEnvironment* environment) {
   Label dont_deopt;
+  Deoptimizer::BailoutType bailout_type = DeoptimizeHeader(environment, NULL);
   __ B(InvertCondition(cond), &dont_deopt);
-  Deoptimize(environment);
+  Deoptimize(environment, bailout_type);
   __ Bind(&dont_deopt);
 }
 
 
 void LCodeGen::DeoptimizeIfZero(Register rt, LEnvironment* environment) {
   Label dont_deopt;
+  Deoptimizer::BailoutType bailout_type = DeoptimizeHeader(environment, NULL);
   __ Cbnz(rt, &dont_deopt);
-  Deoptimize(environment);
+  Deoptimize(environment, bailout_type);
   __ Bind(&dont_deopt);
 }
 
 
 void LCodeGen::DeoptimizeIfNegative(Register rt, LEnvironment* environment) {
   Label dont_deopt;
+  Deoptimizer::BailoutType bailout_type = DeoptimizeHeader(environment, NULL);
   __ Tbz(rt, rt.Is64Bits() ? kXSignBit : kWSignBit, &dont_deopt);
-  Deoptimize(environment);
+  Deoptimize(environment, bailout_type);
   __ Bind(&dont_deopt);
 }
 
 
 void LCodeGen::DeoptimizeIfSmi(Register rt,
                                LEnvironment* environment) {
   Label dont_deopt;
+  Deoptimizer::BailoutType bailout_type = DeoptimizeHeader(environment, NULL);
   __ JumpIfNotSmi(rt, &dont_deopt);
-  Deoptimize(environment);
+  Deoptimize(environment, bailout_type);
   __ Bind(&dont_deopt);
 }
 
 
 void LCodeGen::DeoptimizeIfNotSmi(Register rt, LEnvironment* environment) {
   Label dont_deopt;
+  Deoptimizer::BailoutType bailout_type = DeoptimizeHeader(environment, NULL);
   __ JumpIfSmi(rt, &dont_deopt);
-  Deoptimize(environment);
+  Deoptimize(environment, bailout_type);
   __ Bind(&dont_deopt);
 }
 
 
 void LCodeGen::DeoptimizeIfRoot(Register rt,
                                 Heap::RootListIndex index,
                                 LEnvironment* environment) {
   Label dont_deopt;
+  Deoptimizer::BailoutType bailout_type = DeoptimizeHeader(environment, NULL);
   __ JumpIfNotRoot(rt, index, &dont_deopt);
-  Deoptimize(environment);
+  Deoptimize(environment, bailout_type);
   __ Bind(&dont_deopt);
 }
 
 
 void LCodeGen::DeoptimizeIfNotRoot(Register rt,
                                    Heap::RootListIndex index,
                                    LEnvironment* environment) {
   Label dont_deopt;
+  Deoptimizer::BailoutType bailout_type = DeoptimizeHeader(environment, NULL);
   __ JumpIfRoot(rt, index, &dont_deopt);
-  Deoptimize(environment);
+  Deoptimize(environment, bailout_type);
   __ Bind(&dont_deopt);
 }
 
 
 void LCodeGen::EnsureSpaceForLazyDeopt(int space_needed) {
   if (!info()->IsStub()) {
     // Ensure that we have enough space after the previous lazy-bailout
     // instruction for patching the code here.
     intptr_t current_pc = masm()->pc_offset();
 
@@ skipping 1430 matching lines @@
   Deoptimizer::BailoutType type = instr->hydrogen()->type();
   // TODO(danno): Stubs expect all deopts to be lazy for historical reasons (the
   // needed return address), even though the implementation of LAZY and EAGER is
   // now identical. When LAZY is eventually completely folded into EAGER, remove
   // the special case below.
   if (info()->IsStub() && (type == Deoptimizer::EAGER)) {
     type = Deoptimizer::LAZY;
   }
 
   Comment(";;; deoptimize: %s", instr->hydrogen()->reason());
+  DeoptimizeHeader(instr->environment(), &type);
   Deoptimize(instr->environment(), type);
 }
 
 
 void LCodeGen::DoDivI(LDivI* instr) {
   Register dividend = ToRegister32(instr->left());
   Register result = ToRegister32(instr->result());
 
   bool has_power_of_2_divisor = instr->hydrogen()->RightIsPowerOf2();
   bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
@@ skipping 3161 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