[vm] Cleanup flags which disable argument type checks and strong mode types

The following options are removed:
--use_strong_mode_types
--experimental_unsafe_mode_use_at_your_own_risk

The following flags and predicates are removed:

Dart_IsolateFlags::unsafe_trust_strong_mode_types
Isolate::argument_type_checks()
Isolate::can_use_strong_mode_types()
Isolate::should_emit_strong_mode_checks()

Also, everything depending on these flags is cleaned up.

Change-Id: I9328009ad5a42ea2173842386d612c465e3ebec1
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/147325
Reviewed-by: Martin Kustermann <[email protected]>
Commit-Queue: Alexander Markov <[email protected]>

Author: alexmarkov

runtime/include/dart_api.h

@@ -518,7 +518,7 @@ typedef struct {
  * for each part.
  */
 
-#define DART_FLAGS_CURRENT_VERSION (0x0000000b)
+#define DART_FLAGS_CURRENT_VERSION (0x0000000c)
 
 typedef struct {
   int32_t version;
@@ -528,7 +528,6 @@ typedef struct {
   bool obfuscate;
   Dart_QualifiedFunctionName* entry_points;
   bool load_vmservice_library;
-  bool unsafe_trust_strong_mode_types;
   bool copy_parent_code;
 } Dart_IsolateFlags;
 

runtime/vm/compiler/aot/aot_call_specializer.cc

@@ -294,7 +294,6 @@ bool AotCallSpecializer::IsSupportedIntOperandForStaticDoubleOp(
 Value* AotCallSpecializer::PrepareStaticOpInput(Value* input,
                                                 intptr_t cid,
                                                 Instruction* call) {
-  ASSERT(I->can_use_strong_mode_types());
   ASSERT((cid == kDoubleCid) || (cid == kMintCid));
 
   if (input->Type()->is_nullable()) {
@@ -368,18 +367,13 @@ static void RefineUseTypes(Definition* instr) {
 
 bool AotCallSpecializer::TryOptimizeInstanceCallUsingStaticTypes(
     InstanceCallInstr* instr) {
-  ASSERT(I->can_use_strong_mode_types());
-
   const Token::Kind op_kind = instr->token_kind();
-
   return TryOptimizeIntegerOperation(instr, op_kind) ||
          TryOptimizeDoubleOperation(instr, op_kind);
 }
 
 bool AotCallSpecializer::TryOptimizeStaticCallUsingStaticTypes(
     StaticCallInstr* instr) {
-  ASSERT(I->can_use_strong_mode_types());
-
   const String& name = String::Handle(Z, instr->function().name());
   const Token::Kind op_kind = MethodTokenRecognizer::RecognizeTokenKind(name);
 
@@ -472,8 +466,6 @@ bool AotCallSpecializer::TryOptimizeIntegerOperation(TemplateDartCall<0>* instr,
     return false;
   }
 
-  ASSERT(I->can_use_strong_mode_types());
-
   Definition* replacement = NULL;
   if (instr->ArgumentCount() == 2) {
     Value* left_value = instr->ArgumentValueAt(0);
@@ -801,43 +793,8 @@ void AotCallSpecializer::VisitInstanceCall(InstanceCallInstr* instr) {
 
   const CallTargets& targets = instr->Targets();
   const intptr_t receiver_idx = instr->FirstArgIndex();
-  if (I->can_use_strong_mode_types()) {
-    // In AOT strong mode, we avoid deopting speculation.
-    // TODO(ajcbik): replace this with actual analysis phase
-    //               that determines if checks are removed later.
-  } else if (speculative_policy_->IsAllowedForInlining(instr->deopt_id()) &&
-             !targets.is_empty()) {
-    if ((op_kind == Token::kINDEX) && TryReplaceWithIndexedOp(instr)) {
-      return;
-    }
-    if ((op_kind == Token::kASSIGN_INDEX) && TryReplaceWithIndexedOp(instr)) {
-      return;
-    }
-    if ((op_kind == Token::kEQ) && TryReplaceWithEqualityOp(instr, op_kind)) {
-      return;
-    }
-
-    if (Token::IsRelationalOperator(op_kind) &&
-        TryReplaceWithRelationalOp(instr, op_kind)) {
-      return;
-    }
-
-    if (Token::IsBinaryOperator(op_kind) &&
-        TryReplaceWithBinaryOp(instr, op_kind)) {
-      return;
-    }
-    if (Token::IsUnaryOperator(op_kind) &&
-        TryReplaceWithUnaryOp(instr, op_kind)) {
-      return;
-    }
-
-    if (TryInlineInstanceMethod(instr)) {
-      return;
-    }
-  }
 
-  if (I->can_use_strong_mode_types() &&
-      TryOptimizeInstanceCallUsingStaticTypes(instr)) {
+  if (TryOptimizeInstanceCallUsingStaticTypes(instr)) {
     return;
   }
 

runtime/vm/compiler/backend/flow_graph.cc

@@ -424,8 +424,8 @@ FlowGraph::ToCheck FlowGraph::CheckForInstanceCall(
   if (function().IsDynamicFunction() && IsReceiver(receiver->definition())) {
     // Call receiver is callee receiver: calling "this.g()" in f().
     receiver_class = function().Owner();
-  } else if (isolate()->can_use_strong_mode_types()) {
-    // In strong mode, get the receiver's compile type. Note that
+  } else {
+    // Get the receiver's compile type. Note that
     // we allow nullable types, which may result in just generating
     // a null check rather than the more elaborate class check
     CompileType* type = receiver->Type();
@@ -1381,7 +1381,7 @@ void FlowGraph::RenameRecursive(
           captured_parameters_->Add(index);
         }
 
-        if ((phi != NULL) && isolate()->can_use_strong_mode_types()) {
+        if (phi != nullptr) {
           // Assign type to Phi if it doesn't have a type yet.
           // For a Phi to appear in the local variable it either was placed
           // there as incoming value by renaming or it was stored there by

runtime/vm/compiler/backend/flow_graph_compiler.cc

@@ -1309,26 +1309,8 @@ bool FlowGraphCompiler::TryIntrinsifyHelper() {
         }
         return false;
       }
-      case FunctionLayout::kImplicitSetter: {
-        if (!isolate()->argument_type_checks()) {
-          Field& field = Field::Handle(function().accessor_field());
-          ASSERT(!field.IsNull());
-#if defined(DEBUG)
-          // HACK: Clone the field to ignore assertion in Field::guarded_cid().
-          // The same reasons as above apply, but we only check if it's dynamic.
-          field = field.CloneFromOriginal();
-#endif
-
-          if (field.is_instance() && field.guarded_cid() == kDynamicCid) {
-            SpecialStatsBegin(CombinedCodeStatistics::kTagIntrinsics);
-            GenerateSetterIntrinsic(compiler::target::Field::OffsetOf(field));
-            SpecialStatsEnd(CombinedCodeStatistics::kTagIntrinsics);
-            return true;
-          }
-          return false;
-        }
+      case FunctionLayout::kImplicitSetter:
         break;
-      }
 #if !defined(TARGET_ARCH_IA32)
       case FunctionLayout::kMethodExtractor: {
         auto& extracted_method = Function::ZoneHandle(

runtime/vm/compiler/backend/flow_graph_compiler.h

@@ -1094,7 +1094,6 @@ class FlowGraphCompiler : public ValueObject {
                                         intptr_t type_arguments_field_offset);
 
   void GenerateGetterIntrinsic(intptr_t offset);
-  void GenerateSetterIntrinsic(intptr_t offset);
 
   // Perform a greedy local register allocation.  Consider all registers free.
   void AllocateRegistersLocally(Instruction* instr);

runtime/vm/compiler/backend/flow_graph_compiler_arm.cc

@@ -871,20 +871,6 @@ void FlowGraphCompiler::GenerateGetterIntrinsic(intptr_t offset) {
   __ Ret();
 }
 
-void FlowGraphCompiler::GenerateSetterIntrinsic(intptr_t offset) {
-  // LR: return address.
-  // SP+1: receiver.
-  // SP+0: value.
-  // Sequence node has one store node and one return NULL node.
-  __ Comment("Intrinsic Setter");
-  __ ldr(R0,
-         compiler::Address(SP, 1 * compiler::target::kWordSize));  // Receiver.
-  __ ldr(R1, compiler::Address(SP, 0 * compiler::target::kWordSize));  // Value.
-  __ StoreIntoObjectOffset(R0, offset, R1);
-  __ LoadObject(R0, Object::null_object());
-  __ Ret();
-}
-
 void FlowGraphCompiler::EmitFrameEntry() {
   const Function& function = parsed_function().function();
   if (CanOptimizeFunction() && function.IsOptimizable() &&

runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc

@@ -832,19 +832,6 @@ void FlowGraphCompiler::GenerateGetterIntrinsic(intptr_t offset) {
   __ ret();
 }
 
-void FlowGraphCompiler::GenerateSetterIntrinsic(intptr_t offset) {
-  // LR: return address.
-  // SP+1: receiver.
-  // SP+0: value.
-  // Sequence node has one store node and one return NULL node.
-  __ Comment("Intrinsic Setter");
-  __ LoadFromOffset(R0, SP, 1 * kWordSize);  // Receiver.
-  __ LoadFromOffset(R1, SP, 0 * kWordSize);  // Value.
-  __ StoreIntoObjectOffset(R0, offset, R1);
-  __ LoadObject(R0, Object::null_object());
-  __ ret();
-}
-
 void FlowGraphCompiler::EmitFrameEntry() {
   const Function& function = parsed_function().function();
   if (CanOptimizeFunction() && function.IsOptimizable() &&

runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc

@@ -752,21 +752,6 @@ void FlowGraphCompiler::GenerateGetterIntrinsic(intptr_t offset) {
   __ ret();
 }
 
-void FlowGraphCompiler::GenerateSetterIntrinsic(intptr_t offset) {
-  // TOS: return address.
-  // +1 : value
-  // +2 : receiver.
-  // Sequence node has one store node and one return NULL node.
-  __ Comment("Intrinsic Setter");
-  __ movl(EAX, compiler::Address(ESP, 2 * kWordSize));  // Receiver.
-  __ movl(EBX, compiler::Address(ESP, 1 * kWordSize));  // Value.
-  __ StoreIntoObject(EAX, compiler::FieldAddress(EAX, offset), EBX);
-  const compiler::Immediate& raw_null =
-      compiler::Immediate(static_cast<intptr_t>(Object::null()));
-  __ movl(EAX, raw_null);
-  __ ret();
-}
-
 // NOTE: If the entry code shape changes, ReturnAddressLocator in profiler.cc
 // needs to be updated to match.
 void FlowGraphCompiler::EmitFrameEntry() {

runtime/vm/compiler/backend/flow_graph_compiler_x64.cc

@@ -837,19 +837,6 @@ void FlowGraphCompiler::GenerateGetterIntrinsic(intptr_t offset) {
   __ ret();
 }
 
-void FlowGraphCompiler::GenerateSetterIntrinsic(intptr_t offset) {
-  // TOS: return address.
-  // +1 : value
-  // +2 : receiver.
-  // Sequence node has one store node and one return NULL node.
-  __ Comment("Intrinsic Setter");
-  __ movq(RAX, compiler::Address(RSP, 2 * kWordSize));  // Receiver.
-  __ movq(RBX, compiler::Address(RSP, 1 * kWordSize));  // Value.
-  __ StoreIntoObject(RAX, compiler::FieldAddress(RAX, offset), RBX);
-  __ LoadObject(RAX, Object::null_object());
-  __ ret();
-}
-
 // NOTE: If the entry code shape changes, ReturnAddressLocator in profiler.cc
 // needs to be updated to match.
 void FlowGraphCompiler::EmitFrameEntry() {

runtime/vm/compiler/backend/il.cc

@@ -2337,8 +2337,7 @@ Definition* CheckedSmiComparisonInstr::Canonicalize(FlowGraph* flow_graph) {
 
   if ((left_type->ToCid() == kSmiCid) && (right_type->ToCid() == kSmiCid)) {
     op_cid = kSmiCid;
-  } else if (Isolate::Current()->can_use_strong_mode_types() &&
-             FlowGraphCompiler::SupportsUnboxedInt64() &&
+  } else if (FlowGraphCompiler::SupportsUnboxedInt64() &&
              // TODO(dartbug.com/30480): handle nullable types here
              left_type->IsNullableInt() && !left_type->is_nullable() &&
              right_type->IsNullableInt() && !right_type->is_nullable()) {