Adapt to new calling convention on ARM.

src/bootstrapper.cc

 // Copyright 2006-2008 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 943 matching lines @@
     if (!result) return false;
 
   } else {
     // Empty natives file name - do not install any natives.
     PrintF("Warning: Running without installed natives!\n");
     return true;
   }
 
   InstallNativeFunctions();
 
-#ifndef USE_OLD_CALLING_CONVENTIONS
   // TODO(1240778): Get rid of the JS implementation of
   // Function.prototype.call and simply create a function with the
   // faked formal parameter count (-1) and use the illegal builtin as
   // the code for it.
 
   // Find Function.prototype.call and set it's number of formal
   // parameters to -1 to let the arguments adaptor handle it
   // specially.
   { Handle<JSFunction> function =
         Handle<JSFunction>::cast(GetProperty(Top::global(),
                                              Factory::function_class_symbol()));
     Handle<JSObject> proto =
         Handle<JSObject>(JSObject::cast(function->instance_prototype()));
     Handle<JSFunction> call =
         Handle<JSFunction>::cast(GetProperty(proto, Factory::call_symbol()));
     call->shared()->set_formal_parameter_count(-1);
 
     // Make sure that Function.prototype.call appears to be compiled.
     // The code will never be called, but inline caching for call will
     // only work if it appears to be compiled.
     call->shared()->set_code(Builtins::builtin(Builtins::Illegal));
     ASSERT(call->is_compiled());
 
     // Use the specialized builtin for Function.prototype.apply.
     Handle<JSFunction> apply =
         Handle<JSFunction>::cast(GetProperty(proto, Factory::apply_symbol()));
     apply->shared()->set_code(Builtins::builtin(Builtins::FunctionApply));
   }
-#endif
 
   // Make sure that the builtins object has fast properties.
   // If the ASSERT below fails, please increase the expected number of
   // properties for the builtins object.
   ASSERT(builtins->HasFastProperties());
 #ifdef DEBUG
   builtins->Verify();
 #endif
   return true;
 }
@@ skipping 334 matching lines @@
   if (!ConfigureGlobalObject(global_template)) return;
 
   if (!InstallExtensions(extensions)) return;
 
   if (!InstallSpecialObjects()) return;
 
   result_ = global_context_;
 }
 
 } }  // namespace v8::internal