LCOV - code coverage report
Current view: top level - src/ic - accessor-assembler.h (source / functions) Hit Total Coverage
Test: app.info Lines: 30 30 100.0 %
Date: 2017-04-26 Functions: 10 10 100.0 %

          Line data    Source code
       1             : // Copyright 2016 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_SRC_IC_ACCESSOR_ASSEMBLER_H_
       6             : #define V8_SRC_IC_ACCESSOR_ASSEMBLER_H_
       7             : 
       8             : #include "src/code-stub-assembler.h"
       9             : 
      10             : namespace v8 {
      11             : namespace internal {
      12             : 
      13             : namespace compiler {
      14             : class CodeAssemblerState;
      15             : }
      16             : 
      17             : class ExitPoint;
      18             : 
      19             : class AccessorAssembler : public CodeStubAssembler {
      20             :  public:
      21             :   typedef compiler::Node Node;
      22             : 
      23             :   explicit AccessorAssembler(compiler::CodeAssemblerState* state)
      24        1720 :       : CodeStubAssembler(state) {}
      25             : 
      26             :   void GenerateLoadIC();
      27             :   void GenerateLoadIC_Noninlined();
      28             :   void GenerateLoadIC_Uninitialized();
      29             :   void GenerateLoadField();
      30             :   void GenerateLoadICTrampoline();
      31             :   void GenerateKeyedLoadIC();
      32             :   void GenerateKeyedLoadICTrampoline();
      33             :   void GenerateKeyedLoadIC_Megamorphic();
      34             :   void GenerateStoreIC(LanguageMode language_mode);
      35             :   void GenerateStoreICTrampoline(LanguageMode language_mode);
      36             : 
      37             :   void GenerateLoadICProtoArray(bool throw_reference_error_if_nonexistent);
      38             : 
      39             :   void GenerateLoadGlobalIC(TypeofMode typeof_mode);
      40             :   void GenerateLoadGlobalICTrampoline(TypeofMode typeof_mode);
      41             : 
      42             :   void GenerateKeyedStoreIC(LanguageMode language_mode);
      43             :   void GenerateKeyedStoreICTrampoline(LanguageMode language_mode);
      44             : 
      45             :   void TryProbeStubCache(StubCache* stub_cache, Node* receiver, Node* name,
      46             :                          Label* if_handler, Variable* var_handler,
      47             :                          Label* if_miss);
      48             : 
      49             :   Node* StubCachePrimaryOffsetForTesting(Node* name, Node* map) {
      50             :     return StubCachePrimaryOffset(name, map);
      51             :   }
      52             :   Node* StubCacheSecondaryOffsetForTesting(Node* name, Node* map) {
      53             :     return StubCacheSecondaryOffset(name, map);
      54             :   }
      55             : 
      56             :   struct LoadICParameters {
      57             :     LoadICParameters(Node* context, Node* receiver, Node* name, Node* slot,
      58             :                      Node* vector)
      59             :         : context(context),
      60             :           receiver(receiver),
      61             :           name(name),
      62             :           slot(slot),
      63        1892 :           vector(vector) {}
      64             : 
      65             :     Node* context;
      66             :     Node* receiver;
      67             :     Node* name;
      68             :     Node* slot;
      69             :     Node* vector;
      70             :   };
      71             : 
      72             :   void LoadGlobalIC_TryPropertyCellCase(
      73             :       Node* vector, Node* slot, ExitPoint* exit_point, Label* try_handler,
      74             :       Label* miss, ParameterMode slot_mode = SMI_PARAMETERS);
      75             :   void LoadGlobalIC_TryHandlerCase(const LoadICParameters* p,
      76             :                                    TypeofMode typeof_mode,
      77             :                                    ExitPoint* exit_point, Label* miss);
      78             :   void LoadGlobalIC_MissCase(const LoadICParameters* p, ExitPoint* exit_point);
      79             : 
      80             :   // Specialized LoadIC for inlined bytecode handler, hand-tuned to omit frame
      81             :   // construction on common paths.
      82             :   void LoadIC_BytecodeHandler(const LoadICParameters* p, ExitPoint* exit_point);
      83             : 
      84             :  protected:
      85             :   struct StoreICParameters : public LoadICParameters {
      86             :     StoreICParameters(Node* context, Node* receiver, Node* name, Node* value,
      87             :                       Node* slot, Node* vector)
      88             :         : LoadICParameters(context, receiver, name, slot, vector),
      89         344 :           value(value) {}
      90             :     Node* value;
      91             :   };
      92             : 
      93             :   enum ElementSupport { kOnlyProperties, kSupportElements };
      94             :   void HandleStoreICHandlerCase(
      95             :       const StoreICParameters* p, Node* handler, Label* miss,
      96             :       ElementSupport support_elements = kOnlyProperties);
      97             :   void JumpIfDataProperty(Node* details, Label* writable, Label* readonly);
      98             : 
      99             :  private:
     100             :   // Stub generation entry points.
     101             : 
     102             :   // LoadIC contains the full LoadIC logic, while LoadIC_Noninlined contains
     103             :   // logic not inlined into Ignition bytecode handlers.
     104             :   void LoadIC(const LoadICParameters* p);
     105             :   void LoadIC_Noninlined(const LoadICParameters* p, Node* receiver_map,
     106             :                          Node* feedback, Variable* var_handler,
     107             :                          Label* if_handler, Label* miss, ExitPoint* exit_point);
     108             : 
     109             :   void LoadIC_Uninitialized(const LoadICParameters* p);
     110             :   void LoadICProtoArray(const LoadICParameters* p, Node* handler,
     111             :                         bool throw_reference_error_if_nonexistent);
     112             :   void LoadGlobalIC(const LoadICParameters* p, TypeofMode typeof_mode);
     113             :   void KeyedLoadIC(const LoadICParameters* p);
     114             :   void KeyedLoadICGeneric(const LoadICParameters* p);
     115             :   void StoreIC(const StoreICParameters* p, LanguageMode language_mode);
     116             :   void KeyedStoreIC(const StoreICParameters* p, LanguageMode language_mode);
     117             : 
     118             :   // IC dispatcher behavior.
     119             : 
     120             :   // Checks monomorphic case. Returns {feedback} entry of the vector.
     121             :   Node* TryMonomorphicCase(Node* slot, Node* vector, Node* receiver_map,
     122             :                            Label* if_handler, Variable* var_handler,
     123             :                            Label* if_miss);
     124             :   void HandlePolymorphicCase(Node* receiver_map, Node* feedback,
     125             :                              Label* if_handler, Variable* var_handler,
     126             :                              Label* if_miss, int min_feedback_capacity);
     127             : 
     128             :   // LoadIC implementation.
     129             : 
     130             :   void HandleLoadICHandlerCase(
     131             :       const LoadICParameters* p, Node* handler, Label* miss,
     132             :       ExitPoint* exit_point, ElementSupport support_elements = kOnlyProperties);
     133             : 
     134             :   void HandleLoadICSmiHandlerCase(const LoadICParameters* p, Node* holder,
     135             :                                   Node* smi_handler, Label* miss,
     136             :                                   ExitPoint* exit_point,
     137             :                                   bool throw_reference_error_if_nonexistent,
     138             :                                   ElementSupport support_elements);
     139             : 
     140             :   void HandleLoadICProtoHandlerCase(const LoadICParameters* p, Node* handler,
     141             :                                     Variable* var_holder,
     142             :                                     Variable* var_smi_handler,
     143             :                                     Label* if_smi_handler, Label* miss,
     144             :                                     ExitPoint* exit_point,
     145             :                                     bool throw_reference_error_if_nonexistent);
     146             : 
     147             :   void HandleLoadField(Node* holder, Node* handler_word,
     148             :                        Variable* var_double_value, Label* rebox_double,
     149             :                        ExitPoint* exit_point);
     150             : 
     151             :   Node* EmitLoadICProtoArrayCheck(const LoadICParameters* p, Node* handler,
     152             :                                   Node* handler_length, Node* handler_flags,
     153             :                                   Label* miss);
     154             : 
     155             :   // LoadGlobalIC implementation.
     156             : 
     157             :   void HandleLoadGlobalICHandlerCase(const LoadICParameters* p, Node* handler,
     158             :                                      Label* miss, ExitPoint* exit_point,
     159             :                                      bool throw_reference_error_if_nonexistent);
     160             : 
     161             :   // StoreIC implementation.
     162             : 
     163             :   void HandleStoreICElementHandlerCase(const StoreICParameters* p,
     164             :                                        Node* handler, Label* miss);
     165             : 
     166             :   void HandleStoreICProtoHandler(const StoreICParameters* p, Node* handler,
     167             :                                  Label* miss, ElementSupport support_elements);
     168             :   // If |transition| is nullptr then the normal field store is generated or
     169             :   // transitioning store otherwise.
     170             :   void HandleStoreICSmiHandlerCase(Node* handler_word, Node* holder,
     171             :                                    Node* value, Node* transition, Label* miss);
     172             :   // If |transition| is nullptr then the normal field store is generated or
     173             :   // transitioning store otherwise.
     174             :   void HandleStoreFieldAndReturn(Node* handler_word, Node* holder,
     175             :                                  Representation representation, Node* value,
     176             :                                  Node* transition, Label* miss);
     177             : 
     178             :   // KeyedLoadIC_Generic implementation.
     179             : 
     180             :   void GenericElementLoad(Node* receiver, Node* receiver_map,
     181             :                           Node* instance_type, Node* index, Label* slow);
     182             : 
     183             :   enum UseStubCache { kUseStubCache, kDontUseStubCache };
     184             :   void GenericPropertyLoad(Node* receiver, Node* receiver_map,
     185             :                            Node* instance_type, Node* key,
     186             :                            const LoadICParameters* p, Label* slow,
     187             :                            UseStubCache use_stub_cache = kUseStubCache);
     188             : 
     189             :   // Low-level helpers.
     190             : 
     191             :   Node* PrepareValueForStore(Node* handler_word, Node* holder,
     192             :                              Representation representation, Node* transition,
     193             :                              Node* value, Label* bailout);
     194             : 
     195             :   // Extends properties backing store by JSObject::kFieldsAdded elements.
     196             :   void ExtendPropertiesBackingStore(Node* object, Node* handler_word);
     197             : 
     198             :   void StoreNamedField(Node* handler_word, Node* object, bool is_inobject,
     199             :                        Representation representation, Node* value,
     200             :                        bool transition_to_field, Label* bailout);
     201             : 
     202             :   void EmitFastElementsBoundsCheck(Node* object, Node* elements,
     203             :                                    Node* intptr_index,
     204             :                                    Node* is_jsarray_condition, Label* miss);
     205             :   void EmitElementLoad(Node* object, Node* elements, Node* elements_kind,
     206             :                        Node* key, Node* is_jsarray_condition, Label* if_hole,
     207             :                        Label* rebox_double, Variable* var_double_value,
     208             :                        Label* unimplemented_elements_kind, Label* out_of_bounds,
     209             :                        Label* miss, ExitPoint* exit_point);
     210             :   void CheckPrototype(Node* prototype_cell, Node* name, Label* miss);
     211             :   void NameDictionaryNegativeLookup(Node* object, Node* name, Label* miss);
     212             : 
     213             :   // Stub cache access helpers.
     214             : 
     215             :   // This enum is used here as a replacement for StubCache::Table to avoid
     216             :   // including stub cache header.
     217             :   enum StubCacheTable : int;
     218             : 
     219             :   Node* StubCachePrimaryOffset(Node* name, Node* map);
     220             :   Node* StubCacheSecondaryOffset(Node* name, Node* seed);
     221             : 
     222             :   void TryProbeStubCacheTable(StubCache* stub_cache, StubCacheTable table_id,
     223             :                               Node* entry_offset, Node* name, Node* map,
     224             :                               Label* if_handler, Variable* var_handler,
     225             :                               Label* if_miss);
     226             : };
     227             : 
     228             : // Abstraction over direct and indirect exit points. Direct exits correspond to
     229             : // tailcalls and Return, while indirect exits store the result in a variable
     230             : // and then jump to an exit label.
     231             : class ExitPoint {
     232             :  private:
     233             :   typedef compiler::Node Node;
     234             :   typedef compiler::CodeAssemblerLabel CodeAssemblerLabel;
     235             :   typedef compiler::CodeAssemblerVariable CodeAssemblerVariable;
     236             : 
     237             :  public:
     238             :   explicit ExitPoint(CodeStubAssembler* assembler)
     239             :       : ExitPoint(assembler, nullptr, nullptr) {}
     240             :   ExitPoint(CodeStubAssembler* assembler, CodeAssemblerLabel* out,
     241             :             CodeAssemblerVariable* var_result)
     242        1634 :       : out_(out), var_result_(var_result), asm_(assembler) {
     243             :     DCHECK_EQ(out != nullptr, var_result != nullptr);
     244             :   }
     245             : 
     246             :   template <class... TArgs>
     247        3053 :   void ReturnCallRuntime(Runtime::FunctionId function, Node* context,
     248        3053 :                          TArgs... args) {
     249        3053 :     if (IsDirect()) {
     250         731 :       asm_->TailCallRuntime(function, context, args...);
     251             :     } else {
     252        2322 :       IndirectReturn(asm_->CallRuntime(function, context, args...));
     253             :     }
     254        3053 :   }
     255             : 
     256             :   template <class... TArgs>
     257        2580 :   void ReturnCallStub(Callable const& callable, Node* context, TArgs... args) {
     258        2580 :     if (IsDirect()) {
     259         774 :       asm_->TailCallStub(callable, context, args...);
     260             :     } else {
     261        1806 :       IndirectReturn(asm_->CallStub(callable, context, args...));
     262             :     }
     263        2580 :   }
     264             : 
     265             :   template <class... TArgs>
     266        1032 :   void ReturnCallStub(const CallInterfaceDescriptor& descriptor, Node* target,
     267        1032 :                       Node* context, TArgs... args) {
     268        1032 :     if (IsDirect()) {
     269         258 :       asm_->TailCallStub(descriptor, target, context, args...);
     270             :     } else {
     271        1548 :       IndirectReturn(asm_->CallStub(descriptor, target, context, args...));
     272             :     }
     273        1032 :   }
     274             : 
     275       14491 :   void Return(Node* const result) {
     276       14491 :     if (IsDirect()) {
     277        4558 :       asm_->Return(result);
     278             :     } else {
     279        9933 :       IndirectReturn(result);
     280             :     }
     281       14491 :   }
     282             : 
     283             :   bool IsDirect() const { return out_ == nullptr; }
     284             : 
     285             :  private:
     286       14835 :   void IndirectReturn(Node* const result) {
     287       14835 :     var_result_->Bind(result);
     288       14835 :     asm_->Goto(out_);
     289       14835 :   }
     290             : 
     291             :   CodeAssemblerLabel* const out_;
     292             :   CodeAssemblerVariable* const var_result_;
     293             :   CodeStubAssembler* const asm_;
     294             : };
     295             : 
     296             : }  // namespace internal
     297             : }  // namespace v8
     298             : 
     299             : #endif  // V8_SRC_IC_ACCESSOR_ASSEMBLER_H_

Generated by: LCOV version 1.10