LCOV - code coverage report
Current view: top level - src/compiler - js-native-context-specialization.h (source / functions) Hit Total Coverage
Test: app.info Lines: 2 2 100.0 %
Date: 2017-04-26 Functions: 0 2 0.0 %

          Line data    Source code
       1             : // Copyright 2015 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_COMPILER_JS_NATIVE_CONTEXT_SPECIALIZATION_H_
       6             : #define V8_COMPILER_JS_NATIVE_CONTEXT_SPECIALIZATION_H_
       7             : 
       8             : #include "src/base/flags.h"
       9             : #include "src/compiler/graph-reducer.h"
      10             : #include "src/deoptimize-reason.h"
      11             : #include "src/feedback-vector.h"
      12             : 
      13             : namespace v8 {
      14             : namespace internal {
      15             : 
      16             : // Forward declarations.
      17             : class CompilationDependencies;
      18             : class Factory;
      19             : 
      20             : namespace compiler {
      21             : 
      22             : // Forward declarations.
      23             : enum class AccessMode;
      24             : class CommonOperatorBuilder;
      25             : class ElementAccessInfo;
      26             : class JSGraph;
      27             : class JSOperatorBuilder;
      28             : class MachineOperatorBuilder;
      29             : class PropertyAccessInfo;
      30             : class SimplifiedOperatorBuilder;
      31             : class TypeCache;
      32             : 
      33             : // Specializes a given JSGraph to a given native context, potentially constant
      34             : // folding some {LoadGlobal} nodes or strength reducing some {StoreGlobal}
      35             : // nodes.  And also specializes {LoadNamed} and {StoreNamed} nodes according
      36             : // to type feedback (if available).
      37      395343 : class JSNativeContextSpecialization final : public AdvancedReducer {
      38             :  public:
      39             :   // Flags that control the mode of operation.
      40             :   enum Flag {
      41             :     kNoFlags = 0u,
      42             :     kAccessorInliningEnabled = 1u << 0,
      43             :     kBailoutOnUninitialized = 1u << 1
      44             :   };
      45             :   typedef base::Flags<Flag> Flags;
      46             : 
      47             :   JSNativeContextSpecialization(Editor* editor, JSGraph* jsgraph, Flags flags,
      48             :                                 Handle<Context> native_context,
      49             :                                 CompilationDependencies* dependencies,
      50             :                                 Zone* zone);
      51             : 
      52             :   Reduction Reduce(Node* node) final;
      53             : 
      54             :  private:
      55             :   Reduction ReduceJSAdd(Node* node);
      56             :   Reduction ReduceJSGetSuperConstructor(Node* node);
      57             :   Reduction ReduceJSInstanceOf(Node* node);
      58             :   Reduction ReduceJSOrdinaryHasInstance(Node* node);
      59             :   Reduction ReduceJSLoadContext(Node* node);
      60             :   Reduction ReduceJSLoadGlobal(Node* node);
      61             :   Reduction ReduceJSStoreGlobal(Node* node);
      62             :   Reduction ReduceJSLoadNamed(Node* node);
      63             :   Reduction ReduceJSStoreNamed(Node* node);
      64             :   Reduction ReduceJSLoadProperty(Node* node);
      65             :   Reduction ReduceJSStoreProperty(Node* node);
      66             :   Reduction ReduceJSStoreNamedOwn(Node* node);
      67             :   Reduction ReduceJSStoreDataPropertyInLiteral(Node* node);
      68             : 
      69             :   Reduction ReduceElementAccess(Node* node, Node* index, Node* value,
      70             :                                 MapHandleList const& receiver_maps,
      71             :                                 AccessMode access_mode,
      72             :                                 LanguageMode language_mode,
      73             :                                 KeyedAccessStoreMode store_mode);
      74             :   template <typename KeyedICNexus>
      75             :   Reduction ReduceKeyedAccess(Node* node, Node* index, Node* value,
      76             :                               KeyedICNexus const& nexus, AccessMode access_mode,
      77             :                               LanguageMode language_mode,
      78             :                               KeyedAccessStoreMode store_mode);
      79             :   Reduction ReduceNamedAccessFromNexus(Node* node, Node* value,
      80             :                                        FeedbackNexus const& nexus,
      81             :                                        Handle<Name> name,
      82             :                                        AccessMode access_mode,
      83             :                                        LanguageMode language_mode);
      84             :   Reduction ReduceNamedAccess(Node* node, Node* value,
      85             :                               MapHandleList const& receiver_maps,
      86             :                               Handle<Name> name, AccessMode access_mode,
      87             :                               LanguageMode language_mode,
      88             :                               Node* index = nullptr);
      89             :   Reduction ReduceGlobalAccess(Node* node, Node* receiver, Node* value,
      90             :                                Handle<Name> name, AccessMode access_mode,
      91             :                                Node* index = nullptr);
      92             : 
      93             :   Reduction ReduceSoftDeoptimize(Node* node, DeoptimizeReason reason);
      94             : 
      95             :   // A triple of nodes that represents a continuation.
      96             :   class ValueEffectControl final {
      97             :    public:
      98             :     ValueEffectControl(Node* value, Node* effect, Node* control)
      99      116189 :         : value_(value), effect_(effect), control_(control) {}
     100             : 
     101             :     Node* value() const { return value_; }
     102             :     Node* effect() const { return effect_; }
     103             :     Node* control() const { return control_; }
     104             : 
     105             :    private:
     106             :     Node* const value_;
     107             :     Node* const effect_;
     108             :     Node* const control_;
     109             :   };
     110             : 
     111             :   // Construct the appropriate subgraph for property access.
     112             :   ValueEffectControl BuildPropertyAccess(Node* receiver, Node* value,
     113             :                                          Node* context, Node* frame_state,
     114             :                                          Node* effect, Node* control,
     115             :                                          Handle<Name> name,
     116             :                                          PropertyAccessInfo const& access_info,
     117             :                                          AccessMode access_mode,
     118             :                                          LanguageMode language_mode);
     119             : 
     120             :   // Construct the appropriate subgraph for element access.
     121             :   ValueEffectControl BuildElementAccess(Node* receiver, Node* index,
     122             :                                         Node* value, Node* effect,
     123             :                                         Node* control,
     124             :                                         ElementAccessInfo const& access_info,
     125             :                                         AccessMode access_mode,
     126             :                                         KeyedAccessStoreMode store_mode);
     127             : 
     128             :   // Construct an appropriate heap object check.
     129             :   Node* BuildCheckHeapObject(Node* receiver, Node** effect, Node* control);
     130             : 
     131             :   // Construct an appropriate map check.
     132             :   Node* BuildCheckMaps(Node* receiver, Node* effect, Node* control,
     133             :                        std::vector<Handle<Map>> const& maps);
     134             : 
     135             :   // Construct appropriate subgraph to extend properties backing store.
     136             :   Node* BuildExtendPropertiesBackingStore(Handle<Map> map, Node* properties,
     137             :                                           Node* effect, Node* control);
     138             : 
     139             :   // Adds stability dependencies on all prototypes of every class in
     140             :   // {receiver_type} up to (and including) the {holder}.
     141             :   void AssumePrototypesStable(std::vector<Handle<Map>> const& receiver_maps,
     142             :                               Handle<JSObject> holder);
     143             : 
     144             :   // Checks if we can turn the hole into undefined when loading an element
     145             :   // from an object with one of the {receiver_maps}; sets up appropriate
     146             :   // code dependencies and might use the array protector cell.
     147             :   bool CanTreatHoleAsUndefined(std::vector<Handle<Map>> const& receiver_maps);
     148             : 
     149             :   // Checks if we know at compile time that the {receiver} either definitely
     150             :   // has the {prototype} in it's prototype chain, or the {receiver} definitely
     151             :   // doesn't have the {prototype} in it's prototype chain.
     152             :   enum InferHasInPrototypeChainResult {
     153             :     kIsInPrototypeChain,
     154             :     kIsNotInPrototypeChain,
     155             :     kMayBeInPrototypeChain
     156             :   };
     157             :   InferHasInPrototypeChainResult InferHasInPrototypeChain(
     158             :       Node* receiver, Node* effect, Handle<JSReceiver> prototype);
     159             : 
     160             :   // Extract receiver maps from {nexus} and filter based on {receiver} if
     161             :   // possible.
     162             :   bool ExtractReceiverMaps(Node* receiver, Node* effect,
     163             :                            FeedbackNexus const& nexus,
     164             :                            MapHandleList* receiver_maps);
     165             : 
     166             :   // Try to infer maps for the given {receiver} at the current {effect}.
     167             :   // If maps are returned then you can be sure that the {receiver} definitely
     168             :   // has one of the returned maps at this point in the program (identified
     169             :   // by {effect}).
     170             :   bool InferReceiverMaps(Node* receiver, Node* effect,
     171             :                          MapHandleList* receiver_maps);
     172             :   // Try to infer a root map for the {receiver} independent of the current
     173             :   // program location.
     174             :   MaybeHandle<Map> InferReceiverRootMap(Node* receiver);
     175             : 
     176             :   ValueEffectControl InlineApiCall(
     177             :       Node* receiver, Node* context, Node* target, Node* frame_state,
     178             :       Node* parameter, Node* effect, Node* control,
     179             :       Handle<SharedFunctionInfo> shared_info,
     180             :       Handle<FunctionTemplateInfo> function_template_info);
     181             : 
     182             :   // Script context lookup logic.
     183             :   struct ScriptContextTableLookupResult;
     184             :   bool LookupInScriptContextTable(Handle<Name> name,
     185             :                                   ScriptContextTableLookupResult* result);
     186             : 
     187             :   Graph* graph() const;
     188             :   JSGraph* jsgraph() const { return jsgraph_; }
     189             :   Isolate* isolate() const;
     190             :   Factory* factory() const;
     191             :   CommonOperatorBuilder* common() const;
     192             :   JSOperatorBuilder* javascript() const;
     193             :   SimplifiedOperatorBuilder* simplified() const;
     194             :   MachineOperatorBuilder* machine() const;
     195             :   Flags flags() const { return flags_; }
     196             :   Handle<JSGlobalObject> global_object() const { return global_object_; }
     197             :   Handle<JSGlobalProxy> global_proxy() const { return global_proxy_; }
     198             :   Handle<Context> native_context() const { return native_context_; }
     199             :   CompilationDependencies* dependencies() const { return dependencies_; }
     200             :   Zone* zone() const { return zone_; }
     201             : 
     202             :   JSGraph* const jsgraph_;
     203             :   Flags const flags_;
     204             :   Handle<JSGlobalObject> global_object_;
     205             :   Handle<JSGlobalProxy> global_proxy_;
     206             :   Handle<Context> native_context_;
     207             :   CompilationDependencies* const dependencies_;
     208             :   Zone* const zone_;
     209             :   TypeCache const& type_cache_;
     210             : 
     211             :   DISALLOW_COPY_AND_ASSIGN(JSNativeContextSpecialization);
     212             : };
     213             : 
     214             : DEFINE_OPERATORS_FOR_FLAGS(JSNativeContextSpecialization::Flags)
     215             : 
     216             : }  // namespace compiler
     217             : }  // namespace internal
     218             : }  // namespace v8
     219             : 
     220             : #endif  // V8_COMPILER_JS_NATIVE_CONTEXT_SPECIALIZATION_H_

Generated by: LCOV version 1.10