src/code-stubs.h

   1 // Copyright 2012 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 #ifndef V8_CODE_STUBS_H_
   6 #define V8_CODE_STUBS_H_
   7
   8 #include "src/allocation.h"
   9 #include "src/assembler.h"
  10 #include "src/codegen.h"
  11 #include "src/globals.h"
  12 #include "src/ic/ic-state.h"
  13 #include "src/interface-descriptors.h"
  14 #include "src/macro-assembler.h"
  15 #include "src/ostreams.h"
  16
  17 namespace v8 {
  18 namespace internal {
  19
  20 // List of code stubs used on all platforms.
  21 #define CODE_STUB_LIST_ALL_PLATFORMS(V)     \
  22   /* PlatformCodeStubs */                   \
  23   V(ArgumentsAccess)                        \
  24   V(ArrayConstructor)                       \
  25   V(BinaryOpICWithAllocationSite)           \
  26   V(CallApiFunction)                        \
  27   V(CallApiAccessor)                        \
  28   V(CallApiGetter)                          \
  29   V(CallConstruct)                          \
  30   V(CallFunction)                           \
  31   V(CallIC)                                 \
  32   V(CallIC_Array)                           \
  33   V(CEntry)                                 \
  34   V(CompareIC)                              \
  35   V(DoubleToI)                              \
  36   V(FunctionPrototype)                      \
  37   V(Instanceof)                             \
  38   V(InternalArrayConstructor)               \
  39   V(JSEntry)                                \
  40   V(KeyedLoadICTrampoline)                  \
  41   V(LoadICTrampoline)                       \
  42   V(CallICTrampoline)                       \
  43   V(CallIC_ArrayTrampoline)                 \
  44   V(LoadIndexedInterceptor)                 \
  45   V(LoadIndexedString)                      \
  46   V(MathPow)                                \
  47   V(ProfileEntryHook)                       \
  48   V(RecordWrite)                            \
  49   V(RegExpExec)                             \
  50   V(StoreArrayLiteralElement)               \
  51   V(StoreBufferOverflow)                    \
  52   V(StoreElement)                           \
  53   V(StringCompare)                          \
  54   V(StubFailureTrampoline)                  \
  55   V(SubString)                              \
  56   V(ToNumber)                               \
  57   V(VectorStoreICTrampoline)                \
  58   V(VectorKeyedStoreICTrampoline)           \
  59   V(VectorStoreIC)                          \
  60   V(VectorKeyedStoreIC)                     \
  61   /* HydrogenCodeStubs */                   \
  62   V(AllocateHeapNumber)                     \
  63   V(ArrayNArgumentsConstructor)             \
  64   V(ArrayNoArgumentConstructor)             \
  65   V(ArraySingleArgumentConstructor)         \
  66   V(BinaryOpIC)                             \
  67   V(BinaryOpWithAllocationSite)             \
  68   V(CompareNilIC)                           \
  69   V(CreateAllocationSite)                   \
  70   V(CreateWeakCell)                         \
  71   V(ElementsTransitionAndStore)             \
  72   V(FastCloneShallowArray)                  \
  73   V(FastCloneShallowObject)                 \
  74   V(FastNewClosure)                         \
  75   V(FastNewContext)                         \
  76   V(GrowArrayElements)                      \
  77   V(InternalArrayNArgumentsConstructor)     \
  78   V(InternalArrayNoArgumentConstructor)     \
  79   V(InternalArraySingleArgumentConstructor) \
  80   V(KeyedLoadGeneric)                       \
  81   V(LoadGlobalViaContext)                   \
  82   V(LoadScriptContextField)                 \
  83   V(LoadDictionaryElement)                  \
  84   V(NameDictionaryLookup)                   \
  85   V(NumberToString)                         \
  86   V(Typeof)                                 \
  87   V(RegExpConstructResult)                  \
  88   V(StoreFastElement)                       \
  89   V(StoreGlobalViaContext)                  \
  90   V(StoreScriptContextField)                \
  91   V(StringAdd)                              \
  92   V(ToBoolean)                              \
  93   V(TransitionElementsKind)                 \
  94   V(KeyedLoadIC)                            \
  95   V(LoadIC)                                 \
  96   /* TurboFanCodeStubs */                   \
  97   V(StringLengthTF)                         \
  98   V(StringAddTF)                            \
  99   /* TurboFanICs */                         \
 100   V(MathFloor)                              \
 101   /* IC Handler stubs */                    \
 102   V(ArrayBufferViewLoadField)               \
 103   V(LoadConstant)                           \
 104   V(LoadFastElement)                        \
 105   V(LoadField)                              \
 106   V(KeyedLoadSloppyArguments)               \
 107   V(KeyedStoreSloppyArguments)              \
 108   V(StoreField)                             \
 109   V(StoreGlobal)                            \
 110   V(StoreTransition)                        \
 111   V(StringLength)                           \
 112   V(RestParamAccess)
 113
 114 // List of code stubs only used on ARM 32 bits platforms.
 115 #if V8_TARGET_ARCH_ARM
 116 #define CODE_STUB_LIST_ARM(V) V(DirectCEntry)
 117
 118 #else
 119 #define CODE_STUB_LIST_ARM(V)
 120 #endif
 121
 122 // List of code stubs only used on ARM 64 bits platforms.
 123 #if V8_TARGET_ARCH_ARM64
 124 #define CODE_STUB_LIST_ARM64(V) \
 125   V(DirectCEntry)               \
 126   V(RestoreRegistersState)      \
 127   V(StoreRegistersState)
 128
 129 #else
 130 #define CODE_STUB_LIST_ARM64(V)
 131 #endif
 132
 133 // List of code stubs only used on PPC platforms.
 134 #ifdef V8_TARGET_ARCH_PPC
 135 #define CODE_STUB_LIST_PPC(V) \
 136   V(DirectCEntry)             \
 137   V(StoreRegistersState)      \
 138   V(RestoreRegistersState)
 139 #else
 140 #define CODE_STUB_LIST_PPC(V)
 141 #endif
 142
 143 // List of code stubs only used on MIPS platforms.
 144 #if V8_TARGET_ARCH_MIPS
 145 #define CODE_STUB_LIST_MIPS(V) \
 146   V(DirectCEntry)              \
 147   V(RestoreRegistersState)     \
 148   V(StoreRegistersState)
 149 #elif V8_TARGET_ARCH_MIPS64
 150 #define CODE_STUB_LIST_MIPS(V) \
 151   V(DirectCEntry)              \
 152   V(RestoreRegistersState)     \
 153   V(StoreRegistersState)
 154 #else
 155 #define CODE_STUB_LIST_MIPS(V)
 156 #endif
 157
 158 // Combined list of code stubs.
 159 #define CODE_STUB_LIST(V)         \
 160   CODE_STUB_LIST_ALL_PLATFORMS(V) \
 161   CODE_STUB_LIST_ARM(V)           \
 162   CODE_STUB_LIST_ARM64(V)         \
 163   CODE_STUB_LIST_PPC(V)           \
 164   CODE_STUB_LIST_MIPS(V)
 165
 166 static const int kHasReturnedMinusZeroSentinel = 1;
 167
 168 // Stub is base classes of all stubs.
 169 class CodeStub BASE_EMBEDDED {
 170  public:
 171   enum Major {
 172     // TODO(mvstanton): eliminate the NoCache key by getting rid
 173     //                  of the non-monomorphic-cache.
 174     NoCache = 0,  // marker for stubs that do custom caching]
 175 #define DEF_ENUM(name) name,
 176     CODE_STUB_LIST(DEF_ENUM)
 177 #undef DEF_ENUM
 178     NUMBER_OF_IDS
 179   };
 180
 181   // Retrieve the code for the stub. Generate the code if needed.
 182   Handle<Code> GetCode();
 183
 184   // Retrieve the code for the stub, make and return a copy of the code.
 185   Handle<Code> GetCodeCopy(const Code::FindAndReplacePattern& pattern);
 186
 187   static Major MajorKeyFromKey(uint32_t key) {
 188     return static_cast<Major>(MajorKeyBits::decode(key));
 189   }
 190   static uint32_t MinorKeyFromKey(uint32_t key) {
 191     return MinorKeyBits::decode(key);
 192   }
 193
 194   // Gets the major key from a code object that is a code stub or binary op IC.
 195   static Major GetMajorKey(Code* code_stub) {
 196     return MajorKeyFromKey(code_stub->stub_key());
 197   }
 198
 199   static uint32_t NoCacheKey() { return MajorKeyBits::encode(NoCache); }
 200
 201   static const char* MajorName(Major major_key, bool allow_unknown_keys);
 202
 203   explicit CodeStub(Isolate* isolate) : minor_key_(0), isolate_(isolate) {}
 204   virtual ~CodeStub() {}
 205
 206   static void GenerateStubsAheadOfTime(Isolate* isolate);
 207   static void GenerateFPStubs(Isolate* isolate);
 208
 209   // Some stubs put untagged junk on the stack that cannot be scanned by the
 210   // GC.  This means that we must be statically sure that no GC can occur while
 211   // they are running.  If that is the case they should override this to return
 212   // true, which will cause an assertion if we try to call something that can
 213   // GC or if we try to put a stack frame on top of the junk, which would not
 214   // result in a traversable stack.
 215   virtual bool SometimesSetsUpAFrame() { return true; }
 216
 217   // Lookup the code in the (possibly custom) cache.
 218   bool FindCodeInCache(Code** code_out);
 219
 220   virtual CallInterfaceDescriptor GetCallInterfaceDescriptor() const = 0;
 221
 222   virtual int GetStackParameterCount() const {
 223     return GetCallInterfaceDescriptor().GetStackParameterCount();
 224   }
 225
 226   virtual void InitializeDescriptor(CodeStubDescriptor* descriptor) {}
 227
 228   static void InitializeDescriptor(Isolate* isolate, uint32_t key,
 229                                    CodeStubDescriptor* desc);
 230
 231   static MaybeHandle<Code> GetCode(Isolate* isolate, uint32_t key);
 232
 233   // Returns information for computing the number key.
 234   virtual Major MajorKey() const = 0;
 235   uint32_t MinorKey() const { return minor_key_; }
 236
 237   // BinaryOpStub needs to override this.
 238   virtual Code::Kind GetCodeKind() const;
 239
 240   virtual InlineCacheState GetICState() const { return UNINITIALIZED; }
 241   virtual ExtraICState GetExtraICState() const { return kNoExtraICState; }
 242   virtual Code::StubType GetStubType() const { return Code::NORMAL; }
 243
 244   friend std::ostream& operator<<(std::ostream& os, const CodeStub& s) {
 245     s.PrintName(os);
 246     return os;
 247   }
 248
 249   Isolate* isolate() const { return isolate_; }
 250
 251  protected:
 252   CodeStub(uint32_t key, Isolate* isolate)
 253       : minor_key_(MinorKeyFromKey(key)), isolate_(isolate) {}
 254
 255   // Generates the assembler code for the stub.
 256   virtual Handle<Code> GenerateCode() = 0;
 257
 258   // Returns whether the code generated for this stub needs to be allocated as
 259   // a fixed (non-moveable) code object.
 260   virtual bool NeedsImmovableCode() { return false; }
 261
 262   virtual void PrintName(std::ostream& os) const;        // NOLINT
 263   virtual void PrintBaseName(std::ostream& os) const;    // NOLINT
 264   virtual void PrintState(std::ostream& os) const { ; }  // NOLINT
 265
 266   // Computes the key based on major and minor.
 267   uint32_t GetKey() {
 268     DCHECK(static_cast<int>(MajorKey()) < NUMBER_OF_IDS);
 269     return MinorKeyBits::encode(MinorKey()) | MajorKeyBits::encode(MajorKey());
 270   }
 271
 272   uint32_t minor_key_;
 273
 274  private:
 275   // Perform bookkeeping required after code generation when stub code is
 276   // initially generated.
 277   void RecordCodeGeneration(Handle<Code> code);
 278
 279   // Finish the code object after it has been generated.
 280   virtual void FinishCode(Handle<Code> code) { }
 281
 282   // Activate newly generated stub. Is called after
 283   // registering stub in the stub cache.
 284   virtual void Activate(Code* code) { }
 285
 286   // Add the code to a specialized cache, specific to an individual
 287   // stub type. Please note, this method must add the code object to a
 288   // roots object, otherwise we will remove the code during GC.
 289   virtual void AddToSpecialCache(Handle<Code> new_object) { }
 290
 291   // Find code in a specialized cache, work is delegated to the specific stub.
 292   virtual bool FindCodeInSpecialCache(Code** code_out) {
 293     return false;
 294   }
 295
 296   // If a stub uses a special cache override this.
 297   virtual bool UseSpecialCache() { return false; }
 298
 299   // We use this dispatch to statically instantiate the correct code stub for
 300   // the given stub key and call the passed function with that code stub.
 301   typedef void (*DispatchedCall)(CodeStub* stub, void** value_out);
 302   static void Dispatch(Isolate* isolate, uint32_t key, void** value_out,
 303                        DispatchedCall call);
 304
 305   static void GetCodeDispatchCall(CodeStub* stub, void** value_out);
 306
 307   STATIC_ASSERT(NUMBER_OF_IDS < (1 << kStubMajorKeyBits));
 308   class MajorKeyBits: public BitField<uint32_t, 0, kStubMajorKeyBits> {};
 309   class MinorKeyBits: public BitField<uint32_t,
 310       kStubMajorKeyBits, kStubMinorKeyBits> {};  // NOLINT
 311
 312   friend class BreakPointIterator;
 313
 314   Isolate* isolate_;
 315 };
 316
 317
 318 // TODO(svenpanne) This class is only used to construct a more or less sensible
 319 // CompilationInfo for testing purposes, basically pretending that we are
 320 // currently compiling some kind of code stub. Remove this when the pipeline and
 321 // testing machinery is restructured in such a way that we don't have to come up
 322 // with a CompilationInfo out of thin air, although we only need a few parts of
 323 // it.
 324 struct FakeStubForTesting : public CodeStub {
 325   explicit FakeStubForTesting(Isolate* isolate) : CodeStub(isolate) {}
 326
 327   // Only used by pipeline.cc's GetDebugName in DEBUG mode.
 328   Major MajorKey() const override { return CodeStub::NoCache; }
 329
 330   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override {
 331     UNREACHABLE();
 332     return CallInterfaceDescriptor();
 333   }
 334
 335   Handle<Code> GenerateCode() override {
 336     UNREACHABLE();
 337     return Handle<Code>();
 338   }
 339 };
 340
 341
 342 #define DEFINE_CODE_STUB_BASE(NAME, SUPER)                      \
 343  public:                                                        \
 344   NAME(uint32_t key, Isolate* isolate) : SUPER(key, isolate) {} \
 345                                                                 \
 346  private:                                                       \
 347   DISALLOW_COPY_AND_ASSIGN(NAME)
 348
 349
 350 #define DEFINE_CODE_STUB(NAME, SUPER)                      \
 351  protected:                                                \
 352   inline Major MajorKey() const override { return NAME; }; \
 353   DEFINE_CODE_STUB_BASE(NAME##Stub, SUPER)
 354
 355
 356 #define DEFINE_PLATFORM_CODE_STUB(NAME, SUPER)  \
 357  private:                                       \
 358   void Generate(MacroAssembler* masm) override; \
 359   DEFINE_CODE_STUB(NAME, SUPER)
 360
 361
 362 #define DEFINE_HYDROGEN_CODE_STUB(NAME, SUPER)                        \
 363  public:                                                              \
 364   void InitializeDescriptor(CodeStubDescriptor* descriptor) override; \
 365   Handle<Code> GenerateCode() override;                               \
 366   DEFINE_CODE_STUB(NAME, SUPER)
 367
 368 #define DEFINE_TURBOFAN_CODE_STUB(NAME, SUPER)                          \
 369  public:                                                                \
 370   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override { \
 371     return DESC##Descriptor(isolate());                                 \
 372   };                                                                    \
 373   DEFINE_CODE_STUB(NAME, SUPER)
 374
 375 #define DEFINE_TURBOFAN_IC(NAME, SUPER, DESC)                           \
 376  public:                                                                \
 377   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override { \
 378     if (GetCallMode() == CALL_FROM_OPTIMIZED_CODE) {                    \
 379       return DESC##CallFromOptimizedCodeDescriptor(isolate());          \
 380     } else {                                                            \
 381       return DESC##CallFromUnoptimizedCodeDescriptor(isolate());        \
 382     }                                                                   \
 383   };                                                                    \
 384                                                                         \
 385  protected:                                                             \
 386   DEFINE_CODE_STUB(NAME, SUPER)
 387
 388 #define DEFINE_HANDLER_CODE_STUB(NAME, SUPER) \
 389  public:                                      \
 390   Handle<Code> GenerateCode() override;       \
 391   DEFINE_CODE_STUB(NAME, SUPER)
 392
 393 #define DEFINE_CALL_INTERFACE_DESCRIPTOR(NAME)                          \
 394  public:                                                                \
 395   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override { \
 396     return NAME##Descriptor(isolate());                                 \
 397   }
 398
 399 // There are some code stubs we just can't describe right now with a
 400 // CallInterfaceDescriptor. Isolate behavior for those cases with this macro.
 401 // An attempt to retrieve a descriptor will fail.
 402 #define DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR()                         \
 403  public:                                                                \
 404   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override { \
 405     UNREACHABLE();                                                      \
 406     return CallInterfaceDescriptor();                                   \
 407   }
 408
 409
 410 class PlatformCodeStub : public CodeStub {
 411  public:
 412   // Retrieve the code for the stub. Generate the code if needed.
 413   Handle<Code> GenerateCode() override;
 414
 415  protected:
 416   explicit PlatformCodeStub(Isolate* isolate) : CodeStub(isolate) {}
 417
 418   // Generates the assembler code for the stub.
 419   virtual void Generate(MacroAssembler* masm) = 0;
 420
 421   DEFINE_CODE_STUB_BASE(PlatformCodeStub, CodeStub);
 422 };
 423
 424
 425 enum StubFunctionMode { NOT_JS_FUNCTION_STUB_MODE, JS_FUNCTION_STUB_MODE };
 426 enum HandlerArgumentsMode { DONT_PASS_ARGUMENTS, PASS_ARGUMENTS };
 427
 428
 429 class CodeStubDescriptor {
 430  public:
 431   explicit CodeStubDescriptor(CodeStub* stub);
 432
 433   CodeStubDescriptor(Isolate* isolate, uint32_t stub_key);
 434
 435   void Initialize(Address deoptimization_handler = NULL,
 436                   int hint_stack_parameter_count = -1,
 437                   StubFunctionMode function_mode = NOT_JS_FUNCTION_STUB_MODE);
 438   void Initialize(Register stack_parameter_count,
 439                   Address deoptimization_handler = NULL,
 440                   int hint_stack_parameter_count = -1,
 441                   StubFunctionMode function_mode = NOT_JS_FUNCTION_STUB_MODE,
 442                   HandlerArgumentsMode handler_mode = DONT_PASS_ARGUMENTS);
 443
 444   void SetMissHandler(ExternalReference handler) {
 445     miss_handler_ = handler;
 446     has_miss_handler_ = true;
 447     // Our miss handler infrastructure doesn't currently support
 448     // variable stack parameter counts.
 449     DCHECK(!stack_parameter_count_.is_valid());
 450   }
 451
 452   void set_call_descriptor(CallInterfaceDescriptor d) { call_descriptor_ = d; }
 453   CallInterfaceDescriptor call_descriptor() const { return call_descriptor_; }
 454
 455   int GetRegisterParameterCount() const {
 456     return call_descriptor().GetRegisterParameterCount();
 457   }
 458
 459   Register GetRegisterParameter(int index) const {
 460     return call_descriptor().GetRegisterParameter(index);
 461   }
 462
 463   Type* GetParameterType(int index) const {
 464     return call_descriptor().GetParameterType(index);
 465   }
 466
 467   ExternalReference miss_handler() const {
 468     DCHECK(has_miss_handler_);
 469     return miss_handler_;
 470   }
 471
 472   bool has_miss_handler() const {
 473     return has_miss_handler_;
 474   }
 475
 476   int GetHandlerParameterCount() const {
 477     int params = GetRegisterParameterCount();
 478     if (handler_arguments_mode_ == PASS_ARGUMENTS) {
 479       params += 1;
 480     }
 481     return params;
 482   }
 483
 484   int hint_stack_parameter_count() const { return hint_stack_parameter_count_; }
 485   Register stack_parameter_count() const { return stack_parameter_count_; }
 486   StubFunctionMode function_mode() const { return function_mode_; }
 487   Address deoptimization_handler() const { return deoptimization_handler_; }
 488
 489  private:
 490   CallInterfaceDescriptor call_descriptor_;
 491   Register stack_parameter_count_;
 492   // If hint_stack_parameter_count_ > 0, the code stub can optimize the
 493   // return sequence. Default value is -1, which means it is ignored.
 494   int hint_stack_parameter_count_;
 495   StubFunctionMode function_mode_;
 496
 497   Address deoptimization_handler_;
 498   HandlerArgumentsMode handler_arguments_mode_;
 499
 500   ExternalReference miss_handler_;
 501   bool has_miss_handler_;
 502 };
 503
 504
 505 class HydrogenCodeStub : public CodeStub {
 506  public:
 507   enum InitializationState {
 508     UNINITIALIZED,
 509     INITIALIZED
 510   };
 511
 512   template<class SubClass>
 513   static Handle<Code> GetUninitialized(Isolate* isolate) {
 514     SubClass::GenerateAheadOfTime(isolate);
 515     return SubClass().GetCode(isolate);
 516   }
 517
 518   // Retrieve the code for the stub. Generate the code if needed.
 519   Handle<Code> GenerateCode() override = 0;
 520
 521   bool IsUninitialized() const { return IsMissBits::decode(minor_key_); }
 522
 523   Handle<Code> GenerateLightweightMissCode(ExternalReference miss);
 524
 525   template<class StateType>
 526   void TraceTransition(StateType from, StateType to);
 527
 528  protected:
 529   explicit HydrogenCodeStub(Isolate* isolate,
 530                             InitializationState state = INITIALIZED)
 531       : CodeStub(isolate) {
 532     minor_key_ = IsMissBits::encode(state == UNINITIALIZED);
 533   }
 534
 535   void set_sub_minor_key(uint32_t key) {
 536     minor_key_ = SubMinorKeyBits::update(minor_key_, key);
 537   }
 538
 539   uint32_t sub_minor_key() const { return SubMinorKeyBits::decode(minor_key_); }
 540
 541   static const int kSubMinorKeyBits = kStubMinorKeyBits - 1;
 542
 543  private:
 544   class IsMissBits : public BitField<bool, kSubMinorKeyBits, 1> {};
 545   class SubMinorKeyBits : public BitField<int, 0, kSubMinorKeyBits> {};
 546
 547   void GenerateLightweightMiss(MacroAssembler* masm, ExternalReference miss);
 548
 549   DEFINE_CODE_STUB_BASE(HydrogenCodeStub, CodeStub);
 550 };
 551
 552
 553 class TurboFanCodeStub : public CodeStub {
 554  public:
 555   // Retrieve the code for the stub. Generate the code if needed.
 556   Handle<Code> GenerateCode() override;
 557
 558   virtual int GetStackParameterCount() const override {
 559     return GetCallInterfaceDescriptor().GetStackParameterCount();
 560   }
 561
 562   Code::StubType GetStubType() const override { return Code::FAST; }
 563
 564  protected:
 565   explicit TurboFanCodeStub(Isolate* isolate) : CodeStub(isolate) {}
 566
 567  private:
 568   DEFINE_CODE_STUB_BASE(TurboFanCodeStub, CodeStub);
 569 };
 570
 571
 572 class TurboFanIC : public TurboFanCodeStub {
 573  public:
 574   enum CallMode { CALL_FROM_UNOPTIMIZED_CODE, CALL_FROM_OPTIMIZED_CODE };
 575
 576  protected:
 577   explicit TurboFanIC(Isolate* isolate, CallMode mode)
 578       : TurboFanCodeStub(isolate) {
 579     minor_key_ = CallModeBits::encode(mode);
 580   }
 581
 582   CallMode GetCallMode() const { return CallModeBits::decode(minor_key_); }
 583
 584   void set_sub_minor_key(uint32_t key) {
 585     minor_key_ = SubMinorKeyBits::update(minor_key_, key);
 586   }
 587
 588   uint32_t sub_minor_key() const { return SubMinorKeyBits::decode(minor_key_); }
 589
 590   static const int kSubMinorKeyBits = kStubMinorKeyBits - 1;
 591
 592  private:
 593   class CallModeBits : public BitField<CallMode, 0, 1> {};
 594   class SubMinorKeyBits : public BitField<int, 1, kSubMinorKeyBits> {};
 595   DEFINE_CODE_STUB_BASE(TurboFanIC, TurboFanCodeStub);
 596 };
 597
 598
 599 // Helper interface to prepare to/restore after making runtime calls.
 600 class RuntimeCallHelper {
 601  public:
 602   virtual ~RuntimeCallHelper() {}
 603
 604   virtual void BeforeCall(MacroAssembler* masm) const = 0;
 605
 606   virtual void AfterCall(MacroAssembler* masm) const = 0;
 607
 608  protected:
 609   RuntimeCallHelper() {}
 610
 611  private:
 612   DISALLOW_COPY_AND_ASSIGN(RuntimeCallHelper);
 613 };
 614
 615
 616 } }  // namespace v8::internal
 617
 618 #if V8_TARGET_ARCH_IA32
 619 #include "src/ia32/code-stubs-ia32.h"
 620 #elif V8_TARGET_ARCH_X64
 621 #include "src/x64/code-stubs-x64.h"
 622 #elif V8_TARGET_ARCH_ARM64
 623 #include "src/arm64/code-stubs-arm64.h"
 624 #elif V8_TARGET_ARCH_ARM
 625 #include "src/arm/code-stubs-arm.h"
 626 #elif V8_TARGET_ARCH_PPC
 627 #include "src/ppc/code-stubs-ppc.h"
 628 #elif V8_TARGET_ARCH_MIPS
 629 #include "src/mips/code-stubs-mips.h"
 630 #elif V8_TARGET_ARCH_MIPS64
 631 #include "src/mips64/code-stubs-mips64.h"
 632 #elif V8_TARGET_ARCH_X87
 633 #include "src/x87/code-stubs-x87.h"
 634 #else
 635 #error Unsupported target architecture.
 636 #endif
 637
 638 namespace v8 {
 639 namespace internal {
 640
 641
 642 // RuntimeCallHelper implementation used in stubs: enters/leaves a
 643 // newly created internal frame before/after the runtime call.
 644 class StubRuntimeCallHelper : public RuntimeCallHelper {
 645  public:
 646   StubRuntimeCallHelper() {}
 647
 648   virtual void BeforeCall(MacroAssembler* masm) const;
 649
 650   virtual void AfterCall(MacroAssembler* masm) const;
 651 };
 652
 653
 654 // Trivial RuntimeCallHelper implementation.
 655 class NopRuntimeCallHelper : public RuntimeCallHelper {
 656  public:
 657   NopRuntimeCallHelper() {}
 658
 659   virtual void BeforeCall(MacroAssembler* masm) const {}
 660
 661   virtual void AfterCall(MacroAssembler* masm) const {}
 662 };
 663
 664
 665 class MathFloorStub : public TurboFanIC {
 666  public:
 667   explicit MathFloorStub(Isolate* isolate, TurboFanIC::CallMode mode)
 668       : TurboFanIC(isolate, mode) {}
 669   Code::Kind GetCodeKind() const override { return Code::CALL_IC; }
 670   DEFINE_TURBOFAN_IC(MathFloor, TurboFanIC, MathRoundVariant);
 671 };
 672
 673
 674 class StringLengthTFStub : public TurboFanCodeStub {
 675  public:
 676   explicit StringLengthTFStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
 677
 678   Code::Kind GetCodeKind() const override { return Code::HANDLER; }
 679   InlineCacheState GetICState() const override { return MONOMORPHIC; }
 680   ExtraICState GetExtraICState() const override { return Code::LOAD_IC; }
 681
 682   DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
 683   DEFINE_CODE_STUB(StringLengthTF, TurboFanCodeStub);
 684 };
 685
 686
 687 enum StringAddFlags {
 688   // Omit both parameter checks.
 689   STRING_ADD_CHECK_NONE = 0,
 690   // Check left parameter.
 691   STRING_ADD_CHECK_LEFT = 1 << 0,
 692   // Check right parameter.
 693   STRING_ADD_CHECK_RIGHT = 1 << 1,
 694   // Check both parameters.
 695   STRING_ADD_CHECK_BOTH = STRING_ADD_CHECK_LEFT | STRING_ADD_CHECK_RIGHT
 696 };
 697
 698
 699 std::ostream& operator<<(std::ostream& os, const StringAddFlags& flags);
 700
 701
 702 class StringAddTFStub : public TurboFanCodeStub {
 703  public:
 704   StringAddTFStub(Isolate* isolate, StringAddFlags flags,
 705                   PretenureFlag pretenure_flag)
 706       : TurboFanCodeStub(isolate) {
 707     minor_key_ = StringAddFlagsBits::encode(flags) |
 708                  PretenureFlagBits::encode(pretenure_flag);
 709   }
 710
 711   StringAddFlags flags() const {
 712     return StringAddFlagsBits::decode(MinorKey());
 713   }
 714
 715   PretenureFlag pretenure_flag() const {
 716     return PretenureFlagBits::decode(MinorKey());
 717   }
 718
 719  private:
 720   class StringAddFlagsBits : public BitField<StringAddFlags, 0, 2> {};
 721   class PretenureFlagBits : public BitField<PretenureFlag, 2, 1> {};
 722
 723   void PrintBaseName(std::ostream& os) const override;  // NOLINT
 724
 725   DEFINE_CALL_INTERFACE_DESCRIPTOR(StringAdd);
 726   DEFINE_CODE_STUB(StringAddTF, TurboFanCodeStub);
 727 };
 728
 729
 730 class NumberToStringStub final : public HydrogenCodeStub {
 731  public:
 732   explicit NumberToStringStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
 733
 734   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
 735   static const int kNumber = 0;
 736
 737   DEFINE_CALL_INTERFACE_DESCRIPTOR(NumberToString);
 738   DEFINE_HYDROGEN_CODE_STUB(NumberToString, HydrogenCodeStub);
 739 };
 740
 741
 742 class TypeofStub final : public HydrogenCodeStub {
 743  public:
 744   explicit TypeofStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
 745
 746   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
 747   static const int kObject = 0;
 748
 749   static void GenerateAheadOfTime(Isolate* isolate);
 750
 751   DEFINE_CALL_INTERFACE_DESCRIPTOR(Typeof);
 752   DEFINE_HYDROGEN_CODE_STUB(Typeof, HydrogenCodeStub);
 753 };
 754
 755
 756 class FastNewClosureStub : public HydrogenCodeStub {
 757  public:
 758   FastNewClosureStub(Isolate* isolate, LanguageMode language_mode,
 759                      FunctionKind kind)
 760       : HydrogenCodeStub(isolate) {
 761     DCHECK(IsValidFunctionKind(kind));
 762     set_sub_minor_key(LanguageModeBits::encode(language_mode) |
 763                       FunctionKindBits::encode(kind));
 764   }
 765
 766   LanguageMode language_mode() const {
 767     return LanguageModeBits::decode(sub_minor_key());
 768   }
 769
 770   FunctionKind kind() const {
 771     return FunctionKindBits::decode(sub_minor_key());
 772   }
 773
 774  private:
 775   STATIC_ASSERT(LANGUAGE_END == 3);
 776   class LanguageModeBits : public BitField<LanguageMode, 0, 2> {};
 777   class FunctionKindBits : public BitField<FunctionKind, 2, 8> {};
 778
 779   DEFINE_CALL_INTERFACE_DESCRIPTOR(FastNewClosure);
 780   DEFINE_HYDROGEN_CODE_STUB(FastNewClosure, HydrogenCodeStub);
 781 };
 782
 783
 784 class FastNewContextStub final : public HydrogenCodeStub {
 785  public:
 786   static const int kMaximumSlots = 64;
 787
 788   FastNewContextStub(Isolate* isolate, int slots) : HydrogenCodeStub(isolate) {
 789     DCHECK(slots >= 0 && slots <= kMaximumSlots);
 790     set_sub_minor_key(SlotsBits::encode(slots));
 791   }
 792
 793   int slots() const { return SlotsBits::decode(sub_minor_key()); }
 794
 795   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
 796   static const int kFunction = 0;
 797
 798  private:
 799   class SlotsBits : public BitField<int, 0, 8> {};
 800
 801   DEFINE_CALL_INTERFACE_DESCRIPTOR(FastNewContext);
 802   DEFINE_HYDROGEN_CODE_STUB(FastNewContext, HydrogenCodeStub);
 803 };
 804
 805
 806 class FastCloneShallowArrayStub : public HydrogenCodeStub {
 807  public:
 808   FastCloneShallowArrayStub(Isolate* isolate,
 809                             AllocationSiteMode allocation_site_mode)
 810       : HydrogenCodeStub(isolate) {
 811     set_sub_minor_key(AllocationSiteModeBits::encode(allocation_site_mode));
 812   }
 813
 814   AllocationSiteMode allocation_site_mode() const {
 815     return AllocationSiteModeBits::decode(sub_minor_key());
 816   }
 817
 818  private:
 819   class AllocationSiteModeBits: public BitField<AllocationSiteMode, 0, 1> {};
 820
 821   DEFINE_CALL_INTERFACE_DESCRIPTOR(FastCloneShallowArray);
 822   DEFINE_HYDROGEN_CODE_STUB(FastCloneShallowArray, HydrogenCodeStub);
 823 };
 824
 825
 826 class FastCloneShallowObjectStub : public HydrogenCodeStub {
 827  public:
 828   // Maximum number of properties in copied object.
 829   static const int kMaximumClonedProperties = 6;
 830
 831   FastCloneShallowObjectStub(Isolate* isolate, int length)
 832       : HydrogenCodeStub(isolate) {
 833     DCHECK_GE(length, 0);
 834     DCHECK_LE(length, kMaximumClonedProperties);
 835     set_sub_minor_key(LengthBits::encode(length));
 836   }
 837
 838   int length() const { return LengthBits::decode(sub_minor_key()); }
 839
 840  private:
 841   class LengthBits : public BitField<int, 0, 4> {};
 842
 843   DEFINE_CALL_INTERFACE_DESCRIPTOR(FastCloneShallowObject);
 844   DEFINE_HYDROGEN_CODE_STUB(FastCloneShallowObject, HydrogenCodeStub);
 845 };
 846
 847
 848 class CreateAllocationSiteStub : public HydrogenCodeStub {
 849  public:
 850   explicit CreateAllocationSiteStub(Isolate* isolate)
 851       : HydrogenCodeStub(isolate) { }
 852
 853   static void GenerateAheadOfTime(Isolate* isolate);
 854
 855   DEFINE_CALL_INTERFACE_DESCRIPTOR(CreateAllocationSite);
 856   DEFINE_HYDROGEN_CODE_STUB(CreateAllocationSite, HydrogenCodeStub);
 857 };
 858
 859
 860 class CreateWeakCellStub : public HydrogenCodeStub {
 861  public:
 862   explicit CreateWeakCellStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
 863
 864   static void GenerateAheadOfTime(Isolate* isolate);
 865
 866   DEFINE_CALL_INTERFACE_DESCRIPTOR(CreateWeakCell);
 867   DEFINE_HYDROGEN_CODE_STUB(CreateWeakCell, HydrogenCodeStub);
 868 };
 869
 870
 871 class GrowArrayElementsStub : public HydrogenCodeStub {
 872  public:
 873   GrowArrayElementsStub(Isolate* isolate, bool is_js_array, ElementsKind kind)
 874       : HydrogenCodeStub(isolate) {
 875     set_sub_minor_key(ElementsKindBits::encode(kind) |
 876                       IsJsArrayBits::encode(is_js_array));
 877   }
 878
 879   ElementsKind elements_kind() const {
 880     return ElementsKindBits::decode(sub_minor_key());
 881   }
 882
 883   bool is_js_array() const { return IsJsArrayBits::decode(sub_minor_key()); }
 884
 885  private:
 886   class ElementsKindBits : public BitField<ElementsKind, 0, 8> {};
 887   class IsJsArrayBits : public BitField<bool, ElementsKindBits::kNext, 1> {};
 888
 889   DEFINE_CALL_INTERFACE_DESCRIPTOR(GrowArrayElements);
 890   DEFINE_HYDROGEN_CODE_STUB(GrowArrayElements, HydrogenCodeStub);
 891 };
 892
 893 class InstanceofStub: public PlatformCodeStub {
 894  public:
 895   enum Flags {
 896     kNoFlags = 0,
 897     kArgsInRegisters = 1 << 0,
 898     kCallSiteInlineCheck = 1 << 1,
 899     kReturnTrueFalseObject = 1 << 2
 900   };
 901
 902   InstanceofStub(Isolate* isolate, Flags flags) : PlatformCodeStub(isolate) {
 903     minor_key_ = FlagBits::encode(flags);
 904   }
 905
 906   static Register left() { return InstanceofDescriptor::left(); }
 907   static Register right() { return InstanceofDescriptor::right(); }
 908
 909   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override {
 910     if (HasArgsInRegisters()) {
 911       return InstanceofDescriptor(isolate());
 912     }
 913     return ContextOnlyDescriptor(isolate());
 914   }
 915
 916  private:
 917   Flags flags() const { return FlagBits::decode(minor_key_); }
 918
 919   bool HasArgsInRegisters() const { return (flags() & kArgsInRegisters) != 0; }
 920
 921   bool HasCallSiteInlineCheck() const {
 922     return (flags() & kCallSiteInlineCheck) != 0;
 923   }
 924
 925   bool ReturnTrueFalseObject() const {
 926     return (flags() & kReturnTrueFalseObject) != 0;
 927   }
 928
 929   void PrintName(std::ostream& os) const override;  // NOLINT
 930
 931   class FlagBits : public BitField<Flags, 0, 3> {};
 932
 933   DEFINE_PLATFORM_CODE_STUB(Instanceof, PlatformCodeStub);
 934 };
 935
 936
 937 enum AllocationSiteOverrideMode {
 938   DONT_OVERRIDE,
 939   DISABLE_ALLOCATION_SITES,
 940   LAST_ALLOCATION_SITE_OVERRIDE_MODE = DISABLE_ALLOCATION_SITES
 941 };
 942
 943
 944 class ArrayConstructorStub: public PlatformCodeStub {
 945  public:
 946   enum ArgumentCountKey { ANY, NONE, ONE, MORE_THAN_ONE };
 947
 948   ArrayConstructorStub(Isolate* isolate, int argument_count);
 949
 950   explicit ArrayConstructorStub(Isolate* isolate);
 951
 952  private:
 953   ArgumentCountKey argument_count() const {
 954     return ArgumentCountBits::decode(minor_key_);
 955   }
 956
 957   void GenerateDispatchToArrayStub(MacroAssembler* masm,
 958                                    AllocationSiteOverrideMode mode);
 959
 960   void PrintName(std::ostream& os) const override;  // NOLINT
 961
 962   class ArgumentCountBits : public BitField<ArgumentCountKey, 0, 2> {};
 963
 964   DEFINE_CALL_INTERFACE_DESCRIPTOR(ArrayConstructor);
 965   DEFINE_PLATFORM_CODE_STUB(ArrayConstructor, PlatformCodeStub);
 966 };
 967
 968
 969 class InternalArrayConstructorStub: public PlatformCodeStub {
 970  public:
 971   explicit InternalArrayConstructorStub(Isolate* isolate);
 972
 973  private:
 974   void GenerateCase(MacroAssembler* masm, ElementsKind kind);
 975
 976   DEFINE_CALL_INTERFACE_DESCRIPTOR(InternalArrayConstructor);
 977   DEFINE_PLATFORM_CODE_STUB(InternalArrayConstructor, PlatformCodeStub);
 978 };
 979
 980
 981 class MathPowStub: public PlatformCodeStub {
 982  public:
 983   enum ExponentType { INTEGER, DOUBLE, TAGGED, ON_STACK };
 984
 985   MathPowStub(Isolate* isolate, ExponentType exponent_type)
 986       : PlatformCodeStub(isolate) {
 987     minor_key_ = ExponentTypeBits::encode(exponent_type);
 988   }
 989
 990   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override {
 991     if (exponent_type() == TAGGED) {
 992       return MathPowTaggedDescriptor(isolate());
 993     } else if (exponent_type() == INTEGER) {
 994       return MathPowIntegerDescriptor(isolate());
 995     }
 996     // A CallInterfaceDescriptor doesn't specify double registers (yet).
 997     return ContextOnlyDescriptor(isolate());
 998   }
 999
1000  private:
1001   ExponentType exponent_type() const {
1002     return ExponentTypeBits::decode(minor_key_);
1003   }
1004
1005   class ExponentTypeBits : public BitField<ExponentType, 0, 2> {};
1006
1007   DEFINE_PLATFORM_CODE_STUB(MathPow, PlatformCodeStub);
1008 };
1009
1010
1011 class CallICStub: public PlatformCodeStub {
1012  public:
1013   CallICStub(Isolate* isolate, const CallICState& state)
1014       : PlatformCodeStub(isolate) {
1015     minor_key_ = state.GetExtraICState();
1016   }
1017
1018   Code::Kind GetCodeKind() const override { return Code::CALL_IC; }
1019
1020   InlineCacheState GetICState() const override { return DEFAULT; }
1021
1022   ExtraICState GetExtraICState() const final {
1023     return static_cast<ExtraICState>(minor_key_);
1024   }
1025
1026  protected:
1027   bool CallAsMethod() const {
1028     return state().call_type() == CallICState::METHOD;
1029   }
1030
1031   int arg_count() const { return state().arg_count(); }
1032
1033   CallICState state() const {
1034     return CallICState(static_cast<ExtraICState>(minor_key_));
1035   }
1036
1037   // Code generation helpers.
1038   void GenerateMiss(MacroAssembler* masm);
1039
1040  private:
1041   void PrintState(std::ostream& os) const override;  // NOLINT
1042
1043   DEFINE_CALL_INTERFACE_DESCRIPTOR(CallFunctionWithFeedbackAndVector);
1044   DEFINE_PLATFORM_CODE_STUB(CallIC, PlatformCodeStub);
1045 };
1046
1047
1048 class CallIC_ArrayStub: public CallICStub {
1049  public:
1050   CallIC_ArrayStub(Isolate* isolate, const CallICState& state_in)
1051       : CallICStub(isolate, state_in) {}
1052
1053   InlineCacheState GetICState() const final { return MONOMORPHIC; }
1054
1055  private:
1056   void PrintState(std::ostream& os) const override;  // NOLINT
1057
1058   DEFINE_PLATFORM_CODE_STUB(CallIC_Array, CallICStub);
1059 };
1060
1061
1062 // TODO(verwaest): Translate to hydrogen code stub.
1063 class FunctionPrototypeStub : public PlatformCodeStub {
1064  public:
1065   explicit FunctionPrototypeStub(Isolate* isolate)
1066       : PlatformCodeStub(isolate) {}
1067
1068   Code::Kind GetCodeKind() const override { return Code::HANDLER; }
1069
1070   // TODO(mvstanton): only the receiver register is accessed. When this is
1071   // translated to a hydrogen code stub, a new CallInterfaceDescriptor
1072   // should be created that just uses that register for more efficient code.
1073   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override {
1074     return LoadWithVectorDescriptor(isolate());
1075   }
1076
1077   DEFINE_PLATFORM_CODE_STUB(FunctionPrototype, PlatformCodeStub);
1078 };
1079
1080
1081 // TODO(mvstanton): Translate to hydrogen code stub.
1082 class LoadIndexedInterceptorStub : public PlatformCodeStub {
1083  public:
1084   explicit LoadIndexedInterceptorStub(Isolate* isolate)
1085       : PlatformCodeStub(isolate) {}
1086
1087   Code::Kind GetCodeKind() const override { return Code::HANDLER; }
1088   Code::StubType GetStubType() const override { return Code::FAST; }
1089
1090   DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
1091   DEFINE_PLATFORM_CODE_STUB(LoadIndexedInterceptor, PlatformCodeStub);
1092 };
1093
1094
1095 class LoadIndexedStringStub : public PlatformCodeStub {
1096  public:
1097   explicit LoadIndexedStringStub(Isolate* isolate)
1098       : PlatformCodeStub(isolate) {}
1099
1100   Code::Kind GetCodeKind() const override { return Code::HANDLER; }
1101   Code::StubType GetStubType() const override { return Code::FAST; }
1102
1103   DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
1104   DEFINE_PLATFORM_CODE_STUB(LoadIndexedString, PlatformCodeStub);
1105 };
1106
1107
1108 class HandlerStub : public HydrogenCodeStub {
1109  public:
1110   Code::Kind GetCodeKind() const override { return Code::HANDLER; }
1111   ExtraICState GetExtraICState() const override { return kind(); }
1112   InlineCacheState GetICState() const override { return MONOMORPHIC; }
1113
1114   void InitializeDescriptor(CodeStubDescriptor* descriptor) override;
1115
1116   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override;
1117
1118  protected:
1119   explicit HandlerStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
1120
1121   virtual Code::Kind kind() const = 0;
1122
1123   DEFINE_CODE_STUB_BASE(HandlerStub, HydrogenCodeStub);
1124 };
1125
1126
1127 class LoadFieldStub: public HandlerStub {
1128  public:
1129   LoadFieldStub(Isolate* isolate, FieldIndex index) : HandlerStub(isolate) {
1130     int property_index_key = index.GetFieldAccessStubKey();
1131     set_sub_minor_key(LoadFieldByIndexBits::encode(property_index_key));
1132   }
1133
1134   FieldIndex index() const {
1135     int property_index_key = LoadFieldByIndexBits::decode(sub_minor_key());
1136     return FieldIndex::FromFieldAccessStubKey(property_index_key);
1137   }
1138
1139  protected:
1140   Code::Kind kind() const override { return Code::LOAD_IC; }
1141   Code::StubType GetStubType() const override { return Code::FAST; }
1142
1143  private:
1144   class LoadFieldByIndexBits : public BitField<int, 0, 13> {};
1145
1146   DEFINE_HANDLER_CODE_STUB(LoadField, HandlerStub);
1147 };
1148
1149
1150 class ArrayBufferViewLoadFieldStub : public HandlerStub {
1151  public:
1152   ArrayBufferViewLoadFieldStub(Isolate* isolate, FieldIndex index)
1153       : HandlerStub(isolate) {
1154     int property_index_key = index.GetFieldAccessStubKey();
1155     set_sub_minor_key(
1156         ArrayBufferViewLoadFieldByIndexBits::encode(property_index_key));
1157   }
1158
1159   FieldIndex index() const {
1160     int property_index_key =
1161         ArrayBufferViewLoadFieldByIndexBits::decode(sub_minor_key());
1162     return FieldIndex::FromFieldAccessStubKey(property_index_key);
1163   }
1164
1165  protected:
1166   Code::Kind kind() const override { return Code::LOAD_IC; }
1167   Code::StubType GetStubType() const override { return Code::FAST; }
1168
1169  private:
1170   class ArrayBufferViewLoadFieldByIndexBits : public BitField<int, 0, 13> {};
1171
1172   DEFINE_HANDLER_CODE_STUB(ArrayBufferViewLoadField, HandlerStub);
1173 };
1174
1175
1176 class KeyedLoadSloppyArgumentsStub : public HandlerStub {
1177  public:
1178   explicit KeyedLoadSloppyArgumentsStub(Isolate* isolate)
1179       : HandlerStub(isolate) {}
1180
1181  protected:
1182   Code::Kind kind() const override { return Code::KEYED_LOAD_IC; }
1183   Code::StubType GetStubType() const override { return Code::FAST; }
1184
1185  private:
1186   DEFINE_HANDLER_CODE_STUB(KeyedLoadSloppyArguments, HandlerStub);
1187 };
1188
1189
1190 class KeyedStoreSloppyArgumentsStub : public HandlerStub {
1191  public:
1192   explicit KeyedStoreSloppyArgumentsStub(Isolate* isolate)
1193       : HandlerStub(isolate) {}
1194
1195  protected:
1196   Code::Kind kind() const override { return Code::KEYED_STORE_IC; }
1197   Code::StubType GetStubType() const override { return Code::FAST; }
1198
1199  private:
1200   DEFINE_HANDLER_CODE_STUB(KeyedStoreSloppyArguments, HandlerStub);
1201 };
1202
1203
1204 class LoadConstantStub : public HandlerStub {
1205  public:
1206   LoadConstantStub(Isolate* isolate, int constant_index)
1207       : HandlerStub(isolate) {
1208     set_sub_minor_key(ConstantIndexBits::encode(constant_index));
1209   }
1210
1211   int constant_index() const {
1212     return ConstantIndexBits::decode(sub_minor_key());
1213   }
1214
1215  protected:
1216   Code::Kind kind() const override { return Code::LOAD_IC; }
1217   Code::StubType GetStubType() const override { return Code::FAST; }
1218
1219  private:
1220   class ConstantIndexBits : public BitField<int, 0, kSubMinorKeyBits> {};
1221
1222   DEFINE_HANDLER_CODE_STUB(LoadConstant, HandlerStub);
1223 };
1224
1225
1226 class StringLengthStub: public HandlerStub {
1227  public:
1228   explicit StringLengthStub(Isolate* isolate) : HandlerStub(isolate) {}
1229
1230  protected:
1231   Code::Kind kind() const override { return Code::LOAD_IC; }
1232   Code::StubType GetStubType() const override { return Code::FAST; }
1233
1234   DEFINE_HANDLER_CODE_STUB(StringLength, HandlerStub);
1235 };
1236
1237
1238 class StoreFieldStub : public HandlerStub {
1239  public:
1240   StoreFieldStub(Isolate* isolate, FieldIndex index,
1241                  Representation representation)
1242       : HandlerStub(isolate) {
1243     int property_index_key = index.GetFieldAccessStubKey();
1244     uint8_t repr = PropertyDetails::EncodeRepresentation(representation);
1245     set_sub_minor_key(StoreFieldByIndexBits::encode(property_index_key) |
1246                       RepresentationBits::encode(repr));
1247   }
1248
1249   FieldIndex index() const {
1250     int property_index_key = StoreFieldByIndexBits::decode(sub_minor_key());
1251     return FieldIndex::FromFieldAccessStubKey(property_index_key);
1252   }
1253
1254   Representation representation() {
1255     uint8_t repr = RepresentationBits::decode(sub_minor_key());
1256     return PropertyDetails::DecodeRepresentation(repr);
1257   }
1258
1259  protected:
1260   Code::Kind kind() const override { return Code::STORE_IC; }
1261   Code::StubType GetStubType() const override { return Code::FAST; }
1262
1263  private:
1264   class StoreFieldByIndexBits : public BitField<int, 0, 13> {};
1265   class RepresentationBits : public BitField<uint8_t, 13, 4> {};
1266
1267   DEFINE_HANDLER_CODE_STUB(StoreField, HandlerStub);
1268 };
1269
1270
1271 class StoreTransitionStub : public HandlerStub {
1272  public:
1273   enum StoreMode {
1274     StoreMapOnly,
1275     StoreMapAndValue,
1276     ExtendStorageAndStoreMapAndValue
1277   };
1278
1279   explicit StoreTransitionStub(Isolate* isolate) : HandlerStub(isolate) {
1280     set_sub_minor_key(StoreModeBits::encode(StoreMapOnly));
1281   }
1282
1283   StoreTransitionStub(Isolate* isolate, FieldIndex index,
1284                       Representation representation, StoreMode store_mode)
1285       : HandlerStub(isolate) {
1286     DCHECK(store_mode != StoreMapOnly);
1287     int property_index_key = index.GetFieldAccessStubKey();
1288     uint8_t repr = PropertyDetails::EncodeRepresentation(representation);
1289     set_sub_minor_key(StoreFieldByIndexBits::encode(property_index_key) |
1290                       RepresentationBits::encode(repr) |
1291                       StoreModeBits::encode(store_mode));
1292   }
1293
1294   FieldIndex index() const {
1295     DCHECK(store_mode() != StoreMapOnly);
1296     int property_index_key = StoreFieldByIndexBits::decode(sub_minor_key());
1297     return FieldIndex::FromFieldAccessStubKey(property_index_key);
1298   }
1299
1300   Representation representation() {
1301     DCHECK(store_mode() != StoreMapOnly);
1302     uint8_t repr = RepresentationBits::decode(sub_minor_key());
1303     return PropertyDetails::DecodeRepresentation(repr);
1304   }
1305
1306   StoreMode store_mode() const {
1307     return StoreModeBits::decode(sub_minor_key());
1308   }
1309
1310   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override;
1311
1312  protected:
1313   Code::Kind kind() const override { return Code::STORE_IC; }
1314   Code::StubType GetStubType() const override { return Code::FAST; }
1315
1316  private:
1317   class StoreFieldByIndexBits : public BitField<int, 0, 13> {};
1318   class RepresentationBits : public BitField<uint8_t, 13, 4> {};
1319   class StoreModeBits : public BitField<StoreMode, 17, 2> {};
1320
1321   DEFINE_HANDLER_CODE_STUB(StoreTransition, HandlerStub);
1322 };
1323
1324
1325 class StoreGlobalStub : public HandlerStub {
1326  public:
1327   StoreGlobalStub(Isolate* isolate, PropertyCellType type,
1328                   Maybe<PropertyCellConstantType> constant_type,
1329                   bool check_global)
1330       : HandlerStub(isolate) {
1331     PropertyCellConstantType encoded_constant_type =
1332         constant_type.FromMaybe(PropertyCellConstantType::kSmi);
1333     set_sub_minor_key(CellTypeBits::encode(type) |
1334                       ConstantTypeBits::encode(encoded_constant_type) |
1335                       CheckGlobalBits::encode(check_global));
1336   }
1337
1338   static Handle<HeapObject> property_cell_placeholder(Isolate* isolate) {
1339     return isolate->factory()->uninitialized_value();
1340   }
1341
1342   static Handle<HeapObject> global_map_placeholder(Isolate* isolate) {
1343     return isolate->factory()->termination_exception();
1344   }
1345
1346   Handle<Code> GetCodeCopyFromTemplate(Handle<GlobalObject> global,
1347                                        Handle<PropertyCell> cell) {
1348     Code::FindAndReplacePattern pattern;
1349     if (check_global()) {
1350       pattern.Add(handle(global_map_placeholder(isolate())->map()),
1351                   Map::WeakCellForMap(Handle<Map>(global->map())));
1352     }
1353     pattern.Add(handle(property_cell_placeholder(isolate())->map()),
1354                 isolate()->factory()->NewWeakCell(cell));
1355     return CodeStub::GetCodeCopy(pattern);
1356   }
1357
1358   Code::Kind kind() const override { return Code::STORE_IC; }
1359
1360   PropertyCellType cell_type() const {
1361     return CellTypeBits::decode(sub_minor_key());
1362   }
1363
1364   PropertyCellConstantType constant_type() const {
1365     DCHECK(PropertyCellType::kConstantType == cell_type());
1366     return ConstantTypeBits::decode(sub_minor_key());
1367   }
1368
1369   bool check_global() const { return CheckGlobalBits::decode(sub_minor_key()); }
1370
1371   Representation representation() {
1372     return Representation::FromKind(
1373         RepresentationBits::decode(sub_minor_key()));
1374   }
1375
1376   void set_representation(Representation r) {
1377     set_sub_minor_key(RepresentationBits::update(sub_minor_key(), r.kind()));
1378   }
1379
1380  private:
1381   class CellTypeBits : public BitField<PropertyCellType, 0, 2> {};
1382   class ConstantTypeBits : public BitField<PropertyCellConstantType, 2, 2> {};
1383   class RepresentationBits : public BitField<Representation::Kind, 4, 8> {};
1384   class CheckGlobalBits : public BitField<bool, 12, 1> {};
1385
1386   DEFINE_HANDLER_CODE_STUB(StoreGlobal, HandlerStub);
1387 };
1388
1389
1390 class LoadGlobalViaContextStub : public HydrogenCodeStub {
1391  public:
1392   // Use the loop version for depths higher than this one.
1393   static const int kDynamicDepth = 7;
1394
1395   LoadGlobalViaContextStub(Isolate* isolate, int depth)
1396       : HydrogenCodeStub(isolate) {
1397     if (depth > kDynamicDepth) depth = kDynamicDepth;
1398     set_sub_minor_key(DepthBits::encode(depth));
1399   }
1400
1401   int depth() const { return DepthBits::decode(sub_minor_key()); }
1402
1403  private:
1404   class DepthBits : public BitField<unsigned int, 0, 3> {};
1405   STATIC_ASSERT(kDynamicDepth <= DepthBits::kMax);
1406
1407   DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadGlobalViaContext);
1408   DEFINE_HYDROGEN_CODE_STUB(LoadGlobalViaContext, HydrogenCodeStub);
1409 };
1410
1411
1412 class StoreGlobalViaContextStub : public HydrogenCodeStub {
1413  public:
1414   // Use the loop version for depths higher than this one.
1415   static const int kDynamicDepth = 7;
1416
1417   StoreGlobalViaContextStub(Isolate* isolate, int depth,
1418                             LanguageMode language_mode)
1419       : HydrogenCodeStub(isolate) {
1420     if (depth > kDynamicDepth) depth = kDynamicDepth;
1421     set_sub_minor_key(DepthBits::encode(depth) |
1422                       LanguageModeBits::encode(language_mode));
1423   }
1424
1425   int depth() const { return DepthBits::decode(sub_minor_key()); }
1426
1427   LanguageMode language_mode() const {
1428     return LanguageModeBits::decode(sub_minor_key());
1429   }
1430
1431  private:
1432   class DepthBits : public BitField<unsigned int, 0, 4> {};
1433   STATIC_ASSERT(kDynamicDepth <= DepthBits::kMax);
1434
1435   class LanguageModeBits : public BitField<LanguageMode, 4, 2> {};
1436   STATIC_ASSERT(LANGUAGE_END == 3);
1437
1438  private:
1439   DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreGlobalViaContext);
1440   DEFINE_HYDROGEN_CODE_STUB(StoreGlobalViaContext, HydrogenCodeStub);
1441 };
1442
1443
1444 class CallApiFunctionStub : public PlatformCodeStub {
1445  public:
1446   explicit CallApiFunctionStub(Isolate* isolate, bool call_data_undefined)
1447       : PlatformCodeStub(isolate) {
1448     minor_key_ = CallDataUndefinedBits::encode(call_data_undefined);
1449   }
1450
1451  private:
1452   bool call_data_undefined() const {
1453     return CallDataUndefinedBits::decode(minor_key_);
1454   }
1455
1456   class CallDataUndefinedBits : public BitField<bool, 0, 1> {};
1457
1458   DEFINE_CALL_INTERFACE_DESCRIPTOR(ApiFunction);
1459   DEFINE_PLATFORM_CODE_STUB(CallApiFunction, PlatformCodeStub);
1460 };
1461
1462
1463 class CallApiAccessorStub : public PlatformCodeStub {
1464  public:
1465   CallApiAccessorStub(Isolate* isolate, bool is_store, bool call_data_undefined)
1466       : PlatformCodeStub(isolate) {
1467     minor_key_ = IsStoreBits::encode(is_store) |
1468                  CallDataUndefinedBits::encode(call_data_undefined) |
1469                  ArgumentBits::encode(is_store ? 1 : 0);
1470   }
1471
1472  protected:
1473   // For CallApiFunctionWithFixedArgsStub, see below.
1474   static const int kArgBits = 3;
1475   CallApiAccessorStub(Isolate* isolate, int argc, bool call_data_undefined)
1476       : PlatformCodeStub(isolate) {
1477     minor_key_ = IsStoreBits::encode(false) |
1478                  CallDataUndefinedBits::encode(call_data_undefined) |
1479                  ArgumentBits::encode(argc);
1480   }
1481
1482  private:
1483   bool is_store() const { return IsStoreBits::decode(minor_key_); }
1484   bool call_data_undefined() const {
1485     return CallDataUndefinedBits::decode(minor_key_);
1486   }
1487   int argc() const { return ArgumentBits::decode(minor_key_); }
1488
1489   class IsStoreBits: public BitField<bool, 0, 1> {};
1490   class CallDataUndefinedBits: public BitField<bool, 1, 1> {};
1491   class ArgumentBits : public BitField<int, 2, kArgBits> {};
1492
1493   DEFINE_CALL_INTERFACE_DESCRIPTOR(ApiAccessor);
1494   DEFINE_PLATFORM_CODE_STUB(CallApiAccessor, PlatformCodeStub);
1495 };
1496
1497
1498 // TODO(dcarney): see if it's possible to remove this later without performance
1499 // degradation.
1500 // This is not a real stub, but a way of generating the CallApiAccessorStub
1501 // (which has the same abi) which makes it clear that it is not an accessor.
1502 class CallApiFunctionWithFixedArgsStub : public CallApiAccessorStub {
1503  public:
1504   static const int kMaxFixedArgs = (1 << kArgBits) - 1;
1505   CallApiFunctionWithFixedArgsStub(Isolate* isolate, int argc,
1506                                    bool call_data_undefined)
1507       : CallApiAccessorStub(isolate, argc, call_data_undefined) {
1508     DCHECK(0 <= argc && argc <= kMaxFixedArgs);
1509   }
1510 };
1511
1512
1513 typedef ApiAccessorDescriptor ApiFunctionWithFixedArgsDescriptor;
1514
1515
1516 class CallApiGetterStub : public PlatformCodeStub {
1517  public:
1518   explicit CallApiGetterStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
1519
1520   DEFINE_CALL_INTERFACE_DESCRIPTOR(ApiGetter);
1521   DEFINE_PLATFORM_CODE_STUB(CallApiGetter, PlatformCodeStub);
1522 };
1523
1524
1525 class BinaryOpICStub : public HydrogenCodeStub {
1526  public:
1527   BinaryOpICStub(Isolate* isolate, Token::Value op, Strength strength)
1528       : HydrogenCodeStub(isolate, UNINITIALIZED) {
1529     BinaryOpICState state(isolate, op, strength);
1530     set_sub_minor_key(state.GetExtraICState());
1531   }
1532
1533   BinaryOpICStub(Isolate* isolate, const BinaryOpICState& state)
1534       : HydrogenCodeStub(isolate) {
1535     set_sub_minor_key(state.GetExtraICState());
1536   }
1537
1538   static void GenerateAheadOfTime(Isolate* isolate);
1539
1540   Code::Kind GetCodeKind() const override { return Code::BINARY_OP_IC; }
1541
1542   InlineCacheState GetICState() const final { return state().GetICState(); }
1543
1544   ExtraICState GetExtraICState() const final {
1545     return static_cast<ExtraICState>(sub_minor_key());
1546   }
1547
1548   BinaryOpICState state() const {
1549     return BinaryOpICState(isolate(), GetExtraICState());
1550   }
1551
1552   void PrintState(std::ostream& os) const final;  // NOLINT
1553
1554   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
1555   static const int kLeft = 0;
1556   static const int kRight = 1;
1557
1558  private:
1559   static void GenerateAheadOfTime(Isolate* isolate,
1560                                   const BinaryOpICState& state);
1561
1562   DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
1563   DEFINE_HYDROGEN_CODE_STUB(BinaryOpIC, HydrogenCodeStub);
1564 };
1565
1566
1567 // TODO(bmeurer): Merge this into the BinaryOpICStub once we have proper tail
1568 // call support for stubs in Hydrogen.
1569 class BinaryOpICWithAllocationSiteStub final : public PlatformCodeStub {
1570  public:
1571   BinaryOpICWithAllocationSiteStub(Isolate* isolate,
1572                                    const BinaryOpICState& state)
1573       : PlatformCodeStub(isolate) {
1574     minor_key_ = state.GetExtraICState();
1575   }
1576
1577   static void GenerateAheadOfTime(Isolate* isolate);
1578
1579   Handle<Code> GetCodeCopyFromTemplate(Handle<AllocationSite> allocation_site) {
1580     Code::FindAndReplacePattern pattern;
1581     pattern.Add(isolate()->factory()->undefined_map(), allocation_site);
1582     return CodeStub::GetCodeCopy(pattern);
1583   }
1584
1585   Code::Kind GetCodeKind() const override { return Code::BINARY_OP_IC; }
1586
1587   InlineCacheState GetICState() const override { return state().GetICState(); }
1588
1589   ExtraICState GetExtraICState() const override {
1590     return static_cast<ExtraICState>(minor_key_);
1591   }
1592
1593   void PrintState(std::ostream& os) const override;  // NOLINT
1594
1595  private:
1596   BinaryOpICState state() const {
1597     return BinaryOpICState(isolate(), static_cast<ExtraICState>(minor_key_));
1598   }
1599
1600   static void GenerateAheadOfTime(Isolate* isolate,
1601                                   const BinaryOpICState& state);
1602
1603   DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOpWithAllocationSite);
1604   DEFINE_PLATFORM_CODE_STUB(BinaryOpICWithAllocationSite, PlatformCodeStub);
1605 };
1606
1607
1608 class BinaryOpWithAllocationSiteStub final : public BinaryOpICStub {
1609  public:
1610   BinaryOpWithAllocationSiteStub(Isolate* isolate, Token::Value op,
1611                                  Strength strength)
1612       : BinaryOpICStub(isolate, op, strength) {}
1613
1614   BinaryOpWithAllocationSiteStub(Isolate* isolate, const BinaryOpICState& state)
1615       : BinaryOpICStub(isolate, state) {}
1616
1617   Code::Kind GetCodeKind() const final { return Code::STUB; }
1618
1619   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
1620   static const int kAllocationSite = 0;
1621   static const int kLeft = 1;
1622   static const int kRight = 2;
1623
1624   DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOpWithAllocationSite);
1625   DEFINE_HYDROGEN_CODE_STUB(BinaryOpWithAllocationSite, BinaryOpICStub);
1626 };
1627
1628
1629 class StringAddStub final : public HydrogenCodeStub {
1630  public:
1631   StringAddStub(Isolate* isolate, StringAddFlags flags,
1632                 PretenureFlag pretenure_flag)
1633       : HydrogenCodeStub(isolate) {
1634     set_sub_minor_key(StringAddFlagsBits::encode(flags) |
1635                       PretenureFlagBits::encode(pretenure_flag));
1636   }
1637
1638   StringAddFlags flags() const {
1639     return StringAddFlagsBits::decode(sub_minor_key());
1640   }
1641
1642   PretenureFlag pretenure_flag() const {
1643     return PretenureFlagBits::decode(sub_minor_key());
1644   }
1645
1646   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
1647   static const int kLeft = 0;
1648   static const int kRight = 1;
1649
1650  private:
1651   class StringAddFlagsBits: public BitField<StringAddFlags, 0, 2> {};
1652   class PretenureFlagBits: public BitField<PretenureFlag, 2, 1> {};
1653
1654   void PrintBaseName(std::ostream& os) const override;  // NOLINT
1655
1656   DEFINE_CALL_INTERFACE_DESCRIPTOR(StringAdd);
1657   DEFINE_HYDROGEN_CODE_STUB(StringAdd, HydrogenCodeStub);
1658 };
1659
1660
1661 class CompareICStub : public PlatformCodeStub {
1662  public:
1663   CompareICStub(Isolate* isolate, Token::Value op, Strength strength,
1664                 CompareICState::State left, CompareICState::State right,
1665                 CompareICState::State state)
1666       : PlatformCodeStub(isolate) {
1667     DCHECK(Token::IsCompareOp(op));
1668     minor_key_ = OpBits::encode(op - Token::EQ) |
1669                  StrengthBits::encode(is_strong(strength)) |
1670                  LeftStateBits::encode(left) | RightStateBits::encode(right) |
1671                  StateBits::encode(state);
1672   }
1673
1674   void set_known_map(Handle<Map> map) { known_map_ = map; }
1675
1676   InlineCacheState GetICState() const override;
1677
1678   Token::Value op() const {
1679     return static_cast<Token::Value>(Token::EQ + OpBits::decode(minor_key_));
1680   }
1681
1682   Strength strength() const {
1683     return StrengthBits::decode(minor_key_) ? Strength::STRONG : Strength::WEAK;
1684   }
1685
1686   CompareICState::State left() const {
1687     return LeftStateBits::decode(minor_key_);
1688   }
1689   CompareICState::State right() const {
1690     return RightStateBits::decode(minor_key_);
1691   }
1692   CompareICState::State state() const { return StateBits::decode(minor_key_); }
1693
1694  private:
1695   Code::Kind GetCodeKind() const override { return Code::COMPARE_IC; }
1696
1697   void GenerateSmis(MacroAssembler* masm);
1698   void GenerateNumbers(MacroAssembler* masm);
1699   void GenerateInternalizedStrings(MacroAssembler* masm);
1700   void GenerateStrings(MacroAssembler* masm);
1701   void GenerateUniqueNames(MacroAssembler* masm);
1702   void GenerateObjects(MacroAssembler* masm);
1703   void GenerateMiss(MacroAssembler* masm);
1704   void GenerateKnownObjects(MacroAssembler* masm);
1705   void GenerateGeneric(MacroAssembler* masm);
1706
1707   bool strict() const { return op() == Token::EQ_STRICT; }
1708   Condition GetCondition() const;
1709
1710   void AddToSpecialCache(Handle<Code> new_object) override;
1711   bool FindCodeInSpecialCache(Code** code_out) override;
1712   bool UseSpecialCache() override {
1713     return state() == CompareICState::KNOWN_OBJECT;
1714   }
1715
1716   class OpBits : public BitField<int, 0, 3> {};
1717   class StrengthBits : public BitField<bool, 3, 1> {};
1718   class LeftStateBits : public BitField<CompareICState::State, 4, 4> {};
1719   class RightStateBits : public BitField<CompareICState::State, 8, 4> {};
1720   class StateBits : public BitField<CompareICState::State, 12, 4> {};
1721
1722   Handle<Map> known_map_;
1723
1724   DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
1725   DEFINE_PLATFORM_CODE_STUB(CompareIC, PlatformCodeStub);
1726 };
1727
1728
1729 class CompareNilICStub : public HydrogenCodeStub  {
1730  public:
1731   Type* GetType(Zone* zone, Handle<Map> map = Handle<Map>());
1732   Type* GetInputType(Zone* zone, Handle<Map> map);
1733
1734   CompareNilICStub(Isolate* isolate, NilValue nil) : HydrogenCodeStub(isolate) {
1735     set_sub_minor_key(NilValueBits::encode(nil));
1736   }
1737
1738   CompareNilICStub(Isolate* isolate, ExtraICState ic_state,
1739                    InitializationState init_state = INITIALIZED)
1740       : HydrogenCodeStub(isolate, init_state) {
1741     set_sub_minor_key(ic_state);
1742   }
1743
1744   static Handle<Code> GetUninitialized(Isolate* isolate,
1745                                        NilValue nil) {
1746     return CompareNilICStub(isolate, nil, UNINITIALIZED).GetCode();
1747   }
1748
1749   InlineCacheState GetICState() const override {
1750     State state = this->state();
1751     if (state.Contains(GENERIC)) {
1752       return MEGAMORPHIC;
1753     } else if (state.Contains(MONOMORPHIC_MAP)) {
1754       return MONOMORPHIC;
1755     } else {
1756       return PREMONOMORPHIC;
1757     }
1758   }
1759
1760   Code::Kind GetCodeKind() const override { return Code::COMPARE_NIL_IC; }
1761
1762   ExtraICState GetExtraICState() const override { return sub_minor_key(); }
1763
1764   void UpdateStatus(Handle<Object> object);
1765
1766   bool IsMonomorphic() const { return state().Contains(MONOMORPHIC_MAP); }
1767
1768   NilValue nil_value() const { return NilValueBits::decode(sub_minor_key()); }
1769
1770   void ClearState() {
1771     set_sub_minor_key(TypesBits::update(sub_minor_key(), 0));
1772   }
1773
1774   void PrintState(std::ostream& os) const override;     // NOLINT
1775   void PrintBaseName(std::ostream& os) const override;  // NOLINT
1776
1777  private:
1778   CompareNilICStub(Isolate* isolate, NilValue nil,
1779                    InitializationState init_state)
1780       : HydrogenCodeStub(isolate, init_state) {
1781     set_sub_minor_key(NilValueBits::encode(nil));
1782   }
1783
1784   enum CompareNilType {
1785     UNDEFINED,
1786     NULL_TYPE,
1787     MONOMORPHIC_MAP,
1788     GENERIC,
1789     NUMBER_OF_TYPES
1790   };
1791
1792   // At most 6 different types can be distinguished, because the Code object
1793   // only has room for a single byte to hold a set and there are two more
1794   // boolean flags we need to store. :-P
1795   STATIC_ASSERT(NUMBER_OF_TYPES <= 6);
1796
1797   class State : public EnumSet<CompareNilType, byte> {
1798    public:
1799     State() : EnumSet<CompareNilType, byte>(0) { }
1800     explicit State(byte bits) : EnumSet<CompareNilType, byte>(bits) { }
1801   };
1802   friend std::ostream& operator<<(std::ostream& os, const State& s);
1803
1804   State state() const { return State(TypesBits::decode(sub_minor_key())); }
1805
1806   class NilValueBits : public BitField<NilValue, 0, 1> {};
1807   class TypesBits : public BitField<byte, 1, NUMBER_OF_TYPES> {};
1808
1809   friend class CompareNilIC;
1810
1811   DEFINE_CALL_INTERFACE_DESCRIPTOR(CompareNil);
1812   DEFINE_HYDROGEN_CODE_STUB(CompareNilIC, HydrogenCodeStub);
1813 };
1814
1815
1816 std::ostream& operator<<(std::ostream& os, const CompareNilICStub::State& s);
1817
1818
1819 class CEntryStub : public PlatformCodeStub {
1820  public:
1821   CEntryStub(Isolate* isolate, int result_size,
1822              SaveFPRegsMode save_doubles = kDontSaveFPRegs)
1823       : PlatformCodeStub(isolate) {
1824     minor_key_ = SaveDoublesBits::encode(save_doubles == kSaveFPRegs);
1825     DCHECK(result_size == 1 || result_size == 2);
1826 #if _WIN64 || V8_TARGET_ARCH_PPC
1827     minor_key_ = ResultSizeBits::update(minor_key_, result_size);
1828 #endif  // _WIN64
1829   }
1830
1831   // The version of this stub that doesn't save doubles is generated ahead of
1832   // time, so it's OK to call it from other stubs that can't cope with GC during
1833   // their code generation.  On machines that always have gp registers (x64) we
1834   // can generate both variants ahead of time.
1835   static void GenerateAheadOfTime(Isolate* isolate);
1836
1837  private:
1838   bool save_doubles() const { return SaveDoublesBits::decode(minor_key_); }
1839 #if _WIN64 || V8_TARGET_ARCH_PPC
1840   int result_size() const { return ResultSizeBits::decode(minor_key_); }
1841 #endif  // _WIN64
1842
1843   bool NeedsImmovableCode() override;
1844
1845   class SaveDoublesBits : public BitField<bool, 0, 1> {};
1846   class ResultSizeBits : public BitField<int, 1, 3> {};
1847
1848   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
1849   DEFINE_PLATFORM_CODE_STUB(CEntry, PlatformCodeStub);
1850 };
1851
1852
1853 class JSEntryStub : public PlatformCodeStub {
1854  public:
1855   JSEntryStub(Isolate* isolate, StackFrame::Type type)
1856       : PlatformCodeStub(isolate) {
1857     DCHECK(type == StackFrame::ENTRY || type == StackFrame::ENTRY_CONSTRUCT);
1858     minor_key_ = StackFrameTypeBits::encode(type);
1859   }
1860
1861  private:
1862   void FinishCode(Handle<Code> code) override;
1863
1864   void PrintName(std::ostream& os) const override {  // NOLINT
1865     os << (type() == StackFrame::ENTRY ? "JSEntryStub"
1866                                        : "JSConstructEntryStub");
1867   }
1868
1869   StackFrame::Type type() const {
1870     return StackFrameTypeBits::decode(minor_key_);
1871   }
1872
1873   class StackFrameTypeBits : public BitField<StackFrame::Type, 0, 5> {};
1874
1875   int handler_offset_;
1876
1877   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
1878   DEFINE_PLATFORM_CODE_STUB(JSEntry, PlatformCodeStub);
1879 };
1880
1881
1882 class ArgumentsAccessStub: public PlatformCodeStub {
1883  public:
1884   enum Type {
1885     READ_ELEMENT,
1886     NEW_SLOPPY_FAST,
1887     NEW_SLOPPY_SLOW,
1888     NEW_STRICT
1889   };
1890
1891   ArgumentsAccessStub(Isolate* isolate, Type type) : PlatformCodeStub(isolate) {
1892     minor_key_ = TypeBits::encode(type);
1893   }
1894
1895   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override {
1896     if (type() == READ_ELEMENT) {
1897       return ArgumentsAccessReadDescriptor(isolate());
1898     }
1899     return ContextOnlyDescriptor(isolate());
1900   }
1901
1902  private:
1903   Type type() const { return TypeBits::decode(minor_key_); }
1904
1905   void GenerateReadElement(MacroAssembler* masm);
1906   void GenerateNewStrict(MacroAssembler* masm);
1907   void GenerateNewSloppyFast(MacroAssembler* masm);
1908   void GenerateNewSloppySlow(MacroAssembler* masm);
1909
1910   void PrintName(std::ostream& os) const override;  // NOLINT
1911
1912   class TypeBits : public BitField<Type, 0, 2> {};
1913
1914   DEFINE_PLATFORM_CODE_STUB(ArgumentsAccess, PlatformCodeStub);
1915 };
1916
1917
1918 class RestParamAccessStub: public PlatformCodeStub {
1919  public:
1920   explicit RestParamAccessStub(Isolate* isolate) : PlatformCodeStub(isolate) { }
1921
1922   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override {
1923     return ContextOnlyDescriptor(isolate());
1924   }
1925
1926  private:
1927   void GenerateNew(MacroAssembler* masm);
1928
1929   void PrintName(std::ostream& os) const override;  // NOLINT
1930
1931   DEFINE_PLATFORM_CODE_STUB(RestParamAccess, PlatformCodeStub);
1932 };
1933
1934
1935 class RegExpExecStub: public PlatformCodeStub {
1936  public:
1937   explicit RegExpExecStub(Isolate* isolate) : PlatformCodeStub(isolate) { }
1938
1939   DEFINE_CALL_INTERFACE_DESCRIPTOR(ContextOnly);
1940   DEFINE_PLATFORM_CODE_STUB(RegExpExec, PlatformCodeStub);
1941 };
1942
1943
1944 class RegExpConstructResultStub final : public HydrogenCodeStub {
1945  public:
1946   explicit RegExpConstructResultStub(Isolate* isolate)
1947       : HydrogenCodeStub(isolate) { }
1948
1949   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
1950   static const int kLength = 0;
1951   static const int kIndex = 1;
1952   static const int kInput = 2;
1953
1954   DEFINE_CALL_INTERFACE_DESCRIPTOR(RegExpConstructResult);
1955   DEFINE_HYDROGEN_CODE_STUB(RegExpConstructResult, HydrogenCodeStub);
1956 };
1957
1958
1959 class CallFunctionStub: public PlatformCodeStub {
1960  public:
1961   CallFunctionStub(Isolate* isolate, int argc, CallFunctionFlags flags)
1962       : PlatformCodeStub(isolate) {
1963     DCHECK(argc >= 0 && argc <= Code::kMaxArguments);
1964     minor_key_ = ArgcBits::encode(argc) | FlagBits::encode(flags);
1965   }
1966
1967  private:
1968   int argc() const { return ArgcBits::decode(minor_key_); }
1969   int flags() const { return FlagBits::decode(minor_key_); }
1970
1971   bool CallAsMethod() const {
1972     return flags() == CALL_AS_METHOD || flags() == WRAP_AND_CALL;
1973   }
1974
1975   bool NeedsChecks() const { return flags() != WRAP_AND_CALL; }
1976
1977   void PrintName(std::ostream& os) const override;  // NOLINT
1978
1979   // Minor key encoding in 32 bits with Bitfield <Type, shift, size>.
1980   class FlagBits : public BitField<CallFunctionFlags, 0, 2> {};
1981   class ArgcBits : public BitField<unsigned, 2, Code::kArgumentsBits> {};
1982   STATIC_ASSERT(Code::kArgumentsBits + 2 <= kStubMinorKeyBits);
1983
1984   DEFINE_CALL_INTERFACE_DESCRIPTOR(CallFunction);
1985   DEFINE_PLATFORM_CODE_STUB(CallFunction, PlatformCodeStub);
1986 };
1987
1988
1989 class CallConstructStub: public PlatformCodeStub {
1990  public:
1991   CallConstructStub(Isolate* isolate, CallConstructorFlags flags)
1992       : PlatformCodeStub(isolate) {
1993     minor_key_ = FlagBits::encode(flags);
1994   }
1995
1996   void FinishCode(Handle<Code> code) override {
1997     code->set_has_function_cache(RecordCallTarget());
1998   }
1999
2000  private:
2001   CallConstructorFlags flags() const { return FlagBits::decode(minor_key_); }
2002
2003   bool RecordCallTarget() const {
2004     return (flags() & RECORD_CONSTRUCTOR_TARGET) != 0;
2005   }
2006
2007   bool IsSuperConstructorCall() const {
2008     return (flags() & SUPER_CONSTRUCTOR_CALL) != 0;
2009   }
2010
2011   void PrintName(std::ostream& os) const override;  // NOLINT
2012
2013   class FlagBits : public BitField<CallConstructorFlags, 0, 2> {};
2014
2015   DEFINE_CALL_INTERFACE_DESCRIPTOR(CallConstruct);
2016   DEFINE_PLATFORM_CODE_STUB(CallConstruct, PlatformCodeStub);
2017 };
2018
2019
2020 enum StringIndexFlags {
2021   // Accepts smis or heap numbers.
2022   STRING_INDEX_IS_NUMBER,
2023
2024   // Accepts smis or heap numbers that are valid array indices
2025   // (ECMA-262 15.4). Invalid indices are reported as being out of
2026   // range.
2027   STRING_INDEX_IS_ARRAY_INDEX
2028 };
2029
2030
2031 enum ReceiverCheckMode {
2032   // We don't know anything about the receiver.
2033   RECEIVER_IS_UNKNOWN,
2034
2035   // We know the receiver is a string.
2036   RECEIVER_IS_STRING
2037 };
2038
2039
2040 enum EmbedMode {
2041   // The code being generated is part of an IC handler, which may MISS
2042   // to an IC in failure cases.
2043   PART_OF_IC_HANDLER,
2044
2045   NOT_PART_OF_IC_HANDLER
2046 };
2047
2048
2049 // Generates code implementing String.prototype.charCodeAt.
2050 //
2051 // Only supports the case when the receiver is a string and the index
2052 // is a number (smi or heap number) that is a valid index into the
2053 // string. Additional index constraints are specified by the
2054 // flags. Otherwise, bails out to the provided labels.
2055 //
2056 // Register usage: |object| may be changed to another string in a way
2057 // that doesn't affect charCodeAt/charAt semantics, |index| is
2058 // preserved, |scratch| and |result| are clobbered.
2059 class StringCharCodeAtGenerator {
2060  public:
2061   StringCharCodeAtGenerator(Register object, Register index, Register result,
2062                             Label* receiver_not_string, Label* index_not_number,
2063                             Label* index_out_of_range,
2064                             StringIndexFlags index_flags,
2065                             ReceiverCheckMode check_mode = RECEIVER_IS_UNKNOWN)
2066       : object_(object),
2067         index_(index),
2068         result_(result),
2069         receiver_not_string_(receiver_not_string),
2070         index_not_number_(index_not_number),
2071         index_out_of_range_(index_out_of_range),
2072         index_flags_(index_flags),
2073         check_mode_(check_mode) {
2074     DCHECK(!result_.is(object_));
2075     DCHECK(!result_.is(index_));
2076   }
2077
2078   // Generates the fast case code. On the fallthrough path |result|
2079   // register contains the result.
2080   void GenerateFast(MacroAssembler* masm);
2081
2082   // Generates the slow case code. Must not be naturally
2083   // reachable. Expected to be put after a ret instruction (e.g., in
2084   // deferred code). Always jumps back to the fast case.
2085   void GenerateSlow(MacroAssembler* masm, EmbedMode embed_mode,
2086                     const RuntimeCallHelper& call_helper);
2087
2088   // Skip handling slow case and directly jump to bailout.
2089   void SkipSlow(MacroAssembler* masm, Label* bailout) {
2090     masm->bind(&index_not_smi_);
2091     masm->bind(&call_runtime_);
2092     masm->jmp(bailout);
2093   }
2094
2095  private:
2096   Register object_;
2097   Register index_;
2098   Register result_;
2099
2100   Label* receiver_not_string_;
2101   Label* index_not_number_;
2102   Label* index_out_of_range_;
2103
2104   StringIndexFlags index_flags_;
2105   ReceiverCheckMode check_mode_;
2106
2107   Label call_runtime_;
2108   Label index_not_smi_;
2109   Label got_smi_index_;
2110   Label exit_;
2111
2112   DISALLOW_COPY_AND_ASSIGN(StringCharCodeAtGenerator);
2113 };
2114
2115
2116 // Generates code for creating a one-char string from a char code.
2117 class StringCharFromCodeGenerator {
2118  public:
2119   StringCharFromCodeGenerator(Register code,
2120                               Register result)
2121       : code_(code),
2122         result_(result) {
2123     DCHECK(!code_.is(result_));
2124   }
2125
2126   // Generates the fast case code. On the fallthrough path |result|
2127   // register contains the result.
2128   void GenerateFast(MacroAssembler* masm);
2129
2130   // Generates the slow case code. Must not be naturally
2131   // reachable. Expected to be put after a ret instruction (e.g., in
2132   // deferred code). Always jumps back to the fast case.
2133   void GenerateSlow(MacroAssembler* masm,
2134                     const RuntimeCallHelper& call_helper);
2135
2136   // Skip handling slow case and directly jump to bailout.
2137   void SkipSlow(MacroAssembler* masm, Label* bailout) {
2138     masm->bind(&slow_case_);
2139     masm->jmp(bailout);
2140   }
2141
2142  private:
2143   Register code_;
2144   Register result_;
2145
2146   Label slow_case_;
2147   Label exit_;
2148
2149   DISALLOW_COPY_AND_ASSIGN(StringCharFromCodeGenerator);
2150 };
2151
2152
2153 // Generates code implementing String.prototype.charAt.
2154 //
2155 // Only supports the case when the receiver is a string and the index
2156 // is a number (smi or heap number) that is a valid index into the
2157 // string. Additional index constraints are specified by the
2158 // flags. Otherwise, bails out to the provided labels.
2159 //
2160 // Register usage: |object| may be changed to another string in a way
2161 // that doesn't affect charCodeAt/charAt semantics, |index| is
2162 // preserved, |scratch1|, |scratch2|, and |result| are clobbered.
2163 class StringCharAtGenerator {
2164  public:
2165   StringCharAtGenerator(Register object, Register index, Register scratch,
2166                         Register result, Label* receiver_not_string,
2167                         Label* index_not_number, Label* index_out_of_range,
2168                         StringIndexFlags index_flags,
2169                         ReceiverCheckMode check_mode = RECEIVER_IS_UNKNOWN)
2170       : char_code_at_generator_(object, index, scratch, receiver_not_string,
2171                                 index_not_number, index_out_of_range,
2172                                 index_flags, check_mode),
2173         char_from_code_generator_(scratch, result) {}
2174
2175   // Generates the fast case code. On the fallthrough path |result|
2176   // register contains the result.
2177   void GenerateFast(MacroAssembler* masm) {
2178     char_code_at_generator_.GenerateFast(masm);
2179     char_from_code_generator_.GenerateFast(masm);
2180   }
2181
2182   // Generates the slow case code. Must not be naturally
2183   // reachable. Expected to be put after a ret instruction (e.g., in
2184   // deferred code). Always jumps back to the fast case.
2185   void GenerateSlow(MacroAssembler* masm, EmbedMode embed_mode,
2186                     const RuntimeCallHelper& call_helper) {
2187     char_code_at_generator_.GenerateSlow(masm, embed_mode, call_helper);
2188     char_from_code_generator_.GenerateSlow(masm, call_helper);
2189   }
2190
2191   // Skip handling slow case and directly jump to bailout.
2192   void SkipSlow(MacroAssembler* masm, Label* bailout) {
2193     char_code_at_generator_.SkipSlow(masm, bailout);
2194     char_from_code_generator_.SkipSlow(masm, bailout);
2195   }
2196
2197  private:
2198   StringCharCodeAtGenerator char_code_at_generator_;
2199   StringCharFromCodeGenerator char_from_code_generator_;
2200
2201   DISALLOW_COPY_AND_ASSIGN(StringCharAtGenerator);
2202 };
2203
2204
2205 class LoadDictionaryElementStub : public HydrogenCodeStub {
2206  public:
2207   explicit LoadDictionaryElementStub(Isolate* isolate, const LoadICState& state)
2208       : HydrogenCodeStub(isolate) {
2209     minor_key_ = state.GetExtraICState();
2210   }
2211
2212   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override {
2213     return LoadWithVectorDescriptor(isolate());
2214   }
2215
2216   LanguageMode language_mode() const {
2217     return LoadICState::GetLanguageMode(MinorKey());
2218   }
2219
2220   DEFINE_HYDROGEN_CODE_STUB(LoadDictionaryElement, HydrogenCodeStub);
2221 };
2222
2223
2224 class KeyedLoadGenericStub : public HydrogenCodeStub {
2225  public:
2226   explicit KeyedLoadGenericStub(Isolate* isolate, const LoadICState& state)
2227       : HydrogenCodeStub(isolate) {
2228     minor_key_ = state.GetExtraICState();
2229   }
2230
2231   Code::Kind GetCodeKind() const override { return Code::KEYED_LOAD_IC; }
2232   InlineCacheState GetICState() const override { return GENERIC; }
2233
2234   LanguageMode language_mode() const {
2235     return LoadICState::GetLanguageMode(MinorKey());
2236   }
2237
2238   DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
2239
2240   DEFINE_HYDROGEN_CODE_STUB(KeyedLoadGeneric, HydrogenCodeStub);
2241 };
2242
2243
2244 class LoadICTrampolineStub : public PlatformCodeStub {
2245  public:
2246   LoadICTrampolineStub(Isolate* isolate, const LoadICState& state)
2247       : PlatformCodeStub(isolate) {
2248     minor_key_ = state.GetExtraICState();
2249   }
2250
2251   Code::Kind GetCodeKind() const override { return Code::LOAD_IC; }
2252
2253   InlineCacheState GetICState() const final { return DEFAULT; }
2254
2255   ExtraICState GetExtraICState() const final {
2256     return static_cast<ExtraICState>(minor_key_);
2257   }
2258
2259  protected:
2260   LoadICState state() const {
2261     return LoadICState(static_cast<ExtraICState>(minor_key_));
2262   }
2263
2264   DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
2265   DEFINE_PLATFORM_CODE_STUB(LoadICTrampoline, PlatformCodeStub);
2266 };
2267
2268
2269 class KeyedLoadICTrampolineStub : public LoadICTrampolineStub {
2270  public:
2271   explicit KeyedLoadICTrampolineStub(Isolate* isolate, const LoadICState& state)
2272       : LoadICTrampolineStub(isolate, state) {}
2273
2274   Code::Kind GetCodeKind() const override { return Code::KEYED_LOAD_IC; }
2275
2276   DEFINE_PLATFORM_CODE_STUB(KeyedLoadICTrampoline, LoadICTrampolineStub);
2277 };
2278
2279
2280 class VectorStoreICTrampolineStub : public PlatformCodeStub {
2281  public:
2282   VectorStoreICTrampolineStub(Isolate* isolate, const StoreICState& state)
2283       : PlatformCodeStub(isolate) {
2284     minor_key_ = state.GetExtraICState();
2285   }
2286
2287   Code::Kind GetCodeKind() const override { return Code::STORE_IC; }
2288
2289   InlineCacheState GetICState() const final { return DEFAULT; }
2290
2291   ExtraICState GetExtraICState() const final {
2292     return static_cast<ExtraICState>(minor_key_);
2293   }
2294
2295  protected:
2296   StoreICState state() const {
2297     return StoreICState(static_cast<ExtraICState>(minor_key_));
2298   }
2299
2300  private:
2301   DEFINE_CALL_INTERFACE_DESCRIPTOR(VectorStoreICTrampoline);
2302   DEFINE_PLATFORM_CODE_STUB(VectorStoreICTrampoline, PlatformCodeStub);
2303 };
2304
2305
2306 class VectorKeyedStoreICTrampolineStub : public VectorStoreICTrampolineStub {
2307  public:
2308   VectorKeyedStoreICTrampolineStub(Isolate* isolate, const StoreICState& state)
2309       : VectorStoreICTrampolineStub(isolate, state) {}
2310
2311   Code::Kind GetCodeKind() const override { return Code::KEYED_STORE_IC; }
2312
2313   DEFINE_PLATFORM_CODE_STUB(VectorKeyedStoreICTrampoline,
2314                             VectorStoreICTrampolineStub);
2315 };
2316
2317
2318 class CallICTrampolineStub : public PlatformCodeStub {
2319  public:
2320   CallICTrampolineStub(Isolate* isolate, const CallICState& state)
2321       : PlatformCodeStub(isolate) {
2322     minor_key_ = state.GetExtraICState();
2323   }
2324
2325   Code::Kind GetCodeKind() const override { return Code::CALL_IC; }
2326
2327   InlineCacheState GetICState() const final { return DEFAULT; }
2328
2329   ExtraICState GetExtraICState() const final {
2330     return static_cast<ExtraICState>(minor_key_);
2331   }
2332
2333  protected:
2334   CallICState state() const {
2335     return CallICState(static_cast<ExtraICState>(minor_key_));
2336   }
2337
2338   DEFINE_CALL_INTERFACE_DESCRIPTOR(CallFunctionWithFeedback);
2339   DEFINE_PLATFORM_CODE_STUB(CallICTrampoline, PlatformCodeStub);
2340 };
2341
2342
2343 class CallIC_ArrayTrampolineStub : public CallICTrampolineStub {
2344  public:
2345   CallIC_ArrayTrampolineStub(Isolate* isolate, const CallICState& state)
2346       : CallICTrampolineStub(isolate, state) {}
2347
2348  private:
2349   DEFINE_PLATFORM_CODE_STUB(CallIC_ArrayTrampoline, CallICTrampolineStub);
2350 };
2351
2352
2353 class LoadICStub : public PlatformCodeStub {
2354  public:
2355   explicit LoadICStub(Isolate* isolate, const LoadICState& state)
2356       : PlatformCodeStub(isolate) {
2357     minor_key_ = state.GetExtraICState();
2358   }
2359
2360   void GenerateForTrampoline(MacroAssembler* masm);
2361
2362   Code::Kind GetCodeKind() const override { return Code::LOAD_IC; }
2363   InlineCacheState GetICState() const final { return DEFAULT; }
2364   ExtraICState GetExtraICState() const final {
2365     return static_cast<ExtraICState>(minor_key_);
2366   }
2367
2368   DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
2369   DEFINE_PLATFORM_CODE_STUB(LoadIC, PlatformCodeStub);
2370
2371  protected:
2372   void GenerateImpl(MacroAssembler* masm, bool in_frame);
2373 };
2374
2375
2376 class KeyedLoadICStub : public PlatformCodeStub {
2377  public:
2378   explicit KeyedLoadICStub(Isolate* isolate, const LoadICState& state)
2379       : PlatformCodeStub(isolate) {
2380     minor_key_ = state.GetExtraICState();
2381   }
2382
2383   void GenerateForTrampoline(MacroAssembler* masm);
2384
2385   Code::Kind GetCodeKind() const override { return Code::KEYED_LOAD_IC; }
2386   InlineCacheState GetICState() const final { return DEFAULT; }
2387   ExtraICState GetExtraICState() const final {
2388     return static_cast<ExtraICState>(minor_key_);
2389   }
2390
2391   DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
2392   DEFINE_PLATFORM_CODE_STUB(KeyedLoadIC, PlatformCodeStub);
2393
2394  protected:
2395   void GenerateImpl(MacroAssembler* masm, bool in_frame);
2396 };
2397
2398
2399 class VectorStoreICStub : public PlatformCodeStub {
2400  public:
2401   VectorStoreICStub(Isolate* isolate, const StoreICState& state)
2402       : PlatformCodeStub(isolate) {
2403     minor_key_ = state.GetExtraICState();
2404   }
2405
2406   void GenerateForTrampoline(MacroAssembler* masm);
2407
2408   Code::Kind GetCodeKind() const final { return Code::STORE_IC; }
2409   InlineCacheState GetICState() const final { return DEFAULT; }
2410   ExtraICState GetExtraICState() const final {
2411     return static_cast<ExtraICState>(minor_key_);
2412   }
2413
2414   DEFINE_CALL_INTERFACE_DESCRIPTOR(VectorStoreIC);
2415   DEFINE_PLATFORM_CODE_STUB(VectorStoreIC, PlatformCodeStub);
2416
2417  protected:
2418   void GenerateImpl(MacroAssembler* masm, bool in_frame);
2419 };
2420
2421
2422 class VectorKeyedStoreICStub : public PlatformCodeStub {
2423  public:
2424   VectorKeyedStoreICStub(Isolate* isolate, const StoreICState& state)
2425       : PlatformCodeStub(isolate) {
2426     minor_key_ = state.GetExtraICState();
2427   }
2428
2429   void GenerateForTrampoline(MacroAssembler* masm);
2430
2431   Code::Kind GetCodeKind() const final { return Code::KEYED_STORE_IC; }
2432   InlineCacheState GetICState() const final { return DEFAULT; }
2433   virtual ExtraICState GetExtraICState() const final {
2434     return static_cast<ExtraICState>(minor_key_);
2435   }
2436
2437   DEFINE_CALL_INTERFACE_DESCRIPTOR(VectorStoreIC);
2438   DEFINE_PLATFORM_CODE_STUB(VectorKeyedStoreIC, PlatformCodeStub);
2439
2440  protected:
2441   void GenerateImpl(MacroAssembler* masm, bool in_frame);
2442 };
2443
2444
2445 class DoubleToIStub : public PlatformCodeStub {
2446  public:
2447   DoubleToIStub(Isolate* isolate, Register source, Register destination,
2448                 int offset, bool is_truncating, bool skip_fastpath = false)
2449       : PlatformCodeStub(isolate) {
2450     minor_key_ = SourceRegisterBits::encode(source.code()) |
2451                  DestinationRegisterBits::encode(destination.code()) |
2452                  OffsetBits::encode(offset) |
2453                  IsTruncatingBits::encode(is_truncating) |
2454                  SkipFastPathBits::encode(skip_fastpath) |
2455                  SSE3Bits::encode(CpuFeatures::IsSupported(SSE3) ? 1 : 0);
2456   }
2457
2458   bool SometimesSetsUpAFrame() override { return false; }
2459
2460  private:
2461   Register source() const {
2462     return Register::from_code(SourceRegisterBits::decode(minor_key_));
2463   }
2464   Register destination() const {
2465     return Register::from_code(DestinationRegisterBits::decode(minor_key_));
2466   }
2467   bool is_truncating() const { return IsTruncatingBits::decode(minor_key_); }
2468   bool skip_fastpath() const { return SkipFastPathBits::decode(minor_key_); }
2469   int offset() const { return OffsetBits::decode(minor_key_); }
2470
2471   static const int kBitsPerRegisterNumber = 6;
2472   STATIC_ASSERT((1L << kBitsPerRegisterNumber) >= Register::kNumRegisters);
2473   class SourceRegisterBits:
2474       public BitField<int, 0, kBitsPerRegisterNumber> {};  // NOLINT
2475   class DestinationRegisterBits:
2476       public BitField<int, kBitsPerRegisterNumber,
2477         kBitsPerRegisterNumber> {};  // NOLINT
2478   class IsTruncatingBits:
2479       public BitField<bool, 2 * kBitsPerRegisterNumber, 1> {};  // NOLINT
2480   class OffsetBits:
2481       public BitField<int, 2 * kBitsPerRegisterNumber + 1, 3> {};  // NOLINT
2482   class SkipFastPathBits:
2483       public BitField<int, 2 * kBitsPerRegisterNumber + 4, 1> {};  // NOLINT
2484   class SSE3Bits:
2485       public BitField<int, 2 * kBitsPerRegisterNumber + 5, 1> {};  // NOLINT
2486
2487   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
2488   DEFINE_PLATFORM_CODE_STUB(DoubleToI, PlatformCodeStub);
2489 };
2490
2491
2492 class ScriptContextFieldStub : public HandlerStub {
2493  public:
2494   ScriptContextFieldStub(Isolate* isolate,
2495                          const ScriptContextTable::LookupResult* lookup_result)
2496       : HandlerStub(isolate) {
2497     DCHECK(Accepted(lookup_result));
2498     set_sub_minor_key(ContextIndexBits::encode(lookup_result->context_index) |
2499                       SlotIndexBits::encode(lookup_result->slot_index));
2500   }
2501
2502   int context_index() const {
2503     return ContextIndexBits::decode(sub_minor_key());
2504   }
2505
2506   int slot_index() const { return SlotIndexBits::decode(sub_minor_key()); }
2507
2508   static bool Accepted(const ScriptContextTable::LookupResult* lookup_result) {
2509     return ContextIndexBits::is_valid(lookup_result->context_index) &&
2510            SlotIndexBits::is_valid(lookup_result->slot_index);
2511   }
2512
2513  private:
2514   static const int kContextIndexBits = 13;
2515   static const int kSlotIndexBits = 13;
2516   class ContextIndexBits : public BitField<int, 0, kContextIndexBits> {};
2517   class SlotIndexBits
2518       : public BitField<int, kContextIndexBits, kSlotIndexBits> {};
2519
2520   Code::StubType GetStubType() const override { return Code::FAST; }
2521
2522   DEFINE_CODE_STUB_BASE(ScriptContextFieldStub, HandlerStub);
2523 };
2524
2525
2526 class LoadScriptContextFieldStub : public ScriptContextFieldStub {
2527  public:
2528   LoadScriptContextFieldStub(
2529       Isolate* isolate, const ScriptContextTable::LookupResult* lookup_result)
2530       : ScriptContextFieldStub(isolate, lookup_result) {}
2531
2532  private:
2533   Code::Kind kind() const override { return Code::LOAD_IC; }
2534
2535   DEFINE_HANDLER_CODE_STUB(LoadScriptContextField, ScriptContextFieldStub);
2536 };
2537
2538
2539 class StoreScriptContextFieldStub : public ScriptContextFieldStub {
2540  public:
2541   StoreScriptContextFieldStub(
2542       Isolate* isolate, const ScriptContextTable::LookupResult* lookup_result)
2543       : ScriptContextFieldStub(isolate, lookup_result) {}
2544
2545  private:
2546   Code::Kind kind() const override { return Code::STORE_IC; }
2547
2548   DEFINE_HANDLER_CODE_STUB(StoreScriptContextField, ScriptContextFieldStub);
2549 };
2550
2551
2552 class LoadFastElementStub : public HandlerStub {
2553  public:
2554   LoadFastElementStub(Isolate* isolate, bool is_js_array,
2555                       ElementsKind elements_kind,
2556                       bool convert_hole_to_undefined = false)
2557       : HandlerStub(isolate) {
2558     set_sub_minor_key(
2559         ElementsKindBits::encode(elements_kind) |
2560         IsJSArrayBits::encode(is_js_array) |
2561         CanConvertHoleToUndefined::encode(convert_hole_to_undefined));
2562   }
2563
2564   Code::Kind kind() const override { return Code::KEYED_LOAD_IC; }
2565
2566   bool is_js_array() const { return IsJSArrayBits::decode(sub_minor_key()); }
2567   bool convert_hole_to_undefined() const {
2568     return CanConvertHoleToUndefined::decode(sub_minor_key());
2569   }
2570
2571   ElementsKind elements_kind() const {
2572     return ElementsKindBits::decode(sub_minor_key());
2573   }
2574
2575  private:
2576   class ElementsKindBits: public BitField<ElementsKind, 0, 8> {};
2577   class IsJSArrayBits: public BitField<bool, 8, 1> {};
2578   class CanConvertHoleToUndefined : public BitField<bool, 9, 1> {};
2579
2580   DEFINE_HANDLER_CODE_STUB(LoadFastElement, HandlerStub);
2581 };
2582
2583
2584 class StoreFastElementStub : public HydrogenCodeStub {
2585  public:
2586   StoreFastElementStub(Isolate* isolate, bool is_js_array,
2587                        ElementsKind elements_kind, KeyedAccessStoreMode mode)
2588       : HydrogenCodeStub(isolate) {
2589     set_sub_minor_key(ElementsKindBits::encode(elements_kind) |
2590                       IsJSArrayBits::encode(is_js_array) |
2591                       StoreModeBits::encode(mode));
2592   }
2593
2594   static void GenerateAheadOfTime(Isolate* isolate);
2595
2596   bool is_js_array() const { return IsJSArrayBits::decode(sub_minor_key()); }
2597
2598   ElementsKind elements_kind() const {
2599     return ElementsKindBits::decode(sub_minor_key());
2600   }
2601
2602   KeyedAccessStoreMode store_mode() const {
2603     return StoreModeBits::decode(sub_minor_key());
2604   }
2605
2606  private:
2607   class ElementsKindBits: public BitField<ElementsKind,      0, 8> {};
2608   class StoreModeBits: public BitField<KeyedAccessStoreMode, 8, 4> {};
2609   class IsJSArrayBits: public BitField<bool,                12, 1> {};
2610
2611   DEFINE_CALL_INTERFACE_DESCRIPTOR(Store);
2612   DEFINE_HYDROGEN_CODE_STUB(StoreFastElement, HydrogenCodeStub);
2613 };
2614
2615
2616 class TransitionElementsKindStub : public HydrogenCodeStub {
2617  public:
2618   TransitionElementsKindStub(Isolate* isolate,
2619                              ElementsKind from_kind,
2620                              ElementsKind to_kind,
2621                              bool is_js_array) : HydrogenCodeStub(isolate) {
2622     set_sub_minor_key(FromKindBits::encode(from_kind) |
2623                       ToKindBits::encode(to_kind) |
2624                       IsJSArrayBits::encode(is_js_array));
2625   }
2626
2627   ElementsKind from_kind() const {
2628     return FromKindBits::decode(sub_minor_key());
2629   }
2630
2631   ElementsKind to_kind() const { return ToKindBits::decode(sub_minor_key()); }
2632
2633   bool is_js_array() const { return IsJSArrayBits::decode(sub_minor_key()); }
2634
2635  private:
2636   class FromKindBits: public BitField<ElementsKind, 8, 8> {};
2637   class ToKindBits: public BitField<ElementsKind, 0, 8> {};
2638   class IsJSArrayBits: public BitField<bool, 16, 1> {};
2639
2640   DEFINE_CALL_INTERFACE_DESCRIPTOR(TransitionElementsKind);
2641   DEFINE_HYDROGEN_CODE_STUB(TransitionElementsKind, HydrogenCodeStub);
2642 };
2643
2644
2645 class AllocateHeapNumberStub final : public HydrogenCodeStub {
2646  public:
2647   explicit AllocateHeapNumberStub(Isolate* isolate)
2648       : HydrogenCodeStub(isolate) {}
2649
2650  private:
2651   DEFINE_CALL_INTERFACE_DESCRIPTOR(AllocateHeapNumber);
2652   DEFINE_HYDROGEN_CODE_STUB(AllocateHeapNumber, HydrogenCodeStub);
2653 };
2654
2655
2656 class ArrayConstructorStubBase : public HydrogenCodeStub {
2657  public:
2658   ArrayConstructorStubBase(Isolate* isolate,
2659                            ElementsKind kind,
2660                            AllocationSiteOverrideMode override_mode)
2661       : HydrogenCodeStub(isolate) {
2662     // It only makes sense to override local allocation site behavior
2663     // if there is a difference between the global allocation site policy
2664     // for an ElementsKind and the desired usage of the stub.
2665     DCHECK(override_mode != DISABLE_ALLOCATION_SITES ||
2666            AllocationSite::GetMode(kind) == TRACK_ALLOCATION_SITE);
2667     set_sub_minor_key(ElementsKindBits::encode(kind) |
2668                       AllocationSiteOverrideModeBits::encode(override_mode));
2669   }
2670
2671   ElementsKind elements_kind() const {
2672     return ElementsKindBits::decode(sub_minor_key());
2673   }
2674
2675   AllocationSiteOverrideMode override_mode() const {
2676     return AllocationSiteOverrideModeBits::decode(sub_minor_key());
2677   }
2678
2679   static void GenerateStubsAheadOfTime(Isolate* isolate);
2680
2681   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
2682   static const int kConstructor = 0;
2683   static const int kAllocationSite = 1;
2684
2685  protected:
2686   std::ostream& BasePrintName(std::ostream& os,
2687                               const char* name) const;  // NOLINT
2688
2689  private:
2690   // Ensure data fits within available bits.
2691   STATIC_ASSERT(LAST_ALLOCATION_SITE_OVERRIDE_MODE == 1);
2692
2693   class ElementsKindBits: public BitField<ElementsKind, 0, 8> {};
2694   class AllocationSiteOverrideModeBits: public
2695       BitField<AllocationSiteOverrideMode, 8, 1> {};  // NOLINT
2696
2697   DEFINE_CODE_STUB_BASE(ArrayConstructorStubBase, HydrogenCodeStub);
2698 };
2699
2700
2701 class ArrayNoArgumentConstructorStub : public ArrayConstructorStubBase {
2702  public:
2703   ArrayNoArgumentConstructorStub(
2704       Isolate* isolate,
2705       ElementsKind kind,
2706       AllocationSiteOverrideMode override_mode = DONT_OVERRIDE)
2707       : ArrayConstructorStubBase(isolate, kind, override_mode) {
2708   }
2709
2710  private:
2711   void PrintName(std::ostream& os) const override {  // NOLINT
2712     BasePrintName(os, "ArrayNoArgumentConstructorStub");
2713   }
2714
2715   DEFINE_CALL_INTERFACE_DESCRIPTOR(ArrayConstructorConstantArgCount);
2716   DEFINE_HYDROGEN_CODE_STUB(ArrayNoArgumentConstructor,
2717                             ArrayConstructorStubBase);
2718 };
2719
2720
2721 class ArraySingleArgumentConstructorStub : public ArrayConstructorStubBase {
2722  public:
2723   ArraySingleArgumentConstructorStub(
2724       Isolate* isolate,
2725       ElementsKind kind,
2726       AllocationSiteOverrideMode override_mode = DONT_OVERRIDE)
2727       : ArrayConstructorStubBase(isolate, kind, override_mode) {
2728   }
2729
2730  private:
2731   void PrintName(std::ostream& os) const override {  // NOLINT
2732     BasePrintName(os, "ArraySingleArgumentConstructorStub");
2733   }
2734
2735   DEFINE_CALL_INTERFACE_DESCRIPTOR(ArrayConstructor);
2736   DEFINE_HYDROGEN_CODE_STUB(ArraySingleArgumentConstructor,
2737                             ArrayConstructorStubBase);
2738 };
2739
2740
2741 class ArrayNArgumentsConstructorStub : public ArrayConstructorStubBase {
2742  public:
2743   ArrayNArgumentsConstructorStub(
2744       Isolate* isolate,
2745       ElementsKind kind,
2746       AllocationSiteOverrideMode override_mode = DONT_OVERRIDE)
2747       : ArrayConstructorStubBase(isolate, kind, override_mode) {
2748   }
2749
2750  private:
2751   void PrintName(std::ostream& os) const override {  // NOLINT
2752     BasePrintName(os, "ArrayNArgumentsConstructorStub");
2753   }
2754
2755   DEFINE_CALL_INTERFACE_DESCRIPTOR(ArrayConstructor);
2756   DEFINE_HYDROGEN_CODE_STUB(ArrayNArgumentsConstructor,
2757                             ArrayConstructorStubBase);
2758 };
2759
2760
2761 class InternalArrayConstructorStubBase : public HydrogenCodeStub {
2762  public:
2763   InternalArrayConstructorStubBase(Isolate* isolate, ElementsKind kind)
2764       : HydrogenCodeStub(isolate) {
2765     set_sub_minor_key(ElementsKindBits::encode(kind));
2766   }
2767
2768   static void GenerateStubsAheadOfTime(Isolate* isolate);
2769
2770   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
2771   static const int kConstructor = 0;
2772
2773   ElementsKind elements_kind() const {
2774     return ElementsKindBits::decode(sub_minor_key());
2775   }
2776
2777  private:
2778   class ElementsKindBits : public BitField<ElementsKind, 0, 8> {};
2779
2780   DEFINE_CODE_STUB_BASE(InternalArrayConstructorStubBase, HydrogenCodeStub);
2781 };
2782
2783
2784 class InternalArrayNoArgumentConstructorStub : public
2785     InternalArrayConstructorStubBase {
2786  public:
2787   InternalArrayNoArgumentConstructorStub(Isolate* isolate,
2788                                          ElementsKind kind)
2789       : InternalArrayConstructorStubBase(isolate, kind) { }
2790
2791   DEFINE_CALL_INTERFACE_DESCRIPTOR(InternalArrayConstructorConstantArgCount);
2792   DEFINE_HYDROGEN_CODE_STUB(InternalArrayNoArgumentConstructor,
2793                             InternalArrayConstructorStubBase);
2794 };
2795
2796
2797 class InternalArraySingleArgumentConstructorStub : public
2798     InternalArrayConstructorStubBase {
2799  public:
2800   InternalArraySingleArgumentConstructorStub(Isolate* isolate,
2801                                              ElementsKind kind)
2802       : InternalArrayConstructorStubBase(isolate, kind) { }
2803
2804   DEFINE_CALL_INTERFACE_DESCRIPTOR(InternalArrayConstructor);
2805   DEFINE_HYDROGEN_CODE_STUB(InternalArraySingleArgumentConstructor,
2806                             InternalArrayConstructorStubBase);
2807 };
2808
2809
2810 class InternalArrayNArgumentsConstructorStub : public
2811     InternalArrayConstructorStubBase {
2812  public:
2813   InternalArrayNArgumentsConstructorStub(Isolate* isolate, ElementsKind kind)
2814       : InternalArrayConstructorStubBase(isolate, kind) { }
2815
2816   DEFINE_CALL_INTERFACE_DESCRIPTOR(InternalArrayConstructor);
2817   DEFINE_HYDROGEN_CODE_STUB(InternalArrayNArgumentsConstructor,
2818                             InternalArrayConstructorStubBase);
2819 };
2820
2821
2822 class StoreElementStub : public PlatformCodeStub {
2823  public:
2824   StoreElementStub(Isolate* isolate, ElementsKind elements_kind)
2825       : PlatformCodeStub(isolate) {
2826     minor_key_ = ElementsKindBits::encode(elements_kind);
2827   }
2828
2829  private:
2830   ElementsKind elements_kind() const {
2831     return ElementsKindBits::decode(minor_key_);
2832   }
2833
2834   class ElementsKindBits : public BitField<ElementsKind, 0, 8> {};
2835
2836   DEFINE_CALL_INTERFACE_DESCRIPTOR(Store);
2837   DEFINE_PLATFORM_CODE_STUB(StoreElement, PlatformCodeStub);
2838 };
2839
2840
2841 class ToBooleanStub: public HydrogenCodeStub {
2842  public:
2843   enum Type {
2844     UNDEFINED,
2845     BOOLEAN,
2846     NULL_TYPE,
2847     SMI,
2848     SPEC_OBJECT,
2849     STRING,
2850     SYMBOL,
2851     HEAP_NUMBER,
2852     NUMBER_OF_TYPES
2853   };
2854
2855   enum ResultMode {
2856     RESULT_AS_SMI,             // For Smi(1) on truthy value, Smi(0) otherwise.
2857     RESULT_AS_ODDBALL,         // For {true} on truthy value, {false} otherwise.
2858     RESULT_AS_INVERSE_ODDBALL  // For {false} on truthy value, {true} otherwise.
2859   };
2860
2861   // At most 16 different types can be distinguished, because the Code object
2862   // only has room for two bytes to hold a set of these types. :-P
2863   STATIC_ASSERT(NUMBER_OF_TYPES <= 16);
2864
2865   class Types : public EnumSet<Type, uint16_t> {
2866    public:
2867     Types() : EnumSet<Type, uint16_t>(0) {}
2868     explicit Types(uint16_t bits) : EnumSet<Type, uint16_t>(bits) {}
2869
2870     bool UpdateStatus(Handle<Object> object);
2871     bool NeedsMap() const;
2872     bool CanBeUndetectable() const;
2873     bool IsGeneric() const { return ToIntegral() == Generic().ToIntegral(); }
2874
2875     static Types Generic() { return Types((1 << NUMBER_OF_TYPES) - 1); }
2876   };
2877
2878   ToBooleanStub(Isolate* isolate, ResultMode mode, Types types = Types())
2879       : HydrogenCodeStub(isolate) {
2880     set_sub_minor_key(TypesBits::encode(types.ToIntegral()) |
2881                       ResultModeBits::encode(mode));
2882   }
2883
2884   ToBooleanStub(Isolate* isolate, ExtraICState state)
2885       : HydrogenCodeStub(isolate) {
2886     set_sub_minor_key(TypesBits::encode(static_cast<uint16_t>(state)) |
2887                       ResultModeBits::encode(RESULT_AS_SMI));
2888   }
2889
2890   bool UpdateStatus(Handle<Object> object);
2891   Types types() const { return Types(TypesBits::decode(sub_minor_key())); }
2892   ResultMode mode() const { return ResultModeBits::decode(sub_minor_key()); }
2893
2894   Code::Kind GetCodeKind() const override { return Code::TO_BOOLEAN_IC; }
2895   void PrintState(std::ostream& os) const override;  // NOLINT
2896
2897   bool SometimesSetsUpAFrame() override { return false; }
2898
2899   static Handle<Code> GetUninitialized(Isolate* isolate) {
2900     return ToBooleanStub(isolate, UNINITIALIZED).GetCode();
2901   }
2902
2903   ExtraICState GetExtraICState() const override { return types().ToIntegral(); }
2904
2905   InlineCacheState GetICState() const override {
2906     if (types().IsEmpty()) {
2907       return ::v8::internal::UNINITIALIZED;
2908     } else {
2909       return MONOMORPHIC;
2910     }
2911   }
2912
2913  private:
2914   ToBooleanStub(Isolate* isolate, InitializationState init_state)
2915       : HydrogenCodeStub(isolate, init_state) {
2916     set_sub_minor_key(ResultModeBits::encode(RESULT_AS_SMI));
2917   }
2918
2919   class TypesBits : public BitField<uint16_t, 0, NUMBER_OF_TYPES> {};
2920   class ResultModeBits : public BitField<ResultMode, NUMBER_OF_TYPES, 2> {};
2921
2922   DEFINE_CALL_INTERFACE_DESCRIPTOR(ToBoolean);
2923   DEFINE_HYDROGEN_CODE_STUB(ToBoolean, HydrogenCodeStub);
2924 };
2925
2926
2927 std::ostream& operator<<(std::ostream& os, const ToBooleanStub::Types& t);
2928
2929
2930 class ElementsTransitionAndStoreStub : public HydrogenCodeStub {
2931  public:
2932   ElementsTransitionAndStoreStub(Isolate* isolate, ElementsKind from_kind,
2933                                  ElementsKind to_kind, bool is_jsarray,
2934                                  KeyedAccessStoreMode store_mode)
2935       : HydrogenCodeStub(isolate) {
2936     set_sub_minor_key(FromBits::encode(from_kind) | ToBits::encode(to_kind) |
2937                       IsJSArrayBits::encode(is_jsarray) |
2938                       StoreModeBits::encode(store_mode));
2939   }
2940
2941   ElementsKind from_kind() const { return FromBits::decode(sub_minor_key()); }
2942   ElementsKind to_kind() const { return ToBits::decode(sub_minor_key()); }
2943   bool is_jsarray() const { return IsJSArrayBits::decode(sub_minor_key()); }
2944   KeyedAccessStoreMode store_mode() const {
2945     return StoreModeBits::decode(sub_minor_key());
2946   }
2947
2948   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
2949   enum ParameterIndices {
2950     kValueIndex,
2951     kMapIndex,
2952     kKeyIndex,
2953     kObjectIndex,
2954     kParameterCount
2955   };
2956
2957   static const Register ValueRegister() {
2958     return ElementTransitionAndStoreDescriptor::ValueRegister();
2959   }
2960   static const Register MapRegister() {
2961     return ElementTransitionAndStoreDescriptor::MapRegister();
2962   }
2963   static const Register KeyRegister() {
2964     return ElementTransitionAndStoreDescriptor::NameRegister();
2965   }
2966   static const Register ObjectRegister() {
2967     return ElementTransitionAndStoreDescriptor::ReceiverRegister();
2968   }
2969
2970  private:
2971   class FromBits : public BitField<ElementsKind, 0, 8> {};
2972   class ToBits : public BitField<ElementsKind, 8, 8> {};
2973   class IsJSArrayBits : public BitField<bool, 16, 1> {};
2974   class StoreModeBits : public BitField<KeyedAccessStoreMode, 17, 4> {};
2975
2976   DEFINE_CALL_INTERFACE_DESCRIPTOR(ElementTransitionAndStore);
2977   DEFINE_HYDROGEN_CODE_STUB(ElementsTransitionAndStore, HydrogenCodeStub);
2978 };
2979
2980
2981 class StoreArrayLiteralElementStub : public PlatformCodeStub {
2982  public:
2983   explicit StoreArrayLiteralElementStub(Isolate* isolate)
2984       : PlatformCodeStub(isolate) { }
2985
2986   DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreArrayLiteralElement);
2987   DEFINE_PLATFORM_CODE_STUB(StoreArrayLiteralElement, PlatformCodeStub);
2988 };
2989
2990
2991 class StubFailureTrampolineStub : public PlatformCodeStub {
2992  public:
2993   StubFailureTrampolineStub(Isolate* isolate, StubFunctionMode function_mode)
2994       : PlatformCodeStub(isolate) {
2995     minor_key_ = FunctionModeField::encode(function_mode);
2996   }
2997
2998   static void GenerateAheadOfTime(Isolate* isolate);
2999
3000  private:
3001   StubFunctionMode function_mode() const {
3002     return FunctionModeField::decode(minor_key_);
3003   }
3004
3005   class FunctionModeField : public BitField<StubFunctionMode, 0, 1> {};
3006
3007   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
3008   DEFINE_PLATFORM_CODE_STUB(StubFailureTrampoline, PlatformCodeStub);
3009 };
3010
3011
3012 class ProfileEntryHookStub : public PlatformCodeStub {
3013  public:
3014   explicit ProfileEntryHookStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
3015
3016   // The profile entry hook function is not allowed to cause a GC.
3017   bool SometimesSetsUpAFrame() override { return false; }
3018
3019   // Generates a call to the entry hook if it's enabled.
3020   static void MaybeCallEntryHook(MacroAssembler* masm);
3021
3022  private:
3023   static void EntryHookTrampoline(intptr_t function,
3024                                   intptr_t stack_pointer,
3025                                   Isolate* isolate);
3026
3027   // ProfileEntryHookStub is called at the start of a function, so it has the
3028   // same register set.
3029   DEFINE_CALL_INTERFACE_DESCRIPTOR(CallFunction)
3030   DEFINE_PLATFORM_CODE_STUB(ProfileEntryHook, PlatformCodeStub);
3031 };
3032
3033
3034 class StoreBufferOverflowStub : public PlatformCodeStub {
3035  public:
3036   StoreBufferOverflowStub(Isolate* isolate, SaveFPRegsMode save_fp)
3037       : PlatformCodeStub(isolate) {
3038     minor_key_ = SaveDoublesBits::encode(save_fp == kSaveFPRegs);
3039   }
3040
3041   static void GenerateFixedRegStubsAheadOfTime(Isolate* isolate);
3042   bool SometimesSetsUpAFrame() override { return false; }
3043
3044  private:
3045   bool save_doubles() const { return SaveDoublesBits::decode(minor_key_); }
3046
3047   class SaveDoublesBits : public BitField<bool, 0, 1> {};
3048
3049   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
3050   DEFINE_PLATFORM_CODE_STUB(StoreBufferOverflow, PlatformCodeStub);
3051 };
3052
3053
3054 class SubStringStub : public PlatformCodeStub {
3055  public:
3056   explicit SubStringStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
3057
3058   DEFINE_CALL_INTERFACE_DESCRIPTOR(ContextOnly);
3059   DEFINE_PLATFORM_CODE_STUB(SubString, PlatformCodeStub);
3060 };
3061
3062
3063 class ToNumberStub final : public PlatformCodeStub {
3064  public:
3065   explicit ToNumberStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
3066
3067   DEFINE_CALL_INTERFACE_DESCRIPTOR(ToNumber);
3068   DEFINE_PLATFORM_CODE_STUB(ToNumber, PlatformCodeStub);
3069 };
3070
3071
3072 class StringCompareStub : public PlatformCodeStub {
3073  public:
3074   explicit StringCompareStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
3075
3076   DEFINE_CALL_INTERFACE_DESCRIPTOR(ContextOnly);
3077   DEFINE_PLATFORM_CODE_STUB(StringCompare, PlatformCodeStub);
3078 };
3079
3080
3081 #undef DEFINE_CALL_INTERFACE_DESCRIPTOR
3082 #undef DEFINE_PLATFORM_CODE_STUB
3083 #undef DEFINE_HANDLER_CODE_STUB
3084 #undef DEFINE_HYDROGEN_CODE_STUB
3085 #undef DEFINE_CODE_STUB
3086 #undef DEFINE_CODE_STUB_BASE
3087
3088 extern Representation RepresentationFromType(Type* type);
3089 } }  // namespace v8::internal
3090
3091 #endif  // V8_CODE_STUBS_H_