← Back to branch summary

~yolanda.robla/ubuntu/trusty/nodejs/add_distribution

« back to all changes in this revision

Viewing changes to deps/v8/src/ic.h

  • Committer: Package Import Robot
  • Author(s): Jérémy Lal
  • Date: 2013-08-14 00:16:46 UTC
  • mfrom: (7.1.40 sid)
  • Revision ID: package-import@ubuntu.com-20130814001646-bzlysfh8sd6mukbo
Tags: 0.10.15~dfsg1-4
* Update 2005 patch, adding a handful of tests that can fail on
  slow platforms.
* Add 1004 patch to fix test failures when writing NaN to buffer
  on mipsel.

Show diffs side-by-side

added added

removed removed

Lines of Context:
deps/v8/src/ic.h
1
 
// Copyright 2011 the V8 project authors. All rights reserved.
 
1
// Copyright 2012 the V8 project authors. All rights reserved.
2
2
// Redistribution and use in source and binary forms, with or without
3
3
// modification, are permitted provided that the following conditions are
4
4
// met:
91
91
  // Construct the IC structure with the given number of extra
92
92
  // JavaScript frames on the stack.
93
93
  IC(FrameDepth depth, Isolate* isolate);
 
94
  virtual ~IC() {}
94
95
 
95
96
  // Get the call-site target; used for determining the state.
96
 
  Code* target() { return GetTargetAtAddress(address()); }
97
 
  inline Address address();
 
97
  Code* target() const { return GetTargetAtAddress(address()); }
 
98
  inline Address address() const;
 
99
 
 
100
  virtual bool IsGeneric() const { return false; }
98
101
 
99
102
  // Compute the current IC state based on the target stub, receiver and name.
100
103
  static State StateFrom(Code* target, Object* receiver, Object* name);
139
142
#ifdef ENABLE_DEBUGGER_SUPPORT
140
143
  // Computes the address in the original code when the code running is
141
144
  // containing break points (calls to DebugBreakXXX builtins).
142
 
  Address OriginalCodeAddress();
 
145
  Address OriginalCodeAddress() const;
143
146
#endif
144
147
 
145
148
  // Set the call-site target.
146
149
  void set_target(Code* code) { SetTargetAtAddress(address(), code); }
147
150
 
148
151
#ifdef DEBUG
 
152
  char TransitionMarkFromState(IC::State state);
 
153
 
149
154
  void TraceIC(const char* type,
150
155
               Handle<Object> name,
151
156
               State old_state,
160
165
  // Access the target code for the given IC address.
161
166
  static inline Code* GetTargetAtAddress(Address address);
162
167
  static inline void SetTargetAtAddress(Address address, Code* target);
 
168
  static void PostPatching(Address address, Code* target, Code* old_target);
163
169
 
164
170
 private:
165
171
  // Frame pointer for the frame that uses (calls) the IC.
198
204
  class Contextual: public BitField<bool, 0, 1> {};
199
205
  class StringStubState: public BitField<StringStubFeedback, 1, 1> {};
200
206
 
 
207
  // Returns a JSFunction or a Failure.
 
208
  MUST_USE_RESULT MaybeObject* LoadFunction(State state,
 
209
                                            Code::ExtraICState extra_ic_state,
 
210
                                            Handle<Object> object,
 
211
                                            Handle<String> name);
 
212
 
201
213
 protected:
202
214
  CallICBase(Code::Kind kind, Isolate* isolate)
203
215
      : IC(EXTRA_CALL_FRAME, isolate), kind_(kind) {}
204
216
 
205
 
 public:
206
 
  MUST_USE_RESULT MaybeObject* LoadFunction(State state,
207
 
                                            Code::ExtraICState extra_ic_state,
208
 
                                            Handle<Object> object,
209
 
                                            Handle<String> name);
210
 
 
211
 
 protected:
212
 
  Code::Kind kind_;
213
 
 
214
217
  bool TryUpdateExtraICState(LookupResult* lookup,
215
218
                             Handle<Object> object,
216
219
                             Code::ExtraICState* extra_ic_state);
217
220
 
218
 
  MUST_USE_RESULT MaybeObject* ComputeMonomorphicStub(
219
 
      LookupResult* lookup,
220
 
      State state,
221
 
      Code::ExtraICState extra_ic_state,
222
 
      Handle<Object> object,
223
 
      Handle<String> name);
 
221
  // Compute a monomorphic stub if possible, otherwise return a null handle.
 
222
  Handle<Code> ComputeMonomorphicStub(LookupResult* lookup,
 
223
                                      State state,
 
224
                                      Code::ExtraICState extra_state,
 
225
                                      Handle<Object> object,
 
226
                                      Handle<String> name);
224
227
 
225
 
  // Update the inline cache and the global stub cache based on the
226
 
  // lookup result.
 
228
  // Update the inline cache and the global stub cache based on the lookup
 
229
  // result.
227
230
  void UpdateCaches(LookupResult* lookup,
228
231
                    State state,
229
232
                    Code::ExtraICState extra_ic_state,
230
233
                    Handle<Object> object,
231
234
                    Handle<String> name);
232
235
 
233
 
  // Returns a JSFunction if the object can be called as a function,
234
 
  // and patches the stack to be ready for the call.
235
 
  // Otherwise, it returns the undefined value.
236
 
  Object* TryCallAsFunction(Object* object);
 
236
  // Returns a JSFunction if the object can be called as a function, and
 
237
  // patches the stack to be ready for the call.  Otherwise, it returns the
 
238
  // undefined value.
 
239
  Handle<Object> TryCallAsFunction(Handle<Object> object);
237
240
 
238
241
  void ReceiverToObjectIfRequired(Handle<Object> callee, Handle<Object> object);
239
242
 
240
243
  static void Clear(Address address, Code* target);
241
244
 
 
245
  // Platform-specific code generation functions used by both call and
 
246
  // keyed call.
 
247
  static void GenerateMiss(MacroAssembler* masm,
 
248
                           int argc,
 
249
                           IC::UtilityId id,
 
250
                           Code::ExtraICState extra_state);
 
251
 
 
252
  static void GenerateNormal(MacroAssembler* masm, int argc);
 
253
 
 
254
  static void GenerateMonomorphicCacheProbe(MacroAssembler* masm,
 
255
                                            int argc,
 
256
                                            Code::Kind kind,
 
257
                                            Code::ExtraICState extra_state);
 
258
 
 
259
  Code::Kind kind_;
 
260
 
242
261
  friend class IC;
243
262
};
244
263
 
252
271
  // Code generator routines.
253
272
  static void GenerateInitialize(MacroAssembler* masm,
254
273
                                 int argc,
255
 
                                 Code::ExtraICState extra_ic_state) {
256
 
    GenerateMiss(masm, argc, extra_ic_state);
 
274
                                 Code::ExtraICState extra_state) {
 
275
    GenerateMiss(masm, argc, extra_state);
257
276
  }
 
277
 
258
278
  static void GenerateMiss(MacroAssembler* masm,
259
279
                           int argc,
260
 
                           Code::ExtraICState extra_ic_state);
 
280
                           Code::ExtraICState extra_state) {
 
281
    CallICBase::GenerateMiss(masm, argc, IC::kCallIC_Miss, extra_state);
 
282
  }
 
283
 
261
284
  static void GenerateMegamorphic(MacroAssembler* masm,
262
285
                                  int argc,
263
286
                                  Code::ExtraICState extra_ic_state);
264
 
  static void GenerateNormal(MacroAssembler* masm, int argc);
 
287
 
 
288
  static void GenerateNormal(MacroAssembler* masm, int argc) {
 
289
    CallICBase::GenerateNormal(masm, argc);
 
290
    GenerateMiss(masm, argc, Code::kNoExtraICState);
 
291
  }
265
292
};
266
293
 
267
294
 
280
307
  static void GenerateInitialize(MacroAssembler* masm, int argc) {
281
308
    GenerateMiss(masm, argc);
282
309
  }
283
 
  static void GenerateMiss(MacroAssembler* masm, int argc);
 
310
 
 
311
  static void GenerateMiss(MacroAssembler* masm, int argc) {
 
312
    CallICBase::GenerateMiss(masm, argc, IC::kKeyedCallIC_Miss,
 
313
                             Code::kNoExtraICState);
 
314
  }
 
315
 
284
316
  static void GenerateMegamorphic(MacroAssembler* masm, int argc);
285
317
  static void GenerateNormal(MacroAssembler* masm, int argc);
286
318
  static void GenerateNonStrictArguments(MacroAssembler* masm, int argc);
321
353
                    Handle<String> name);
322
354
 
323
355
  // Stub accessors.
324
 
  Code* megamorphic_stub() {
325
 
    return isolate()->builtins()->builtin(
326
 
        Builtins::kLoadIC_Megamorphic);
 
356
  Handle<Code> megamorphic_stub() {
 
357
    return isolate()->builtins()->LoadIC_Megamorphic();
327
358
  }
328
359
  static Code* initialize_stub() {
329
360
    return Isolate::Current()->builtins()->builtin(
330
361
        Builtins::kLoadIC_Initialize);
331
362
  }
332
 
  Code* pre_monomorphic_stub() {
333
 
    return isolate()->builtins()->builtin(
334
 
        Builtins::kLoadIC_PreMonomorphic);
 
363
  Handle<Code> pre_monomorphic_stub() {
 
364
    return isolate()->builtins()->LoadIC_PreMonomorphic();
335
365
  }
336
366
 
337
367
  static void Clear(Address address, Code* target);
342
372
 
343
373
class KeyedIC: public IC {
344
374
 public:
 
375
  enum StubKind {
 
376
    LOAD,
 
377
    STORE_NO_TRANSITION,
 
378
    STORE_TRANSITION_SMI_TO_OBJECT,
 
379
    STORE_TRANSITION_SMI_TO_DOUBLE,
 
380
    STORE_TRANSITION_DOUBLE_TO_OBJECT,
 
381
    STORE_TRANSITION_HOLEY_SMI_TO_OBJECT,
 
382
    STORE_TRANSITION_HOLEY_SMI_TO_DOUBLE,
 
383
    STORE_TRANSITION_HOLEY_DOUBLE_TO_OBJECT,
 
384
    STORE_AND_GROW_NO_TRANSITION,
 
385
    STORE_AND_GROW_TRANSITION_SMI_TO_OBJECT,
 
386
    STORE_AND_GROW_TRANSITION_SMI_TO_DOUBLE,
 
387
    STORE_AND_GROW_TRANSITION_DOUBLE_TO_OBJECT,
 
388
    STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_OBJECT,
 
389
    STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_DOUBLE,
 
390
    STORE_AND_GROW_TRANSITION_HOLEY_DOUBLE_TO_OBJECT
 
391
  };
 
392
 
 
393
  static const int kGrowICDelta = STORE_AND_GROW_NO_TRANSITION -
 
394
      STORE_NO_TRANSITION;
 
395
  STATIC_ASSERT(kGrowICDelta ==
 
396
                STORE_AND_GROW_TRANSITION_SMI_TO_OBJECT -
 
397
                STORE_TRANSITION_SMI_TO_OBJECT);
 
398
  STATIC_ASSERT(kGrowICDelta ==
 
399
                STORE_AND_GROW_TRANSITION_SMI_TO_DOUBLE -
 
400
                STORE_TRANSITION_SMI_TO_DOUBLE);
 
401
  STATIC_ASSERT(kGrowICDelta ==
 
402
                STORE_AND_GROW_TRANSITION_DOUBLE_TO_OBJECT -
 
403
                STORE_TRANSITION_DOUBLE_TO_OBJECT);
 
404
 
345
405
  explicit KeyedIC(Isolate* isolate) : IC(NO_EXTRA_FRAME, isolate) {}
346
406
  virtual ~KeyedIC() {}
347
407
 
348
 
  virtual MaybeObject* GetElementStubWithoutMapCheck(
 
408
  static inline KeyedAccessGrowMode GetGrowModeFromStubKind(
 
409
      StubKind stub_kind) {
 
410
    return (stub_kind >= STORE_AND_GROW_NO_TRANSITION)
 
411
        ? ALLOW_JSARRAY_GROWTH
 
412
        : DO_NOT_ALLOW_JSARRAY_GROWTH;
 
413
  }
 
414
 
 
415
  static inline StubKind GetGrowStubKind(StubKind stub_kind) {
 
416
    ASSERT(stub_kind != LOAD);
 
417
    if (stub_kind < STORE_AND_GROW_NO_TRANSITION) {
 
418
      stub_kind = static_cast<StubKind>(static_cast<int>(stub_kind) +
 
419
                                        kGrowICDelta);
 
420
    }
 
421
    return stub_kind;
 
422
  }
 
423
 
 
424
  virtual Handle<Code> GetElementStubWithoutMapCheck(
349
425
      bool is_js_array,
350
 
      ElementsKind elements_kind) = 0;
 
426
      ElementsKind elements_kind,
 
427
      KeyedAccessGrowMode grow_mode) = 0;
351
428
 
352
429
 protected:
353
 
  virtual Code* string_stub() {
354
 
    return NULL;
 
430
  virtual Handle<Code> string_stub() {
 
431
    return Handle<Code>::null();
355
432
  }
356
433
 
357
434
  virtual Code::Kind kind() const = 0;
358
435
 
359
 
  MaybeObject* ComputeStub(JSObject* receiver,
360
 
                           bool is_store,
 
436
  Handle<Code> ComputeStub(Handle<JSObject> receiver,
 
437
                           StubKind stub_kind,
361
438
                           StrictModeFlag strict_mode,
362
 
                           Code* default_stub);
363
 
 
364
 
  virtual MaybeObject* ConstructMegamorphicStub(
365
 
      MapList* receiver_maps,
366
 
      CodeList* targets,
367
 
      StrictModeFlag strict_mode) = 0;
 
439
                           Handle<Code> default_stub);
 
440
 
 
441
  virtual Handle<Code> ComputePolymorphicStub(
 
442
      MapHandleList* receiver_maps,
 
443
      StrictModeFlag strict_mode,
 
444
      KeyedAccessGrowMode grow_mode) = 0;
 
445
 
 
446
  Handle<Code> ComputeMonomorphicStubWithoutMapCheck(
 
447
      Handle<Map> receiver_map,
 
448
      StrictModeFlag strict_mode,
 
449
      KeyedAccessGrowMode grow_mode);
368
450
 
369
451
 private:
370
 
  void GetReceiverMapsForStub(Code* stub, MapList* result);
371
 
 
372
 
  MaybeObject* ComputeMonomorphicStubWithoutMapCheck(
373
 
      Map* receiver_map,
374
 
      StrictModeFlag strict_mode);
375
 
 
376
 
  MaybeObject* ComputeMonomorphicStub(JSObject* receiver,
377
 
                                      bool is_store,
 
452
  void GetReceiverMapsForStub(Handle<Code> stub, MapHandleList* result);
 
453
 
 
454
  Handle<Code> ComputeMonomorphicStub(Handle<Map> receiver_map,
 
455
                                      StubKind stub_kind,
378
456
                                      StrictModeFlag strict_mode,
379
 
                                      Code* default_stub);
 
457
                                      Handle<Code> default_stub);
 
458
 
 
459
  Handle<Map> ComputeTransitionedMap(Handle<JSObject> receiver,
 
460
                                     StubKind stub_kind);
 
461
 
 
462
  static bool IsTransitionStubKind(StubKind stub_kind) {
 
463
    return stub_kind > STORE_NO_TRANSITION &&
 
464
        stub_kind != STORE_AND_GROW_NO_TRANSITION;
 
465
  }
 
466
 
 
467
  static bool IsGrowStubKind(StubKind stub_kind) {
 
468
    return stub_kind >= STORE_AND_GROW_NO_TRANSITION;
 
469
  }
 
470
 
 
471
  static StubKind GetNoTransitionStubKind(StubKind stub_kind) {
 
472
    if (!IsTransitionStubKind(stub_kind)) return stub_kind;
 
473
    if (IsGrowStubKind(stub_kind)) return STORE_AND_GROW_NO_TRANSITION;
 
474
    return STORE_NO_TRANSITION;
 
475
  }
380
476
};
381
477
 
382
478
 
412
508
  static const int kSlowCaseBitFieldMask =
413
509
      (1 << Map::kIsAccessCheckNeeded) | (1 << Map::kHasIndexedInterceptor);
414
510
 
415
 
  virtual MaybeObject* GetElementStubWithoutMapCheck(
 
511
  virtual Handle<Code> GetElementStubWithoutMapCheck(
416
512
      bool is_js_array,
417
 
      ElementsKind elements_kind);
 
513
      ElementsKind elements_kind,
 
514
      KeyedAccessGrowMode grow_mode);
 
515
 
 
516
  virtual bool IsGeneric() const {
 
517
    return target() == *generic_stub();
 
518
  }
418
519
 
419
520
 protected:
420
521
  virtual Code::Kind kind() const { return Code::KEYED_LOAD_IC; }
421
522
 
422
 
  virtual MaybeObject* ConstructMegamorphicStub(
423
 
      MapList* receiver_maps,
424
 
      CodeList* targets,
425
 
      StrictModeFlag strict_mode);
 
523
  virtual Handle<Code> ComputePolymorphicStub(MapHandleList* receiver_maps,
 
524
                                              StrictModeFlag strict_mode,
 
525
                                              KeyedAccessGrowMode grow_mode);
426
526
 
427
 
  virtual Code* string_stub() {
428
 
    return isolate()->builtins()->builtin(
429
 
        Builtins::kKeyedLoadIC_String);
 
527
  virtual Handle<Code> string_stub() {
 
528
    return isolate()->builtins()->KeyedLoadIC_String();
430
529
  }
431
530
 
432
531
 private:
441
540
    return Isolate::Current()->builtins()->builtin(
442
541
        Builtins::kKeyedLoadIC_Initialize);
443
542
  }
444
 
  Code* megamorphic_stub() {
445
 
    return isolate()->builtins()->builtin(
446
 
        Builtins::kKeyedLoadIC_Generic);
447
 
  }
448
 
  Code* generic_stub() {
449
 
    return isolate()->builtins()->builtin(
450
 
        Builtins::kKeyedLoadIC_Generic);
451
 
  }
452
 
  Code* pre_monomorphic_stub() {
453
 
    return isolate()->builtins()->builtin(
454
 
        Builtins::kKeyedLoadIC_PreMonomorphic);
455
 
  }
456
 
  Code* indexed_interceptor_stub() {
457
 
    return isolate()->builtins()->builtin(
458
 
        Builtins::kKeyedLoadIC_IndexedInterceptor);
459
 
  }
460
 
  Code* non_strict_arguments_stub() {
461
 
    return isolate()->builtins()->builtin(
462
 
        Builtins::kKeyedLoadIC_NonStrictArguments);
 
543
  Handle<Code> megamorphic_stub() {
 
544
    return isolate()->builtins()->KeyedLoadIC_Generic();
 
545
  }
 
546
  Handle<Code> generic_stub() const {
 
547
    return isolate()->builtins()->KeyedLoadIC_Generic();
 
548
  }
 
549
  Handle<Code> pre_monomorphic_stub() {
 
550
    return isolate()->builtins()->KeyedLoadIC_PreMonomorphic();
 
551
  }
 
552
  Handle<Code> indexed_interceptor_stub() {
 
553
    return isolate()->builtins()->KeyedLoadIC_IndexedInterceptor();
 
554
  }
 
555
  Handle<Code> non_strict_arguments_stub() {
 
556
    return isolate()->builtins()->KeyedLoadIC_NonStrictArguments();
463
557
  }
464
558
 
465
559
  static void Clear(Address address, Code* target);
502
596
 
503
597
  void set_target(Code* code) {
504
598
    // Strict mode must be preserved across IC patching.
505
 
    ASSERT((code->extra_ic_state() & kStrictMode) ==
506
 
           (target()->extra_ic_state() & kStrictMode));
 
599
    ASSERT(Code::GetStrictMode(code->extra_ic_state()) ==
 
600
           Code::GetStrictMode(target()->extra_ic_state()));
507
601
    IC::set_target(code);
508
602
  }
509
603
 
524
618
    return Isolate::Current()->builtins()->builtin(
525
619
        Builtins::kStoreIC_Initialize_Strict);
526
620
  }
527
 
  Code* global_proxy_stub() {
528
 
    return isolate()->builtins()->builtin(
529
 
        Builtins::kStoreIC_GlobalProxy);
 
621
  Handle<Code> global_proxy_stub() {
 
622
    return isolate()->builtins()->StoreIC_GlobalProxy();
530
623
  }
531
 
  Code* global_proxy_stub_strict() {
532
 
    return isolate()->builtins()->builtin(
533
 
        Builtins::kStoreIC_GlobalProxy_Strict);
 
624
  Handle<Code> global_proxy_stub_strict() {
 
625
    return isolate()->builtins()->StoreIC_GlobalProxy_Strict();
534
626
  }
535
627
 
536
628
  static void Clear(Address address, Code* target);
539
631
};
540
632
 
541
633
 
 
634
enum KeyedStoreCheckMap {
 
635
  kDontCheckMap,
 
636
  kCheckMap
 
637
};
 
638
 
 
639
 
 
640
enum KeyedStoreIncrementLength {
 
641
  kDontIncrementLength,
 
642
  kIncrementLength
 
643
};
 
644
 
 
645
 
542
646
class KeyedStoreIC: public KeyedIC {
543
647
 public:
544
648
  explicit KeyedStoreIC(Isolate* isolate) : KeyedIC(isolate) {
546
650
  }
547
651
 
548
652
  MUST_USE_RESULT MaybeObject* Store(State state,
549
 
                                   StrictModeFlag strict_mode,
 
653
                                     StrictModeFlag strict_mode,
550
654
                                     Handle<Object> object,
551
655
                                     Handle<Object> name,
552
656
                                     Handle<Object> value,
562
666
                                         StrictModeFlag strict_mode);
563
667
  static void GenerateGeneric(MacroAssembler* masm, StrictModeFlag strict_mode);
564
668
  static void GenerateNonStrictArguments(MacroAssembler* masm);
 
669
  static void GenerateTransitionElementsSmiToDouble(MacroAssembler* masm);
 
670
  static void GenerateTransitionElementsDoubleToObject(MacroAssembler* masm);
565
671
 
566
 
  virtual MaybeObject* GetElementStubWithoutMapCheck(
 
672
  virtual Handle<Code> GetElementStubWithoutMapCheck(
567
673
      bool is_js_array,
568
 
      ElementsKind elements_kind);
 
674
      ElementsKind elements_kind,
 
675
      KeyedAccessGrowMode grow_mode);
 
676
 
 
677
  virtual bool IsGeneric() const {
 
678
    return target() == *generic_stub() ||
 
679
        target() == *generic_stub_strict();
 
680
  }
569
681
 
570
682
 protected:
571
683
  virtual Code::Kind kind() const { return Code::KEYED_STORE_IC; }
572
684
 
573
 
  virtual MaybeObject* ConstructMegamorphicStub(
574
 
      MapList* receiver_maps,
575
 
      CodeList* targets,
576
 
      StrictModeFlag strict_mode);
 
685
  virtual Handle<Code> ComputePolymorphicStub(MapHandleList* receiver_maps,
 
686
                                              StrictModeFlag strict_mode,
 
687
                                              KeyedAccessGrowMode grow_mode);
577
688
 
578
689
  private:
579
690
  // Update the inline cache.
586
697
 
587
698
  void set_target(Code* code) {
588
699
    // Strict mode must be preserved across IC patching.
589
 
    ASSERT((code->extra_ic_state() & kStrictMode) ==
590
 
           (target()->extra_ic_state() & kStrictMode));
 
700
    ASSERT(Code::GetStrictMode(code->extra_ic_state()) ==
 
701
           Code::GetStrictMode(target()->extra_ic_state()));
591
702
    IC::set_target(code);
592
703
  }
593
704
 
596
707
    return Isolate::Current()->builtins()->builtin(
597
708
        Builtins::kKeyedStoreIC_Initialize);
598
709
  }
599
 
  Code* megamorphic_stub() {
600
 
    return isolate()->builtins()->builtin(
601
 
        Builtins::kKeyedStoreIC_Generic);
602
 
  }
603
710
  static Code* initialize_stub_strict() {
604
711
    return Isolate::Current()->builtins()->builtin(
605
712
        Builtins::kKeyedStoreIC_Initialize_Strict);
606
713
  }
607
 
  Code* megamorphic_stub_strict() {
608
 
    return isolate()->builtins()->builtin(
609
 
        Builtins::kKeyedStoreIC_Generic_Strict);
610
 
  }
611
 
  Code* generic_stub() {
612
 
    return isolate()->builtins()->builtin(
613
 
        Builtins::kKeyedStoreIC_Generic);
614
 
  }
615
 
  Code* generic_stub_strict() {
616
 
    return isolate()->builtins()->builtin(
617
 
        Builtins::kKeyedStoreIC_Generic_Strict);
618
 
  }
619
 
  Code* non_strict_arguments_stub() {
620
 
    return isolate()->builtins()->builtin(
621
 
        Builtins::kKeyedStoreIC_NonStrictArguments);
 
714
  Handle<Code> megamorphic_stub() {
 
715
    return isolate()->builtins()->KeyedStoreIC_Generic();
 
716
  }
 
717
  Handle<Code> megamorphic_stub_strict() {
 
718
    return isolate()->builtins()->KeyedStoreIC_Generic_Strict();
 
719
  }
 
720
  Handle<Code> generic_stub() const {
 
721
    return isolate()->builtins()->KeyedStoreIC_Generic();
 
722
  }
 
723
  Handle<Code> generic_stub_strict() const {
 
724
    return isolate()->builtins()->KeyedStoreIC_Generic_Strict();
 
725
  }
 
726
  Handle<Code> non_strict_arguments_stub() {
 
727
    return isolate()->builtins()->KeyedStoreIC_NonStrictArguments();
622
728
  }
623
729
 
624
730
  static void Clear(Address address, Code* target);
625
731
 
 
732
  StubKind GetStubKind(Handle<JSObject> receiver,
 
733
                       Handle<Object> key,
 
734
                       Handle<Object> value);
 
735
 
626
736
  friend class IC;
627
737
};
628
738
 
689
799
    SYMBOLS,
690
800
    STRINGS,
691
801
    OBJECTS,
 
802
    KNOWN_OBJECTS,
692
803
    GENERIC
693
804
  };
694
805
 
707
818
  // Helper function for determining the state of a compare IC.
708
819
  static State ComputeState(Code* target);
709
820
 
 
821
  // Helper function for determining the operation a compare IC is for.
 
822
  static Token::Value ComputeOperation(Code* target);
 
823
 
710
824
  static const char* GetStateName(State state);
711
825
 
712
826
 private:
717
831
  Condition GetCondition() const { return ComputeCondition(op_); }
718
832
  State GetState() { return ComputeState(target()); }
719
833
 
 
834
  static Code* GetRawUninitialized(Token::Value op);
 
835
 
 
836
  static void Clear(Address address, Code* target);
 
837
 
720
838
  Token::Value op_;
 
839
 
 
840
  friend class IC;
721
841
};
722
842
 
723
843
 
730
850
 
731
851
 
732
852
// Helper for BinaryOpIC and CompareIC.
733
 
void PatchInlinedSmiCode(Address address);
 
853
enum InlinedSmiCheck { ENABLE_INLINED_SMI_CHECK, DISABLE_INLINED_SMI_CHECK };
 
854
void PatchInlinedSmiCode(Address address, InlinedSmiCheck check);
734
855
 
735
856
} }  // namespace v8::internal
736
857