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/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   DisallowHeapAllocation no_alloc;
 131   if (receiver_map->IsPrimitiveMap()) {
 132     int constructor_function_index =
 133         receiver_map->GetConstructorFunctionIndex();
 134     if (constructor_function_index != Map::kNoConstructorFunctionIndex) {
 135       return JSFunction::cast(native_context->get(constructor_function_index));
 136     }
 137   }
 138   return nullptr;
 139 }
 140
 141
 142 Handle<Map> IC::GetHandlerCacheHolder(Handle<Map> receiver_map,
 143                                       bool receiver_is_holder, Isolate* isolate,
 144                                       CacheHolderFlag* flag) {
 145   if (receiver_is_holder) {
 146     *flag = kCacheOnReceiver;
 147     return receiver_map;
 148   }
 149   Context* native_context = *isolate->native_context();
 150   JSFunction* builtin_ctor = GetRootConstructor(*receiver_map, native_context);
 151   if (builtin_ctor != NULL) {
 152     *flag = kCacheOnPrototypeReceiverIsPrimitive;
 153     return handle(HeapObject::cast(builtin_ctor->instance_prototype())->map());
 154   }
 155   *flag = receiver_map->is_dictionary_map()
 156               ? kCacheOnPrototypeReceiverIsDictionary
 157               : kCacheOnPrototype;
 158   // Callers must ensure that the prototype is non-null.
 159   return handle(JSObject::cast(receiver_map->prototype())->map());
 160 }
 161
 162
 163 Handle<Map> IC::GetICCacheHolder(Handle<Map> map, Isolate* isolate,
 164                                  CacheHolderFlag* flag) {
 165   Context* native_context = *isolate->native_context();
 166   JSFunction* builtin_ctor = GetRootConstructor(*map, native_context);
 167   if (builtin_ctor != NULL) {
 168     *flag = kCacheOnPrototype;
 169     return handle(builtin_ctor->initial_map());
 170   }
 171   *flag = kCacheOnReceiver;
 172   return map;
 173 }
 174
 175
 176 Code* IC::get_host() {
 177   return isolate()
 178       ->inner_pointer_to_code_cache()
 179       ->GetCacheEntry(address())
 180       ->code;
 181 }
 182
 183
 184 bool IC::AddressIsDeoptimizedCode() const {
 185   return AddressIsDeoptimizedCode(isolate(), address());
 186 }
 187
 188
 189 bool IC::AddressIsDeoptimizedCode(Isolate* isolate, Address address) {
 190   Code* host =
 191       isolate->inner_pointer_to_code_cache()->GetCacheEntry(address)->code;
 192   return (host->kind() == Code::OPTIMIZED_FUNCTION &&
 193           host->marked_for_deoptimization());
 194 }
 195 }
 196 }  // namespace v8::internal
 197
 198 #endif  // V8_IC_INL_H_