Support deferred library prefix syntax

runtime/vm/object.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 107 matching lines @@
 RawClass* Object::patch_class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::function_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::closure_data_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::redirection_data_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::field_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::literal_token_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::token_stream_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::script_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
-RawClass* Object::library_prefix_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::namespace_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::code_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instructions_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::pc_descriptors_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::stackmap_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::var_descriptors_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::exception_handlers_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::deopt_info_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ skipping 423 matching lines @@
 
   cls = Class::New<TokenStream>();
   token_stream_class_ = cls.raw();
 
   cls = Class::New<Script>();
   script_class_ = cls.raw();
 
   cls = Class::New<Library>();
   library_class_ = cls.raw();
 
-  cls = Class::New<LibraryPrefix>();
-  library_prefix_class_ = cls.raw();
-
   cls = Class::New<Namespace>();
   namespace_class_ = cls.raw();
 
   cls = Class::New<Code>();
   code_class_ = cls.raw();
 
   cls = Class::New<Instructions>();
   instructions_class_ = cls.raw();
 
   cls = Class::New<PcDescriptors>();
@@ skipping 178 matching lines @@
   SET_CLASS_NAME(type_arguments, TypeArguments);
   SET_CLASS_NAME(patch_class, PatchClass);
   SET_CLASS_NAME(function, Function);
   SET_CLASS_NAME(closure_data, ClosureData);
   SET_CLASS_NAME(redirection_data, RedirectionData);
   SET_CLASS_NAME(field, Field);
   SET_CLASS_NAME(literal_token, LiteralToken);
   SET_CLASS_NAME(token_stream, TokenStream);
   SET_CLASS_NAME(script, Script);
   SET_CLASS_NAME(library, LibraryClass);
-  SET_CLASS_NAME(library_prefix, LibraryPrefix);
   SET_CLASS_NAME(namespace, Namespace);
   SET_CLASS_NAME(code, Code);
   SET_CLASS_NAME(instructions, Instructions);
   SET_CLASS_NAME(pc_descriptors, PcDescriptors);
   SET_CLASS_NAME(stackmap, Stackmap);
   SET_CLASS_NAME(var_descriptors, LocalVarDescriptors);
   SET_CLASS_NAME(exception_handlers, ExceptionHandlers);
   SET_CLASS_NAME(deopt_info, DeoptInfo);
   SET_CLASS_NAME(context, Context);
   SET_CLASS_NAME(context_scope, ContextScope);
@@ skipping 154 matching lines @@
 
   cls = Class::New<TypeParameter>();
   object_store->set_type_parameter_class(cls);
 
   cls = Class::New<BoundedType>();
   object_store->set_bounded_type_class(cls);
 
   cls = Class::New<MixinAppType>();
   object_store->set_mixin_app_type_class(cls);
 
+  cls = Class::New<LibraryPrefix>();
+  object_store->set_library_prefix_class(cls);
+
   // Pre-allocate the OneByteString class needed by the symbol table.
   cls = Class::NewStringClass(kOneByteStringCid);
   object_store->set_one_byte_string_class(cls);
 
   // Pre-allocate the TwoByteString class needed by the symbol table.
   cls = Class::NewStringClass(kTwoByteStringCid);
   object_store->set_two_byte_string_class(cls);
 
   // Setup the symbol table for the symbols created in the isolate.
   Symbols::SetupSymbolTable(isolate);
@@ skipping 98 matching lines @@
   pending_classes.Add(cls);
 
   cls = Class::New<Instance>(kNullCid);
   object_store->set_null_class(cls);
   cls.set_num_type_arguments(0);
   cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   RegisterClass(cls, Symbols::Null(), core_lib);
   pending_classes.Add(cls);
 
+  cls = object_store->library_prefix_class();
+  ASSERT(!cls.IsNull());
+  RegisterPrivateClass(cls, Symbols::_LibraryPrefix(), core_lib);
+  pending_classes.Add(cls);
+
   cls = object_store->type_class();
   RegisterPrivateClass(cls, Symbols::Type(), core_lib);
   pending_classes.Add(cls);
 
   cls = object_store->type_ref_class();
   RegisterPrivateClass(cls, Symbols::TypeRef(), core_lib);
   pending_classes.Add(cls);
 
   cls = object_store->type_parameter_class();
   RegisterPrivateClass(cls, Symbols::TypeParameter(), core_lib);
@@ skipping 254 matching lines @@
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle();
 
   // Set up empty classes in the object store, these will get
   // initialized correctly when we read from the snapshot.
   // This is done to allow bootstrapping of reading classes from the snapshot.
   cls = Class::New<Instance>(kInstanceCid);
   object_store->set_object_class(cls);
 
+  cls = Class::New<LibraryPrefix>();
+  object_store->set_library_prefix_class(cls);
+
   cls = Class::New<Type>();
   object_store->set_type_class(cls);
 
   cls = Class::New<TypeRef>();
   object_store->set_type_ref_class(cls);
 
   cls = Class::New<TypeParameter>();
   object_store->set_type_parameter_class(cls);
 
   cls = Class::New<BoundedType>();
@@ skipping 1086 matching lines @@
       weak_property ^= code_objects.At(i);
       code ^= weak_property.key();
       if (code.IsNull()) {
         // Code was garbage collected already.
         continue;
       }
 
       function ^= code.function();
       // If function uses dependent code switch it to unoptimized.
       if (function.CurrentCode() == code.raw()) {
-        ASSERT(function.HasOptimizedCode());
         ReportSwitchingCode(code);
-        function.SwitchToUnoptimizedCode();
+        if (code.is_optimized()) {
+          function.SwitchToUnoptimizedCode();
+        } else {
+          function.ClearCode();
+        }
       }
     }
   }
 
  private:
   const Array& array_;
   DISALLOW_COPY_AND_ASSIGN(WeakCodeReferences);
 };
 
 
@@ skipping 6686 matching lines @@
       }
     }
   }
   return false;
 }
 
 
 void LibraryPrefix::AddImport(const Namespace& import) const {
   intptr_t num_current_imports = num_imports();
 
+  // Prefixes with deferred libraries can only contain one library.
+  ASSERT((num_current_imports == 0) || !is_deferred_load());
+
   // The library needs to be added to the list.
   Array& imports = Array::Handle(this->imports());
   const intptr_t length = (imports.IsNull()) ? 0 : imports.Length();
   // Grow the list if it is full.
   if (num_current_imports >= length) {
     const intptr_t new_length = length + kIncrementSize;
     imports = Array::Grow(imports, new_length, Heap::kOld);
     set_imports(imports);
   }
   imports.SetAt(num_current_imports, import);
   set_num_imports(num_current_imports + 1);
 }
 
 
 RawObject* LibraryPrefix::LookupObject(const String& name) const {
+  if (!is_loaded()) {
+    return Object::null();
+  }
   Array& imports = Array::Handle(this->imports());
   Object& obj = Object::Handle();
   Namespace& import = Namespace::Handle();
   Library& import_lib = Library::Handle();
   String& import_lib_url = String::Handle();
   String& first_import_lib_url = String::Handle();
   Object& found_obj = Object::Handle();
   for (intptr_t i = 0; i < num_imports(); i++) {
     import ^= imports.At(i);
     obj = import.Lookup(name);
@@ skipping 26 matching lines @@
 
 RawClass* LibraryPrefix::LookupClass(const String& class_name) const {
   const Object& obj = Object::Handle(LookupObject(class_name));
   if (obj.IsClass()) {
     return Class::Cast(obj).raw();
   }
   return Class::null();
 }
 
 
+void LibraryPrefix::set_is_loaded() const {
+  raw_ptr()->is_loaded_ = true;
+}
+
+
+void LibraryPrefix::LoadLibrary() const {
+  // Non-deferred prefixes are loaded.
+  ASSERT(is_deferred_load() || is_loaded());
+  if (is_loaded()) {
+    return;
+  }
+  InvalidateDependentCode();
+  set_is_loaded();
+}
+
+
+RawArray* LibraryPrefix::dependent_code() const {
+  return raw_ptr()->dependent_code_;
+}
+
+
+void LibraryPrefix::set_dependent_code(const Array& array) const {
+  StorePointer(&raw_ptr()->dependent_code_, array.raw());
+}
+
+
+class PrefixDependentArray : public WeakCodeReferences {
+ public:
+  explicit PrefixDependentArray(const LibraryPrefix& prefix)
+      : WeakCodeReferences(Array::Handle(prefix.dependent_code())),
+                           prefix_(prefix) {}
+
+  virtual void UpdateArrayTo(const Array& value) {
+    prefix_.set_dependent_code(value);
+  }
+
+  virtual void ReportDeoptimization(const Code& code) {
+    // This gets called when the code object is on the stack
+    // while nuking code that depends on a prefix. We don't expect
+    // this to happen, so make sure we die loudly if we find
+    // ourselves here.
+    UNIMPLEMENTED();
+  }
+
+  virtual void ReportSwitchingCode(const Code& code) {
+    if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
+      OS::PrintErr("Prefix '%s': deleting code for function '%s'\n",
+        String::Handle(prefix_.name()).ToCString(),
+        Function::Handle(code.function()).ToCString());
+    }
+  }
+
+ private:
+  const LibraryPrefix& prefix_;
+  DISALLOW_COPY_AND_ASSIGN(PrefixDependentArray);
+};
+
+
+void LibraryPrefix::RegisterDependentCode(const Code& code) const {
+  ASSERT(is_deferred_load());
+  ASSERT(!is_loaded());
+  PrefixDependentArray a(*this);
+  a.Register(code);
+}
+
+
+void LibraryPrefix::InvalidateDependentCode() const {
+  PrefixDependentArray a(*this);
+  a.DisableCode();
+}
+
+
 RawLibraryPrefix* LibraryPrefix::New() {
-  ASSERT(Object::library_prefix_class() != Class::null());
+  ASSERT(Isolate::Current()->object_store()->library_prefix_class() !=
+      Class::null());
   RawObject* raw = Object::Allocate(LibraryPrefix::kClassId,
                                     LibraryPrefix::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLibraryPrefix*>(raw);
 }
 
 
 RawLibraryPrefix* LibraryPrefix::New(const String& name,
-                                     const Namespace& import) {
+                                     const Namespace& import,
+                                     bool deferred_load) {
   const LibraryPrefix& result = LibraryPrefix::Handle(LibraryPrefix::New());
   result.set_name(name);
   result.set_num_imports(0);
+  result.raw_ptr()->is_deferred_load_ = deferred_load;
+  result.raw_ptr()->is_loaded_ = !deferred_load;
   result.set_imports(Array::Handle(Array::New(kInitialSize)));
   result.AddImport(import);
+  result.set_dependent_code(Object::null_array());
   return result.raw();
 }
 
 
 void LibraryPrefix::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
@@ skipping 8870 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart