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

runtime/vm/intermediate_language.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_INTERMEDIATE_LANGUAGE_H_
 #define RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/flags.h"
@@ skipping 160 matching lines @@
  private:
   bool CanComputeIsInstanceOf(const AbstractType& type,
                               bool is_nullable,
                               bool* is_instance);
 
   bool is_nullable_;
   intptr_t cid_;
   const AbstractType* type_;
 };
 
+// TODO(alexmarkov): remove EffectSet as there are no tracked effects anymore
 class EffectSet : public ValueObject {
  public:
   enum Effects {
     kNoEffects = 0,
-    kExternalization = 1,
-    kLastEffect = kExternalization
+    kUnusedEffect = 1,  // Currently unused.
+    kLastEffect = kUnusedEffect
   };
 
   EffectSet(const EffectSet& other) : ValueObject(), effects_(other.effects_) {}
 
   bool IsNone() const { return effects_ == kNoEffects; }
 
   static EffectSet None() { return EffectSet(kNoEffects); }
   static EffectSet All() {
     ASSERT(EffectSet::kLastEffect == 1);
-    return EffectSet(kExternalization);
+    return EffectSet(kUnusedEffect);
   }
 
-  static EffectSet Externalization() { return EffectSet(kExternalization); }
-
   bool ToInt() { return effects_; }
 
  private:
   explicit EffectSet(intptr_t effects) : effects_(effects) {}
 
   intptr_t effects_;
 };
 
 class Value : public ZoneAllocated {
  public:
@@ skipping 412 matching lines @@
   void SetLength(intptr_t len) { cid_ranges_.SetLength(len); }
 
   bool is_empty() const { return cid_ranges_.is_empty(); }
 
   void Sort(int compare(CidRange* const* a, CidRange* const* b)) {
     cid_ranges_.Sort(compare);
   }
 
   bool IsMonomorphic() const;
   intptr_t MonomorphicReceiverCid() const;
-  bool ContainsExternalizableCids() const;
   intptr_t ComputeLowestCid() const;
   intptr_t ComputeHighestCid() const;
 
  protected:
   void CreateHelper(Zone* zone,
                     const ICData& ic_data,
                     int argument_number,
                     bool include_targets);
   GrowableArray<CidRange*> cid_ranges_;
   Zone* zone_;
@@ skipping 3744 matching lines @@
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   intptr_t offset_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadUntaggedInstr);
 };
 
-class LoadClassIdInstr : public TemplateDefinition<1, NoThrow> {
+class LoadClassIdInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   explicit LoadClassIdInstr(Value* object) { SetInputAt(0, object); }
 
   virtual Representation representation() const { return kTagged; }
   DECLARE_INSTRUCTION(LoadClassId)
   virtual CompileType ComputeType() const;
 
   Value* object() const { return inputs_[0]; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  virtual bool AllowsCSE() const { return true; }
-  virtual EffectSet Dependencies() const {
-    return EffectSet::Externalization();
-  }
-  virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LoadClassIdInstr);
 };
 
 class LoadFieldInstr : public TemplateDefinition<1, NoThrow> {
  public:
   LoadFieldInstr(Value* instance,
                  intptr_t offset_in_bytes,
@@ skipping 3181 matching lines @@
   bool IsNullCheck() const { return IsDeoptIfNull() || IsDeoptIfNotNull(); }
 
   bool IsDeoptIfNull() const;
   bool IsDeoptIfNotNull() const;
 
   bool IsBitTest() const;
   static bool IsCompactCidRange(const Cids& cids);
   intptr_t ComputeCidMask() const;
 
   virtual bool AllowsCSE() const { return true; }
-  virtual EffectSet Dependencies() const;
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const;
 
   bool licm_hoisted() const { return licm_hoisted_; }
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const Cids& cids_;
@@ skipping 59 matching lines @@
   Value* value() const { return inputs_[0]; }
   const CidRange& cids() const { return cids_; }
 
   DECLARE_INSTRUCTION(CheckClassId)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AllowsCSE() const { return true; }
-  virtual EffectSet Dependencies() const;
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   bool Contains(intptr_t cid) const;
 
   CidRange cids_;
 
@@ skipping 389 matching lines @@
 #define DEFINE_UNIMPLEMENTED_INSTRUCTION(Name)                                 \
   LocationSummary* Name::MakeLocationSummary(Zone* zone, bool opt) const {     \
     UNIMPLEMENTED();                                                           \
     return NULL;                                                               \
   }                                                                            \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_