[VM, Precompiler] PoC Obfuscator

runtime/vm/isolate.h

Index: runtime/vm/isolate.h
diff --git a/runtime/vm/isolate.h b/runtime/vm/isolate.h
index 316c26a488a9ca4e285ef916ed10bbac92b8a276..ecf072890bab7155502f827320fc7a0a53102af7 100644
--- a/runtime/vm/isolate.h
+++ b/runtime/vm/isolate.h
@@ -132,15 +132,17 @@ typedef FixedCache<intptr_t, CatchEntryState, 16> CatchEntryStateCache;
 //       V(name, Dart_IsolateFlags-member-name, command-line-flag-name)
 //
 #define ISOLATE_FLAG_LIST(V)                                                   \
-  V(type_checks, EnableTypeChecks, enable_type_checks,                         \
+  V(NONPRODUCT, type_checks, EnableTypeChecks, enable_type_checks,             \
     FLAG_enable_type_checks)                                                   \
-  V(asserts, EnableAsserts, enable_asserts, FLAG_enable_asserts)               \
-  V(error_on_bad_type, ErrorOnBadType, enable_error_on_bad_type,               \
+  V(NONPRODUCT, asserts, EnableAsserts, enable_asserts, FLAG_enable_asserts)   \
+  V(NONPRODUCT, error_on_bad_type, ErrorOnBadType, enable_error_on_bad_type,   \
     FLAG_error_on_bad_type)                                                    \
-  V(error_on_bad_override, ErrorOnBadOverride, enable_error_on_bad_override,   \
-    FLAG_error_on_bad_override)                                                \
-  V(use_field_guards, UseFieldGuards, use_field_guards, FLAG_use_field_guards) \
-  V(use_osr, UseOsr, use_osr, FLAG_use_osr)
+  V(NONPRODUCT, error_on_bad_override, ErrorOnBadOverride,                     \
+    enable_error_on_bad_override, FLAG_error_on_bad_override)                  \
+  V(NONPRODUCT, use_field_guards, UseFieldGuards, use_field_guards,            \
+    FLAG_use_field_guards)                                                     \
+  V(NONPRODUCT, use_osr, UseOsr, use_osr, FLAG_use_osr)                        \
+  V(PRECOMPILER, obfuscate, Obfuscate, obfuscate, false_by_default)
 
 class Isolate : public BaseIsolate {
  public:
@@ -295,9 +297,9 @@ class Isolate : public BaseIsolate {
   MessageHandler* message_handler() const { return message_handler_; }
   void set_message_handler(MessageHandler* value) { message_handler_ = value; }
 
-  bool is_runnable() const { return RunnableBit::decode(isolate_flags_); }
+  bool is_runnable() const { return IsRunnableBit::decode(isolate_flags_); }
   void set_is_runnable(bool value) {
-    isolate_flags_ = RunnableBit::update(value, isolate_flags_);
+    isolate_flags_ = IsRunnableBit::update(value, isolate_flags_);
 #if !defined(PRODUCT)
     if (is_runnable()) {
       set_last_resume_timestamp();
@@ -685,28 +687,50 @@ class Isolate : public BaseIsolate {
   RawFunction* ClosureFunctionFromIndex(intptr_t idx) const;
 
   bool is_service_isolate() const {
-    return ServiceIsolateBit::decode(isolate_flags_);
+    return IsServiceIsolateBit::decode(isolate_flags_);
   }
   void set_is_service_isolate(bool value) {
-    isolate_flags_ = ServiceIsolateBit::update(value, isolate_flags_);
+    isolate_flags_ = IsServiceIsolateBit::update(value, isolate_flags_);
   }
 
+  Dart_QualifiedFunctionName* embedder_entry_points() const {
+    return embedder_entry_points_;
+  }
+
+  void set_obfuscation_map(const char** map) { obfuscation_map_ = map; }
+  const char** obfuscation_map() const { return obfuscation_map_; }
+
   // Isolate-specific flag handling.
   static void FlagsInitialize(Dart_IsolateFlags* api_flags);
   void FlagsCopyTo(Dart_IsolateFlags* api_flags) const;
   void FlagsCopyFrom(const Dart_IsolateFlags& api_flags);
 
-#if defined(PRODUCT)
-#define DECLARE_GETTER(name, bitname, isolate_flag_name, flag_name)            \
-  bool name() const { return flag_name; }
+#if defined(DART_PRECOMPILER)
+#define FLAG_FOR_PRECOMPILER(from_field, from_flag) (from_field)
+#else
+#define FLAG_FOR_PRECOMPILER(from_field, from_flag) (from_flag)
+#endif
+
+#if !defined(PRODUCT)
+#define FLAG_FOR_NONPRODUCT(from_field, from_flag) (from_field)
+#else
+#define FLAG_FOR_NONPRODUCT(from_field, from_flag) (from_flag)
+#endif
+
+#define DECLARE_GETTER(when, name, bitname, isolate_flag_name, flag_name)      \
+  bool name() const {                                                          \
+    const bool false_by_default = false;                                       \
+    USE(false_by_default);                                                     \
+    return FLAG_FOR_##when(bitname##Bit::decode(isolate_flags_), flag_name);   \
+  }
   ISOLATE_FLAG_LIST(DECLARE_GETTER)
+#undef FLAG_FOR_NONPRODUCT
+#undef FLAG_FOR_PRECOMPILER
 #undef DECLARE_GETTER
+
+#if defined(PRODUCT)
   void set_use_osr(bool use_osr) { ASSERT(!use_osr); }
 #else  // defined(PRODUCT)
-#define DECLARE_GETTER(name, bitname, isolate_flag_name, flag_name)            \
-  bool name() const { return bitname##Bit::decode(isolate_flags_); }
-  ISOLATE_FLAG_LIST(DECLARE_GETTER)
-#undef DECLARE_GETTER
   void set_use_osr(bool use_osr) {
     isolate_flags_ = UseOsrBit::update(use_osr, isolate_flags_);
   }
@@ -805,55 +829,37 @@ class Isolate : public BaseIsolate {
   ClassTable class_table_;
   bool single_step_;
 
+#define ISOLATE_FLAG_BITS(V)                                                   \
+  V(ErrorsFatal)                                                               \
+  V(IsRunnable)                                                                \
+  V(IsServiceIsolate)                                                          \
+  V(CompilationAllowed)                                                        \
+  V(AllClassesFinalized)                                                       \
+  V(RemappingCids)                                                             \
+  V(ResumeRequest)                                                             \
+  V(HasAttemptedReload)                                                        \
+  V(ShouldPausePostServiceRequest)                                             \
+  V(UseDartFrontEnd)                                                           \
+  V(EnableTypeChecks)                                                          \
+  V(EnableAsserts)                                                             \
+  V(ErrorOnBadType)                                                            \
+  V(ErrorOnBadOverride)                                                        \
+  V(UseFieldGuards)                                                            \
+  V(UseOsr)                                                                    \
+  V(Obfuscate)
+
   // Isolate specific flags.
   enum FlagBits {
-    kErrorsFatalBit = 0,
-    kIsRunnableBit = 1,
-    kIsServiceIsolateBit = 2,
-    kCompilationAllowedBit = 3,
-    kAllClassesFinalizedBit = 4,
-    kRemappingCidsBit = 5,
-    kResumeRequestBit = 6,
-    kHasAttemptedReloadBit = 7,
-    kShouldPausePostServiceRequestBit = 8,
-    kUseDartFrontEndBit = 9,
-    kEnableTypeChecksBit = 10,
-    kEnableAssertsBit = 11,
-    kErrorOnBadTypeBit = 12,
-    kErrorOnBadOverrideBit = 13,
-    kUseFieldGuardsBit = 14,
-    kUseOsrBit = 15,
+#define DECLARE_BIT(Name) k##Name##Bit,
+    ISOLATE_FLAG_BITS(DECLARE_BIT)
+#undef DECLARE_BIT
   };
-  class ErrorsFatalBit : public BitField<uint32_t, bool, kErrorsFatalBit, 1> {};
-  class RunnableBit : public BitField<uint32_t, bool, kIsRunnableBit, 1> {};
-  class ServiceIsolateBit
-      : public BitField<uint32_t, bool, kIsServiceIsolateBit, 1> {};
-  class CompilationAllowedBit
-      : public BitField<uint32_t, bool, kCompilationAllowedBit, 1> {};
-  class AllClassesFinalizedBit
-      : public BitField<uint32_t, bool, kAllClassesFinalizedBit, 1> {};
-  class RemappingCidsBit
-      : public BitField<uint32_t, bool, kRemappingCidsBit, 1> {};
-  class ResumeRequestBit
-      : public BitField<uint32_t, bool, kResumeRequestBit, 1> {};
-  class HasAttemptedReloadBit
-      : public BitField<uint32_t, bool, kHasAttemptedReloadBit, 1> {};
-  class ShouldPausePostServiceRequestBit
-      : public BitField<uint32_t, bool, kShouldPausePostServiceRequestBit, 1> {
-  };
-  class UseDartFrontEndBit
-      : public BitField<uint32_t, bool, kUseDartFrontEndBit, 1> {};
-  class EnableTypeChecksBit
-      : public BitField<uint32_t, bool, kEnableTypeChecksBit, 1> {};
-  class EnableAssertsBit
-      : public BitField<uint32_t, bool, kEnableAssertsBit, 1> {};
-  class ErrorOnBadTypeBit
-      : public BitField<uint32_t, bool, kErrorOnBadTypeBit, 1> {};
-  class ErrorOnBadOverrideBit
-      : public BitField<uint32_t, bool, kErrorOnBadOverrideBit, 1> {};
-  class UseFieldGuardsBit
-      : public BitField<uint32_t, bool, kUseFieldGuardsBit, 1> {};
-  class UseOsrBit : public BitField<uint32_t, bool, kUseOsrBit, 1> {};
+
+#define DECLARE_BITFIELD(Name)                                                 \
+  class Name##Bit : public BitField<uint32_t, bool, k##Name##Bit, 1> {};
+  ISOLATE_FLAG_BITS(DECLARE_BITFIELD)
+#undef DECLARE_BITFIELD
+
   uint32_t isolate_flags_;
 
   // Background compilation.
@@ -969,6 +975,9 @@ class Isolate : public BaseIsolate {
   HandlerInfoCache handler_info_cache_;
   CatchEntryStateCache catch_entry_state_cache_;
 
+  Dart_QualifiedFunctionName* embedder_entry_points_;
+  const char** obfuscation_map_;
+
   static Dart_IsolateCreateCallback create_callback_;
   static Dart_IsolateShutdownCallback shutdown_callback_;
   static Dart_IsolateCleanupCallback cleanup_callback_;