A64: Rejig truncating and non double to i/smi

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 2419 matching lines @@
       __ Bind(&deopt);
       Deoptimize(instr->environment());
       __ Bind(&div_ok);
     } else {
       ASSERT(instr->temp() == NULL);
     }
   }
 }
 
 
-void LCodeGen::DoDoubleToI(LDoubleToI* instr) {
+void LCodeGen::DoDoubleToIntOrSmi(LDoubleToIntOrSmi* instr) {
   DoubleRegister input = ToDoubleRegister(instr->value());
+  Register result = ToRegister32(instr->result());
+  Label done, deopt;
 
-  if (instr->truncating()) {
-    Register result = ToRegister(instr->result());
-    Register scratch1 = ToRegister(instr->temp1());
-    Register scratch2 = ToRegister(instr->temp2());
-    __ ECMA262ToInt32(result, input, scratch1, scratch2);
-  } else {
-    Register result = ToRegister32(instr->result());
-    ASSERT((instr->temp1() == NULL) && (instr->temp2() == NULL));
-    Label done, deopt;
+  if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
+    __ JumpIfMinusZero(input, &deopt);
+  }
 
-    if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
-      // Check for an input of -0.0, using the result register as a scratch.
-      __ Fmov(result, input);
-      __ Cmp(result, 1);
-      __ B(&deopt, vs);
-    }
+  __ TryConvertDoubleToInt32(result, input, double_scratch(), &done);
+  __ Bind(&deopt);
+  Deoptimize(instr->environment());
+  __ Bind(&done);
 
-    __ TryConvertDoubleToInt32(result, input, double_scratch(), &done);
-    __ Bind(&deopt);
-    Deoptimize(instr->environment());
-    __ Bind(&done);
+  if (instr->tag_result()) {
+    __ SmiTag(result.X());
   }
 }
 
 
-// TODO(jbramley): This is almost the same as DoDoubleToI. Can we merge them?
-void LCodeGen::DoDoubleToSmi(LDoubleToSmi* instr) {
-  DoubleRegister input = ToDoubleRegister(instr->value());
-
-  if (instr->truncating()) {
-    Register result = ToRegister(instr->result());
-    Register scratch1 = ToRegister(instr->temp1());
-    Register scratch2 = ToRegister(instr->temp2());
-    __ ECMA262ToInt32(result, input, scratch1, scratch2);
-  } else {
-    Register result = ToRegister32(instr->result());
-    ASSERT((instr->temp1() == NULL) && (instr->temp2() == NULL));
-    Label done, deopt;
-
-    if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
-      // Check for an input of -0.0, using the result register as a scratch.
-      __ Fmov(result, input);
-      __ Cmp(result, 1);
-      __ B(&deopt, vs);
-    }
-
-    __ TryConvertDoubleToInt32(result, input, double_scratch(), &done);
-    __ Bind(&deopt);
-    Deoptimize(instr->environment());
-    __ Bind(&done);
-  }
-  __ SmiTag(ToRegister(instr->result()));
-}
-
-
 void LCodeGen::DoDrop(LDrop* instr) {
   TODO_UNIMPLEMENTED("DoDrop is untested.");
   __ Drop(instr->count());
 }
 
 
 void LCodeGen::DoDummyUse(LDummyUse* instr) {
   // Nothing to see here, move on!
 }
 
@@ skipping 1184 matching lines @@
 
 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)) {
-    // Check for an input of -0.0, using the result register as a scratch.
-    __ Fmov(result, input);
-    __ Cmp(result, 1);
-    __ B(&deopt, vs);
+    __ JumpIfMinusZero(input, &deopt);
   }
 
   __ 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);
@@ skipping 590 matching lines @@
 
     // Heap number map check.
     Label* not_heap_number = allow_undefined_as_nan ? &convert_undefined
                                                     : &deopt;
     __ Ldr(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
     __ JumpIfNotRoot(scratch, Heap::kHeapNumberMapRootIndex, not_heap_number);
 
     // Load heap number.
     __ Ldr(result, FieldMemOperand(input, HeapNumber::kValueOffset));
     if (instr->hydrogen()->deoptimize_on_minus_zero()) {
-      ASM_UNIMPLEMENTED_BREAK("NumberUntagD - deopt on minus zero");
+      __ JumpIfMinusZero(result, &deopt);
     }
     __ B(&done);
 
     if (allow_undefined_as_nan) {
       Label load_nan;
 
       __ Bind(&convert_undefined);
       // Convert undefined (and hole) to NaN.
       if (mode == NUMBER_CANDIDATE_IS_ANY_TAGGED_CONVERT_HOLE) {
         __ JumpIfRoot(input, Heap::kUndefinedValueRootIndex, &load_nan);
@@ skipping 951 matching lines @@
 
 void LCodeGen::DoTrapAllocationMemento(LTrapAllocationMemento* instr) {
   Register object = ToRegister(instr->object());
   Register temp1 = ToRegister(instr->temp1());
   Register temp2 = ToRegister(instr->temp2());
   __ TestJSArrayForAllocationSiteInfo(object, temp1, temp2);
   DeoptimizeIf(eq, instr->environment());
 }
 
 
+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()
+                        ? MacroAssembler::SMI
+                        : MacroAssembler::INT32_IN_W);
+}
+
+
 void LCodeGen::DoTypeof(LTypeof* instr) {
   Register input = ToRegister(instr->value());
   __ Push(input);
   CallRuntime(Runtime::kTypeof, 1, instr);
 }
 
 
 void LCodeGen::DoTypeofIsAndBranch(LTypeofIsAndBranch* instr) {
   Handle<String> type_name = instr->type_literal();
   Label* true_label = instr->TrueLabel(chunk_);
@@ skipping 189 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