A64: Synchronize with r18444.

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 1604 matching lines @@
       //
       // TODO(jbramley): See if it's possible to do this inline, rather than by
       // calling a helper function. With frintz (to produce the intermediate
       // quotient) and fmsub (to calculate the remainder without loss of
       // precision), it should be possible. However, we would need support for
       // fdiv in round-towards-zero mode, and the A64 simulator doesn't support
       // that yet.
       ASSERT(left.Is(d0));
       ASSERT(right.Is(d1));
       __ CallCFunction(
-          ExternalReference::double_fp_operation(Token::MOD, isolate()),
+          ExternalReference::mod_two_doubles_operation(isolate()),
           0, 2);
       ASSERT(result.Is(d0));
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
 }
 
@@ skipping 353 matching lines @@
     case CodeStub::SubString: {
       SubStringStub stub;
       CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
       break;
     }
     case CodeStub::StringCompare: {
       StringCompareStub stub;
       CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
       break;
     }
-    case CodeStub::TranscendentalCache: {
-      __ Peek(x0, 0);
-      TranscendentalCacheStub stub(instr->transcendental_type(),
-                                   TranscendentalCacheStub::TAGGED);
-      CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
-      break;
-    }
     default:
       UNREACHABLE();
   }
 }
 
 
 void LCodeGen::DoUnknownOSRValue(LUnknownOSRValue* instr) {
   GenerateOsrPrologue();
 }
 
@@ skipping 1506 matching lines @@
 
   Register result = ToRegister(instr->result());
   Register source;
   if (access.IsInobject()) {
     source = object;
   } else {
     // Load the properties array, using result as a scratch register.
     __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
     source = result;
   }
-  __ Load(result, FieldMemOperand(source, offset), access.representation());
+
+  if (access.representation().IsSmi() &&
+      instr->hydrogen()->representation().IsInteger32()) {
+    // Read int value directly from upper half of the smi.
+    __ Load(result, UntagSmiFieldMemOperand(source, offset),
+            Representation::Integer32());
+  } else {
+    __ Load(result, FieldMemOperand(source, offset), access.representation());
+  }
 }
 
 
 void LCodeGen::DoLoadNamedGeneric(LLoadNamedGeneric* instr) {
   // LoadIC expects x2 to hold the name, and x0 to hold the receiver.
   ASSERT(ToRegister(instr->object()).is(x0));
   __ Mov(x2, Operand(instr->name()));
 
   Handle<Code> ic = isolate()->builtins()->LoadIC_Initialize();
   CallCode(ic, RelocInfo::CODE_TARGET, instr);
@@ skipping 239 matching lines @@
   // Check if the result needs to be corrected.
   __ Msub(remainder, result, right, left);
   __ Cbz(remainder, &done);
   __ Sub(result, result, 1);
 
   __ Bind(&done);
 }
 
 
 void LCodeGen::DoMathLog(LMathLog* instr) {
-  ASSERT(ToDoubleRegister(instr->result()).is(d0));
-  TranscendentalCacheStub stub(TranscendentalCache::LOG,
-                               TranscendentalCacheStub::UNTAGGED);
-  CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
+  ASSERT(instr->IsMarkedAsCall());
+  ASSERT(ToDoubleRegister(instr->value()).is(d0));
+  __ CallCFunction(ExternalReference::math_log_double_function(isolate()),
+                   0, 1);
   ASSERT(ToDoubleRegister(instr->result()).Is(d0));
 }
 
 
 void LCodeGen::DoMathPowHalf(LMathPowHalf* instr) {
   DoubleRegister input = ToDoubleRegister(instr->value());
   DoubleRegister result = ToDoubleRegister(instr->result());
   Label done;
 
   // Math.pow(x, 0.5) differs from fsqrt(x) in the following cases:
@@ skipping 1819 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