A64: Introduce a DeoptimizeIfMinusZero() helper.

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 1088 matching lines @@
 
 
 void LCodeGen::DeoptimizeIfNotRoot(Register rt,
                                    Heap::RootListIndex index,
                                    LEnvironment* environment) {
   __ CompareRoot(rt, index);
   DeoptimizeIf(ne, environment);
 }
 
 
+void LCodeGen::DeoptimizeIfMinusZero(DoubleRegister input,
+                                     LEnvironment* environment) {
+  __ TestForMinusZero(input);
+  DeoptimizeIf(vs, 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)) {
       ptrdiff_t padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
       ASSERT((padding_size % kInstructionSize) == 0);
       InstructionAccurateScope instruction_accurate(
@@ skipping 1618 matching lines @@
   __ B(&div_ok);
   __ Bind(&deopt);
   Deoptimize(instr->environment());
   __ Bind(&div_ok);
 }
 
 
 void LCodeGen::DoDoubleToIntOrSmi(LDoubleToIntOrSmi* instr) {
   DoubleRegister input = ToDoubleRegister(instr->value());
   Register result = ToRegister32(instr->result());
-  Label done, deopt;
 
   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
-    __ JumpIfMinusZero(input, &deopt);
+    DeoptimizeIfMinusZero(input, instr->environment());
   }
 
-  __ TryConvertDoubleToInt32(result, input, double_scratch(), &done);
-  __ Bind(&deopt);
-  Deoptimize(instr->environment());
-  __ Bind(&done);
+  __ TryConvertDoubleToInt32(result, input, double_scratch());
+  DeoptimizeIf(ne, instr->environment());
 
   if (instr->tag_result()) {
     __ SmiTag(result.X());
   }
 }
 
 
 void LCodeGen::DoDrop(LDrop* instr) {
   __ Drop(instr->count());
 }
@@ skipping 1042 matching lines @@
                                 double_temp1, double_temp2,
                                 temp1, temp2, temp3);
 }
 
 
 void LCodeGen::DoMathFloor(LMathFloor* instr) {
   // TODO(jbramley): If we could provide a double result, we could use frintm
   // and produce a valid double result in a single instruction.
   DoubleRegister input = ToDoubleRegister(instr->value());
   Register result = ToRegister(instr->result());
-  Label deopt;
-  Label done;
 
   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
-    __ JumpIfMinusZero(input, &deopt);
+    DeoptimizeIfMinusZero(input, instr->environment());
   }
 
   __ Fcvtms(result, input);
 
   // Check that the result fits into a 32-bit integer.
   //  - The result did not overflow.
   __ Cmp(result, Operand(result, SXTW));
   //  - The input was not NaN.
   __ Fccmp(input, input, NoFlag, eq);
-  __ B(&done, eq);
-
-  __ Bind(&deopt);
-  Deoptimize(instr->environment());
-
-  __ Bind(&done);
+  DeoptimizeIf(ne, instr->environment());
 }
 
 
 void LCodeGen::DoFlooringDivByPowerOf2I(LFlooringDivByPowerOf2I* instr) {
   Register dividend = ToRegister32(instr->dividend());
   Register result = ToRegister32(instr->result());
   int32_t divisor = instr->divisor();
 
   // If the divisor is positive, things are easy: There can be no deopts and we
   // can simply do an arithmetic right shift.
@@ skipping 670 matching lines @@
   Label done, load_smi;
 
   // Work out what untag mode we're working with.
   HValue* value = instr->hydrogen()->value();
   NumberUntagDMode mode = value->representation().IsSmi()
       ? NUMBER_CANDIDATE_IS_SMI : NUMBER_CANDIDATE_IS_ANY_TAGGED;
 
   if (mode == NUMBER_CANDIDATE_IS_ANY_TAGGED) {
     __ JumpIfSmi(input, &load_smi);
 
-    Label convert_undefined, deopt;
+    Label convert_undefined;
 
     // Heap number map check.
-    Label* not_heap_number = can_convert_undefined_to_nan ? &convert_undefined
-                                                          : &deopt;
     __ Ldr(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
-    __ JumpIfNotRoot(scratch, Heap::kHeapNumberMapRootIndex, not_heap_number);
+    if (can_convert_undefined_to_nan) {
+      __ JumpIfNotRoot(scratch, Heap::kHeapNumberMapRootIndex,
+                       &convert_undefined);
+    } else {
+      DeoptimizeIfNotRoot(scratch, Heap::kHeapNumberMapRootIndex,
+                          instr->environment());
+    }
 
     // Load heap number.
     __ Ldr(result, FieldMemOperand(input, HeapNumber::kValueOffset));
     if (instr->hydrogen()->deoptimize_on_minus_zero()) {
-      __ JumpIfMinusZero(result, &deopt);
+      DeoptimizeIfMinusZero(result, instr->environment());
     }
     __ B(&done);
 
     if (can_convert_undefined_to_nan) {
       __ Bind(&convert_undefined);
-      __ JumpIfNotRoot(input, Heap::kUndefinedValueRootIndex, &deopt);
+      DeoptimizeIfNotRoot(input, Heap::kUndefinedValueRootIndex,
+                          instr->environment());
 
       __ LoadRoot(scratch, Heap::kNanValueRootIndex);
       __ Ldr(result, FieldMemOperand(scratch, HeapNumber::kValueOffset));
       __ B(&done);
     }
 
-    __ Bind(&deopt);
-    Deoptimize(instr->environment());
   } else {
     ASSERT(mode == NUMBER_CANDIDATE_IS_SMI);
     // Fall through to load_smi.
   }
 
   // Smi to double register conversion.
   __ Bind(&load_smi);
   __ SmiUntagToDouble(result, input);
 
   __ Bind(&done);
@@ skipping 922 matching lines @@
     __ B(eq, &done);
 
     // Output contains zero, undefined is converted to zero for truncating
     // conversions.
     DeoptimizeIfNotRoot(input, Heap::kUndefinedValueRootIndex,
                         instr->environment());
   } else {
     Register output = ToRegister32(instr->result());
 
     DoubleRegister dbl_scratch2 = ToDoubleRegister(temp2);
-    Label converted;
 
     // Deoptimized if it's not a heap number.
     DeoptimizeIfNotRoot(scratch1, Heap::kHeapNumberMapRootIndex,
                         instr->environment());
 
     // A heap number: load value and convert to int32 using non-truncating
     // function. If the result is out of range, branch to deoptimize.
     __ Ldr(dbl_scratch1, FieldMemOperand(input, HeapNumber::kValueOffset));
-    __ TryConvertDoubleToInt32(output, dbl_scratch1, dbl_scratch2, &converted);
-    Deoptimize(instr->environment());
-
-    __ Bind(&converted);
+    __ TryConvertDoubleToInt32(output, dbl_scratch1, dbl_scratch2);
+    DeoptimizeIf(ne, instr->environment());
 
     if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
       __ Cmp(output, 0);
       __ B(ne, &done);
       __ Fmov(scratch1, dbl_scratch1);
       DeoptimizeIfNegative(scratch1, instr->environment());
     }
   }
   __ Bind(&done);
 }
@@ skipping 319 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