src/v8/src/ic/handler-compiler.cc

   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 #include "src/v8.h"
   6
   7 #include "src/ic/call-optimization.h"
   8 #include "src/ic/handler-compiler.h"
   9 #include "src/ic/ic.h"
  10 #include "src/ic/ic-inl.h"
  11
  12 namespace v8 {
  13 namespace internal {
  14
  15
  16 Handle<Code> PropertyHandlerCompiler::Find(Handle<Name> name,
  17                                            Handle<Map> stub_holder,
  18                                            Code::Kind kind,
  19                                            CacheHolderFlag cache_holder,
  20                                            Code::StubType type) {
  21   Code::Flags flags = Code::ComputeHandlerFlags(kind, type, cache_holder);
  22   Object* probe = stub_holder->FindInCodeCache(*name, flags);
  23   if (probe->IsCode()) return handle(Code::cast(probe));
  24   return Handle<Code>::null();
  25 }
  26
  27
  28 Handle<Code> NamedLoadHandlerCompiler::ComputeLoadNonexistent(
  29     Handle<Name> name, Handle<HeapType> type) {
  30   Isolate* isolate = name->GetIsolate();
  31   Handle<Map> receiver_map = IC::TypeToMap(*type, isolate);
  32   if (receiver_map->prototype()->IsNull()) {
  33     // TODO(jkummerow/verwaest): If there is no prototype and the property
  34     // is nonexistent, introduce a builtin to handle this (fast properties
  35     // -> return undefined, dictionary properties -> do negative lookup).
  36     return Handle<Code>();
  37   }
  38   CacheHolderFlag flag;
  39   Handle<Map> stub_holder_map =
  40       IC::GetHandlerCacheHolder(*type, false, isolate, &flag);
  41
  42   // If no dictionary mode objects are present in the prototype chain, the load
  43   // nonexistent IC stub can be shared for all names for a given map and we use
  44   // the empty string for the map cache in that case. If there are dictionary
  45   // mode objects involved, we need to do negative lookups in the stub and
  46   // therefore the stub will be specific to the name.
  47   Handle<Name> cache_name =
  48       receiver_map->is_dictionary_map()
  49           ? name
  50           : Handle<Name>::cast(isolate->factory()->nonexistent_symbol());
  51   Handle<Map> current_map = stub_holder_map;
  52   Handle<JSObject> last(JSObject::cast(receiver_map->prototype()));
  53   while (true) {
  54     if (current_map->is_dictionary_map()) cache_name = name;
  55     if (current_map->prototype()->IsNull()) break;
  56     last = handle(JSObject::cast(current_map->prototype()));
  57     current_map = handle(last->map());
  58   }
  59   // Compile the stub that is either shared for all names or
  60   // name specific if there are global objects involved.
  61   Handle<Code> handler = PropertyHandlerCompiler::Find(
  62       cache_name, stub_holder_map, Code::LOAD_IC, flag, Code::FAST);
  63   if (!handler.is_null()) return handler;
  64
  65   NamedLoadHandlerCompiler compiler(isolate, type, last, flag);
  66   handler = compiler.CompileLoadNonexistent(cache_name);
  67   Map::UpdateCodeCache(stub_holder_map, cache_name, handler);
  68   return handler;
  69 }
  70
  71
  72 Handle<Code> PropertyHandlerCompiler::GetCode(Code::Kind kind,
  73                                               Code::StubType type,
  74                                               Handle<Name> name) {
  75   Code::Flags flags = Code::ComputeHandlerFlags(kind, type, cache_holder());
  76   Handle<Code> code = GetCodeWithFlags(flags, name);
  77   PROFILE(isolate(), CodeCreateEvent(Logger::STUB_TAG, *code, *name));
  78   return code;
  79 }
  80
  81
  82 void PropertyHandlerCompiler::set_type_for_object(Handle<Object> object) {
  83   type_ = IC::CurrentTypeOf(object, isolate());
  84 }
  85
  86
  87 #define __ ACCESS_MASM(masm())
  88
  89
  90 Register NamedLoadHandlerCompiler::FrontendHeader(Register object_reg,
  91                                                   Handle<Name> name,
  92                                                   Label* miss) {
  93   PrototypeCheckType check_type = CHECK_ALL_MAPS;
  94   int function_index = -1;
  95   if (type()->Is(HeapType::String())) {
  96     function_index = Context::STRING_FUNCTION_INDEX;
  97   } else if (type()->Is(HeapType::Symbol())) {
  98     function_index = Context::SYMBOL_FUNCTION_INDEX;
  99   } else if (type()->Is(HeapType::Number())) {
 100     function_index = Context::NUMBER_FUNCTION_INDEX;
 101   } else if (type()->Is(HeapType::Boolean())) {
 102     function_index = Context::BOOLEAN_FUNCTION_INDEX;
 103   } else {
 104     check_type = SKIP_RECEIVER;
 105   }
 106
 107   if (check_type == CHECK_ALL_MAPS) {
 108     GenerateDirectLoadGlobalFunctionPrototype(masm(), function_index,
 109                                               scratch1(), miss);
 110     Object* function = isolate()->native_context()->get(function_index);
 111     Object* prototype = JSFunction::cast(function)->instance_prototype();
 112     set_type_for_object(handle(prototype, isolate()));
 113     object_reg = scratch1();
 114   }
 115
 116   // Check that the maps starting from the prototype haven't changed.
 117   return CheckPrototypes(object_reg, scratch1(), scratch2(), scratch3(), name,
 118                          miss, check_type);
 119 }
 120
 121
 122 // Frontend for store uses the name register. It has to be restored before a
 123 // miss.
 124 Register NamedStoreHandlerCompiler::FrontendHeader(Register object_reg,
 125                                                    Handle<Name> name,
 126                                                    Label* miss) {
 127   return CheckPrototypes(object_reg, this->name(), scratch1(), scratch2(), name,
 128                          miss, SKIP_RECEIVER);
 129 }
 130
 131
 132 Register PropertyHandlerCompiler::Frontend(Register object_reg,
 133                                            Handle<Name> name) {
 134   Label miss;
 135   Register reg = FrontendHeader(object_reg, name, &miss);
 136   FrontendFooter(name, &miss);
 137   return reg;
 138 }
 139
 140
 141 void PropertyHandlerCompiler::NonexistentFrontendHeader(Handle<Name> name,
 142                                                         Label* miss,
 143                                                         Register scratch1,
 144                                                         Register scratch2) {
 145   Register holder_reg;
 146   Handle<Map> last_map;
 147   if (holder().is_null()) {
 148     holder_reg = receiver();
 149     last_map = IC::TypeToMap(*type(), isolate());
 150     // If |type| has null as its prototype, |holder()| is
 151     // Handle<JSObject>::null().
 152     DCHECK(last_map->prototype() == isolate()->heap()->null_value());
 153   } else {
 154     holder_reg = FrontendHeader(receiver(), name, miss);
 155     last_map = handle(holder()->map());
 156   }
 157
 158   if (last_map->is_dictionary_map()) {
 159     if (last_map->IsJSGlobalObjectMap()) {
 160       Handle<JSGlobalObject> global =
 161           holder().is_null()
 162               ? Handle<JSGlobalObject>::cast(type()->AsConstant()->Value())
 163               : Handle<JSGlobalObject>::cast(holder());
 164       GenerateCheckPropertyCell(masm(), global, name, scratch1, miss);
 165     } else {
 166       if (!name->IsUniqueName()) {
 167         DCHECK(name->IsString());
 168         name = factory()->InternalizeString(Handle<String>::cast(name));
 169       }
 170       DCHECK(holder().is_null() ||
 171              holder()->property_dictionary()->FindEntry(name) ==
 172                  NameDictionary::kNotFound);
 173       GenerateDictionaryNegativeLookup(masm(), miss, holder_reg, name, scratch1,
 174                                        scratch2);
 175     }
 176   }
 177 }
 178
 179
 180 Handle<Code> NamedLoadHandlerCompiler::CompileLoadField(Handle<Name> name,
 181                                                         FieldIndex field) {
 182   Register reg = Frontend(receiver(), name);
 183   __ Move(receiver(), reg);
 184   LoadFieldStub stub(isolate(), field);
 185   GenerateTailCall(masm(), stub.GetCode());
 186   return GetCode(kind(), Code::FAST, name);
 187 }
 188
 189
 190 Handle<Code> NamedLoadHandlerCompiler::CompileLoadConstant(Handle<Name> name,
 191                                                            int constant_index) {
 192   Register reg = Frontend(receiver(), name);
 193   __ Move(receiver(), reg);
 194   LoadConstantStub stub(isolate(), constant_index);
 195   GenerateTailCall(masm(), stub.GetCode());
 196   return GetCode(kind(), Code::FAST, name);
 197 }
 198
 199
 200 Handle<Code> NamedLoadHandlerCompiler::CompileLoadNonexistent(
 201     Handle<Name> name) {
 202   Label miss;
 203   NonexistentFrontendHeader(name, &miss, scratch2(), scratch3());
 204   GenerateLoadConstant(isolate()->factory()->undefined_value());
 205   FrontendFooter(name, &miss);
 206   return GetCode(kind(), Code::FAST, name);
 207 }
 208
 209
 210 Handle<Code> NamedLoadHandlerCompiler::CompileLoadCallback(
 211     Handle<Name> name, Handle<ExecutableAccessorInfo> callback) {
 212   Register reg = Frontend(receiver(), name);
 213   GenerateLoadCallback(reg, callback);
 214   return GetCode(kind(), Code::FAST, name);
 215 }
 216
 217
 218 Handle<Code> NamedLoadHandlerCompiler::CompileLoadCallback(
 219     Handle<Name> name, const CallOptimization& call_optimization) {
 220   DCHECK(call_optimization.is_simple_api_call());
 221   Frontend(receiver(), name);
 222   Handle<Map> receiver_map = IC::TypeToMap(*type(), isolate());
 223   GenerateFastApiCall(masm(), call_optimization, receiver_map, receiver(),
 224                       scratch1(), false, 0, NULL);
 225   return GetCode(kind(), Code::FAST, name);
 226 }
 227
 228
 229 Handle<Code> NamedLoadHandlerCompiler::CompileLoadInterceptor(
 230     LookupIterator* it) {
 231   // So far the most popular follow ups for interceptor loads are FIELD and
 232   // ExecutableAccessorInfo, so inline only them. Other cases may be added
 233   // later.
 234   bool inline_followup = false;
 235   switch (it->state()) {
 236     case LookupIterator::TRANSITION:
 237       UNREACHABLE();
 238     case LookupIterator::ACCESS_CHECK:
 239     case LookupIterator::INTERCEPTOR:
 240     case LookupIterator::JSPROXY:
 241     case LookupIterator::NOT_FOUND:
 242       break;
 243     case LookupIterator::DATA:
 244       inline_followup = it->property_details().type() == FIELD;
 245       break;
 246     case LookupIterator::ACCESSOR: {
 247       Handle<Object> accessors = it->GetAccessors();
 248       inline_followup = accessors->IsExecutableAccessorInfo();
 249       if (!inline_followup) break;
 250       Handle<ExecutableAccessorInfo> info =
 251           Handle<ExecutableAccessorInfo>::cast(accessors);
 252       inline_followup = info->getter() != NULL &&
 253                         ExecutableAccessorInfo::IsCompatibleReceiverType(
 254                             isolate(), info, type());
 255     }
 256   }
 257
 258   Register reg = Frontend(receiver(), it->name());
 259   if (inline_followup) {
 260     // TODO(368): Compile in the whole chain: all the interceptors in
 261     // prototypes and ultimate answer.
 262     GenerateLoadInterceptorWithFollowup(it, reg);
 263   } else {
 264     GenerateLoadInterceptor(reg);
 265   }
 266   return GetCode(kind(), Code::FAST, it->name());
 267 }
 268
 269
 270 void NamedLoadHandlerCompiler::GenerateLoadPostInterceptor(
 271     LookupIterator* it, Register interceptor_reg) {
 272   Handle<JSObject> real_named_property_holder(it->GetHolder<JSObject>());
 273
 274   set_type_for_object(holder());
 275   set_holder(real_named_property_holder);
 276   Register reg = Frontend(interceptor_reg, it->name());
 277
 278   switch (it->state()) {
 279     case LookupIterator::ACCESS_CHECK:
 280     case LookupIterator::INTERCEPTOR:
 281     case LookupIterator::JSPROXY:
 282     case LookupIterator::NOT_FOUND:
 283     case LookupIterator::TRANSITION:
 284       UNREACHABLE();
 285     case LookupIterator::DATA: {
 286       DCHECK_EQ(FIELD, it->property_details().type());
 287       __ Move(receiver(), reg);
 288       LoadFieldStub stub(isolate(), it->GetFieldIndex());
 289       GenerateTailCall(masm(), stub.GetCode());
 290       break;
 291     }
 292     case LookupIterator::ACCESSOR:
 293       Handle<ExecutableAccessorInfo> info =
 294           Handle<ExecutableAccessorInfo>::cast(it->GetAccessors());
 295       DCHECK_NE(NULL, info->getter());
 296       GenerateLoadCallback(reg, info);
 297   }
 298 }
 299
 300
 301 Handle<Code> NamedLoadHandlerCompiler::CompileLoadViaGetter(
 302     Handle<Name> name, Handle<JSFunction> getter) {
 303   Frontend(receiver(), name);
 304   GenerateLoadViaGetter(masm(), type(), receiver(), getter);
 305   return GetCode(kind(), Code::FAST, name);
 306 }
 307
 308
 309 // TODO(verwaest): Cleanup. holder() is actually the receiver.
 310 Handle<Code> NamedStoreHandlerCompiler::CompileStoreTransition(
 311     Handle<Map> transition, Handle<Name> name) {
 312   Label miss;
 313
 314   // Ensure no transitions to deprecated maps are followed.
 315   __ CheckMapDeprecated(transition, scratch1(), &miss);
 316
 317   // Check that we are allowed to write this.
 318   bool is_nonexistent = holder()->map() == transition->GetBackPointer();
 319   if (is_nonexistent) {
 320     // Find the top object.
 321     Handle<JSObject> last;
 322     PrototypeIterator iter(isolate(), holder());
 323     while (!iter.IsAtEnd()) {
 324       last = Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
 325       iter.Advance();
 326     }
 327     if (!last.is_null()) set_holder(last);
 328     NonexistentFrontendHeader(name, &miss, scratch1(), scratch2());
 329   } else {
 330     FrontendHeader(receiver(), name, &miss);
 331     DCHECK(holder()->HasFastProperties());
 332   }
 333
 334   int descriptor = transition->LastAdded();
 335   DescriptorArray* descriptors = transition->instance_descriptors();
 336   PropertyDetails details = descriptors->GetDetails(descriptor);
 337   Representation representation = details.representation();
 338   DCHECK(!representation.IsNone());
 339
 340   // Stub is never generated for objects that require access checks.
 341   DCHECK(!transition->is_access_check_needed());
 342
 343   // Call to respective StoreTransitionStub.
 344   if (details.type() == CONSTANT) {
 345     GenerateConstantCheck(descriptors->GetValue(descriptor), value(), &miss);
 346
 347     GenerateRestoreNameAndMap(name, transition);
 348     StoreTransitionStub stub(isolate());
 349     GenerateTailCall(masm(), stub.GetCode());
 350
 351   } else {
 352     if (representation.IsHeapObject()) {
 353       GenerateFieldTypeChecks(descriptors->GetFieldType(descriptor), value(),
 354                               &miss);
 355     }
 356     StoreTransitionStub::StoreMode store_mode =
 357         Map::cast(transition->GetBackPointer())->unused_property_fields() == 0
 358             ? StoreTransitionStub::ExtendStorageAndStoreMapAndValue
 359             : StoreTransitionStub::StoreMapAndValue;
 360
 361     GenerateRestoreNameAndMap(name, transition);
 362     StoreTransitionStub stub(isolate(),
 363                              FieldIndex::ForDescriptor(*transition, descriptor),
 364                              representation, store_mode);
 365     GenerateTailCall(masm(), stub.GetCode());
 366   }
 367
 368   GenerateRestoreName(&miss, name);
 369   TailCallBuiltin(masm(), MissBuiltin(kind()));
 370
 371   return GetCode(kind(), Code::FAST, name);
 372 }
 373
 374
 375 Handle<Code> NamedStoreHandlerCompiler::CompileStoreField(LookupIterator* it) {
 376   Label miss;
 377   DCHECK(it->representation().IsHeapObject());
 378
 379   GenerateFieldTypeChecks(*it->GetFieldType(), value(), &miss);
 380   StoreFieldStub stub(isolate(), it->GetFieldIndex(), it->representation());
 381   GenerateTailCall(masm(), stub.GetCode());
 382
 383   __ bind(&miss);
 384   TailCallBuiltin(masm(), MissBuiltin(kind()));
 385   return GetCode(kind(), Code::FAST, it->name());
 386 }
 387
 388
 389 Handle<Code> NamedStoreHandlerCompiler::CompileStoreViaSetter(
 390     Handle<JSObject> object, Handle<Name> name, Handle<JSFunction> setter) {
 391   Frontend(receiver(), name);
 392   GenerateStoreViaSetter(masm(), type(), receiver(), setter);
 393
 394   return GetCode(kind(), Code::FAST, name);
 395 }
 396
 397
 398 Handle<Code> NamedStoreHandlerCompiler::CompileStoreCallback(
 399     Handle<JSObject> object, Handle<Name> name,
 400     const CallOptimization& call_optimization) {
 401   Frontend(receiver(), name);
 402   Register values[] = {value()};
 403   GenerateFastApiCall(masm(), call_optimization, handle(object->map()),
 404                       receiver(), scratch1(), true, 1, values);
 405   return GetCode(kind(), Code::FAST, name);
 406 }
 407
 408
 409 #undef __
 410
 411
 412 void ElementHandlerCompiler::CompileElementHandlers(
 413     MapHandleList* receiver_maps, CodeHandleList* handlers) {
 414   for (int i = 0; i < receiver_maps->length(); ++i) {
 415     Handle<Map> receiver_map = receiver_maps->at(i);
 416     Handle<Code> cached_stub;
 417
 418     if (receiver_map->IsStringMap()) {
 419       cached_stub = LoadIndexedStringStub(isolate()).GetCode();
 420     } else if (receiver_map->instance_type() < FIRST_JS_RECEIVER_TYPE) {
 421       cached_stub = isolate()->builtins()->KeyedLoadIC_Slow();
 422     } else {
 423       bool is_js_array = receiver_map->instance_type() == JS_ARRAY_TYPE;
 424       ElementsKind elements_kind = receiver_map->elements_kind();
 425       if (receiver_map->has_indexed_interceptor()) {
 426         cached_stub = LoadIndexedInterceptorStub(isolate()).GetCode();
 427       } else if (IsSloppyArgumentsElements(elements_kind)) {
 428         cached_stub = KeyedLoadSloppyArgumentsStub(isolate()).GetCode();
 429       } else if (IsFastElementsKind(elements_kind) ||
 430                  IsExternalArrayElementsKind(elements_kind) ||
 431                  IsFixedTypedArrayElementsKind(elements_kind)) {
 432         cached_stub = LoadFastElementStub(isolate(), is_js_array, elements_kind)
 433                           .GetCode();
 434       } else {
 435         DCHECK(elements_kind == DICTIONARY_ELEMENTS);
 436         cached_stub = LoadDictionaryElementStub(isolate()).GetCode();
 437       }
 438     }
 439
 440     handlers->Add(cached_stub);
 441   }
 442 }
 443 }
 444 }  // namespace v8::internal