A64 support for DoubleToIStub (truncating).

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 5290 matching lines @@
   if (instr->truncating()) {
     Register output = ToRegister(instr->result());
     Register scratch2 = ToRegister(temp2);
     Label check_bools;
 
     // If it's not a heap number, jump to undefined check.
     __ 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);
+    __ TruncateDoubleToI(output, dbl_scratch1);
     __ B(&done);
 
     __ Bind(&check_bools);
 
     Register true_root = output;
     Register false_root = scratch2;
     __ LoadTrueFalseRoots(true_root, false_root);
     __ Cmp(scratch1, true_root);
     __ Cset(output, eq);
     __ Ccmp(scratch1, false_root, ZFlag, ne);
@@ skipping 166 matching lines @@
   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()
-                        ? MacroAssembler::SMI
-                        : MacroAssembler::INT32_IN_W);
+  __ TruncateDoubleToI(result, input);
+  if (instr->tag_result()) {
+    __ SmiTag(result, result);
+  }
 }
 
 
 void LCodeGen::DoTypeof(LTypeof* instr) {
   Register input = ToRegister(instr->value());
   __ Push(input);
   CallRuntime(Runtime::kTypeof, 1, instr);
 }
 
 
@@ skipping 187 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