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 12namespace v8 { 13namespace internal { 14 15 16class 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