Implement ICs for constructor calls.

src/ia32/ic-ia32.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 900 matching lines @@
 
   // Probe the stub cache for the value object.
   __ bind(&probe);
   isolate->stub_cache()->GenerateProbe(masm, flags, edx, ecx, ebx, no_reg);
   __ bind(&miss);
 }
 
 
 static void GenerateFunctionTailCall(MacroAssembler* masm,
                                      int argc,
+                                     Code::ExtraICState extra_state,
                                      Label* miss) {
   // ----------- S t a t e -------------
   //  -- ecx                 : name
   //  -- edi                 : function
   //  -- esp[0]              : return address
   //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
   //  -- ...
   //  -- esp[(argc + 1) * 4] : receiver
   // -----------------------------------
 
   // Check that the result is not a smi.
   __ JumpIfSmi(edi, miss);
 
   // Check that the value is a JavaScript function, fetching its map into eax.
   __ CmpObjectType(edi, JS_FUNCTION_TYPE, eax);
   __ j(not_equal, miss);
 
   // Invoke the function.
-  ParameterCount actual(argc);
-  __ InvokeFunction(edi, actual, JUMP_FUNCTION,
-                    NullCallWrapper(), CALL_AS_METHOD);
+  if (CallICBase::ConstructCall::decode(extra_state)) {
+    ParameterCount actual(argc);
+    __ InvokeConstruct(edi, actual);
+  } else {
+    ParameterCount actual(argc);
+    __ InvokeFunction(edi, actual, JUMP_FUNCTION,
+                      NullCallWrapper(), CALL_AS_METHOD);
+  }
 }
 
 
 // The generated code falls through if the call should be handled by runtime.
-void CallICBase::GenerateNormal(MacroAssembler* masm, int argc) {
+void CallICBase::GenerateNormal(MacroAssembler* masm,
+                                int argc,
+                                Code::ExtraICState extra_state) {
   // ----------- S t a t e -------------
   //  -- ecx                 : name
   //  -- esp[0]              : return address
   //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
   //  -- ...
   //  -- esp[(argc + 1) * 4] : receiver
   // -----------------------------------
   Label miss;
 
   // Get the receiver of the function from the stack; 1 ~ return address.
   __ mov(edx, Operand(esp, (argc + 1) * kPointerSize));
 
   GenerateStringDictionaryReceiverCheck(masm, edx, eax, ebx, &miss);
 
   // eax: elements
   // Search the dictionary placing the result in edi.
   GenerateDictionaryLoad(masm, &miss, eax, ecx, edi, ebx, edi);
-  GenerateFunctionTailCall(masm, argc, &miss);
+  GenerateFunctionTailCall(masm, argc, extra_state, &miss);
 
   __ bind(&miss);
 }
 
 
 void CallICBase::GenerateMiss(MacroAssembler* masm,
                               int argc,
                               IC::UtilityId id,
                               Code::ExtraICState extra_state) {
   // ----------- S t a t e -------------
@@ skipping 45 matching lines @@
     __ j(not_equal, &invoke, Label::kNear);
 
     // Patch the receiver on the stack.
     __ bind(&global);
     __ mov(edx, FieldOperand(edx, GlobalObject::kGlobalReceiverOffset));
     __ mov(Operand(esp, (argc + 1) * kPointerSize), edx);
     __ bind(&invoke);
   }
 
   // Invoke the function.
-  CallKind call_kind = CallICBase::Contextual::decode(extra_state)
-      ? CALL_AS_FUNCTION
-      : CALL_AS_METHOD;
-  ParameterCount actual(argc);
-  __ InvokeFunction(edi,
-                    actual,
-                    JUMP_FUNCTION,
-                    NullCallWrapper(),
-                    call_kind);
+  if (CallICBase::ConstructCall::decode(extra_state)) {
+    ParameterCount actual(argc);
+    __ InvokeConstruct(edi, actual);
+  } else {
+    CallKind call_kind = CallICBase::Contextual::decode(extra_state)
+        ? CALL_AS_FUNCTION
+        : CALL_AS_METHOD;
+    ParameterCount actual(argc);
+    __ InvokeFunction(edi,
+                      actual,
+                      JUMP_FUNCTION,
+                      NullCallWrapper(),
+                      call_kind);
+  }
 }
 
 
 void CallIC::GenerateMegamorphic(MacroAssembler* masm,
                                  int argc,
                                  Code::ExtraICState extra_state) {
   // ----------- S t a t e -------------
   //  -- ecx                 : name
   //  -- esp[0]              : return address
   //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
   //  -- ...
   //  -- esp[(argc + 1) * 4] : receiver
   // -----------------------------------
 
   // Get the receiver of the function from the stack; 1 ~ return address.
   __ mov(edx, Operand(esp, (argc + 1) * kPointerSize));
   CallICBase::GenerateMonomorphicCacheProbe(masm, argc, Code::CALL_IC,
                                             extra_state);
 
   GenerateMiss(masm, argc, extra_state);
 }
 
 
-void KeyedCallIC::GenerateMegamorphic(MacroAssembler* masm, int argc) {
+void KeyedCallIC::GenerateMegamorphic(MacroAssembler* masm,
+                                      int argc,
+                                      Code::ExtraICState extra_state) {
   // ----------- S t a t e -------------
   //  -- ecx                 : name
   //  -- esp[0]              : return address
   //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
   //  -- ...
   //  -- esp[(argc + 1) * 4] : receiver
   // -----------------------------------
 
   // Get the receiver of the function from the stack; 1 ~ return address.
   __ mov(edx, Operand(esp, (argc + 1) * kPointerSize));
@@ skipping 15 matching lines @@
   GenerateFastArrayLoad(
       masm, edx, ecx, eax, edi, &check_number_dictionary, &slow_load);
   Isolate* isolate = masm->isolate();
   Counters* counters = isolate->counters();
   __ IncrementCounter(counters->keyed_call_generic_smi_fast(), 1);
 
   __ bind(&do_call);
   // receiver in edx is not used after this point.
   // ecx: key
   // edi: function
-  GenerateFunctionTailCall(masm, argc, &slow_call);
+  GenerateFunctionTailCall(masm, argc, extra_state, &slow_call);
 
   __ bind(&check_number_dictionary);
   // eax: elements
   // ecx: smi key
   // Check whether the elements is a number dictionary.
   __ CheckMap(eax,
               isolate->factory()->hash_table_map(),
               &slow_load,
               DONT_DO_SMI_CHECK);
   __ mov(ebx, ecx);
@@ skipping 42 matching lines @@
               &lookup_monomorphic_cache,
               DONT_DO_SMI_CHECK);
 
   GenerateDictionaryLoad(masm, &slow_load, ebx, ecx, eax, edi, edi);
   __ IncrementCounter(counters->keyed_call_generic_lookup_dict(), 1);
   __ jmp(&do_call);
 
   __ bind(&lookup_monomorphic_cache);
   __ IncrementCounter(counters->keyed_call_generic_lookup_cache(), 1);
   CallICBase::GenerateMonomorphicCacheProbe(masm, argc, Code::KEYED_CALL_IC,
-                                            Code::kNoExtraICState);
+                                            extra_state);
   // Fall through on miss.
 
   __ bind(&slow_call);
   // This branch is taken if:
   // - the receiver requires boxing or access check,
   // - the key is neither smi nor symbol,
   // - the value loaded is not a function,
   // - there is hope that the runtime will create a monomorphic call stub
   //   that will get fetched next time.
   __ IncrementCounter(counters->keyed_call_generic_slow(), 1);
-  GenerateMiss(masm, argc);
+  GenerateMiss(masm, argc, extra_state);
 
   __ bind(&index_string);
   __ IndexFromHash(ebx, ecx);
   // Now jump to the place where smi keys are handled.
   __ jmp(&index_smi);
 }
 
 
 void KeyedCallIC::GenerateNonStrictArguments(MacroAssembler* masm,
-                                             int argc) {
+                                             int argc,
+                                             Code::ExtraICState extra_state) {
   // ----------- S t a t e -------------
   //  -- ecx                 : name
   //  -- esp[0]              : return address
   //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
   //  -- ...
   //  -- esp[(argc + 1) * 4] : receiver
   // -----------------------------------
   Label slow, notin;
   Factory* factory = masm->isolate()->factory();
   __ mov(edx, Operand(esp, (argc + 1) * kPointerSize));
   Operand mapped_location =
       GenerateMappedArgumentsLookup(masm, edx, ecx, ebx, eax, &notin, &slow);
   __ mov(edi, mapped_location);
-  GenerateFunctionTailCall(masm, argc, &slow);
+  GenerateFunctionTailCall(masm, argc, extra_state, &slow);
   __ bind(&notin);
   // The unmapped lookup expects that the parameter map is in ebx.
   Operand unmapped_location =
       GenerateUnmappedArgumentsLookup(masm, ecx, ebx, eax, &slow);
   __ cmp(unmapped_location, factory->the_hole_value());
   __ j(equal, &slow);
   __ mov(edi, unmapped_location);
-  GenerateFunctionTailCall(masm, argc, &slow);
+  GenerateFunctionTailCall(masm, argc, extra_state, &slow);
   __ bind(&slow);
-  GenerateMiss(masm, argc);
+  GenerateMiss(masm, argc, extra_state);
 }
 
 
-void KeyedCallIC::GenerateNormal(MacroAssembler* masm, int argc) {
+void KeyedCallIC::GenerateNormal(MacroAssembler* masm,
+                                 int argc,
+                                 Code::ExtraICState extra_state) {
   // ----------- S t a t e -------------
   //  -- ecx                 : name
   //  -- esp[0]              : return address
   //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
   //  -- ...
   //  -- esp[(argc + 1) * 4] : receiver
   // -----------------------------------
 
   // Check if the name is a string.
   Label miss;
   __ JumpIfSmi(ecx, &miss);
   Condition cond = masm->IsObjectStringType(ecx, eax, eax);
   __ j(NegateCondition(cond), &miss);
-  CallICBase::GenerateNormal(masm, argc);
+  CallICBase::GenerateNormal(masm, argc, extra_state);
   __ bind(&miss);
-  GenerateMiss(masm, argc);
+  GenerateMiss(masm, argc, extra_state);
 }
 
 
 void LoadIC::GenerateMegamorphic(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- eax    : receiver
   //  -- ecx    : name
   //  -- esp[0] : return address
   // -----------------------------------
 
@@ skipping 437 matching lines @@
   Condition cc = *jmp_address == Assembler::kJncShortOpcode
       ? not_zero
       : zero;
   *jmp_address = static_cast<byte>(Assembler::kJccShortPrefix | cc);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32