LCOV - code coverage report
Current view: top level - src - code-factory.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 216 224 96.4 %
Date: 2017-04-26 Functions: 131 135 97.0 %

          Line data    Source code
       1             : // Copyright 2014 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/code-factory.h"
       6             : 
       7             : #include "src/bootstrapper.h"
       8             : #include "src/builtins/builtins-descriptors.h"
       9             : #include "src/ic/ic.h"
      10             : #include "src/objects-inl.h"
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : 
      15             : namespace {
      16             : 
      17             : // TODO(ishell): make it (const Stub& stub) once CodeStub::GetCode() is const.
      18             : template <typename Stub>
      19     3398335 : Callable make_callable(Stub& stub) {
      20             :   typedef typename Stub::Descriptor Descriptor;
      21    10195012 :   return Callable(stub.GetCode(), Descriptor(stub.isolate()));
      22             : }
      23             : 
      24             : }  // namespace
      25             : 
      26             : // static
      27      153807 : Handle<Code> CodeFactory::RuntimeCEntry(Isolate* isolate, int result_size) {
      28             :   CEntryStub stub(isolate, result_size);
      29      153807 :   return stub.GetCode();
      30             : }
      31             : 
      32             : // static
      33     2134682 : Callable CodeFactory::LoadIC(Isolate* isolate) {
      34             :   return Callable(isolate->builtins()->LoadICTrampoline(),
      35     6404046 :                   LoadDescriptor(isolate));
      36             : }
      37             : 
      38             : // static
      39         903 : Callable CodeFactory::LoadICProtoArray(Isolate* isolate,
      40             :                                        bool throw_if_nonexistent) {
      41             :   return Callable(
      42             :       throw_if_nonexistent
      43         301 :           ? isolate->builtins()->LoadICProtoArrayThrowIfNonexistent()
      44         602 :           : isolate->builtins()->LoadICProtoArray(),
      45        3612 :       LoadICProtoArrayDescriptor(isolate));
      46             : }
      47             : 
      48             : // static
      49        1591 : Callable CodeFactory::ApiGetter(Isolate* isolate) {
      50             :   CallApiGetterStub stub(isolate);
      51        1591 :   return make_callable(stub);
      52             : }
      53             : 
      54             : // static
      55      258976 : Callable CodeFactory::LoadICInOptimizedCode(Isolate* isolate) {
      56             :   return Callable(isolate->builtins()->LoadIC(),
      57      776928 :                   LoadWithVectorDescriptor(isolate));
      58             : }
      59             : 
      60             : // static
      61         129 : Callable CodeFactory::LoadICInOptimizedCode_Noninlined(Isolate* isolate) {
      62             :   return Callable(isolate->builtins()->LoadIC_Noninlined(),
      63         387 :                   LoadWithVectorDescriptor(isolate));
      64             : }
      65             : 
      66             : // static
      67      910895 : Callable CodeFactory::LoadGlobalIC(Isolate* isolate, TypeofMode typeof_mode) {
      68             :   return Callable(
      69             :       typeof_mode == NOT_INSIDE_TYPEOF
      70      910351 :           ? isolate->builtins()->LoadGlobalICTrampoline()
      71         545 :           : isolate->builtins()->LoadGlobalICInsideTypeofTrampoline(),
      72     3643582 :       LoadGlobalDescriptor(isolate));
      73             : }
      74             : 
      75             : // static
      76       54736 : Callable CodeFactory::LoadGlobalICInOptimizedCode(Isolate* isolate,
      77             :                                                   TypeofMode typeof_mode) {
      78             :   return Callable(typeof_mode == NOT_INSIDE_TYPEOF
      79       54644 :                       ? isolate->builtins()->LoadGlobalIC()
      80          92 :                       : isolate->builtins()->LoadGlobalICInsideTypeof(),
      81      218944 :                   LoadGlobalWithVectorDescriptor(isolate));
      82             : }
      83             : 
      84             : // static
      85      279537 : Callable CodeFactory::KeyedLoadIC(Isolate* isolate) {
      86             :   return Callable(isolate->builtins()->KeyedLoadICTrampoline(),
      87      838611 :                   LoadDescriptor(isolate));
      88             : }
      89             : 
      90             : // static
      91       74599 : Callable CodeFactory::KeyedLoadICInOptimizedCode(Isolate* isolate) {
      92             :   return Callable(isolate->builtins()->KeyedLoadIC(),
      93      223797 :                   LoadWithVectorDescriptor(isolate));
      94             : }
      95             : 
      96             : // static
      97      628481 : Callable CodeFactory::CallIC(Isolate* isolate, ConvertReceiverMode mode,
      98             :                              TailCallMode tail_call_mode) {
      99             :   CallICStub stub(isolate, mode, tail_call_mode);
     100      628481 :   return make_callable(stub);
     101             : }
     102             : 
     103             : // static
     104     1105373 : Callable CodeFactory::CallICTrampoline(Isolate* isolate,
     105             :                                        ConvertReceiverMode mode,
     106             :                                        TailCallMode tail_call_mode) {
     107             :   CallICTrampolineStub stub(isolate, mode, tail_call_mode);
     108     1105373 :   return make_callable(stub);
     109             : }
     110             : 
     111             : // static
     112      969476 : Callable CodeFactory::StoreIC(Isolate* isolate, LanguageMode language_mode) {
     113             :   return Callable(language_mode == STRICT
     114      905124 :                       ? isolate->builtins()->StoreICStrictTrampoline()
     115       64352 :                       : isolate->builtins()->StoreICTrampoline(),
     116     3877904 :                   StoreDescriptor(isolate));
     117             : }
     118             : 
     119             : // static
     120       46448 : Callable CodeFactory::StoreICInOptimizedCode(Isolate* isolate,
     121             :                                              LanguageMode language_mode) {
     122       32515 :   return Callable(language_mode == STRICT ? isolate->builtins()->StoreICStrict()
     123       13933 :                                           : isolate->builtins()->StoreIC(),
     124      185792 :                   StoreWithVectorDescriptor(isolate));
     125             : }
     126             : 
     127             : // static
     128          86 : Callable CodeFactory::StoreIC_Uninitialized(Isolate* isolate,
     129             :                                             LanguageMode language_mode) {
     130             :   return Callable(language_mode == STRICT
     131          43 :                       ? isolate->builtins()->StoreICStrict_Uninitialized()
     132          43 :                       : isolate->builtins()->StoreIC_Uninitialized(),
     133         344 :                   StoreWithVectorDescriptor(isolate));
     134             : }
     135             : 
     136      224447 : Callable CodeFactory::StoreOwnIC(Isolate* isolate) {
     137             :   // TODO(ishell): Currently we use StoreOwnIC only for storing properties that
     138             :   // already exist in the boilerplate therefore we can use StoreIC.
     139             :   return Callable(isolate->builtins()->StoreICStrictTrampoline(),
     140      673341 :                   StoreDescriptor(isolate));
     141             : }
     142             : 
     143       18978 : Callable CodeFactory::StoreOwnICInOptimizedCode(Isolate* isolate) {
     144             :   // TODO(ishell): Currently we use StoreOwnIC only for storing properties that
     145             :   // already exist in the boilerplate therefore we can use StoreIC.
     146             :   return Callable(isolate->builtins()->StoreICStrict(),
     147       56934 :                   StoreWithVectorDescriptor(isolate));
     148             : }
     149             : 
     150             : // static
     151       77702 : Callable CodeFactory::StoreGlobalIC(Isolate* isolate,
     152             :                                     LanguageMode language_mode) {
     153             :   // TODO(ishell): Use StoreGlobalIC[Strict]Trampoline when it's ready.
     154             :   return Callable(language_mode == STRICT
     155        1271 :                       ? isolate->builtins()->StoreICStrictTrampoline()
     156       76431 :                       : isolate->builtins()->StoreICTrampoline(),
     157      310808 :                   StoreDescriptor(isolate));
     158             : }
     159             : 
     160             : // static
     161       11398 : Callable CodeFactory::StoreGlobalICInOptimizedCode(Isolate* isolate,
     162             :                                                    LanguageMode language_mode) {
     163             :   // TODO(ishell): Use StoreGlobalIC[Strict] when it's ready.
     164         285 :   return Callable(language_mode == STRICT ? isolate->builtins()->StoreICStrict()
     165       11113 :                                           : isolate->builtins()->StoreIC(),
     166       45592 :                   StoreWithVectorDescriptor(isolate));
     167             : }
     168             : 
     169             : // static
     170      239691 : Callable CodeFactory::KeyedStoreIC(Isolate* isolate,
     171             :                                    LanguageMode language_mode) {
     172             :   return Callable(language_mode == STRICT
     173      146521 :                       ? isolate->builtins()->KeyedStoreICStrictTrampoline()
     174       93170 :                       : isolate->builtins()->KeyedStoreICTrampoline(),
     175      958764 :                   StoreDescriptor(isolate));
     176             : }
     177             : 
     178             : // static
     179       24097 : Callable CodeFactory::KeyedStoreICInOptimizedCode(Isolate* isolate,
     180             :                                                   LanguageMode language_mode) {
     181             :   return Callable(language_mode == STRICT
     182        8938 :                       ? isolate->builtins()->KeyedStoreICStrict()
     183       15159 :                       : isolate->builtins()->KeyedStoreIC(),
     184       96388 :                   StoreWithVectorDescriptor(isolate));
     185             : }
     186             : 
     187             : // static
     188          86 : Callable CodeFactory::KeyedStoreIC_Megamorphic(Isolate* isolate,
     189             :                                                LanguageMode language_mode) {
     190             :   return Callable(language_mode == STRICT
     191          43 :                       ? isolate->builtins()->KeyedStoreIC_Megamorphic_Strict()
     192          43 :                       : isolate->builtins()->KeyedStoreIC_Megamorphic(),
     193         344 :                   StoreWithVectorDescriptor(isolate));
     194             : }
     195             : 
     196             : // static
     197      712479 : Callable CodeFactory::CompareIC(Isolate* isolate, Token::Value op) {
     198             :   CompareICStub stub(isolate, op);
     199      712479 :   return make_callable(stub);
     200             : }
     201             : 
     202             : // static
     203      834261 : Callable CodeFactory::BinaryOpIC(Isolate* isolate, Token::Value op) {
     204      834261 :   BinaryOpICStub stub(isolate, op);
     205      834261 :   return make_callable(stub);
     206             : }
     207             : 
     208             : // static
     209        3189 : Callable CodeFactory::GetProperty(Isolate* isolate) {
     210             :   GetPropertyStub stub(isolate);
     211        3189 :   return make_callable(stub);
     212             : }
     213             : 
     214             : // static
     215        2200 : Callable CodeFactory::NonPrimitiveToPrimitive(Isolate* isolate,
     216             :                                               ToPrimitiveHint hint) {
     217             :   return Callable(isolate->builtins()->NonPrimitiveToPrimitive(hint),
     218        6600 :                   TypeConversionDescriptor(isolate));
     219             : }
     220             : 
     221             : // static
     222         215 : Callable CodeFactory::OrdinaryToPrimitive(Isolate* isolate,
     223             :                                           OrdinaryToPrimitiveHint hint) {
     224             :   return Callable(isolate->builtins()->OrdinaryToPrimitive(hint),
     225         645 :                   TypeConversionDescriptor(isolate));
     226             : }
     227             : 
     228             : // static
     229         430 : Callable CodeFactory::NumberToString(Isolate* isolate) {
     230             :   NumberToStringStub stub(isolate);
     231         430 :   return make_callable(stub);
     232             : }
     233             : 
     234             : // static
     235           0 : Callable CodeFactory::StringFromCharCode(Isolate* isolate) {
     236           0 :   Handle<Code> code(isolate->builtins()->StringFromCharCode());
     237           0 :   return Callable(code, BuiltinDescriptor(isolate));
     238             : }
     239             : 
     240             : #define TFS_BUILTIN(Name)                                                 \
     241             :   Callable CodeFactory::Name(Isolate* isolate) {                          \
     242             :     Handle<Code> code(isolate->builtins()->Name());                       \
     243             :     return Callable(code, Builtin_##Name##_InterfaceDescriptor(isolate)); \
     244             :   }
     245             : 
     246       21822 : TFS_BUILTIN(ToString)
     247       59813 : TFS_BUILTIN(Add)
     248       30370 : TFS_BUILTIN(Subtract)
     249       36998 : TFS_BUILTIN(Multiply)
     250       25588 : TFS_BUILTIN(Divide)
     251        1556 : TFS_BUILTIN(Modulus)
     252        4028 : TFS_BUILTIN(BitwiseAnd)
     253        3392 : TFS_BUILTIN(BitwiseOr)
     254        1924 : TFS_BUILTIN(BitwiseXor)
     255        2808 : TFS_BUILTIN(ShiftLeft)
     256        1178 : TFS_BUILTIN(ShiftRight)
     257         802 : TFS_BUILTIN(ShiftRightLogical)
     258       47040 : TFS_BUILTIN(LessThan)
     259        2473 : TFS_BUILTIN(LessThanOrEqual)
     260       12364 : TFS_BUILTIN(GreaterThan)
     261        6156 : TFS_BUILTIN(GreaterThanOrEqual)
     262       20554 : TFS_BUILTIN(Equal)
     263      256086 : TFS_BUILTIN(StrictEqual)
     264         688 : TFS_BUILTIN(CreateIterResultObject)
     265       24974 : TFS_BUILTIN(HasProperty)
     266       20422 : TFS_BUILTIN(NonNumberToNumber)
     267        1486 : TFS_BUILTIN(StringToNumber)
     268        3022 : TFS_BUILTIN(ToBoolean)
     269        4284 : TFS_BUILTIN(ToInteger)
     270        5686 : TFS_BUILTIN(ToLength)
     271        2742 : TFS_BUILTIN(ToName)
     272      180548 : TFS_BUILTIN(ToNumber)
     273       11994 : TFS_BUILTIN(ToObject)
     274        5666 : TFS_BUILTIN(ClassOf)
     275      113448 : TFS_BUILTIN(Typeof)
     276        4366 : TFS_BUILTIN(InstanceOf)
     277         438 : TFS_BUILTIN(OrdinaryHasInstance)
     278         362 : TFS_BUILTIN(CopyFastSmiOrObjectElements)
     279         372 : TFS_BUILTIN(GrowFastDoubleElements)
     280        3736 : TFS_BUILTIN(GrowFastSmiOrObjectElements)
     281        7596 : TFS_BUILTIN(NewUnmappedArgumentsElements)
     282       86804 : TFS_BUILTIN(FastCloneRegExp)
     283      732226 : TFS_BUILTIN(FastNewClosure)
     284         460 : TFS_BUILTIN(FastNewObject)
     285           0 : TFS_BUILTIN(FastNewRestParameter)
     286        7680 : TFS_BUILTIN(FastNewSloppyArguments)
     287           0 : TFS_BUILTIN(FastNewStrictArguments)
     288        3662 : TFS_BUILTIN(ForInFilter)
     289         148 : TFS_BUILTIN(GetSuperConstructor)
     290         172 : TFS_BUILTIN(LoadIC_Uninitialized)
     291          86 : TFS_BUILTIN(KeyedLoadIC_Megamorphic)
     292          86 : TFS_BUILTIN(PromiseHandleReject)
     293          86 : TFS_BUILTIN(RegExpReplace)
     294          86 : TFS_BUILTIN(RegExpSplit)
     295         574 : TFS_BUILTIN(StringCharAt)
     296         758 : TFS_BUILTIN(StringCharCodeAt)
     297       32290 : TFS_BUILTIN(StringEqual)
     298        1610 : TFS_BUILTIN(StringLessThan)
     299         626 : TFS_BUILTIN(StringLessThanOrEqual)
     300         372 : TFS_BUILTIN(StringGreaterThan)
     301         418 : TFS_BUILTIN(StringGreaterThanOrEqual)
     302         316 : TFS_BUILTIN(AsyncGeneratorResolve)
     303         100 : TFS_BUILTIN(AsyncGeneratorReject)
     304         172 : TFS_BUILTIN(AsyncGeneratorResumeNext)
     305             : 
     306             : #undef TFS_BUILTIN
     307             : 
     308             : // static
     309       71435 : Callable CodeFactory::StringAdd(Isolate* isolate, StringAddFlags flags,
     310             :                                 PretenureFlag pretenure_flag) {
     311             :   StringAddStub stub(isolate, flags, pretenure_flag);
     312       71435 :   return make_callable(stub);
     313             : }
     314             : 
     315             : // static
     316       13249 : Callable CodeFactory::StringCompare(Isolate* isolate, Token::Value token) {
     317       13249 :   switch (token) {
     318             :     case Token::EQ:
     319             :     case Token::EQ_STRICT:
     320       12908 :       return StringEqual(isolate);
     321             :     case Token::LT:
     322         254 :       return StringLessThan(isolate);
     323             :     case Token::GT:
     324          14 :       return StringGreaterThan(isolate);
     325             :     case Token::LTE:
     326          36 :       return StringLessThanOrEqual(isolate);
     327             :     case Token::GTE:
     328          37 :       return StringGreaterThanOrEqual(isolate);
     329             :     default:
     330             :       break;
     331             :   }
     332           0 :   UNREACHABLE();
     333             :   return StringEqual(isolate);
     334             : }
     335             : 
     336             : // static
     337         211 : Callable CodeFactory::StringIndexOf(Isolate* isolate) {
     338             :   return Callable(isolate->builtins()->StringIndexOf(),
     339         633 :                   StringIndexOfDescriptor(isolate));
     340             : }
     341             : 
     342             : // static
     343         492 : Callable CodeFactory::SubString(Isolate* isolate) {
     344             :   SubStringStub stub(isolate);
     345         984 :   return Callable(stub.GetCode(), stub.GetCallInterfaceDescriptor());
     346             : }
     347             : 
     348             : // static
     349         344 : Callable CodeFactory::ResumeGenerator(Isolate* isolate) {
     350             :   return Callable(isolate->builtins()->ResumeGeneratorTrampoline(),
     351        1032 :                   ResumeGeneratorDescriptor(isolate));
     352             : }
     353             : 
     354             : // static
     355         903 : Callable CodeFactory::FrameDropperTrampoline(Isolate* isolate) {
     356             :   return Callable(isolate->builtins()->FrameDropperTrampoline(),
     357        2709 :                   FrameDropperTrampolineDescriptor(isolate));
     358             : }
     359             : 
     360             : // static
     361        1123 : Callable CodeFactory::HandleDebuggerStatement(Isolate* isolate) {
     362             :   return Callable(isolate->builtins()->HandleDebuggerStatement(),
     363        3369 :                   ContextOnlyDescriptor(isolate));
     364             : }
     365             : 
     366             : // static
     367       92354 : Callable CodeFactory::FastCloneShallowArray(
     368             :     Isolate* isolate, AllocationSiteMode allocation_mode) {
     369             :   return Callable(isolate->builtins()->NewCloneShallowArray(allocation_mode),
     370      277062 :                   FastCloneShallowArrayDescriptor(isolate));
     371             : }
     372             : 
     373             : // static
     374       47983 : Callable CodeFactory::FastCloneShallowObject(Isolate* isolate, int length) {
     375             :   return Callable(isolate->builtins()->NewCloneShallowObject(length),
     376      143949 :                   FastCloneShallowObjectDescriptor(isolate));
     377             : }
     378             : 
     379             : // static
     380       45327 : Callable CodeFactory::FastNewFunctionContext(Isolate* isolate,
     381             :                                              ScopeType scope_type) {
     382             :   return Callable(isolate->builtins()->NewFunctionContext(scope_type),
     383      135981 :                   FastNewFunctionContextDescriptor(isolate));
     384             : }
     385             : 
     386             : // static
     387        1299 : Callable CodeFactory::ForInPrepare(Isolate* isolate) {
     388             :   return Callable(isolate->builtins()->ForInPrepare(),
     389        3897 :                   ForInPrepareDescriptor(isolate));
     390             : }
     391             : 
     392             : // static
     393           0 : Callable CodeFactory::ForInNext(Isolate* isolate) {
     394             :   return Callable(isolate->builtins()->ForInNext(),
     395           0 :                   ForInNextDescriptor(isolate));
     396             : }
     397             : 
     398             : // static
     399       12944 : Callable CodeFactory::AllocateHeapNumber(Isolate* isolate) {
     400             :   AllocateHeapNumberStub stub(isolate);
     401       12944 :   return make_callable(stub);
     402             : }
     403             : 
     404             : // static
     405       51548 : Callable CodeFactory::ArgumentAdaptor(Isolate* isolate) {
     406             :   return Callable(isolate->builtins()->ArgumentsAdaptorTrampoline(),
     407      154644 :                   ArgumentAdaptorDescriptor(isolate));
     408             : }
     409             : 
     410             : // static
     411      176186 : Callable CodeFactory::Call(Isolate* isolate, ConvertReceiverMode mode,
     412             :                            TailCallMode tail_call_mode) {
     413             :   return Callable(isolate->builtins()->Call(mode, tail_call_mode),
     414      528558 :                   CallTrampolineDescriptor(isolate));
     415             : }
     416             : 
     417             : // static
     418         175 : Callable CodeFactory::CallWithSpread(Isolate* isolate) {
     419             :   return Callable(isolate->builtins()->CallWithSpread(),
     420         525 :                   CallTrampolineDescriptor(isolate));
     421             : }
     422             : 
     423             : // static
     424       29225 : Callable CodeFactory::CallFunction(Isolate* isolate, ConvertReceiverMode mode,
     425             :                                    TailCallMode tail_call_mode) {
     426             :   return Callable(isolate->builtins()->CallFunction(mode, tail_call_mode),
     427       87675 :                   CallTrampolineDescriptor(isolate));
     428             : }
     429             : 
     430             : // static
     431          25 : Callable CodeFactory::CallForwardVarargs(Isolate* isolate) {
     432             :   return Callable(isolate->builtins()->CallForwardVarargs(),
     433          75 :                   CallForwardVarargsDescriptor(isolate));
     434             : }
     435             : 
     436             : // static
     437         198 : Callable CodeFactory::CallFunctionForwardVarargs(Isolate* isolate) {
     438             :   return Callable(isolate->builtins()->CallFunctionForwardVarargs(),
     439         594 :                   CallForwardVarargsDescriptor(isolate));
     440             : }
     441             : 
     442             : // static
     443       37683 : Callable CodeFactory::Construct(Isolate* isolate) {
     444             :   return Callable(isolate->builtins()->Construct(),
     445      113049 :                   ConstructTrampolineDescriptor(isolate));
     446             : }
     447             : 
     448             : // static
     449         247 : Callable CodeFactory::ConstructWithSpread(Isolate* isolate) {
     450             :   return Callable(isolate->builtins()->ConstructWithSpread(),
     451         741 :                   ConstructTrampolineDescriptor(isolate));
     452             : }
     453             : 
     454             : // static
     455         656 : Callable CodeFactory::ConstructFunction(Isolate* isolate) {
     456             :   return Callable(isolate->builtins()->ConstructFunction(),
     457        1968 :                   ConstructTrampolineDescriptor(isolate));
     458             : }
     459             : 
     460             : // static
     461        1447 : Callable CodeFactory::InterpreterPushArgsThenCall(
     462             :     Isolate* isolate, ConvertReceiverMode receiver_mode,
     463             :     TailCallMode tail_call_mode, InterpreterPushArgsMode mode) {
     464             :   return Callable(isolate->builtins()->InterpreterPushArgsThenCall(
     465             :                       receiver_mode, tail_call_mode, mode),
     466        4341 :                   InterpreterPushArgsThenCallDescriptor(isolate));
     467             : }
     468             : 
     469             : // static
     470         387 : Callable CodeFactory::InterpreterPushArgsThenConstruct(
     471             :     Isolate* isolate, InterpreterPushArgsMode mode) {
     472             :   return Callable(isolate->builtins()->InterpreterPushArgsThenConstruct(mode),
     473        1161 :                   InterpreterPushArgsThenConstructDescriptor(isolate));
     474             : }
     475             : 
     476             : // static
     477         129 : Callable CodeFactory::InterpreterPushArgsThenConstructArray(Isolate* isolate) {
     478             :   return Callable(isolate->builtins()->InterpreterPushArgsThenConstructArray(),
     479         387 :                   InterpreterPushArgsThenConstructArrayDescriptor(isolate));
     480             : }
     481             : 
     482             : // static
     483         270 : Callable CodeFactory::InterpreterCEntry(Isolate* isolate, int result_size) {
     484             :   // Note: If we ever use fpregs in the interpreter then we will need to
     485             :   // save fpregs too.
     486             :   CEntryStub stub(isolate, result_size, kDontSaveFPRegs, kArgvInRegister);
     487         810 :   return Callable(stub.GetCode(), InterpreterCEntryDescriptor(isolate));
     488             : }
     489             : 
     490             : // static
     491         129 : Callable CodeFactory::InterpreterOnStackReplacement(Isolate* isolate) {
     492             :   return Callable(isolate->builtins()->InterpreterOnStackReplacement(),
     493         387 :                   ContextOnlyDescriptor(isolate));
     494             : }
     495             : 
     496             : // static
     497       28148 : Callable CodeFactory::ArrayConstructor(Isolate* isolate) {
     498       28148 :   ArrayConstructorStub stub(isolate);
     499       28148 :   return make_callable(stub);
     500             : }
     501             : 
     502             : // static
     503          43 : Callable CodeFactory::ArrayPush(Isolate* isolate) {
     504         129 :   return Callable(isolate->builtins()->ArrayPush(), BuiltinDescriptor(isolate));
     505             : }
     506             : 
     507             : // static
     508          43 : Callable CodeFactory::ArrayFilterLoopContinuation(Isolate* isolate) {
     509             :   return Callable(isolate->builtins()->ArrayFilterLoopContinuation(),
     510         129 :                   IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
     511             : }
     512             : 
     513             : // static
     514          43 : Callable CodeFactory::ArrayMapLoopContinuation(Isolate* isolate) {
     515             :   return Callable(isolate->builtins()->ArrayMapLoopContinuation(),
     516         129 :                   IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
     517             : }
     518             : 
     519             : // static
     520          43 : Callable CodeFactory::ArrayForEachLoopContinuation(Isolate* isolate) {
     521             :   return Callable(isolate->builtins()->ArrayForEachLoopContinuation(),
     522         129 :                   IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
     523             : }
     524             : 
     525             : // static
     526          43 : Callable CodeFactory::ArraySomeLoopContinuation(Isolate* isolate) {
     527             :   return Callable(isolate->builtins()->ArraySomeLoopContinuation(),
     528         129 :                   IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
     529             : }
     530             : 
     531             : // static
     532          43 : Callable CodeFactory::ArrayEveryLoopContinuation(Isolate* isolate) {
     533             :   return Callable(isolate->builtins()->ArrayEveryLoopContinuation(),
     534         129 :                   IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
     535             : }
     536             : 
     537             : // static
     538          43 : Callable CodeFactory::ArrayReduceLoopContinuation(Isolate* isolate) {
     539             :   return Callable(isolate->builtins()->ArrayReduceLoopContinuation(),
     540         129 :                   IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
     541             : }
     542             : 
     543             : // static
     544          43 : Callable CodeFactory::ArrayReduceRightLoopContinuation(Isolate* isolate) {
     545             :   return Callable(isolate->builtins()->ArrayReduceRightLoopContinuation(),
     546         129 :                   IteratingArrayBuiltinLoopContinuationDescriptor(isolate));
     547             : }
     548             : 
     549             : // static
     550          43 : Callable CodeFactory::FunctionPrototypeBind(Isolate* isolate) {
     551             :   return Callable(isolate->builtins()->FunctionPrototypeBind(),
     552         129 :                   BuiltinDescriptor(isolate));
     553             : }
     554             : 
     555             : }  // namespace internal
     556             : }  // namespace v8

Generated by: LCOV version 1.10