- Convert all isolate flags to a bit field.

runtime/vm/isolate.cc

 // Copyright (c) 2013, 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/isolate.h"
 
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "platform/text_buffer.h"
@@ skipping 674 matching lines @@
       }
 #endif  // !defined(PRODUCT)
       return kError;
     }
   }
   return kOK;
 }
 
 void Isolate::FlagsInitialize(Dart_IsolateFlags* api_flags) {
   api_flags->version = DART_FLAGS_CURRENT_VERSION;
-#define INIT_FROM_FLAG(name, isolate_flag, flag) api_flags->isolate_flag = flag;
+#define INIT_FROM_FLAG(name, bitname, isolate_flag, flag)                      \
+  api_flags->isolate_flag = flag;
   ISOLATE_FLAG_LIST(INIT_FROM_FLAG)
 #undef INIT_FROM_FLAG
+  api_flags->use_dart_frontend = false;
 }
 
 void Isolate::FlagsCopyTo(Dart_IsolateFlags* api_flags) const {
   api_flags->version = DART_FLAGS_CURRENT_VERSION;
-#define INIT_FROM_FIELD(name, isolate_flag, flag)                              \
+#define INIT_FROM_FIELD(name, bitname, isolate_flag, flag)                     \
   api_flags->isolate_flag = name();
   ISOLATE_FLAG_LIST(INIT_FROM_FIELD)
 #undef INIT_FROM_FIELD
+  api_flags->use_dart_frontend = use_dart_frontend();
 }
 
+void Isolate::FlagsCopyFrom(const Dart_IsolateFlags& api_flags) {
 #if !defined(PRODUCT)
-void Isolate::FlagsCopyFrom(const Dart_IsolateFlags& api_flags) {
-#define SET_FROM_FLAG(name, isolate_flag, flag)                                \
-  name##_ = api_flags.isolate_flag;
+#define SET_FROM_FLAG(name, bitname, isolate_flag, flag)                       \
+  isolate_flags_ = bitname##Bit::update(api_flags.isolate_flag, isolate_flags_);
   ISOLATE_FLAG_LIST(SET_FROM_FLAG)
 #undef SET_FROM_FLAG
+#endif  // !defined(PRODUCT)
+  set_use_dart_frontend(api_flags.use_dart_frontend);
   // Leave others at defaults.
 }
-#endif  // !defined(PRODUCT)
 
 #if defined(DEBUG)
 // static
 void BaseIsolate::AssertCurrent(BaseIsolate* isolate) {
   ASSERT(isolate == Isolate::Current());
 }
 
 void BaseIsolate::AssertCurrentThreadIsMutator() const {
   ASSERT(Isolate::Current() == this);
   ASSERT(Thread::Current()->IsMutatorThread());
@@ skipping 15 matching lines @@
     : BaseIsolate(),
       store_buffer_(new StoreBuffer()),
       heap_(NULL),
       user_tag_(0),
       current_tag_(UserTag::null()),
       default_tag_(UserTag::null()),
       ic_miss_code_(Code::null()),
       object_store_(NULL),
       class_table_(),
       single_step_(false),
-      errors_fatal_(true),
-      is_runnable_(false),
-      is_service_isolate_(false),
-      compilation_allowed_(true),
-      all_classes_finalized_(false),
-      remapping_cids_(false),
+      isolate_flags_(0),
+      background_compiler_disabled_depth_(0),
+      background_compiler_(NULL),
 #if !defined(PRODUCT)
-      resume_request_(false),
-      has_attempted_reload_(false),
-      should_pause_post_service_request_(false),
       debugger_name_(NULL),
       debugger_(NULL),
       last_resume_timestamp_(OS::GetCurrentTimeMillis()),
       last_allocationprofile_accumulator_reset_timestamp_(0),
       last_allocationprofile_gc_timestamp_(0),
       vm_tag_counters_(),
       pending_service_extension_calls_(GrowableObjectArray::null()),
       registered_service_extension_handlers_(GrowableObjectArray::null()),
       metrics_list_head_(NULL),
       pause_loop_monitor_(NULL),
@@ skipping 30 matching lines @@
       message_handler_(NULL),
       spawn_state_(NULL),
       gc_prologue_callback_(NULL),
       gc_epilogue_callback_(NULL),
       defer_finalization_count_(0),
       pending_deopts_(new MallocGrowableArray<PendingLazyDeopt>),
       deopt_context_(NULL),
       tag_table_(GrowableObjectArray::null()),
       deoptimized_code_array_(GrowableObjectArray::null()),
       sticky_error_(Error::null()),
-      background_compiler_(NULL),
-      background_compiler_disabled_depth_(0),
       next_(NULL),
       loading_invalidation_gen_(kInvalidGen),
       top_level_parsing_count_(0),
       field_list_mutex_(new Mutex()),
       boxed_field_list_(GrowableObjectArray::null()),
       spawn_count_monitor_(new Monitor()),
       spawn_count_(0),
       handler_info_cache_(),
       catch_entry_state_cache_() {
-  NOT_IN_PRODUCT(FlagsCopyFrom(api_flags));
+  FlagsCopyFrom(api_flags);
+  SetErrorsFatal(true);
+  set_compilation_allowed(true);
   // TODO(asiva): A Thread is not available here, need to figure out
   // how the vm_tag (kEmbedderTagId) can be set, these tags need to
   // move to the OSThread structure.
   set_user_tag(UserTags::kDefaultUserTag);
 }
 
 #undef REUSABLE_HANDLE_SCOPE_INIT
 #undef REUSABLE_HANDLE_INITIALIZERS
 
 Isolate::~Isolate() {
@@ skipping 223 matching lines @@
          (AtomicOperations::LoadRelaxed(&no_reload_scope_depth_) == 0) &&
          IsolateCreationEnabled();
 }
 
 bool Isolate::ReloadSources(JSONStream* js,
                             bool force_reload,
                             const char* root_script_url,
                             const char* packages_url,
                             bool dont_delete_reload_context) {
   ASSERT(!IsReloading());
-  has_attempted_reload_ = true;
+  SetHasAttemptedReload(true);
   reload_context_ = new IsolateReloadContext(this, js);
   reload_context_->Reload(force_reload, root_script_url, packages_url);
   bool success = !reload_context_->reload_aborted();
   if (!dont_delete_reload_context) {
     DeleteReloadContext();
   }
   return success;
 }
 
 void Isolate::DeleteReloadContext() {
@@ skipping 759 matching lines @@
 #ifndef PRODUCT
   if (IsReloading()) {
     raw_class = reload_context()->GetClassForHeapWalkAt(cid);
   } else {
     raw_class = class_table()->At(cid);
   }
 #else
   raw_class = class_table()->At(cid);
 #endif  // !PRODUCT
   ASSERT(raw_class != NULL);
-  ASSERT(remapping_cids_ || raw_class->ptr()->id_ == cid);
+  ASSERT(remapping_cids() || raw_class->ptr()->id_ == cid);
   return raw_class;
 }
 
 void Isolate::AddPendingDeopt(uword fp, uword pc) {
   // GrowableArray::Add is not atomic and may be interrupt by a profiler
   // stack walk.
   MallocGrowableArray<PendingLazyDeopt>* old_pending_deopts = pending_deopts_;
   MallocGrowableArray<PendingLazyDeopt>* new_pending_deopts =
       new MallocGrowableArray<PendingLazyDeopt>(old_pending_deopts->length() +
                                                 1);
@@ skipping 79 matching lines @@
   } else if (message_handler()->is_paused_on_start() ||
              message_handler()->should_pause_on_start()) {
     ASSERT((debugger() == NULL) || (debugger()->PauseEvent() == NULL));
     ServiceEvent pause_event(this, ServiceEvent::kPauseStart);
     jsobj.AddProperty("pauseEvent", &pause_event);
   } else if (message_handler()->is_paused_on_exit() &&
              ((debugger() == NULL) || (debugger()->PauseEvent() == NULL))) {
     ServiceEvent pause_event(this, ServiceEvent::kPauseExit);
     jsobj.AddProperty("pauseEvent", &pause_event);
   } else if ((debugger() != NULL) && (debugger()->PauseEvent() != NULL) &&
-             !resume_request_) {
+             !ResumeRequest()) {
     jsobj.AddProperty("pauseEvent", debugger()->PauseEvent());
   } else {
     ServiceEvent pause_event(this, ServiceEvent::kResume);
 
     if (debugger() != NULL) {
       // TODO(turnidge): Don't compute a full stack trace.
       DebuggerStackTrace* stack = debugger()->StackTrace();
       if (stack->Length() > 0) {
         pause_event.set_top_frame(stack->FrameAt(0));
       }
@@ skipping 876 matching lines @@
 void IsolateSpawnState::DecrementSpawnCount() {
   ASSERT(spawn_count_monitor_ != NULL);
   ASSERT(spawn_count_ != NULL);
   MonitorLocker ml(spawn_count_monitor_);
   ASSERT(*spawn_count_ > 0);
   *spawn_count_ = *spawn_count_ - 1;
   ml.Notify();
 }
 
 }  // namespace dart