A64: Synchronize with r16756.

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 3704 matching lines @@
 
 void LCodeGen::DoMathCos(LMathCos* instr) {
   ASSERT(ToDoubleRegister(instr->result()).is(d0));
   TranscendentalCacheStub stub(TranscendentalCache::COS,
                                TranscendentalCacheStub::UNTAGGED);
   CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
   ASSERT(ToDoubleRegister(instr->result()).Is(d0));
 }
 
 
+// TODO(all): This will disappear when Math.random is rewritten in JavaScript.
 void LCodeGen::DoRandom(LRandom* instr) {
   class DeferredDoRandom: public LDeferredCode {
    public:
     DeferredDoRandom(LCodeGen* codegen, LRandom* instr)
         : LDeferredCode(codegen), instr_(instr) { }
     virtual void Generate() { codegen()->DoDeferredRandom(instr_); }
     virtual LInstruction* instr() { return instr_; }
 
    private:
     LRandom* instr_;
@@ skipping 44 matching lines @@
   __ And(w3, w3, 0x3FFFF);
   __ Add(w0, w3, Operand(w2, LSL, 14));
 
   __ Bind(deferred->exit());
   // Interpret the 32 random bits as a 0.32 fixed point number, and convert to
   // a double in the range 0.0 <= number < 1.0.
   __ Ucvtf(d7, w0, 32);
 }
 
 
+// TODO(all): This will disappear when Math.random is rewritten in JavaScript.
 void LCodeGen::DoDeferredRandom(LRandom* instr) {
   __ CallCFunction(ExternalReference::random_uint32_function(isolate()), 1);
   // Return value is in x0.
 }
 
 
 void LCodeGen::DoMathExp(LMathExp* instr) {
   DoubleRegister input = ToDoubleRegister(instr->value());
   DoubleRegister result = ToDoubleRegister(instr->result());
   DoubleRegister double_temp1 = ToDoubleRegister(instr->double_temp1());
@@ skipping 731 matching lines @@
   }
   __ Ret();
 
   if (no_frame_start != -1) {
     info_->AddNoFrameRange(no_frame_start, masm_->pc_offset());
   }
 }
 
 
 void LCodeGen::DoSeqStringSetChar(LSeqStringSetChar* instr) {
+  // TODO(all): Port ARM optimizations from r16707.
+
   String::Encoding encoding = instr->encoding();
   Register string = ToRegister(instr->string());
   Register index = ToRegister(instr->index());
   Register value = ToRegister(instr->value());
   Register temp = ToRegister(instr->temp());
 
   if (FLAG_debug_code) {
     __ Ldr(temp, FieldMemOperand(string, HeapObject::kMapOffset));
     __ Ldrb(temp, FieldMemOperand(temp, Map::kInstanceTypeOffset));
     __ And(temp, temp, kStringRepresentationMask | kStringEncodingMask);
@@ skipping 713 matching lines @@
     }
 
     virtual LInstruction* instr() { return instr_; }
    private:
     LTaggedToI* instr_;
   };
 
   Register input = ToRegister(instr->value());
   Register output = ToRegister(instr->result());
 
-  DeferredTaggedToI* deferred = new(zone()) DeferredTaggedToI(this, instr);
+  if (instr->hydrogen()->value()->representation().IsSmi()) {
+    __ SmiUntag(input);
+  } else {
+    DeferredTaggedToI* deferred = new(zone()) DeferredTaggedToI(this, instr);
 
-  // TODO(jbramley): We can't use JumpIfNotSmi here because the tbz it uses
-  // doesn't always have enough range. Consider making a variant of it, or a
-  // TestIsSmi helper.
-  STATIC_ASSERT(kSmiTag == 0);
-  __ Tst(input, kSmiTagMask);
-  __ B(ne, deferred->entry());
+    // TODO(jbramley): We can't use JumpIfNotSmi here because the tbz it uses
+    // doesn't always have enough range. Consider making a variant of it, or a
+    // TestIsSmi helper.
+    STATIC_ASSERT(kSmiTag == 0);
+    __ Tst(input, kSmiTagMask);
+    __ B(ne, deferred->entry());
 
-  __ SmiUntag(output, input);
-  __ Bind(deferred->exit());
+    __ SmiUntag(output, input);
+    __ Bind(deferred->exit());
+  }
 }
 
 
 void LCodeGen::DoThisFunction(LThisFunction* instr) {
   Register result = ToRegister(instr->result());
   __ Ldr(result, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
 }
 
 
 void LCodeGen::DoToFastProperties(LToFastProperties* instr) {
@@ skipping 312 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