Home | History | Annotate | Download | only in ic 
      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_ACCESS_COMPILER_H_
      6 #define V8_IC_ACCESS_COMPILER_H_
      7 
      8 #include "src/code-stubs.h"
      9 #include "src/macro-assembler.h"
     10 #include "src/objects.h"
     11 
     12 namespace v8 {
     13 namespace internal {
     14 
     15 
     16 class PropertyAccessCompiler BASE_EMBEDDED {
     17  public:
     18   static Builtins::Name MissBuiltin(Code::Kind kind) {
     19     switch (kind) {
     20       case Code::LOAD_IC:
     21         return Builtins::kLoadIC_Miss;
     22       case Code::STORE_IC:
     23         return Builtins::kStoreIC_Miss;
     24       case Code::KEYED_LOAD_IC:
     25         return Builtins::kKeyedLoadIC_Miss;
     26       case Code::KEYED_STORE_IC:
     27         return Builtins::kKeyedStoreIC_Miss;
     28       default:
     29         UNREACHABLE();
     30     }
     31     return Builtins::kLoadIC_Miss;
     32   }
     33 
     34   static void TailCallBuiltin(MacroAssembler* masm, Builtins::Name name);
     35 
     36  protected:
     37   PropertyAccessCompiler(Isolate* isolate, Code::Kind kind,
     38                          CacheHolderFlag cache_holder)
     39       : registers_(GetCallingConvention(kind)),
     40         kind_(kind),
     41         cache_holder_(cache_holder),
     42         isolate_(isolate),
     43         masm_(isolate, NULL, 256) {}
     44 
     45   Code::Kind kind() const { return kind_; }
     46   CacheHolderFlag cache_holder() const { return cache_holder_; }
     47   MacroAssembler* masm() { return &masm_; }
     48   Isolate* isolate() const { return isolate_; }
     49   Heap* heap() const { return isolate()->heap(); }
     50   Factory* factory() const { return isolate()->factory(); }
     51 
     52   Register receiver() const { return registers_[0]; }
     53   Register name() const { return registers_[1]; }
     54   Register scratch1() const { return registers_[2]; }
     55   Register scratch2() const { return registers_[3]; }
     56   Register scratch3() const { return registers_[4]; }
     57 
     58   // Calling convention between indexed store IC and handler.
     59   Register transition_map() const { return scratch1(); }
     60 
     61   static Register* GetCallingConvention(Code::Kind);
     62   static Register* load_calling_convention();
     63   static Register* store_calling_convention();
     64   static Register* keyed_store_calling_convention();
     65 
     66   Register* registers_;
     67 
     68   static void GenerateTailCall(MacroAssembler* masm, Handle<Code> code);
     69 
     70   Handle<Code> GetCodeWithFlags(Code::Flags flags, const char* name);
     71   Handle<Code> GetCodeWithFlags(Code::Flags flags, Handle<Name> name);
     72 
     73  private:
     74   Code::Kind kind_;
     75   CacheHolderFlag cache_holder_;
     76 
     77   Isolate* isolate_;
     78   MacroAssembler masm_;
     79 };
     80 }
     81 }  // namespace v8::internal
     82 
     83 #endif  // V8_IC_ACCESS_COMPILER_H_
     84