VM: [Cleanup] Delete legacy code associated with BranchInstr.

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/growable_array.h"
@@ skipping 175 matching lines @@
 
   CompileType* ToCompileType() { return &type_; }
 
  protected:
   explicit ZoneCompileType(const CompileType& type) : type_(type) {}
 
   CompileType type_;
 };
 
 
-// ConstrainedCompileType represents a compile type that is computed from
-// another compile type.
-class ConstrainedCompileType : public ZoneCompileType {
- public:
-  virtual ~ConstrainedCompileType() {}
-
-  // Recompute compile type.
-  virtual void Update() = 0;
-
- protected:
-  explicit ConstrainedCompileType(const CompileType& type)
-      : ZoneCompileType(type) {}
-};
-
-
-// NotNullConstrainedCompileType represents not-null constraint applied to
-// the source compile type. Result is non-nullable version of the incoming
-// compile type. It is used to represent compile type propagated downwards
-// from strict comparison with the null constant.
-class NotNullConstrainedCompileType : public ConstrainedCompileType {
- public:
-  explicit NotNullConstrainedCompileType(CompileType* source)
-      : ConstrainedCompileType(source->CopyNonNullable()), source_(source) {}
-
-  virtual void Update() { type_ = source_->CopyNonNullable(); }
-
- private:
-  CompileType* source_;
-};
-
-
 class EffectSet : public ValueObject {
  public:
   enum Effects {
     kNoEffects = 0,
     kExternalization = 1,
     kLastEffect = kExternalization
   };
 
   EffectSet(const EffectSet& other) : ValueObject(), effects_(other.effects_) {}
 
@@ skipping 2111 matching lines @@
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 };
 
 
 class BranchInstr : public Instruction {
  public:
   explicit BranchInstr(ComparisonInstr* comparison)
       : Instruction(Thread::Current()->GetNextDeoptId()),
         comparison_(comparison),
-        is_checked_(false),
-        constrained_type_(NULL),
         constant_target_(NULL) {
     ASSERT(comparison->env() == NULL);
     for (intptr_t i = comparison->InputCount() - 1; i >= 0; --i) {
       comparison->InputAt(i)->set_instruction(this);
     }
   }
 
   DECLARE_INSTRUCTION(Branch)
 
   virtual intptr_t ArgumentCount() const {
     return comparison()->ArgumentCount();
   }
 
   intptr_t InputCount() const { return comparison()->InputCount(); }
 
   Value* InputAt(intptr_t i) const { return comparison()->InputAt(i); }
 
   virtual TokenPosition token_pos() const { return comparison_->token_pos(); }
 
-  virtual bool CanDeoptimize() const {
-    // Branches need a deoptimization info in checked mode if they
-    // can throw a type check error.
-    return comparison()->CanDeoptimize() || is_checked();
-  }
+  virtual bool CanDeoptimize() const { return comparison()->CanDeoptimize(); }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     return comparison()->CanBecomeDeoptimizationTarget();
   }
 
   virtual EffectSet Effects() const { return comparison()->Effects(); }
 
   ComparisonInstr* comparison() const { return comparison_; }
   void SetComparison(ComparisonInstr* comp);
 
-  void set_is_checked(bool value) { is_checked_ = value; }
-  bool is_checked() const { return is_checked_; }
-
   virtual intptr_t DeoptimizationTarget() const {
     return comparison()->DeoptimizationTarget();
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return comparison()->RequiredInputRepresentation(i);
   }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
-  // Set compile type constrained by the comparison of this branch.
-  // FlowGraphPropagator propagates it downwards into either true or false
-  // successor.
-  void set_constrained_type(ConstrainedCompileType* type) {
-    constrained_type_ = type;
-  }
-
-  // Return compile type constrained by the comparison of this branch.
-  ConstrainedCompileType* constrained_type() const { return constrained_type_; }
-
   void set_constant_target(TargetEntryInstr* target) {
     ASSERT(target == true_successor() || target == false_successor());
     constant_target_ = target;
   }
   TargetEntryInstr* constant_target() const { return constant_target_; }
 
   virtual void InheritDeoptTarget(Zone* zone, Instruction* other);
 
   virtual bool MayThrow() const { return comparison()->MayThrow(); }
 
   TargetEntryInstr* true_successor() const { return true_successor_; }
   TargetEntryInstr* false_successor() const { return false_successor_; }
 
   TargetEntryInstr** true_successor_address() { return &true_successor_; }
   TargetEntryInstr** false_successor_address() { return &false_successor_; }
 
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   PRINT_TO_SUPPORT
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     comparison()->RawSetInputAt(i, value);
   }
 
   TargetEntryInstr* true_successor_;
   TargetEntryInstr* false_successor_;
   ComparisonInstr* comparison_;
-  bool is_checked_;
-  ConstrainedCompileType* constrained_type_;
   TargetEntryInstr* constant_target_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 
 class DeoptimizeInstr : public TemplateInstruction<0, NoThrow, Pure> {
  public:
   DeoptimizeInstr(ICData::DeoptReasonId deopt_reason, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), deopt_reason_(deopt_reason) {}
@@ skipping 5630 matching lines @@
   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_