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, CodeObjectRequired::kYes) {
     44     // TODO(yangguo): remove this once we can serialize IC stubs.
     45     masm_.enable_serializer();
     46   }
     47 
     48   Code::Kind kind() const { return kind_; }
     49   CacheHolderFlag cache_holder() const { return cache_holder_; }
     50   MacroAssembler* masm() { return &masm_; }
     51   Isolate* isolate() const { return isolate_; }
     52   Heap* heap() const { return isolate()->heap(); }
     53   Factory* factory() const { return isolate()->factory(); }
     54 
     55   Register receiver() const { return registers_[0]; }
     56   Register name() const { return registers_[1]; }
     57   Register slot() const;
     58   Register vector() const;
     59   Register scratch1() const { return registers_[2]; }
     60   Register scratch2() const { return registers_[3]; }
     61 
     62   static Register* GetCallingConvention(Code::Kind);
     63   static Register* load_calling_convention();
     64   static Register* store_calling_convention();
     65   static Register* keyed_store_calling_convention();
     66 
     67   Register* registers_;
     68 
     69   static void GenerateTailCall(MacroAssembler* masm, Handle<Code> code);
     70 
     71   Handle<Code> GetCodeWithFlags(Code::Flags flags, const char* name);
     72   Handle<Code> GetCodeWithFlags(Code::Flags flags, Handle<Name> name);
     73 
     74  private:
     75   Code::Kind kind_;
     76   CacheHolderFlag cache_holder_;
     77 
     78   Isolate* isolate_;
     79   MacroAssembler masm_;
     80   // Ensure that MacroAssembler has a reasonable size.
     81   STATIC_ASSERT(sizeof(MacroAssembler) < 128 * kPointerSize);
     82 };
     83 }  // namespace internal
     84 }  // namespace v8
     85 
     86 #endif  // V8_IC_ACCESS_COMPILER_H_
     87