- Make Boolean 'true' and 'false' singleton VM isolate objects.

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 46 matching lines @@
 
 // These are initialized to a value that will force a illegal memory access if
 // they are being used.
 #if defined(RAW_NULL)
 #error RAW_NULL should not be defined.
 #endif
 #define RAW_NULL kHeapObjectTag
 Array* Object::empty_array_ = NULL;
 Instance* Object::sentinel_ = NULL;
 Instance* Object::transition_sentinel_ = NULL;
+Bool* Object::bool_true_ = NULL;
+Bool* Object::bool_false_ = NULL;
 
 RawObject* Object::null_ = reinterpret_cast<RawObject*>(RAW_NULL);
 RawClass* Object::class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 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_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instantiated_type_arguments_class_ =
@@ skipping 162 matching lines @@
     Smi fake_smi;
     Object::handle_vtable_ = fake_object.vtable();
     Smi::handle_vtable_ = fake_smi.vtable();
   }
 
   // Allocate the read only object handles here.
   empty_array_ = reinterpret_cast<Array*>(Dart::AllocateReadOnlyHandle());
   sentinel_ = reinterpret_cast<Instance*>(Dart::AllocateReadOnlyHandle());
   transition_sentinel_ =
       reinterpret_cast<Instance*>(Dart::AllocateReadOnlyHandle());
+  bool_true_ = reinterpret_cast<Bool*>(Dart::AllocateReadOnlyHandle());
+  bool_false_ = reinterpret_cast<Bool*>(Dart::AllocateReadOnlyHandle());
 
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
   // Allocate and initialize the null instance.
   // 'null_' must be the first object allocated as it is used in allocation to
   // clear the object.
   {
     uword address = heap->Allocate(Instance::InstanceSize(), Heap::kOld);
     null_ = reinterpret_cast<RawInstance*>(address + kHeapObjectTag);
     // The call below is using 'null_' to initialize itself.
@@ skipping 161 matching lines @@
   cls = Class::NewStringClass(kTwoByteStringCid);
   isolate->object_store()->set_two_byte_string_class(cls);
 
   // Allocate and initialize the empty_array instance.
   {
     uword address = heap->Allocate(Array::InstanceSize(0), Heap::kOld);
     *empty_array_ = reinterpret_cast<RawArray*>(address + kHeapObjectTag);
     InitializeObject(address, kArrayCid, Array::InstanceSize(0));
     empty_array_->raw()->ptr()->length_ = Smi::New(0);
   }
+
+  // Allocate and initialize singleton true and false boolean objects.
+  cls = Class::New<Bool>();
+  isolate->object_store()->set_bool_class(cls);
+  *bool_true_ = Bool::New(true);
+  *bool_false_ = Bool::New(false);
 }
 
 
 #define SET_CLASS_NAME(class_name, name)                                       \
   cls = class_name##_class();                                                  \
   cls.set_name(Symbols::name());                                               \
 
 void Object::RegisterSingletonClassNames() {
   Class& cls = Class::Handle();
 
@@ skipping 450 matching lines @@
   object_store->set_void_type(type);
 
   // The class 'dynamic' is registered in the class dictionary because its name
   // is a built-in identifier, rather than a reserved keyword. Its name is not
   // heap allocated, because the class resides in the VM isolate.
   // The corresponding type, the "unknown type", is stored in the object store.
   cls = dynamic_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_dynamic_type(type);
 
-  // Allocate pre-initialized values.
-  Bool& bool_value = Bool::Handle();
-  bool_value = Bool::New(true);
-  object_store->set_true_value(bool_value);
-  bool_value = Bool::New(false);
-  object_store->set_false_value(bool_value);
-
   // Setup some default native field classes which can be extended for
   // specifying native fields in dart classes.
   Library::InitNativeWrappersLibrary(isolate);
   ASSERT(isolate->object_store()->native_wrappers_library() != Library::null());
 
   // Finish the initialization by compiling the bootstrap scripts containing the
   // base interfaces and the implementation of the internal classes.
   Error& error = Error::Handle();
   error = Bootstrap::Compile(core_lib, script);
   if (!error.IsNull()) {
@@ skipping 207 matching lines @@
   object_store->set_jsregexp_class(cls);
 
   // Some classes are not stored in the object store. Yet we still need to
   // create their Class object so that they get put into the class_table
   // (as a side effect of Class::New()).
   cls = Class::New<DartFunction>();
   cls = Class::New<Number>();
 
   cls = Class::New<WeakProperty>();
   object_store->set_weak_property_class(cls);
-
-  // Allocate pre-initialized values.
-  Bool& bool_value = Bool::Handle();
-  bool_value = Bool::New(true);
-  object_store->set_true_value(bool_value);
-  bool_value = Bool::New(false);
-  object_store->set_false_value(bool_value);
 }
 
 
 void Object::Print() const {
   OS::Print("%s\n", ToCString());
 }
 
 
 RawString* Object::DictionaryName() const {
   return String::null();
@@ skipping 10129 matching lines @@
   return ExternalTwoByteString::raw(result);
 }
 
 
 void ExternalTwoByteString::Finalize(Dart_Handle handle, void* peer) {
   delete reinterpret_cast<ExternalStringData<uint16_t>*>(peer);
   DeleteWeakPersistentHandle(handle);
 }
 
 
-RawBool* Bool::True() {
-  return Isolate::Current()->object_store()->true_value();
-}
-
-
-RawBool* Bool::False() {
-  return Isolate::Current()->object_store()->false_value();
-}
-
-
 RawBool* Bool::New(bool value) {
   ASSERT(Isolate::Current()->object_store()->bool_class() != Class::null());
   Bool& result = Bool::Handle();
   {
     // Since the two boolean instances are singletons we allocate them straight
     // in the old generation.
     RawObject* raw = Object::Allocate(Bool::kClassId,
                                       Bool::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_value(value);
+  result.SetCanonical();
   return result.raw();
 }
 
 
 const char* Bool::ToCString() const {
   return value() ? "true" : "false";
 }
 
 
 bool Array::Equals(const Instance& other) const {
@@ skipping 1109 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart