Introduce a special kind of frames for construct frames, e.g....

src/builtins-arm.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 40 matching lines @@
 
 
 void Builtins::Generate_JSConstructCall(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- r0     : number of arguments
   //  -- r1     : constructor function
   //  -- lr     : return address
   //  -- sp[...]: constructor arguments
   // -----------------------------------
 
-  // Enter an internal frame.
-  __ EnterInternalFrame();
+  // Enter a construct frame.
+  __ EnterConstructFrame();
 
   // Preserve the two incoming parameters
   __ mov(r0, Operand(r0, LSL, kSmiTagSize));
   __ push(r0);  // smi-tagged arguments count
   __ push(r1);  // constructor function
 
   // Allocate the new receiver object.
   __ push(r1);  // argument for Runtime_NewObject
   __ CallRuntime(Runtime::kNewObject, 1);
   __ push(r0);  // save the receiver
@@ skipping 36 matching lines @@
   __ bind(&loop);
   __ ldr(ip, MemOperand(r2, r3, LSL, kPointerSizeLog2 - 1));
   __ push(ip);
   __ bind(&entry);
   __ sub(r3, r3, Operand(2), SetCC);
   __ b(ge, &loop);
 
   // Call the function.
   // r0: number of arguments
   // r1: constructor function
-  Label return_site;
   ParameterCount actual(r0);
   __ InvokeFunction(r1, actual, CALL_FUNCTION);
-  __ bind(&return_site);
 
   // Pop the function from the stack.
   // sp[0]: constructor function
   // sp[2]: receiver
   // sp[3]: constructor function
   // sp[4]: number of arguments (smi-tagged)
   __ pop();
 
   // Restore context from the frame.
   // r0: result
@@ skipping 28 matching lines @@
   __ ldr(r0, MemOperand(sp));
 
   // Remove receiver from the stack, remove caller arguments, and
   // return.
   __ bind(&exit);
   // r0: result
   // sp[0]: receiver (newly allocated object)
   // sp[1]: constructor function
   // sp[2]: number of arguments (smi-tagged)
   __ ldr(r1, MemOperand(sp, 2 * kPointerSize));
-  __ LeaveInternalFrame();
+  __ LeaveConstructFrame();
   __ add(sp, sp, Operand(r1, LSL, kPointerSizeLog2 - 1));
   __ add(sp, sp, Operand(kPointerSize));
   __ mov(pc, Operand(lr));
-
-  // Compute the offset from the beginning of the JSConstructCall
-  // builtin code object to the return address after the call.
-  ASSERT(return_site.is_bound());
-  construct_call_pc_offset_ = return_site.pos() + Code::kHeaderSize;
 }
 
 
 static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm,
                                              bool is_construct) {
   // Called from Generate_JS_Entry
   // r0: code entry
   // r1: function
   // r2: receiver
   // r3: argc
@@ skipping 342 matching lines @@
 
 
 static void EnterArgumentsAdaptorFrame(MacroAssembler* masm) {
   __ mov(r0, Operand(r0, LSL, kSmiTagSize));
   __ mov(r4, Operand(ArgumentsAdaptorFrame::SENTINEL));
   __ stm(db_w, sp, r0.bit() | r1.bit() | r4.bit() | fp.bit() | lr.bit());
   __ add(fp, sp, Operand(3 * kPointerSize));
 }
 
 
-static void ExitArgumentsAdaptorFrame(MacroAssembler* masm) {
+static void LeaveArgumentsAdaptorFrame(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- r0 : result being passed through
   // -----------------------------------
   // Get the number of arguments passed (as a smi), tear down the frame and
   // then tear down the parameters.
   __ ldr(r1, MemOperand(fp, -3 * kPointerSize));
   __ mov(sp, fp);
   __ ldm(ia_w, sp, fp.bit() | lr.bit());
   __ add(sp, sp, Operand(r1, LSL, kPointerSizeLog2 - kSmiTagSize));
   __ add(sp, sp, Operand(kPointerSize));  // adjust for receiver
@@ skipping 81 matching lines @@
     __ sub(r2, r2, Operand(4 * kPointerSize));  // Adjust for frame.
 
     Label fill;
     __ bind(&fill);
     __ push(ip);
     __ cmp(sp, r2);
     __ b(ne, &fill);
   }
 
   // Call the entry point.
-  Label return_site;
   __ bind(&invoke);
+  __ Call(r3);
 
-  __ Call(r3);
-  __ bind(&return_site);
-
-  ExitArgumentsAdaptorFrame(masm);
+  // Exit frame and return.
+  LeaveArgumentsAdaptorFrame(masm);
   __ mov(pc, lr);
 
-  // Compute the offset from the beginning of the ArgumentsAdaptorTrampoline
-  // builtin code object to the return address after the call.
-  ASSERT(return_site.is_bound());
-  arguments_adaptor_call_pc_offset_ = return_site.pos() + Code::kHeaderSize;
-
 
   // -------------------------------------------
   // Dont adapt arguments.
   // -------------------------------------------
   __ bind(&dont_adapt_arguments);
   __ mov(pc, r3);
 }
 
 
 static void Generate_DebugBreakCallHelper(MacroAssembler* masm,
@@ skipping 155 matching lines @@
 }
 
 void Builtins::Generate_StubNoRegisters_DebugBreak(MacroAssembler* masm) {
   // Generate nothing as CodeStub CallFunction is not used on ARM.
 }
 
 
 #undef __
 
 } }  // namespace v8::internal