Fix compile failure on Win64.

src/x64/macro-assembler-x64.cc

 // Copyright 2011 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 31 matching lines @@
 
 MacroAssembler::MacroAssembler(void* buffer, int size)
     : Assembler(buffer, size),
       generating_stub_(false),
       allow_stub_calls_(true),
       root_array_available_(true),
       code_object_(HEAP->undefined_value()) {
 }
 
 
-static intptr_t RootRegisterDelta(ExternalReference other) {
+  static intptr_t RootRegisterDelta(ExternalReference other, Isolate* isolate) {
   Address roots_register_value = kRootRegisterBias +
-      reinterpret_cast<Address>(Isolate::Current()->heap()->roots_address());
+      reinterpret_cast<Address>(isolate->heap()->roots_address());
   intptr_t delta = other.address() - roots_register_value;
   return delta;
 }
 
 
 Operand MacroAssembler::ExternalOperand(ExternalReference target,
                                         Register scratch) {
   if (root_array_available_ && !Serializer::enabled()) {
-    intptr_t delta = RootRegisterDelta(target);
+    intptr_t delta = RootRegisterDelta(target, isolate());
     if (is_int32(delta)) {
       Serializer::TooLateToEnableNow();
-      return Operand(kRootRegister, delta);
+      return Operand(kRootRegister, static_cast<int32_t>(delta));
     }
   }
   movq(scratch, target);
   return Operand(scratch, 0);
 }
 
 
 void MacroAssembler::Load(Register destination, ExternalReference source) {
   if (root_array_available_ && !Serializer::enabled()) {
-    intptr_t delta = RootRegisterDelta(source);
+    intptr_t delta = RootRegisterDelta(source, isolate());
     if (is_int32(delta)) {
       Serializer::TooLateToEnableNow();
       movq(destination, Operand(kRootRegister, static_cast<int32_t>(delta)));
       return;
     }
   }
   // Safe code.
   if (destination.is(rax)) {
     load_rax(source);
   } else {
     movq(kScratchRegister, source);
     movq(destination, Operand(kScratchRegister, 0));
   }
 }
 
 
 void MacroAssembler::Store(ExternalReference destination, Register source) {
   if (root_array_available_ && !Serializer::enabled()) {
-    intptr_t delta = RootRegisterDelta(destination);
+    intptr_t delta = RootRegisterDelta(destination, isolate());
     if (is_int32(delta)) {
       Serializer::TooLateToEnableNow();
       movq(Operand(kRootRegister, static_cast<int32_t>(delta)), source);
       return;
     }
   }
   // Safe code.
   if (source.is(rax)) {
     store_rax(destination);
   } else {
     movq(kScratchRegister, destination);
     movq(Operand(kScratchRegister, 0), source);
   }
 }
 
 
 void MacroAssembler::LoadAddress(Register destination,
                                  ExternalReference source) {
   if (root_array_available_ && !Serializer::enabled()) {
-    intptr_t delta = RootRegisterDelta(source);
+    intptr_t delta = RootRegisterDelta(source, isolate());
     if (is_int32(delta)) {
       Serializer::TooLateToEnableNow();
       lea(destination, Operand(kRootRegister, static_cast<int32_t>(delta)));
       return;
     }
   }
   // Safe code.
   movq(destination, source);
 }
 
 
 int MacroAssembler::LoadAddressSize(ExternalReference source) {
   if (root_array_available_ && !Serializer::enabled()) {
     // This calculation depends on the internals of LoadAddress.
     // It's correctness is ensured by the asserts in the Call
     // instruction below.
-    intptr_t delta = RootRegisterDelta(source);
+    intptr_t delta = RootRegisterDelta(source, isolate());
     if (is_int32(delta)) {
       Serializer::TooLateToEnableNow();
       // Operand is lea(scratch, Operand(kRootRegister, delta));
       // Opcodes : REX.W 8D ModRM Disp8/Disp32  - 4 or 7.
       int size = 4;
       if (!is_int8(static_cast<int32_t>(delta))) {
         size += 3;  // Need full four-byte displacement in lea.
       }
       return size;
     }
@@ skipping 2714 matching lines @@
   CPU::FlushICache(address_, size_);
 
   // Check that the code was patched as expected.
   ASSERT(masm_.pc_ == address_ + size_);
   ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64