[vm] Remove Dart_MakeExternalString and --support-externalizable-strings

runtime/vm/intermediate_language.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.
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/bootstrap.h"
@@ skipping 26 matching lines @@
             "Propagate IC data from unoptimized to optimized IC calls.");
 DEFINE_FLAG(bool,
             two_args_smi_icd,
             true,
             "Generate special IC stubs for two args Smi operations");
 DEFINE_FLAG(bool,
             unbox_numeric_fields,
             !USING_DBC,
             "Support unboxed double and float32x4 fields.");
 DECLARE_FLAG(bool, eliminate_type_checks);
-DECLARE_FLAG(bool, support_externalizable_strings);
 
 #if defined(DEBUG)
 void Instruction::CheckField(const Field& field) const {
   ASSERT(field.IsZoneHandle());
   ASSERT(!Compiler::IsBackgroundCompilation() || !field.IsOriginal());
 }
 #endif  // DEBUG
 
 Definition::Definition(intptr_t deopt_id)
     : Instruction(deopt_id),
@@ skipping 83 matching lines @@
   return (*a)->cid_start - (*b)->cid_start;
 }
 
 static int OrderByFrequency(CidRange* const* a, CidRange* const* b) {
   const TargetInfo* target_info_a = static_cast<const TargetInfo*>(*a);
   const TargetInfo* target_info_b = static_cast<const TargetInfo*>(*b);
   // Negative if 'a' should sort before 'b'.
   return target_info_b->count - target_info_a->count;
 }
 
-bool Cids::ContainsExternalizableCids() const {
-  for (intptr_t i = 0; i < length(); i++) {
-    for (intptr_t cid = cid_ranges_[i]->cid_start;
-         cid <= cid_ranges_[i]->cid_end; cid++) {
-      if (Field::IsExternalizableCid(cid)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
 bool Cids::Equals(const Cids& other) const {
   if (length() != other.length()) return false;
   for (int i = 0; i < length(); i++) {
     if (cid_ranges_[i]->cid_start != other.cid_ranges_[i]->cid_start ||
         cid_ranges_[i]->cid_end != other.cid_ranges_[i]->cid_end) {
       return false;
     }
   }
   return true;
 }
@@ skipping 111 matching lines @@
   ASSERT(number_of_checks != 1 || !cids[0].IsSingleCid() ||
          cids[0].cid_start != kSmiCid);
 }
 
 bool CheckClassInstr::AttributesEqual(Instruction* other) const {
   CheckClassInstr* other_check = other->AsCheckClass();
   ASSERT(other_check != NULL);
   return cids().Equals(other_check->cids());
 }
 
-EffectSet CheckClassInstr::Dependencies() const {
-  // Externalization of strings via the API can change the class-id.
-  return cids_.ContainsExternalizableCids() ? EffectSet::Externalization()
-                                            : EffectSet::None();
-}
-
-EffectSet CheckClassIdInstr::Dependencies() const {
-  // Externalization of strings via the API can change the class-id.
-  for (intptr_t i = cids_.cid_start; i <= cids_.cid_end; i++) {
-    if (Field::IsExternalizableCid(i)) return EffectSet::Externalization();
-  }
-  return EffectSet::None();
-}
-
 bool CheckClassInstr::IsDeoptIfNull() const {
   if (!cids().IsMonomorphic()) {
     return false;
   }
   CompileType* in_type = value()->Type();
   const intptr_t cid = cids().MonomorphicReceiverCid();
   // Performance check: use CheckSmiInstr instead.
   ASSERT(cid != kSmiCid);
   return in_type->is_nullable() && (in_type->ToNullableCid() == cid);
 }
@@ skipping 3743 matching lines @@
   }
   set_is_auto_scope(auto_setup_scope);
   set_native_c_function(native_function);
 }
 
 #undef __
 
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)