LCOV - code coverage report
Current view: top level - src/ic - handler-compiler.h (source / functions) Hit Total Coverage
Test: app.info Lines: 12 15 80.0 %
Date: 2017-04-26 Functions: 3 11 27.3 %

          Line data    Source code
       1             : // Copyright 2014 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_IC_HANDLER_COMPILER_H_
       6             : #define V8_IC_HANDLER_COMPILER_H_
       7             : 
       8             : #include "src/ic/access-compiler.h"
       9             : #include "src/ic/ic-state.h"
      10             : 
      11             : namespace v8 {
      12             : namespace internal {
      13             : 
      14             : class CallOptimization;
      15             : 
      16             : class PropertyHandlerCompiler : public PropertyAccessCompiler {
      17             :  public:
      18             :   static Handle<Code> Find(Handle<Name> name, Handle<Map> map, Code::Kind kind);
      19             : 
      20             :  protected:
      21             :   PropertyHandlerCompiler(Isolate* isolate, Code::Kind kind, Handle<Map> map,
      22             :                           Handle<JSObject> holder)
      23       38698 :       : PropertyAccessCompiler(isolate, kind), map_(map), holder_(holder) {}
      24             : 
      25       38698 :   virtual ~PropertyHandlerCompiler() {}
      26             : 
      27           0 :   virtual Register FrontendHeader(Register object_reg, Handle<Name> name,
      28             :                                   Label* miss) {
      29           0 :     UNREACHABLE();
      30             :     return receiver();
      31             :   }
      32             : 
      33           0 :   virtual void FrontendFooter(Handle<Name> name, Label* miss) { UNREACHABLE(); }
      34             : 
      35             :   // Frontend loads from receiver(), returns holder register which may be
      36             :   // different.
      37             :   Register Frontend(Handle<Name> name);
      38             : 
      39             :   // When FLAG_vector_ics is true, handlers that have the possibility of missing
      40             :   // will need to save and pass these to miss handlers.
      41       38698 :   void PushVectorAndSlot() { PushVectorAndSlot(vector(), slot()); }
      42             :   void PushVectorAndSlot(Register vector, Register slot);
      43       77340 :   void PopVectorAndSlot() { PopVectorAndSlot(vector(), slot()); }
      44             :   void PopVectorAndSlot(Register vector, Register slot);
      45             : 
      46             :   void DiscardVectorAndSlot();
      47             : 
      48             :   // TODO(verwaest): Make non-static.
      49             :   static void GenerateApiAccessorCall(MacroAssembler* masm,
      50             :                                       const CallOptimization& optimization,
      51             :                                       Handle<Map> receiver_map,
      52             :                                       Register receiver, Register scratch,
      53             :                                       bool is_store, Register store_parameter,
      54             :                                       Register accessor_holder,
      55             :                                       int accessor_index);
      56             : 
      57             :   // Helper function used to check that the dictionary doesn't contain
      58             :   // the property. This function may return false negatives, so miss_label
      59             :   // must always call a backup property check that is complete.
      60             :   // This function is safe to call if the receiver has fast properties.
      61             :   // Name must be unique and receiver must be a heap object.
      62             :   static void GenerateDictionaryNegativeLookup(MacroAssembler* masm,
      63             :                                                Label* miss_label,
      64             :                                                Register receiver,
      65             :                                                Handle<Name> name, Register r0,
      66             :                                                Register r1);
      67             : 
      68             :   // Generate code to check that a global property cell is empty. Create
      69             :   // the property cell at compilation time if no cell exists for the
      70             :   // property.
      71             :   static void GenerateCheckPropertyCell(MacroAssembler* masm,
      72             :                                         Handle<JSGlobalObject> global,
      73             :                                         Handle<Name> name, Register scratch,
      74             :                                         Label* miss);
      75             : 
      76             :   // Generates check that current native context has the same access rights
      77             :   // as the given |native_context_cell|.
      78             :   // If |compare_native_contexts_only| is true then access check is considered
      79             :   // passed if the execution-time native context is equal to contents of
      80             :   // |native_context_cell|.
      81             :   // If |compare_native_contexts_only| is false then access check is considered
      82             :   // passed if the execution-time native context is equal to contents of
      83             :   // |native_context_cell| or security tokens of both contexts are equal.
      84             :   void GenerateAccessCheck(Handle<WeakCell> native_context_cell,
      85             :                            Register scratch1, Register scratch2, Label* miss,
      86             :                            bool compare_native_contexts_only);
      87             : 
      88             :   // Generates code that verifies that the property holder has not changed
      89             :   // (checking maps of objects in the prototype chain for fast and global
      90             :   // objects or doing negative lookup for slow objects, ensures that the
      91             :   // property cells for global objects are still empty) and checks that the map
      92             :   // of the holder has not changed. If necessary the function also generates
      93             :   // code for security check in case of global object holders. Helps to make
      94             :   // sure that the current IC is still valid.
      95             :   //
      96             :   // The scratch and holder registers are always clobbered, but the object
      97             :   // register is only clobbered if it the same as the holder register. The
      98             :   // function returns a register containing the holder - either object_reg or
      99             :   // holder_reg.
     100             :   Register CheckPrototypes(Register object_reg, Register holder_reg,
     101             :                            Register scratch1, Register scratch2,
     102             :                            Handle<Name> name, Label* miss);
     103             : 
     104             :   Handle<Code> GetCode(Code::Kind kind, Handle<Name> name);
     105             :   Handle<Map> map() const { return map_; }
     106             :   Handle<JSObject> holder() const { return holder_; }
     107             : 
     108             :  private:
     109             :   Handle<Map> map_;
     110             :   Handle<JSObject> holder_;
     111             : };
     112             : 
     113             : 
     114             : class NamedLoadHandlerCompiler : public PropertyHandlerCompiler {
     115             :  public:
     116             :   NamedLoadHandlerCompiler(Isolate* isolate, Handle<Map> map,
     117             :                            Handle<JSObject> holder)
     118         277 :       : PropertyHandlerCompiler(isolate, Code::LOAD_IC, map, holder) {}
     119             : 
     120         277 :   virtual ~NamedLoadHandlerCompiler() {}
     121             : 
     122             :   Handle<Code> CompileLoadCallback(Handle<Name> name,
     123             :                                    const CallOptimization& call_optimization,
     124             :                                    int accessor_index, Handle<Code> slow_stub);
     125             : 
     126             :   static void GenerateLoadViaGetterForDeopt(MacroAssembler* masm);
     127             : 
     128             :  protected:
     129             :   virtual Register FrontendHeader(Register object_reg, Handle<Name> name,
     130             :                                   Label* miss);
     131             : 
     132             :   virtual void FrontendFooter(Handle<Name> name, Label* miss);
     133             : 
     134             :  private:
     135         277 :   Register scratch3() { return registers_[4]; }
     136             : };
     137             : 
     138             : 
     139             : class NamedStoreHandlerCompiler : public PropertyHandlerCompiler {
     140             :  public:
     141             :   // All store handlers use StoreWithVectorDescriptor calling convention.
     142             :   typedef StoreWithVectorDescriptor Descriptor;
     143             : 
     144             :   explicit NamedStoreHandlerCompiler(Isolate* isolate, Handle<Map> map,
     145             :                                      Handle<JSObject> holder)
     146       38421 :       : PropertyHandlerCompiler(isolate, Code::STORE_IC, map, holder) {
     147             : #ifdef DEBUG
     148             :     if (Descriptor::kPassLastArgsOnStack) {
     149             :       ZapStackArgumentsRegisterAliases();
     150             :     }
     151             : #endif
     152             :   }
     153             : 
     154       38421 :   virtual ~NamedStoreHandlerCompiler() {}
     155             : 
     156             :   void ZapStackArgumentsRegisterAliases();
     157             : 
     158             :   Handle<Code> CompileStoreCallback(Handle<JSObject> object, Handle<Name> name,
     159             :                                     Handle<AccessorInfo> callback,
     160             :                                     LanguageMode language_mode);
     161             :   Handle<Code> CompileStoreCallback(Handle<JSObject> object, Handle<Name> name,
     162             :                                     const CallOptimization& call_optimization,
     163             :                                     int accessor_index, Handle<Code> slow_stub);
     164             :   Handle<Code> CompileStoreViaSetter(Handle<JSObject> object, Handle<Name> name,
     165             :                                      int accessor_index,
     166             :                                      int expected_arguments);
     167             : 
     168             :   static void GenerateStoreViaSetter(MacroAssembler* masm, Handle<Map> map,
     169             :                                      Register receiver, Register holder,
     170             :                                      int accessor_index, int expected_arguments,
     171             :                                      Register scratch);
     172             : 
     173          43 :   static void GenerateStoreViaSetterForDeopt(MacroAssembler* masm) {
     174             :     GenerateStoreViaSetter(masm, Handle<Map>::null(), no_reg, no_reg, -1, -1,
     175          43 :                            no_reg);
     176          43 :   }
     177             : 
     178             :  protected:
     179             :   virtual Register FrontendHeader(Register object_reg, Handle<Name> name,
     180             :                                   Label* miss);
     181             : 
     182             :   virtual void FrontendFooter(Handle<Name> name, Label* miss);
     183             :   void GenerateRestoreName(Label* label, Handle<Name> name);
     184             : 
     185             :  private:
     186             :   static Register value();
     187             : };
     188             : 
     189             : }  // namespace internal
     190             : }  // namespace v8
     191             : 
     192             : #endif  // V8_IC_HANDLER_COMPILER_H_

Generated by: LCOV version 1.10