[VM, Precompiler] PoC Obfuscator

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 673 matching lines @@
         }
       }
 #endif  // !defined(PRODUCT)
       return kError;
     }
   }
   return kOK;
 }
 
 void Isolate::FlagsInitialize(Dart_IsolateFlags* api_flags) {
+  const bool false_by_default = false;
+  const bool true_by_default = true;
+  USE(true_by_default);
+  USE(false_by_default);
+
   api_flags->version = DART_FLAGS_CURRENT_VERSION;
 #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;
+  api_flags->entry_points = NULL;
 }
 
 void Isolate::FlagsCopyTo(Dart_IsolateFlags* api_flags) const {
   api_flags->version = DART_FLAGS_CURRENT_VERSION;
 #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();
+  api_flags->entry_points = NULL;
 }
 
 void Isolate::FlagsCopyFrom(const Dart_IsolateFlags& api_flags) {
 #if !defined(PRODUCT)
 #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);
+
+  // Copy entry points list.
+  ASSERT(embedder_entry_points_ == NULL);
+  if (api_flags.entry_points != NULL) {
+    intptr_t count = 0;
+    while (api_flags.entry_points[count].function_name != NULL)
+      count++;
+    embedder_entry_points_ = new Dart_QualifiedFunctionName[count + 1];
+    for (intptr_t i = 0; i < count; i++) {
+      embedder_entry_points_[i].library_uri =
+          strdup(api_flags.entry_points[i].library_uri);
+      embedder_entry_points_[i].class_name =
+          strdup(api_flags.entry_points[i].class_name);
+      embedder_entry_points_[i].function_name =
+          strdup(api_flags.entry_points[i].function_name);
+    }
+    memset(&embedder_entry_points_[count], 0,
+           sizeof(Dart_QualifiedFunctionName));
+  }
+
   // Leave others at defaults.
 }
 
 #if defined(DEBUG)
 // static
 void BaseIsolate::AssertCurrent(BaseIsolate* isolate) {
   ASSERT(isolate == Isolate::Current());
 }
 
 void BaseIsolate::AssertCurrentThreadIsMutator() const {
@@ skipping 79 matching lines @@
       deoptimized_code_array_(GrowableObjectArray::null()),
       sticky_error_(Error::null()),
       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_() {
+      catch_entry_state_cache_(),
+      embedder_entry_points_(NULL),
+      obfuscation_map_(NULL) {
   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);
+
+  if (obfuscate()) {
+    OS::PrintErr(
+        "Warning: This VM has been configured to obfuscate symbol information "
+        "which violates the Dart standard.\n"
+        "         See dartbug.com/30524 for more information.\n");
+  }
 }
 
 #undef REUSABLE_HANDLE_SCOPE_INIT
 #undef REUSABLE_HANDLE_INITIALIZERS
 
 Isolate::~Isolate() {
 #if !defined(PRODUCT)
   free(debugger_name_);
   delete debugger_;
   if (FLAG_support_service) {
@@ skipping 27 matching lines @@
   delete message_handler_;
   message_handler_ = NULL;  // Fail fast if we send messages to a dead isolate.
   ASSERT(deopt_context_ == NULL);  // No deopt in progress when isolate deleted.
   delete spawn_state_;
   delete field_list_mutex_;
   field_list_mutex_ = NULL;
   ASSERT(spawn_count_ == 0);
   delete spawn_count_monitor_;
   delete safepoint_handler_;
   delete thread_registry_;
+
+  if (obfuscation_map_ != NULL) {
+    for (intptr_t i = 0; obfuscation_map_[i] != NULL; i++) {
+      delete[] obfuscation_map_[i];
+    }
+    delete[] obfuscation_map_;
+  }
+
+  if (embedder_entry_points_ != NULL) {
+    for (intptr_t i = 0; embedder_entry_points_[i].function_name != NULL; i++) {
+      free(const_cast<char*>(embedder_entry_points_[i].library_uri));
+      free(const_cast<char*>(embedder_entry_points_[i].class_name));
+      free(const_cast<char*>(embedder_entry_points_[i].function_name));
+    }
+    delete[] embedder_entry_points_;
+  }
 }
 
 void Isolate::InitOnce() {
   create_callback_ = NULL;
   isolates_list_monitor_ = new Monitor();
   ASSERT(isolates_list_monitor_ != NULL);
   EnableIsolateCreation();
 }
 
 Isolate* Isolate::Init(const char* name_prefix,
@@ skipping 1949 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