src/v8/src/contexts.cc

   1 // Copyright 2011 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/bootstrapper.h"
   8 #include "src/debug.h"
   9 #include "src/scopeinfo.h"
  10
  11 namespace v8 {
  12 namespace internal {
  13
  14 Context* Context::declaration_context() {
  15   Context* current = this;
  16   while (!current->IsFunctionContext() && !current->IsNativeContext()) {
  17     current = current->previous();
  18     DCHECK(current->closure() == closure());
  19   }
  20   return current;
  21 }
  22
  23
  24 JSBuiltinsObject* Context::builtins() {
  25   GlobalObject* object = global_object();
  26   if (object->IsJSGlobalObject()) {
  27     return JSGlobalObject::cast(object)->builtins();
  28   } else {
  29     DCHECK(object->IsJSBuiltinsObject());
  30     return JSBuiltinsObject::cast(object);
  31   }
  32 }
  33
  34
  35 Context* Context::global_context() {
  36   Context* current = this;
  37   while (!current->IsGlobalContext()) {
  38     current = current->previous();
  39   }
  40   return current;
  41 }
  42
  43
  44 Context* Context::native_context() {
  45   // Fast case: the global object for this context has been set.  In
  46   // that case, the global object has a direct pointer to the global
  47   // context.
  48   if (global_object()->IsGlobalObject()) {
  49     return global_object()->native_context();
  50   }
  51
  52   // During bootstrapping, the global object might not be set and we
  53   // have to search the context chain to find the native context.
  54   DCHECK(this->GetIsolate()->bootstrapper()->IsActive());
  55   Context* current = this;
  56   while (!current->IsNativeContext()) {
  57     JSFunction* closure = JSFunction::cast(current->closure());
  58     current = Context::cast(closure->context());
  59   }
  60   return current;
  61 }
  62
  63
  64 JSObject* Context::global_proxy() {
  65   return native_context()->global_proxy_object();
  66 }
  67
  68
  69 void Context::set_global_proxy(JSObject* object) {
  70   native_context()->set_global_proxy_object(object);
  71 }
  72
  73
  74 /**
  75  * Lookups a property in an object environment, taking the unscopables into
  76  * account. This is used For HasBinding spec algorithms for ObjectEnvironment.
  77  */
  78 static Maybe<PropertyAttributes> UnscopableLookup(LookupIterator* it) {
  79   Isolate* isolate = it->isolate();
  80
  81   Maybe<PropertyAttributes> attrs = JSReceiver::GetPropertyAttributes(it);
  82   DCHECK(attrs.has_value || isolate->has_pending_exception());
  83   if (!attrs.has_value || attrs.value == ABSENT) return attrs;
  84
  85   Handle<Symbol> unscopables_symbol(
  86       isolate->native_context()->unscopables_symbol(), isolate);
  87   Handle<Object> receiver = it->GetReceiver();
  88   Handle<Object> unscopables;
  89   MaybeHandle<Object> maybe_unscopables =
  90       Object::GetProperty(receiver, unscopables_symbol);
  91   if (!maybe_unscopables.ToHandle(&unscopables)) {
  92     return Maybe<PropertyAttributes>();
  93   }
  94   if (!unscopables->IsSpecObject()) return attrs;
  95   Maybe<bool> blacklist = JSReceiver::HasProperty(
  96       Handle<JSReceiver>::cast(unscopables), it->name());
  97   if (!blacklist.has_value) {
  98     DCHECK(isolate->has_pending_exception());
  99     return Maybe<PropertyAttributes>();
 100   }
 101   if (blacklist.value) return maybe(ABSENT);
 102   return attrs;
 103 }
 104
 105
 106 Handle<Object> Context::Lookup(Handle<String> name,
 107                                ContextLookupFlags flags,
 108                                int* index,
 109                                PropertyAttributes* attributes,
 110                                BindingFlags* binding_flags) {
 111   Isolate* isolate = GetIsolate();
 112   Handle<Context> context(this, isolate);
 113
 114   bool follow_context_chain = (flags & FOLLOW_CONTEXT_CHAIN) != 0;
 115   *index = -1;
 116   *attributes = ABSENT;
 117   *binding_flags = MISSING_BINDING;
 118
 119   if (FLAG_trace_contexts) {
 120     PrintF("Context::Lookup(");
 121     name->ShortPrint();
 122     PrintF(")\n");
 123   }
 124
 125   do {
 126     if (FLAG_trace_contexts) {
 127       PrintF(" - looking in context %p", reinterpret_cast<void*>(*context));
 128       if (context->IsNativeContext()) PrintF(" (native context)");
 129       PrintF("\n");
 130     }
 131
 132     // 1. Check global objects, subjects of with, and extension objects.
 133     if (context->IsNativeContext() ||
 134         context->IsWithContext() ||
 135         (context->IsFunctionContext() && context->has_extension())) {
 136       Handle<JSReceiver> object(
 137           JSReceiver::cast(context->extension()), isolate);
 138       // Context extension objects needs to behave as if they have no
 139       // prototype.  So even if we want to follow prototype chains, we need
 140       // to only do a local lookup for context extension objects.
 141       Maybe<PropertyAttributes> maybe;
 142       if ((flags & FOLLOW_PROTOTYPE_CHAIN) == 0 ||
 143           object->IsJSContextExtensionObject()) {
 144         maybe = JSReceiver::GetOwnPropertyAttributes(object, name);
 145       } else if (context->IsWithContext()) {
 146         LookupIterator it(object, name);
 147         maybe = UnscopableLookup(&it);
 148       } else {
 149         maybe = JSReceiver::GetPropertyAttributes(object, name);
 150       }
 151
 152       if (!maybe.has_value) return Handle<Object>();
 153       DCHECK(!isolate->has_pending_exception());
 154       *attributes = maybe.value;
 155
 156       if (maybe.value != ABSENT) {
 157         if (FLAG_trace_contexts) {
 158           PrintF("=> found property in context object %p\n",
 159                  reinterpret_cast<void*>(*object));
 160         }
 161         return object;
 162       }
 163     }
 164
 165     // 2. Check the context proper if it has slots.
 166     if (context->IsFunctionContext() || context->IsBlockContext()) {
 167       // Use serialized scope information of functions and blocks to search
 168       // for the context index.
 169       Handle<ScopeInfo> scope_info;
 170       if (context->IsFunctionContext()) {
 171         scope_info = Handle<ScopeInfo>(
 172             context->closure()->shared()->scope_info(), isolate);
 173       } else {
 174         scope_info = Handle<ScopeInfo>(
 175             ScopeInfo::cast(context->extension()), isolate);
 176       }
 177       VariableMode mode;
 178       InitializationFlag init_flag;
 179       // TODO(sigurds) Figure out whether maybe_assigned_flag should
 180       // be used to compute binding_flags.
 181       MaybeAssignedFlag maybe_assigned_flag;
 182       int slot_index = ScopeInfo::ContextSlotIndex(
 183           scope_info, name, &mode, &init_flag, &maybe_assigned_flag);
 184       DCHECK(slot_index < 0 || slot_index >= MIN_CONTEXT_SLOTS);
 185       if (slot_index >= 0) {
 186         if (FLAG_trace_contexts) {
 187           PrintF("=> found local in context slot %d (mode = %d)\n",
 188                  slot_index, mode);
 189         }
 190         *index = slot_index;
 191         // Note: Fixed context slots are statically allocated by the compiler.
 192         // Statically allocated variables always have a statically known mode,
 193         // which is the mode with which they were declared when added to the
 194         // scope. Thus, the DYNAMIC mode (which corresponds to dynamically
 195         // declared variables that were introduced through declaration nodes)
 196         // must not appear here.
 197         switch (mode) {
 198           case INTERNAL:  // Fall through.
 199           case VAR:
 200             *attributes = NONE;
 201             *binding_flags = MUTABLE_IS_INITIALIZED;
 202             break;
 203           case LET:
 204             *attributes = NONE;
 205             *binding_flags = (init_flag == kNeedsInitialization)
 206                 ? MUTABLE_CHECK_INITIALIZED : MUTABLE_IS_INITIALIZED;
 207             break;
 208           case CONST_LEGACY:
 209             *attributes = READ_ONLY;
 210             *binding_flags = (init_flag == kNeedsInitialization)
 211                 ? IMMUTABLE_CHECK_INITIALIZED : IMMUTABLE_IS_INITIALIZED;
 212             break;
 213           case CONST:
 214             *attributes = READ_ONLY;
 215             *binding_flags = (init_flag == kNeedsInitialization)
 216                 ? IMMUTABLE_CHECK_INITIALIZED_HARMONY :
 217                 IMMUTABLE_IS_INITIALIZED_HARMONY;
 218             break;
 219           case MODULE:
 220             *attributes = READ_ONLY;
 221             *binding_flags = IMMUTABLE_IS_INITIALIZED_HARMONY;
 222             break;
 223           case DYNAMIC:
 224           case DYNAMIC_GLOBAL:
 225           case DYNAMIC_LOCAL:
 226           case TEMPORARY:
 227             UNREACHABLE();
 228             break;
 229         }
 230         return context;
 231       }
 232
 233       // Check the slot corresponding to the intermediate context holding
 234       // only the function name variable.
 235       if (follow_context_chain && context->IsFunctionContext()) {
 236         VariableMode mode;
 237         int function_index = scope_info->FunctionContextSlotIndex(*name, &mode);
 238         if (function_index >= 0) {
 239           if (FLAG_trace_contexts) {
 240             PrintF("=> found intermediate function in context slot %d\n",
 241                    function_index);
 242           }
 243           *index = function_index;
 244           *attributes = READ_ONLY;
 245           DCHECK(mode == CONST_LEGACY || mode == CONST);
 246           *binding_flags = (mode == CONST_LEGACY)
 247               ? IMMUTABLE_IS_INITIALIZED : IMMUTABLE_IS_INITIALIZED_HARMONY;
 248           return context;
 249         }
 250       }
 251
 252     } else if (context->IsCatchContext()) {
 253       // Catch contexts have the variable name in the extension slot.
 254       if (String::Equals(name, handle(String::cast(context->extension())))) {
 255         if (FLAG_trace_contexts) {
 256           PrintF("=> found in catch context\n");
 257         }
 258         *index = Context::THROWN_OBJECT_INDEX;
 259         *attributes = NONE;
 260         *binding_flags = MUTABLE_IS_INITIALIZED;
 261         return context;
 262       }
 263     }
 264
 265     // 3. Prepare to continue with the previous (next outermost) context.
 266     if (context->IsNativeContext()) {
 267       follow_context_chain = false;
 268     } else {
 269       context = Handle<Context>(context->previous(), isolate);
 270     }
 271   } while (follow_context_chain);
 272
 273   if (FLAG_trace_contexts) {
 274     PrintF("=> no property/slot found\n");
 275   }
 276   return Handle<Object>::null();
 277 }
 278
 279
 280 void Context::AddOptimizedFunction(JSFunction* function) {
 281   DCHECK(IsNativeContext());
 282 #ifdef ENABLE_SLOW_DCHECKS
 283   if (FLAG_enable_slow_asserts) {
 284     Object* element = get(OPTIMIZED_FUNCTIONS_LIST);
 285     while (!element->IsUndefined()) {
 286       CHECK(element != function);
 287       element = JSFunction::cast(element)->next_function_link();
 288     }
 289   }
 290
 291   // Check that the context belongs to the weak native contexts list.
 292   bool found = false;
 293   Object* context = GetHeap()->native_contexts_list();
 294   while (!context->IsUndefined()) {
 295     if (context == this) {
 296       found = true;
 297       break;
 298     }
 299     context = Context::cast(context)->get(Context::NEXT_CONTEXT_LINK);
 300   }
 301   CHECK(found);
 302 #endif
 303
 304   // If the function link field is already used then the function was
 305   // enqueued as a code flushing candidate and we remove it now.
 306   if (!function->next_function_link()->IsUndefined()) {
 307     CodeFlusher* flusher = GetHeap()->mark_compact_collector()->code_flusher();
 308     flusher->EvictCandidate(function);
 309   }
 310
 311   DCHECK(function->next_function_link()->IsUndefined());
 312
 313   function->set_next_function_link(get(OPTIMIZED_FUNCTIONS_LIST));
 314   set(OPTIMIZED_FUNCTIONS_LIST, function);
 315 }
 316
 317
 318 void Context::RemoveOptimizedFunction(JSFunction* function) {
 319   DCHECK(IsNativeContext());
 320   Object* element = get(OPTIMIZED_FUNCTIONS_LIST);
 321   JSFunction* prev = NULL;
 322   while (!element->IsUndefined()) {
 323     JSFunction* element_function = JSFunction::cast(element);
 324     DCHECK(element_function->next_function_link()->IsUndefined() ||
 325            element_function->next_function_link()->IsJSFunction());
 326     if (element_function == function) {
 327       if (prev == NULL) {
 328         set(OPTIMIZED_FUNCTIONS_LIST, element_function->next_function_link());
 329       } else {
 330         prev->set_next_function_link(element_function->next_function_link());
 331       }
 332       element_function->set_next_function_link(GetHeap()->undefined_value());
 333       return;
 334     }
 335     prev = element_function;
 336     element = element_function->next_function_link();
 337   }
 338   UNREACHABLE();
 339 }
 340
 341
 342 void Context::SetOptimizedFunctionsListHead(Object* head) {
 343   DCHECK(IsNativeContext());
 344   set(OPTIMIZED_FUNCTIONS_LIST, head);
 345 }
 346
 347
 348 Object* Context::OptimizedFunctionsListHead() {
 349   DCHECK(IsNativeContext());
 350   return get(OPTIMIZED_FUNCTIONS_LIST);
 351 }
 352
 353
 354 void Context::AddOptimizedCode(Code* code) {
 355   DCHECK(IsNativeContext());
 356   DCHECK(code->kind() == Code::OPTIMIZED_FUNCTION);
 357   DCHECK(code->next_code_link()->IsUndefined());
 358   code->set_next_code_link(get(OPTIMIZED_CODE_LIST));
 359   set(OPTIMIZED_CODE_LIST, code);
 360 }
 361
 362
 363 void Context::SetOptimizedCodeListHead(Object* head) {
 364   DCHECK(IsNativeContext());
 365   set(OPTIMIZED_CODE_LIST, head);
 366 }
 367
 368
 369 Object* Context::OptimizedCodeListHead() {
 370   DCHECK(IsNativeContext());
 371   return get(OPTIMIZED_CODE_LIST);
 372 }
 373
 374
 375 void Context::SetDeoptimizedCodeListHead(Object* head) {
 376   DCHECK(IsNativeContext());
 377   set(DEOPTIMIZED_CODE_LIST, head);
 378 }
 379
 380
 381 Object* Context::DeoptimizedCodeListHead() {
 382   DCHECK(IsNativeContext());
 383   return get(DEOPTIMIZED_CODE_LIST);
 384 }
 385
 386
 387 Handle<Object> Context::ErrorMessageForCodeGenerationFromStrings() {
 388   Isolate* isolate = GetIsolate();
 389   Handle<Object> result(error_message_for_code_gen_from_strings(), isolate);
 390   if (!result->IsUndefined()) return result;
 391   return isolate->factory()->NewStringFromStaticChars(
 392       "Code generation from strings disallowed for this context");
 393 }
 394
 395
 396 #ifdef DEBUG
 397 bool Context::IsBootstrappingOrValidParentContext(
 398     Object* object, Context* child) {
 399   // During bootstrapping we allow all objects to pass as
 400   // contexts. This is necessary to fix circular dependencies.
 401   if (child->GetIsolate()->bootstrapper()->IsActive()) return true;
 402   if (!object->IsContext()) return false;
 403   Context* context = Context::cast(object);
 404   return context->IsNativeContext() || context->IsGlobalContext() ||
 405          context->IsModuleContext() || !child->IsModuleContext();
 406 }
 407
 408
 409 bool Context::IsBootstrappingOrGlobalObject(Isolate* isolate, Object* object) {
 410   // During bootstrapping we allow all objects to pass as global
 411   // objects. This is necessary to fix circular dependencies.
 412   return isolate->heap()->gc_state() != Heap::NOT_IN_GC ||
 413       isolate->bootstrapper()->IsActive() ||
 414       object->IsGlobalObject();
 415 }
 416 #endif
 417
 418 } }  // namespace v8::internal