src/ic/ic-inl.h

   1 // Copyright 2012 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_INL_H_
   6 #define V8_IC_INL_H_
   7
   8 #include "src/ic/ic.h"
   9
  10 #include "src/compiler.h"
  11 #include "src/debug.h"
  12 #include "src/macro-assembler.h"
  13 #include "src/prototype.h"
  14
  15 namespace v8 {
  16 namespace internal {
  17
  18
  19 Address IC::address() const {
  20   // Get the address of the call.
  21   return Assembler::target_address_from_return_address(pc());
  22 }
  23
  24
  25 Address IC::constant_pool() const {
  26   if (FLAG_enable_embedded_constant_pool) {
  27     return raw_constant_pool();
  28   } else {
  29     return NULL;
  30   }
  31 }
  32
  33
  34 Address IC::raw_constant_pool() const {
  35   if (FLAG_enable_embedded_constant_pool) {
  36     return *constant_pool_address_;
  37   } else {
  38     return NULL;
  39   }
  40 }
  41
  42
  43 Code* IC::GetTargetAtAddress(Address address, Address constant_pool) {
  44   // Get the target address of the IC.
  45   Address target = Assembler::target_address_at(address, constant_pool);
  46   // Convert target address to the code object. Code::GetCodeFromTargetAddress
  47   // is safe for use during GC where the map might be marked.
  48   Code* result = Code::GetCodeFromTargetAddress(target);
  49   DCHECK(result->is_inline_cache_stub());
  50   return result;
  51 }
  52
  53
  54 void IC::SetTargetAtAddress(Address address, Code* target,
  55                             Address constant_pool) {
  56   if (AddressIsDeoptimizedCode(target->GetIsolate(), address)) return;
  57
  58   DCHECK(target->is_inline_cache_stub() || target->is_compare_ic_stub());
  59
  60   DCHECK(!target->is_inline_cache_stub() ||
  61          (target->kind() != Code::LOAD_IC &&
  62           target->kind() != Code::KEYED_LOAD_IC &&
  63           (!FLAG_vector_stores || (target->kind() != Code::STORE_IC &&
  64                                    target->kind() != Code::KEYED_STORE_IC))));
  65
  66   Heap* heap = target->GetHeap();
  67   Code* old_target = GetTargetAtAddress(address, constant_pool);
  68 #ifdef DEBUG
  69   // STORE_IC and KEYED_STORE_IC use Code::extra_ic_state() to mark
  70   // ICs as language mode. The language mode of the IC must be preserved.
  71   if (old_target->kind() == Code::STORE_IC ||
  72       old_target->kind() == Code::KEYED_STORE_IC) {
  73     DCHECK(StoreICState::GetLanguageMode(old_target->extra_ic_state()) ==
  74            StoreICState::GetLanguageMode(target->extra_ic_state()));
  75   }
  76 #endif
  77   Assembler::set_target_address_at(address, constant_pool,
  78                                    target->instruction_start());
  79   if (heap->gc_state() == Heap::MARK_COMPACT) {
  80     heap->mark_compact_collector()->RecordCodeTargetPatch(address, target);
  81   } else {
  82     heap->incremental_marking()->RecordCodeTargetPatch(address, target);
  83   }
  84   PostPatching(address, target, old_target);
  85 }
  86
  87
  88 void IC::set_target(Code* code) {
  89   SetTargetAtAddress(address(), code, constant_pool());
  90   target_set_ = true;
  91 }
  92
  93
  94 void LoadIC::set_target(Code* code) {
  95   // The contextual mode must be preserved across IC patching.
  96   DCHECK(LoadICState::GetTypeofMode(code->extra_ic_state()) ==
  97          LoadICState::GetTypeofMode(target()->extra_ic_state()));
  98   // Strongness must be preserved across IC patching.
  99   DCHECK(LoadICState::GetLanguageMode(code->extra_ic_state()) ==
 100          LoadICState::GetLanguageMode(target()->extra_ic_state()));
 101
 102   IC::set_target(code);
 103 }
 104
 105
 106 void StoreIC::set_target(Code* code) {
 107   // Language mode must be preserved across IC patching.
 108   DCHECK(StoreICState::GetLanguageMode(code->extra_ic_state()) ==
 109          StoreICState::GetLanguageMode(target()->extra_ic_state()));
 110   IC::set_target(code);
 111 }
 112
 113
 114 void KeyedStoreIC::set_target(Code* code) {
 115   // Language mode must be preserved across IC patching.
 116   DCHECK(StoreICState::GetLanguageMode(code->extra_ic_state()) ==
 117          language_mode());
 118   IC::set_target(code);
 119 }
 120
 121
 122 Code* IC::raw_target() const {
 123   return GetTargetAtAddress(address(), constant_pool());
 124 }
 125
 126 void IC::UpdateTarget() { target_ = handle(raw_target(), isolate_); }
 127
 128
 129 JSFunction* IC::GetRootConstructor(Map* receiver_map, Context* native_context) {
 130   Isolate* isolate = receiver_map->GetIsolate();
 131   if (receiver_map == isolate->heap()->boolean_map()) {
 132     return native_context->boolean_function();
 133   } else if (receiver_map->instance_type() == HEAP_NUMBER_TYPE) {
 134     return native_context->number_function();
 135   } else if (receiver_map->instance_type() < FIRST_NONSTRING_TYPE) {
 136     return native_context->string_function();
 137   } else if (receiver_map->instance_type() == SYMBOL_TYPE) {
 138     return native_context->symbol_function();
 139   } else {
 140     return NULL;
 141   }
 142 }
 143
 144
 145 Handle<Map> IC::GetHandlerCacheHolder(Handle<Map> receiver_map,
 146                                       bool receiver_is_holder, Isolate* isolate,
 147                                       CacheHolderFlag* flag) {
 148   if (receiver_is_holder) {
 149     *flag = kCacheOnReceiver;
 150     return receiver_map;
 151   }
 152   Context* native_context = *isolate->native_context();
 153   JSFunction* builtin_ctor = GetRootConstructor(*receiver_map, native_context);
 154   if (builtin_ctor != NULL) {
 155     *flag = kCacheOnPrototypeReceiverIsPrimitive;
 156     return handle(HeapObject::cast(builtin_ctor->instance_prototype())->map());
 157   }
 158   *flag = receiver_map->is_dictionary_map()
 159               ? kCacheOnPrototypeReceiverIsDictionary
 160               : kCacheOnPrototype;
 161   // Callers must ensure that the prototype is non-null.
 162   return handle(JSObject::cast(receiver_map->prototype())->map());
 163 }
 164
 165
 166 Handle<Map> IC::GetICCacheHolder(Handle<Map> map, Isolate* isolate,
 167                                  CacheHolderFlag* flag) {
 168   Context* native_context = *isolate->native_context();
 169   JSFunction* builtin_ctor = GetRootConstructor(*map, native_context);
 170   if (builtin_ctor != NULL) {
 171     *flag = kCacheOnPrototype;
 172     return handle(builtin_ctor->initial_map());
 173   }
 174   *flag = kCacheOnReceiver;
 175   return map;
 176 }
 177
 178
 179 Code* IC::get_host() {
 180   return isolate()
 181       ->inner_pointer_to_code_cache()
 182       ->GetCacheEntry(address())
 183       ->code;
 184 }
 185
 186
 187 bool IC::AddressIsDeoptimizedCode() const {
 188   return AddressIsDeoptimizedCode(isolate(), address());
 189 }
 190
 191
 192 bool IC::AddressIsDeoptimizedCode(Isolate* isolate, Address address) {
 193   Code* host =
 194       isolate->inner_pointer_to_code_cache()->GetCacheEntry(address)->code;
 195   return (host->kind() == Code::OPTIMIZED_FUNCTION &&
 196           host->marked_for_deoptimization());
 197 }
 198 }
 199 }  // namespace v8::internal
 200
 201 #endif  // V8_IC_INL_H_