A64: Improve the deoptimization helpers to generate fewer instructions.

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 987 matching lines @@
     __ Bind(&not_zero);
     __ Str(w1, MemOperand(x0));
     __ Msr(NZCV, x2);
     __ Pop(x0, x1, x2);
   }
 
   return bailout_type;
 }
 
 
-void LCodeGen::Deoptimize(LEnvironment* environment,
-                          Deoptimizer::BailoutType bailout_type) {
+void LCodeGen::DeoptimizeBranch(LEnvironment* environment,
+                                Deoptimizer::BailoutType bailout_type,
+                                BranchType branch_type,
+                                Register reg,
+                                int bit) {

[jochen (gone - plz use gerrit), 2014/02/19 16:22:47]

it should be possible to merge DeoptimizeHeader into this method now, no?

[Alexandre Rames, 2014/02/19 17:20:29]

Done.

   ASSERT(environment->HasBeenRegistered());
   ASSERT(info()->IsOptimizing() || info()->IsStub());
   int id = environment->deoptimization_index();
   Address entry =
       Deoptimizer::GetDeoptimizationEntry(isolate(), id, bailout_type);
 
   if (info()->ShouldTrapOnDeopt()) {
+    Label dont_trap;
+    __ B(&dont_trap, InvertBranchType(branch_type), reg, bit);
     __ Debug("trap_on_deopt", __LINE__, BREAK);
+    __ Bind(&dont_trap);
   }
 
   ASSERT(info()->IsStub() || frame_is_built_);
   // Go through jump table if we need to build frame, or restore caller doubles.
   if (frame_is_built_ && !info()->saves_caller_doubles()) {
+    Label dont_deopt;
+    __ B(&dont_deopt, InvertBranchType(branch_type), reg, bit);
     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
+    __ Bind(&dont_deopt);
   } else {
     // We often have several deopts to the same entry, reuse the last
     // jump entry if this is the case.
     if (deopt_jump_table_.is_empty() ||
         (deopt_jump_table_.last().address != entry) ||
         (deopt_jump_table_.last().bailout_type != bailout_type) ||
         (deopt_jump_table_.last().needs_frame != !frame_is_built_)) {
       Deoptimizer::JumpTableEntry table_entry(entry,
                                               bailout_type,
                                               !frame_is_built_);
       deopt_jump_table_.Add(table_entry, zone());
     }
-    __ B(&deopt_jump_table_.last().label);
+    __ B(&deopt_jump_table_.last().label,
+         branch_type, reg, bit);
   }
 }
 
 
+void LCodeGen::Deoptimize(LEnvironment* environment,
+                          Deoptimizer::BailoutType bailout_type) {
+  DeoptimizeBranch(environment, bailout_type, always);
+}
+
+
 void LCodeGen::Deoptimize(LEnvironment* environment) {
-  Deoptimizer::BailoutType bailout_type = DeoptimizeHeader(environment, NULL);
-  Deoptimize(environment, bailout_type);
+  DeoptimizeBranch(environment, always);
 }
 
 
 void LCodeGen::DeoptimizeIf(Condition cond, LEnvironment* environment) {
-  Label dont_deopt;
-  Deoptimizer::BailoutType bailout_type = DeoptimizeHeader(environment, NULL);
-  __ B(InvertCondition(cond), &dont_deopt);
-  Deoptimize(environment, bailout_type);
-  __ Bind(&dont_deopt);
+  DeoptimizeBranch(environment, static_cast<BranchType>(cond));
 }
 
 
 void LCodeGen::DeoptimizeIfZero(Register rt, LEnvironment* environment) {
-  Label dont_deopt;
-  Deoptimizer::BailoutType bailout_type = DeoptimizeHeader(environment, NULL);
-  __ Cbnz(rt, &dont_deopt);
-  Deoptimize(environment, bailout_type);
-  __ Bind(&dont_deopt);
+  DeoptimizeBranch(environment, reg_zero, rt);
 }
 
 
 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, bailout_type);
-  __ Bind(&dont_deopt);
+  int sign_bit = rt.Is64Bits() ? kXSignBit : kWSignBit;
+  DeoptimizeBranch(environment, reg_bit_set, rt, sign_bit);
 }
 
 
 void LCodeGen::DeoptimizeIfSmi(Register rt,
                                LEnvironment* environment) {
-  Label dont_deopt;
-  Deoptimizer::BailoutType bailout_type = DeoptimizeHeader(environment, NULL);
-  __ JumpIfNotSmi(rt, &dont_deopt);
-  Deoptimize(environment, bailout_type);
-  __ Bind(&dont_deopt);
+  DeoptimizeBranch(environment, reg_bit_clear, rt, MaskToBit(kSmiTagMask));
 }
 
 
 void LCodeGen::DeoptimizeIfNotSmi(Register rt, LEnvironment* environment) {
-  Label dont_deopt;
-  Deoptimizer::BailoutType bailout_type = DeoptimizeHeader(environment, NULL);
-  __ JumpIfSmi(rt, &dont_deopt);
-  Deoptimize(environment, bailout_type);
-  __ Bind(&dont_deopt);
+  DeoptimizeBranch(environment, reg_bit_set, rt, MaskToBit(kSmiTagMask));
 }
 
 
 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, bailout_type);
-  __ Bind(&dont_deopt);
+  __ CompareRoot(rt, index);
+  DeoptimizeIf(eq, environment);
 }
 
 
 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, bailout_type);
-  __ Bind(&dont_deopt);
+  __ CompareRoot(rt, index);
+  DeoptimizeIf(ne, environment);
 }
 
 
 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();
 
     if (current_pc < (last_lazy_deopt_pc_ + space_needed)) {
@@ skipping 997 matching lines @@
   } else {
     Deoptimize(instr->environment());
   }
 
   __ Bind(&success);
 }
 
 
 void LCodeGen::DoCheckNonSmi(LCheckNonSmi* instr) {
   if (!instr->hydrogen()->value()->IsHeapObject()) {
-    // TODO(all): Depending of how we chose to implement the deopt, if we could
-    // guarantee that we have a deopt handler reachable by a tbz instruction,
-    // we could use tbz here and produce less code to support this instruction.
     DeoptimizeIfSmi(ToRegister(instr->value()), instr->environment());
   }
 }
 
 
 void LCodeGen::DoCheckSmi(LCheckSmi* instr) {
   Register value = ToRegister(instr->value());
   ASSERT(!instr->result() || ToRegister(instr->result()).Is(value));
-  // TODO(all): See DoCheckNonSmi for comments on use of tbz.
   DeoptimizeIfNotSmi(value, instr->environment());
 }
 
 
 void LCodeGen::DoCheckInstanceType(LCheckInstanceType* instr) {
   Register input = ToRegister(instr->value());
   Register scratch = ToRegister(instr->temp());
 
   __ Ldr(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
   __ Ldrb(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
@@ skipping 3539 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