A load static of an initialized static final field can be converted to its value, as long as it is …

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 53 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;
+Instance* Object::unknown_constant_ = NULL;
+Instance* Object::non_constant_ = NULL;
 Bool* Object::bool_true_ = NULL;
 Bool* Object::bool_false_ = NULL;
 LanguageError* Object::snapshot_writer_error_ = 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_ =
@@ skipping 230 matching lines @@
     Smi::handle_vtable_ = fake_smi.vtable();
   }
 
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
 
   // Allocate the read only object handles here.
   empty_array_ = Array::ReadOnlyHandle(isolate);
   sentinel_ = Instance::ReadOnlyHandle(isolate);
   transition_sentinel_ = Instance::ReadOnlyHandle(isolate);
+  unknown_constant_ =  Instance::ReadOnlyHandle(isolate);
+  non_constant_ =  Instance::ReadOnlyHandle(isolate);
   bool_true_ = Bool::ReadOnlyHandle(isolate);
   bool_false_ = Bool::ReadOnlyHandle(isolate);
   snapshot_writer_error_ = LanguageError::ReadOnlyHandle(isolate);
 
   // 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);
@@ skipping 43 matching lines @@
 
   // Allocate and initialize the sentinel values of Null class.
   {
     *sentinel_ ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
 
     *transition_sentinel_ ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
   }
 
+  // Allocate and initialize optimizing compiler constants.
+  {
+    *unknown_constant_ ^=
+        Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
+    *non_constant_ ^=
+        Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
+  }
+
   cls = Class::New<Instance>(kDynamicCid);
   cls.set_is_finalized();
   cls.set_is_abstract();
   dynamic_class_ = cls.raw();
 
   // Allocate the remaining VM internal classes.
   cls = Class::New<UnresolvedClass>();
   unresolved_class_class_ = cls.raw();
 
   cls = Class::New<Instance>(kVoidCid);
@@ skipping 120 matching lines @@
 
   *snapshot_writer_error_ =
       LanguageError::New(String::Handle(String::New("SnapshotWriter Error")));
 
   ASSERT(!empty_array_->IsSmi());
   ASSERT(empty_array_->IsArray());
   ASSERT(!sentinel_->IsSmi());
   ASSERT(sentinel_->IsInstance());
   ASSERT(!transition_sentinel_->IsSmi());
   ASSERT(transition_sentinel_->IsInstance());
+  ASSERT(!unknown_constant_->IsSmi());
+  ASSERT(unknown_constant_->IsInstance());
+  ASSERT(!non_constant_->IsSmi());
+  ASSERT(non_constant_->IsInstance());
   ASSERT(!bool_true_->IsSmi());
   ASSERT(bool_true_->IsBool());
   ASSERT(!bool_false_->IsSmi());
   ASSERT(bool_false_->IsBool());
   ASSERT(!snapshot_writer_error_->IsSmi());
   ASSERT(snapshot_writer_error_->IsLanguageError());
 }
 
 
 #define SET_CLASS_NAME(class_name, name)                                       \
@@ skipping 8633 matching lines @@
 }
 
 
 const char* Instance::ToCString() const {
   if (IsNull()) {
     return "null";
   } else if (raw() == Object::sentinel().raw()) {
     return "sentinel";
   } else if (raw() == Object::transition_sentinel().raw()) {
     return "transition_sentinel";
+  } else if (raw() == Object::unknown_constant().raw()) {
+    return "unknown_constant";
+  } else if (raw() == Object::non_constant().raw()) {
+    return "non_constant";
   } else if (Isolate::Current()->no_gc_scope_depth() > 0) {
     // Can occur when running disassembler.
     return "Instance";
   } else {
     if (IsClosure()) {
       return Closure::ToCString(*this);
     }
     const char* kFormat = "Instance of '%s'";
     const Class& cls = Class::Handle(clazz());
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
@@ skipping 4044 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart