- Support for patching of class methods and fields.

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/bigint_operations.h"
@@ skipping 56 matching lines @@
 RawClass* Object::null_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::dynamic_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::void_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unresolved_class_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_parameter_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instantiated_type_arguments_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::patch_class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::function_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::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);
@@ skipping 194 matching lines @@
 
   cls = Class::New<TypeParameter>();
   type_parameter_class_ = cls.raw();
 
   cls = Class::New<TypeArguments>();
   type_arguments_class_ = cls.raw();
 
   cls = Class::New<InstantiatedTypeArguments>();
   instantiated_type_arguments_class_ = cls.raw();
 
+  cls = Class::New<PatchClass>();
+  patch_class_class_ = cls.raw();
+
   cls = Class::New<Function>();
   function_class_ = cls.raw();
 
   cls = Class::New<Field>();
   field_class_ = cls.raw();
 
   cls = Class::New<LiteralToken>();
   literal_token_class_ = cls.raw();
 
   cls = Class::New<TokenStream>();
@@ skipping 922 matching lines @@
 }
 
 void Class::SetFunctions(const Array& value) const {
   ASSERT(!value.IsNull());
 #if defined(DEBUG)
   // Verify that all the functions in the array have this class as owner.
   Function& func = Function::Handle();
   intptr_t len = value.Length();
   for (intptr_t i = 0; i < len; i++) {
     func ^= value.At(i);
-    ASSERT(func.owner() == raw());
+    ASSERT(func.Owner() == raw());
   }
 #endif
   StorePointer(&raw_ptr()->functions_, value.raw());
 }
 
 
 void Class::AddClosureFunction(const Function& function) const {
   GrowableObjectArray& closures =
       GrowableObjectArray::Handle(raw_ptr()->closure_functions_);
   if (closures.IsNull()) {
@@ skipping 69 matching lines @@
 
 
 intptr_t Class::NumTypeArguments() const {
   // To work properly, this call requires the super class of this class to be
   // resolved, which is checked by the SuperClass() call.
   Class& cls = Class::Handle(raw());
   if (IsSignatureClass()) {
     const Function& signature_fun = Function::Handle(signature_function());
     if (!signature_fun.is_static() &&
         !signature_fun.HasInstantiatedSignature()) {
-      cls = signature_fun.owner();
+      cls = signature_fun.Owner();
     }
   }
   intptr_t num_type_args = NumTypeParameters();
   const Class& superclass = Class::Handle(cls.SuperClass());
   // Object is its own super class during bootstrap.
   if (!superclass.IsNull() && (superclass.raw() != raw())) {
     num_type_args += superclass.NumTypeArguments();
   }
   return num_type_args;
 }
@@ skipping 139 matching lines @@
   // Prefinalized classes have a VM internal representation and no Dart fields.
   // Their instance size  is precomputed and field offsets are known.
   if (!is_prefinalized()) {
     // Compute offsets of instance fields and instance size.
     CalculateFieldOffsets();
   }
   set_is_finalized();
 }
 
 
+void Class::ApplyPatch(const Class& with) const {
+  ASSERT(!is_finalized());
+  const Script& patch_script = Script::Handle(with.script());
+  const String& str = String::Handle(patch_script.Source());
+  OS::PrintErr("patch_script: %s\n", str.ToCString());

[Ivan Posva, 2012/08/14 01:21:49]

Debug print removed...

+  const PatchClass& patch = PatchClass::Handle(
+      PatchClass::New(*this, patch_script));
+
+  const Array& orig_functions = Array::Handle(functions());
+  intptr_t orig_len = orig_functions.Length();
+
+  const Array& patch_functions = Array::Handle(with.functions());
+  intptr_t patch_len = patch_functions.Length();
+
+  // TODO(iposva): Verify that only patching existing methods and adding only
+  // new private methods.
+  Function& func = Function::Handle();
+  const Array& new_functions = Array::Handle(Array::New(patch_len + orig_len));

[siva, 2012/08/15 00:16:04]

I think you should add a comment here that currently all patched functions are
prepended to the functions list and
maybe a TODO that this list will be changed to override the function in the
original list or append new functions if any.

[Ivan Posva, 2012/08/15 06:50:39]

I attempted to address the second part of your suggestion in the TODO on line
1501. I guess I failed. I will try to come up with a better wording in a
different CL unless I do implement the correct behaviour first.

+  for (intptr_t i = 0; i < patch_len; i++) {
+    func ^= patch_functions.At(i);
+    func.set_owner(patch);
+    new_functions.SetAt(i, func);
+  }
+  for (intptr_t i = 0; i < orig_len; i++) {
+    func ^= orig_functions.At(i);
+    new_functions.SetAt(patch_len + i, func);
+  }
+  SetFunctions(new_functions);
+
+  const Array& orig_fields = Array::Handle(fields());
+  orig_len = orig_fields.Length();
+
+  const Array& patch_fields = Array::Handle(with.fields());
+  patch_len = patch_fields.Length();

[siva, 2012/08/15 00:16:04]

why not call the array handle variables orig_list, patch_list and new_list. You
could then resuse them between the function and field loop.

[Ivan Posva, 2012/08/15 06:50:39]

ditto

+
+  // TODO(iposva): Verify that no duplicate fields are entered.
+  Field& field = Field::Handle();
+  const Array& new_fields = Array::Handle(Array::New(patch_len + orig_len));
+  for (intptr_t i = 0; i < patch_len; i++) {
+    field ^= patch_fields.At(i);
+    field.set_owner(*this);
+    new_fields.SetAt(i, field);
+  }
+  for (intptr_t i = 0; i < orig_len; i++) {
+    field ^= orig_fields.At(i);
+    new_fields.SetAt(patch_len + i, field);
+  }
+  SetFields(new_fields);
+}
+
+
 void Class::SetFields(const Array& value) const {
   ASSERT(!value.IsNull());
 #if defined(DEBUG)
   // Verify that all the fields in the array have this class as owner.
   Field& field = Field::Handle();
   intptr_t len = value.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= value.At(i);
     ASSERT(field.owner() == raw());
   }
@@ skipping 57 matching lines @@
   Class& result = Class::Handle(New<Instance>(name, script, token_pos));
   result.set_is_interface();
   return result.raw();
 }
 
 
 RawClass* Class::NewSignatureClass(const String& name,
                                    const Function& signature_function,
                                    const Script& script) {
   ASSERT(!signature_function.IsNull());
-  const Class& owner_class = Class::Handle(signature_function.owner());
+  const Class& owner_class = Class::Handle(signature_function.Owner());
   ASSERT(!owner_class.IsNull());
   TypeArguments& type_parameters = TypeArguments::Handle();
   // A signature class extends class Instance and is parameterized in the same
   // way as the owner class of its non-static signature function.
   // It is not type parameterized if its signature function is static.
   if (!signature_function.is_static() &&
       (owner_class.NumTypeParameters() > 0) &&
       !signature_function.HasInstantiatedSignature()) {
     type_parameters = owner_class.type_parameters();
   }
@@ skipping 1924 matching lines @@
   const char* instantiator_cstr =
       AbstractTypeArguments::Handle(instantiator_type_arguments()).ToCString();
   intptr_t len =
       OS::SNPrint(NULL, 0, format, arg_cstr, instantiator_cstr) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, arg_cstr, instantiator_cstr);
   return chars;
 }
 
 
+const char* PatchClass::ToCString() const {
+  const char* kFormat = "PatchClass for %s";
+  const Class& cls = Class::Handle(patched_class());
+  const char* cls_name = cls.ToCString();
+  intptr_t len = OS::SNPrint(NULL, 0, kFormat, cls_name) + 1;
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  OS::SNPrint(chars, len, kFormat, cls_name);
+  return chars;
+}
+
+
+RawPatchClass* PatchClass::New(const Class& patched_class,
+                               const Script& script) {
+  const PatchClass& result = PatchClass::Handle(PatchClass::New());
+  result.set_patched_class(patched_class);
+  result.set_script(script);
+  return result.raw();
+}
+
+
+RawPatchClass* PatchClass::New() {
+  ASSERT(Object::patch_class_class() != Class::null());
+  RawObject* raw = Object::Allocate(PatchClass::kClassId,
+                                    PatchClass::InstanceSize(),
+                                    Heap::kOld);
+  return reinterpret_cast<RawPatchClass*>(raw);
+}
+
+
+void PatchClass::set_patched_class(const Class& value) const {
+  StorePointer(&raw_ptr()->patched_class_, value.raw());
+}
+
+
+void PatchClass::set_script(const Script& value) const {
+  StorePointer(&raw_ptr()->script_, value.raw());
+}
+
+
 void Function::SetCode(const Code& value) const {
   StorePointer(&raw_ptr()->code_, value.raw());
   ASSERT(Function::Handle(value.function()).IsNull() ||
     (value.function() == this->raw()));
   value.set_function(*this);
 }
 
 
 void Function::SwitchToUnoptimizedCode() const {
   ASSERT(HasOptimizedCode());
@@ skipping 47 matching lines @@
   return outer_function.IsFactory();
 }
 
 
 void Function::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
-void Function::set_owner(const Class& value) const {
+void Function::set_owner(const Object& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->owner_, value.raw());
 }
 
 
 void Function::set_result_type(const AbstractType& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->result_type_, value.raw());
 }
 
@@ skipping 223 matching lines @@
 // Set 'chars' to allocated buffer and return number of written characters.
 static intptr_t ConstructFunctionFullyQualifiedCString(const Function& function,
                                                        char** chars,
                                                        intptr_t reserve_len) {
   const char* name = String::Handle(function.name()).ToCString();
   const char* function_format = (reserve_len == 0) ? "%s" : "%s_";
   reserve_len += OS::SNPrint(NULL, 0, function_format, name);
   const Function& parent = Function::Handle(function.parent_function());
   intptr_t written = 0;
   if (parent.IsNull()) {
-    const Class& function_class = Class::Handle(function.owner());
+    const Class& function_class = Class::Handle(function.Owner());
     ASSERT(!function_class.IsNull());
     const char* class_name = String::Handle(function_class.Name()).ToCString();
     ASSERT(class_name != NULL);
     const Library& library = Library::Handle(function_class.library());
     ASSERT(!library.IsNull());
     const char* library_name = String::Handle(library.url()).ToCString();
     ASSERT(library_name != NULL);
     const char* lib_class_format =
         (library_name[0] == '\0') ? "%s%s_" : "%s_%s_";
     reserve_len +=
@@ skipping 219 matching lines @@
   result.set_is_native(false);
   return result.raw();
 }
 
 
 RawFunction* Function::NewClosureFunction(const String& name,
                                           const Function& parent,
                                           intptr_t token_pos) {
   ASSERT(name.IsOneByteString());
   ASSERT(!parent.IsNull());
-  const Class& parent_class = Class::Handle(parent.owner());
+  const Class& parent_class = Class::Handle(parent.Owner());
   ASSERT(!parent_class.IsNull());
   const Function& result = Function::Handle(
       Function::New(name,
                     RawFunction::kClosureFunction,
                     /* is_static = */ parent.is_static(),
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     parent_class,
                     token_pos));
@@ skipping 41 matching lines @@
   String& param_name = String::Handle();
   for (int i = 0; i < num_params; i++) {
     param_type = ParameterTypeAt(i + has_receiver);
     closure_function.SetParameterTypeAt(i, param_type);
     param_name = ParameterNameAt(i + has_receiver);
     closure_function.SetParameterNameAt(i, param_name);
   }
 
   // Lookup or create a new signature class for the closure function in the
   // library of the owner class.
-  const Class& owner_class = Class::Handle(owner());
-  ASSERT(!owner_class.IsNull() && (owner() == closure_function.owner()));
+  const Class& owner_class = Class::Handle(Owner());
+  ASSERT(!owner_class.IsNull() && (Owner() == closure_function.Owner()));
   const Library& library = Library::Handle(owner_class.library());
   ASSERT(!library.IsNull());
   const String& signature = String::Handle(closure_function.Signature());
   Class& signature_class = Class::ZoneHandle(
       library.LookupLocalClass(signature));
   if (signature_class.IsNull()) {
-    const Script& script = Script::Handle(owner_class.script());
+    const Script& script = Script::Handle(this->script());
     signature_class = Class::NewSignatureClass(signature,
                                                closure_function,
                                                script);
     library.AddClass(signature_class);
   } else {
     closure_function.set_signature_class(signature_class);
   }
   const Type& signature_type = Type::Handle(signature_class.SignatureType());
   if (!signature_type.IsFinalized()) {
     ClassFinalizer::FinalizeType(
@@ skipping 19 matching lines @@
   const String& kLBracket = String::Handle(Symbols::New("["));
   const String& kRBracket = String::Handle(Symbols::New("]"));
   String& name = String::Handle();
   if (!instantiate && !is_static()) {
     // Prefix the signature with its type parameters, if any (e.g. "<K, V>").
     // The signature of static functions cannot be type parameterized.
     const String& kSpaceExtendsSpace =
         String::Handle(Symbols::New(" extends "));
     const String& kLAngleBracket = String::Handle(Symbols::New("<"));
     const String& kRAngleBracket = String::Handle(Symbols::New(">"));
-    const Class& function_class = Class::Handle(owner());
+    const Class& function_class = Class::Handle(Owner());
     ASSERT(!function_class.IsNull());
     const TypeArguments& type_parameters = TypeArguments::Handle(
         function_class.type_parameters());
     if (!type_parameters.IsNull()) {
       intptr_t num_type_parameters = type_parameters.Length();
       pieces.Add(kLAngleBracket);
       TypeParameter& type_parameter = TypeParameter::Handle();
       AbstractType& bound = AbstractType::Handle();
       for (intptr_t i = 0; i < num_type_parameters; i++) {
         type_parameter ^= type_parameters.TypeAt(i);
@@ skipping 70 matching lines @@
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = ParameterTypeAt(i);
     if (!type.IsInstantiated()) {
       return false;
     }
   }
   return true;
 }
 
 
+RawClass* Function::Owner() const {
+  const Object& obj = Object::Handle(raw_ptr()->owner_);

[hausner, 2012/08/14 18:25:06]

It would be nice if you could avoid this extra handle allocation (with implied
thread local storage lookup) for such a common operation, especially since it's
caused by this very uncommon corner case.

[Ivan Posva, 2012/08/15 06:50:39]

I have seen 0% impact by this change on performance. It is just not called
enough when running the VM.

+  if (obj.IsClass()) {
+    return Class::Cast(obj).raw();
+  }
+  ASSERT(obj.IsPatchClass());
+  return PatchClass::Cast(obj).patched_class();
+}
+
+
+RawScript* Function::script() const {
+  const Object& obj = Object::Handle(raw_ptr()->owner_);
+  if (obj.IsClass()) {
+    return Class::Cast(obj).script();
+  }
+  ASSERT(obj.IsPatchClass());
+  return PatchClass::Cast(obj).script();
+}
+
+
 bool Function::HasOptimizedCode() const {
   return HasCode() && Code::Handle(raw_ptr()->code_).is_optimized();
 }
 
 
 RawString* Function::UserVisibleName() const {
   const String& str = String::Handle(name());
   return IdentifierPrettyName(str);
 }
 
 
 RawString* Function::QualifiedUserVisibleName() const {
   String& tmp = String::Handle();
   String& suffix = String::Handle();
-  const Class& cls = Class::Handle(owner());
+  const Class& cls = Class::Handle(Owner());
 
   if (IsClosureFunction()) {
     if (IsLocalFunction()) {
       const Function& parent = Function::Handle(parent_function());
       tmp = parent.QualifiedUserVisibleName();
     } else {
       return UserVisibleName();
     }
   } else {
     if (cls.IsTopLevel()) {
@@ skipping 1210 matching lines @@
 
 
 RawArray* Library::LoadedScripts() const {
   // We compute the list of loaded scripts lazily. The result is
   // cached in loaded_scripts_.
   if (loaded_scripts() == Array::null()) {
     // Iterate over the library dictionary and collect all scripts.
     const GrowableObjectArray& scripts =
         GrowableObjectArray::Handle(GrowableObjectArray::New(8));
     Object& entry = Object::Handle();
-    Function& func = Function::Handle();
-    Field& field = Field::Handle();
     Class& cls = Class::Handle();
     Script& owner_script = Script::Handle();
     DictionaryIterator it(*this);
     Script& script_obj = Script::Handle();
     while (it.HasNext()) {
       entry = it.GetNext();
       if (entry.IsClass()) {
-        cls ^= entry.raw();
+        owner_script = Class::Cast(entry).script();
       } else if (entry.IsFunction()) {
-        func ^= entry.raw();
-        cls = func.owner();
+        owner_script = Function::Cast(entry).script();
       } else if (entry.IsField()) {
-        field ^= entry.raw();
-        cls = field.owner();
+        cls = Field::Cast(entry).owner();
+        owner_script = cls.script();
       } else {
         continue;
       }
-      owner_script = cls.script();
       if (owner_script.IsNull()) {
         continue;
       }
       bool is_unique = true;
       for (int i = 0; i < scripts.Length(); i++) {
         script_obj ^= scripts.At(i);
         if (script_obj.raw() == owner_script.raw()) {
           // We already have a reference to this script.
           is_unique = false;
           break;
@@ skipping 239 matching lines @@
       // library in which it is defined as it might be defined in one of
       // the imported libraries.
       Class& cls = Class::Handle(isolate, Class::null());
       Function& func = Function::Handle(isolate, Function::null());
       Field& field = Field::Handle(isolate, Field::null());
       if (obj.IsClass()) {
         cls ^= obj.raw();
         lib ^= cls.library();
       } else if (obj.IsFunction()) {
         func ^= obj.raw();
-        cls ^= func.owner();
+        cls ^= func.Owner();
         lib ^= cls.library();
       } else if (obj.IsField()) {
         field ^= obj.raw();
         cls ^= field.owner();
         lib ^= cls.library();
       }
       return lib.raw();
     }
   }
   return Library::null();
@@ skipping 1843 matching lines @@
     }
   }
   return result.raw();
 }
 
 
 bool ICData::AllTargetsHaveSameOwner(intptr_t owner_cid) const {
   if (NumberOfChecks() == 0) return false;
   Class& cls = Class::Handle();
   for (intptr_t i = 0; i < NumberOfChecks(); i++) {
-    cls = Function::Handle(GetTargetAt(i)).owner();
+    cls = Function::Handle(GetTargetAt(i)).Owner();
     if (cls.id() != owner_cid) {
       return false;
     }
   }
   return true;
 }
 
 
 bool ICData::AllReceiversAreNumbers() const {
   if (NumberOfChecks() == 0) return false;
   Class& cls = Class::Handle();
   for (intptr_t i = 0; i < NumberOfChecks(); i++) {
-    cls = Function::Handle(GetTargetAt(i)).owner();
+    cls = Function::Handle(GetTargetAt(i)).Owner();
     const intptr_t cid = cls.id();
     if ((cid != kSmiCid) &&
         (cid != kMintCid) &&
         (cid != kBigintCid) &&
         (cid != kDoubleCid)) {
       return false;
     }
   }
   return true;
 }
@@ skipping 3262 matching lines @@
     code_array.SetAt(i, obj);
     obj = pc_offset_list.At(j);
     pc_offset_array.SetAt(i, obj);
   }
 }
 
 
 const char* Stacktrace::ToCString() const {
   Function& function = Function::Handle();
   Code& code = Code::Handle();
-  Class& owner = Class::Handle();
   Script& script = Script::Handle();
   String& function_name = String::Handle();
   String& url = String::Handle();
 
   // Iterate through the stack frames and create C string description
   // for each frame.
   intptr_t total_len = 0;
   const char* kFormat = "#%-6d %s (%s:%d:%d)\n";
   GrowableArray<char*> frame_strings;
   for (intptr_t i = 0; i < Length(); i++) {
     function = FunctionAtFrame(i);
     code = CodeAtFrame(i);
     uword pc = code.EntryPoint() + Smi::Value(PcOffsetAtFrame(i));
     intptr_t token_pos = code.GetTokenIndexOfPC(pc);
-    owner = function.owner();
-    script = owner.script();
+    script = function.script();
     function_name = function.QualifiedUserVisibleName();
     url = script.url();
     intptr_t line = -1;
     intptr_t column = -1;
     if (token_pos >= 0) {
       script.GetTokenLocation(token_pos, &line, &column);
     }
     intptr_t len = OS::SNPrint(NULL, 0, kFormat,
                                i,
                                function_name.ToCString(),
@@ skipping 113 matching lines @@
 const char* JSRegExp::ToCString() const {
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart