Use a root array register for constant loads and stack guards on x64....

src/x64/stub-cache-x64.cc

 // Copyright 2009 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 416 matching lines @@
     __ push(holder);
     __ push(name_);
 
     CompileCallLoadPropertyWithInterceptor(masm,
                                            receiver,
                                            holder,
                                            name_,
                                            holder_obj);
 
     Label interceptor_failed;
-    __ Cmp(rax, Factory::no_interceptor_result_sentinel());
+    __ CompareRoot(rax, Heap::kNoInterceptorResultSentinelRootIndex);
     __ j(equal, &interceptor_failed);
     __ LeaveInternalFrame();
     __ ret(0);
 
     __ bind(&interceptor_failed);
     __ pop(name_);
     __ pop(holder);
     if (lookup->type() == CALLBACKS) {
       __ pop(receiver);
     }
@@ skipping 157 matching lines @@
         masm,
         receiver,
         holder,
         // Under EnterInternalFrame this refers to name.
         Operand(rbp, (argc_ + 3) * kPointerSize),
         holder_obj);
 
     __ pop(receiver);  // restore holder
     __ LeaveInternalFrame();
 
-    __ Cmp(rax, Factory::no_interceptor_result_sentinel());
+    __ CompareRoot(rax, Heap::kNoInterceptorResultSentinelRootIndex);
     Label invoke;
     __ j(not_equal, &invoke);
 
     stub_compiler->CheckPrototypes(holder_obj, receiver,
                                    lookup->holder(), scratch1,
                                    scratch2,
                                    name,
                                    miss_label);
     if (lookup->holder()->IsGlobalObject()) {
       __ movq(rdx, Operand(rsp, (argc_ + 1) * kPointerSize));
@@ skipping 122 matching lines @@
                                           Context::NUMBER_FUNCTION_INDEX,
                                           rcx);
       CheckPrototypes(JSObject::cast(object->GetPrototype()), rcx, holder,
                       rbx, rdx, name, &miss);
       break;
     }
 
     case BOOLEAN_CHECK: {
       Label fast;
       // Check that the object is a boolean.
-      __ Cmp(rdx, Factory::true_value());
+      __ CompareRoot(rdx, Heap::kTrueValueRootIndex);
       __ j(equal, &fast);
-      __ Cmp(rdx, Factory::false_value());
+      __ CompareRoot(rdx, Heap::kFalseValueRootIndex);
       __ j(not_equal, &miss);
       __ bind(&fast);
       // Check that the maps starting from the prototype haven't changed.
       GenerateLoadGlobalFunctionPrototype(masm(),
                                           Context::BOOLEAN_FUNCTION_INDEX,
                                           rcx);
       CheckPrototypes(JSObject::cast(object->GetPrototype()), rcx, holder,
                       rbx, rdx, name, &miss);
       break;
     }
@@ skipping 347 matching lines @@
 
   // Check that the maps haven't changed.
   CheckPrototypes(object, rax, holder, rbx, rdx, name, &miss);
 
   // Get the value from the cell.
   __ Move(rax, Handle<JSGlobalPropertyCell>(cell));
   __ movq(rax, FieldOperand(rax, JSGlobalPropertyCell::kValueOffset));
 
   // Check for deleted property if property can actually be deleted.
   if (!is_dont_delete) {
-    __ Cmp(rax, Factory::the_hole_value());
+    __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);
     __ j(equal, &miss);
   } else if (FLAG_debug_code) {
-    __ Cmp(rax, Factory::the_hole_value());
+    __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);
     __ Check(not_equal, "DontDelete cells can't contain the hole");
   }
 
   __ IncrementCounter(&Counters::named_load_global_inline, 1);
   __ ret(0);
 
   __ bind(&miss);
   __ IncrementCounter(&Counters::named_load_global_inline_miss, 1);
   GenerateLoadMiss(masm(), Code::LOAD_IC);
 
@@ skipping 604 matching lines @@
   __ Jump(generic_construct_stub, RelocInfo::CODE_TARGET);
 
   // Return the generated code.
   return GetCode();
 }
 
 
 #undef __
 
 } }  // namespace v8::internal