Port inlining of type checks in call ICs for API functions to x64 and arm (is...

src/arm/macro-assembler-arm.cc

 // Copyright 2006-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 703 matching lines @@
   pop(r1);
   mov(ip, Operand(ExternalReference(Top::k_handler_address)));
   add(sp, sp, Operand(StackHandlerConstants::kSize - kPointerSize));
   str(r1, MemOperand(ip));
 }
 
 
 Register MacroAssembler::CheckMaps(JSObject* object, Register object_reg,
                                    JSObject* holder, Register holder_reg,
                                    Register scratch,
+                                   int save_at_depth,
                                    Label* miss) {
   // Make sure there's no overlap between scratch and the other
   // registers.
   ASSERT(!scratch.is(object_reg) && !scratch.is(holder_reg));
 
   // Keep track of the current object in register reg.
   Register reg = object_reg;
-  int depth = 1;
+  int depth = 0;
+
+  if (save_at_depth == depth) {
+    str(reg, MemOperand(sp));
+  }
 
   // Check the maps in the prototype chain.
   // Traverse the prototype chain from the object and do map checks.
   while (object != holder) {
     depth++;
 
     // Only global objects and objects that do not require access
     // checks are allowed in stubs.
     ASSERT(object->IsJSGlobalProxy() || !object->IsAccessCheckNeeded());
 
@@ skipping 19 matching lines @@
     JSObject* prototype = JSObject::cast(object->GetPrototype());
     if (Heap::InNewSpace(prototype)) {
       // The prototype is in new space; we cannot store a reference
       // to it in the code. Load it from the map.
       ldr(reg, FieldMemOperand(scratch, Map::kPrototypeOffset));
     } else {
       // The prototype is in old space; load it directly.
       mov(reg, Operand(Handle<JSObject>(prototype)));
     }
 
+    if (save_at_depth == depth) {
+      str(reg, MemOperand(sp));
+    }
+
     // Go to the next object in the prototype chain.
     object = prototype;
   }
 
   // Check the holder map.
   ldr(scratch, FieldMemOperand(reg, HeapObject::kMapOffset));
   cmp(scratch, Operand(Handle<Map>(object->map())));
   b(ne, miss);
 
   // Log the check depth.
-  LOG(IntEvent("check-maps-depth", depth));
+  LOG(IntEvent("check-maps-depth", depth + 1));
 
   // Perform security check for access to the global object and return
   // the holder register.
   ASSERT(object == holder);
   ASSERT(object->IsJSGlobalProxy() || !object->IsAccessCheckNeeded());
   if (object->IsJSGlobalProxy()) {
     CheckAccessGlobalProxy(reg, scratch, miss);
   }
   return reg;
 }
@@ skipping 868 matching lines @@
 }
 
 
 void CodePatcher::Emit(Address addr) {
   masm()->emit(reinterpret_cast<Instr>(addr));
 }
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 
 } }  // namespace v8::internal