[VM, Precompiler] PoC Obfuscator

runtime/vm/isolate.h

 // 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.
 
 #ifndef RUNTIME_VM_ISOLATE_H_
 #define RUNTIME_VM_ISOLATE_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/atomic.h"
@@ skipping 114 matching lines @@
 typedef FixedCache<intptr_t, ExceptionHandlerInfo, 16> HandlerInfoCache;
 // Fixed cache for catch entry state lookup.
 typedef FixedCache<intptr_t, CatchEntryState, 16> CatchEntryStateCache;
 
 // List of Isolate flags with corresponding members of Dart_IsolateFlags and
 // corresponding global command line flags.
 //
 //       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:
   // Keep both these enums in sync with isolate_patch.dart.
   // The different Isolate API message types.
   enum LibMsgId {
     kPauseMsg = 1,
     kResumeMsg = 2,
     kPingMsg = 3,
     kKillMsg = 4,
@@ skipping 134 matching lines @@
                      const char* root_script_url = NULL,
                      const char* packages_url = NULL,
                      bool dont_delete_reload_context = false);
 
   bool MakeRunnable();
   void Run();
 
   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();
     }
 #endif
   }
 
   IsolateSpawnState* spawn_state() const { return spawn_state_; }
   void set_spawn_state(IsolateSpawnState* value) { spawn_state_ = value; }
 
@@ skipping 367 matching lines @@
   void PauseEventHandler();
 #endif
 
   void AddClosureFunction(const Function& function) const;
   RawFunction* LookupClosureFunction(const Function& parent,
                                      TokenPosition token_pos) const;
   intptr_t FindClosureIndex(const Function& needle) const;
   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(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)
-#define DECLARE_GETTER(name, bitname, isolate_flag_name, flag_name)            \
-  bool name() const { return flag_name; }
-  ISOLATE_FLAG_LIST(DECLARE_GETTER)
-#undef DECLARE_GETTER
   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_);
   }
 #endif  // defined(PRODUCT)
 
   static void KillAllIsolates(LibMsgId msg_id);
   static void KillIfExists(Isolate* isolate, LibMsgId msg_id);
 
   static void DisableIsolateCreation();
   static void EnableIsolateCreation();
@@ skipping 78 matching lines @@
   StoreBuffer* store_buffer_;
   Heap* heap_;
   uword user_tag_;
   RawUserTag* current_tag_;
   RawUserTag* default_tag_;
   RawCode* ic_miss_code_;
   ObjectStore* object_store_;
   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.
   int16_t background_compiler_disabled_depth_;
   BackgroundCompiler* background_compiler_;
 
 // Fields that aren't needed in a product build go here with boolean flags at
 // the top.
 #if !defined(PRODUCT)
   char* debugger_name_;
@@ skipping 95 matching lines @@
   RawGrowableObjectArray* boxed_field_list_;
 
   // This guards spawn_count_. An isolate cannot complete shutdown and be
   // destroyed while there are child isolates in the midst of a spawn.
   Monitor* spawn_count_monitor_;
   intptr_t spawn_count_;
 
   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_;
 
 #if !defined(PRODUCT)
   static void WakePauseEventHandler(Dart_Isolate isolate);
 #endif
 
   // Manage list of existing isolates.
   static bool AddIsolateToList(Isolate* isolate);
@@ skipping 144 matching lines @@
   intptr_t* spawn_count_;
 
   Dart_IsolateFlags isolate_flags_;
   bool paused_;
   bool errors_are_fatal_;
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_ISOLATE_H_