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/ic/access-compiler-data.h" 10#include "src/macro-assembler.h" 11#include "src/objects.h" 12 13namespace v8 { 14namespace internal { 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(isolate, 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 Register* registers_; 63 64 static void GenerateTailCall(MacroAssembler* masm, Handle<Code> code); 65 66 Handle<Code> GetCodeWithFlags(Code::Flags flags, const char* name); 67 Handle<Code> GetCodeWithFlags(Code::Flags flags, Handle<Name> name); 68 69 private: 70 static Register* GetCallingConvention(Isolate* isolate, Code::Kind kind); 71 static void InitializePlatformSpecific(AccessCompilerData* data); 72 73 Code::Kind kind_; 74 CacheHolderFlag cache_holder_; 75 76 Isolate* isolate_; 77 MacroAssembler masm_; 78 // Ensure that MacroAssembler has a reasonable size. 79 STATIC_ASSERT(sizeof(MacroAssembler) < 128 * kPointerSize); 80}; 81} // namespace internal 82} // namespace v8 83 84#endif // V8_IC_ACCESS_COMPILER_H_ 85