[vm] Add unsafe mode to VM

This CL adds experimental --experimental-unsafe-mode-use-at-your-own-risk
VM option which does the following:
* Dart 2 strong mode type and bool checks are omitted.
* VM compiler optimizations which rely on strong mode types are disabled.

Applications which do not fail any strong mode checks at run time
should behave exactly the same in strong and weak modes.
Applications with failing strong mode checks will not see corresponding
errors but VM should not crash.

This option can be used for experiments, or as a temporary remedy for
regressions caused by expensive strong mode type checks.

Change-Id: I042cbccba83c105b61b3e11c659a35c20e0329cd
Reviewed-on: https://dart-review.googlesource.com/65484
Reviewed-by: Siva Annamalai <[email protected]>
Commit-Queue: Alexander Markov <[email protected]>

Author: alexmarkov

runtime/vm/compiler/backend/type_propagator.cc

@@ -130,7 +130,7 @@ void FlowGraphTypePropagator::PropagateRecursive(BlockEntryInstr* block) {
   // can contain [AssertAssignableInstr]s and we therefore enable this
   // optimization.
   Isolate* isolate = Isolate::Current();
-  if (isolate->type_checks() || isolate->strong()) {
+  if (isolate->argument_type_checks()) {
     StrengthenAsserts(block);
   }
 

runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc

@@ -880,6 +880,10 @@ FlowGraph* StreamingFlowGraphBuilder::BuildGraphOfNoSuchMethodForwarder(
 
 Fragment StreamingFlowGraphBuilder::BuildArgumentTypeChecks(
     TypeChecksToBuild mode) {
+  if (FLAG_omit_strong_type_checks) {
+    return Fragment();
+  }
+
   FunctionNodeHelper function_node_helper(this);
   function_node_helper.SetNext(FunctionNodeHelper::kTypeParameters);
   const Function& dart_function = parsed_function()->function();
@@ -2627,7 +2631,8 @@ Fragment StreamingFlowGraphBuilder::BuildPropertySet(TokenPosition* p) {
     const intptr_t kNumArgsChecked = 1;
 
     const String* mangled_name = &setter_name;
-    if (!FLAG_precompiled_mode && I->strong() && H.IsRoot(itarget_name)) {
+    if (!FLAG_precompiled_mode && I->strong() &&
+        !FLAG_omit_strong_type_checks && H.IsRoot(itarget_name)) {
       mangled_name = &String::ZoneHandle(
           Z, Function::CreateDynamicInvocationForwarderName(setter_name));
     }
@@ -3201,6 +3206,7 @@ Fragment StreamingFlowGraphBuilder::BuildMethodInvocation(TokenPosition* p) {
     //     those cases require a dynamic invocation forwarder;
     //   * we assume that all closures are entered in a checked way.
     if (!FLAG_precompiled_mode && I->strong() &&
+        !FLAG_omit_strong_type_checks &&
         (name.raw() != Symbols::EqualOperator().raw()) &&
         (name.raw() != Symbols::Call().raw()) && H.IsRoot(itarget_name)) {
       mangled_name = &String::ZoneHandle(

runtime/vm/compiler/frontend/kernel_to_il.cc

@@ -1571,6 +1571,9 @@ Fragment FlowGraphBuilder::CheckAssignable(const AbstractType& dst_type,
   if (dst_type.IsMalformed()) {
     return ThrowTypeError();
   }
+  if (FLAG_omit_strong_type_checks) {
+    return Fragment();
+  }
   if (!dst_type.IsDynamicType() && !dst_type.IsObjectType() &&
       !dst_type.IsVoidType()) {
     LocalVariable* top_of_stack = MakeTemporary();
@@ -1583,6 +1586,9 @@ Fragment FlowGraphBuilder::CheckAssignable(const AbstractType& dst_type,
 }
 
 Fragment FlowGraphBuilder::AssertBool(TokenPosition position) {
+  if (FLAG_omit_strong_type_checks) {
+    return Fragment();
+  }
   Value* value = Pop();
   AssertBooleanInstr* instr =
       new (Z) AssertBooleanInstr(position, value, GetNextDeoptId());
@@ -1594,6 +1600,10 @@ Fragment FlowGraphBuilder::AssertAssignable(TokenPosition position,
                                             const AbstractType& dst_type,
                                             const String& dst_name,
                                             AssertAssignableInstr::Kind kind) {
+  if (FLAG_omit_strong_type_checks) {
+    return Fragment();
+  }
+
   Fragment instructions;
   Value* value = Pop();
 

runtime/vm/compiler/jit/compiler.cc

@@ -133,6 +133,18 @@ DEFINE_FLAG_HANDLER(PrecompilationModeHandler,
                     precompilation,
                     "Precompilation mode");
 
+static void UnsafeModeHandler(bool value) {
+  if (value) {
+    FLAG_omit_strong_type_checks = true;
+    FLAG_use_strong_mode_types = false;
+  }
+}
+
+DEFINE_FLAG_HANDLER(UnsafeModeHandler,
+                    experimental_unsafe_mode_use_at_your_own_risk,
+                    "Omit runtime strong mode type checks and disable "
+                    "optimizations based on types.");
+
 #ifndef DART_PRECOMPILED_RUNTIME
 
 bool UseKernelFrontEndFor(ParsedFunction* parsed_function) {

runtime/vm/flag_list.h

@@ -122,6 +122,7 @@ constexpr bool kDartPrecompiledRuntime = false;
     "Max size of new gen semi space in MB")                                    \
   P(new_gen_semi_initial_size, int, (kWordSize <= 4) ? 1 : 2,                  \
     "Initial size of new gen semi space in MB")                                \
+  P(omit_strong_type_checks, bool, false, "Omit strong mode type checks.")     \
   P(optimization_counter_threshold, int, 30000,                                \
     "Function's usage-counter value before it is optimized, -1 means never")   \
   P(old_gen_heap_size, int, kDefaultMaxOldGenHeapSize,                         \

runtime/vm/isolate.h

@@ -749,7 +749,9 @@ class Isolate : public BaseIsolate {
 
   // Convenience flag tester indicating whether incoming function arguments
   // should be type checked.
-  bool argument_type_checks() { return strong() || type_checks(); }
+  bool argument_type_checks() {
+    return (strong() && !FLAG_omit_strong_type_checks) || type_checks();
+  }
 
   static void KillAllIsolates(LibMsgId msg_id);
   static void KillIfExists(Isolate* isolate, LibMsgId msg_id);

runtime/vm/object.h

@@ -2428,6 +2428,9 @@ class Function : public Object {
 
   bool NeedsArgumentTypeChecks(Isolate* I) const {
     if (I->strong()) {
+      if (FLAG_omit_strong_type_checks) {
+        return false;
+      }
       return IsNonImplicitClosureFunction() ||
              !(is_static() || (kind() == RawFunction::kConstructor));
     }

runtime/vm/scopes.h

@@ -129,7 +129,9 @@ class LocalVariable : public ZoneAllocated {
 
   // Returns true if this local variable represents a parameter that needs type
   // check when we enter the function.
-  bool needs_type_check() const { return type_check_mode_ == kDoTypeCheck; }
+  bool needs_type_check() const {
+    return (type_check_mode_ == kDoTypeCheck) && !FLAG_omit_strong_type_checks;
+  }
 
   // Returns true if this local variable represents a parameter which type is
   // guaranteed by the caller.