Optimize checked mode asserts with uninstantiated types and known constant type-arguments.

runtime/vm/intermediate_language.h

 // Copyright (c) 2012, 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 VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
 #include "vm/handles_impl.h"
 #include "vm/locations.h"
 #include "vm/object.h"
 
 namespace dart {
 
 class BitVector;
 class BlockEntryInstr;
 class BufferFormatter;
 class ComparisonInstr;
 class ControlInstruction;
 class Definition;
 class Environment;
 class FlowGraphCompiler;
 class FlowGraphVisitor;
 class Instruction;
 class LocalVariable;
 class Range;
+class FlowGraphOptimizer;
 
 
 // TODO(srdjan): Add _ByteArrayBase, get:length.
 // TODO(srdjan): Unify with INTRINSIC_LIST.
 // (class-name, function-name, recognized enum, fingerprint).
 // See intrinsifier for fingerprint computation.
 #define RECOGNIZED_LIST(V)                                                     \
   V(_ObjectArray, get:length, ObjectArrayLength, 405297088)                    \
   V(_ImmutableArray, get:length, ImmutableArrayLength, 433698233)              \
   V(_GrowableObjectArray, get:length, GrowableArrayLength, 725548050)          \
@@ skipping 423 matching lines @@
   // that input operands conversions inserted for this instruction can jump
   // to.
   virtual intptr_t DeoptimizationTarget() const {
     UNREACHABLE();
     return Isolate::kNoDeoptId;
   }
 
   // Returns a replacement for the instruction or NULL if the instruction can
   // be eliminated.  By default returns the this instruction which means no
   // change.
-  virtual Instruction* Canonicalize();
+  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
   // Insert this instruction before 'next'.
   void InsertBefore(Instruction* next);
 
   // Insert this instruction after 'prev'.
   void InsertAfter(Instruction* prev);
 
   // Returns true if the instruction is affected by side effects.
   // Only instructions that are not affected by side effects can participate
   // in redundancy elimination or loop invariant code motion.
@@ skipping 646 matching lines @@
   //    - unknown sentinel
   Object& constant_value() const { return constant_value_; }
 
   virtual void InferRange();
 
   Range* range() const { return range_; }
 
   // Definitions can be canonicalized only into definitions to ensure
   // this check statically we override base Canonicalize with a Canonicalize
   // returning Definition (return type is covariant).
-  virtual Definition* Canonicalize();
+  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
  protected:
   friend class RangeAnalysis;
 
   Range* range_;
 
  private:
   intptr_t temp_index_;
   intptr_t ssa_temp_index_;
   // TODO(regis): GrowableArray<const AbstractType*> propagated_types_;
@@ skipping 692 matching lines @@
 
 class AssertAssignableInstr : public TemplateDefinition<3> {
  public:
   AssertAssignableInstr(intptr_t token_pos,
                         Value* value,
                         Value* instantiator,
                         Value* instantiator_type_arguments,
                         const AbstractType& dst_type,
                         const String& dst_name)
       : token_pos_(token_pos),
-        dst_type_(dst_type),
+        dst_type_(AbstractType::ZoneHandle(dst_type.raw())),
         dst_name_(dst_name),
         is_eliminated_(false) {
     ASSERT(value != NULL);
     ASSERT(instantiator != NULL);
     ASSERT(instantiator_type_arguments != NULL);
     ASSERT(!dst_type.IsNull());
     ASSERT(!dst_name.IsNull());
     inputs_[0] = value;
     inputs_[1] = instantiator;
     inputs_[2] = instantiator_type_arguments;
   }
 
   DECLARE_INSTRUCTION(AssertAssignable)
   virtual RawAbstractType* CompileType() const;
 
   Value* value() const { return inputs_[0]; }
   Value* instantiator() const { return inputs_[1]; }
   Value* instantiator_type_arguments() const { return inputs_[2]; }
 
   intptr_t token_pos() const { return token_pos_; }
   const AbstractType& dst_type() const { return dst_type_; }
+  void set_dst_type(const AbstractType& dst_type) {
+    dst_type_ = dst_type.raw();
+  }
   const String& dst_name() const { return dst_name_; }
 
   bool is_eliminated() const {
     return is_eliminated_;
   }
   void eliminate() {
     ASSERT(!is_eliminated_);
     is_eliminated_ = true;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual intptr_t ResultCid() const { return value()->ResultCid(); }
   virtual intptr_t GetPropagatedCid();
 
-  virtual Definition* Canonicalize();
+  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
  private:
   const intptr_t token_pos_;
-  const AbstractType& dst_type_;
+  AbstractType& dst_type_;
   const String& dst_name_;
   bool is_eliminated_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
 };
 
 
 class AssertBooleanInstr : public TemplateDefinition<1> {
  public:
   AssertBooleanInstr(intptr_t token_pos, Value* value)
@@ skipping 21 matching lines @@
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual intptr_t ResultCid() const { return kBoolCid; }
 
-  virtual Definition* Canonicalize();
+  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
  private:
   const intptr_t token_pos_;
   bool is_eliminated_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
 
 class ArgumentDefinitionTestInstr : public TemplateDefinition<1> {
@@ skipping 288 matching lines @@
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const;
   virtual bool AffectedBySideEffect() const { return false; }
 
-  virtual Definition* Canonicalize();
+  virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
   virtual intptr_t ResultCid() const { return kBoolCid; }
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   bool needs_number_check() const { return needs_number_check_; }
   void set_needs_number_check(bool value) { needs_number_check_ = value; }
 
  private:
@@ skipping 1118 matching lines @@
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual bool AffectedBySideEffect() const { return false; }
 
   Value* left() const { return inputs_[0]; }
 
   Value* right() const { return inputs_[1]; }
 
-  virtual Instruction* Canonicalize();
+  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckEitherNonSmiInstr);
 };
 
 
 class BoxDoubleInstr : public TemplateDefinition<1> {
  public:
   BoxDoubleInstr(Value* value, InstanceCallInstr* instance_call)
       : token_pos_((instance_call != NULL) ? instance_call->token_pos() : 0) {
@@ skipping 591 matching lines @@
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual bool AffectedBySideEffect() const { return false; }
 
   Value* value() const { return inputs_[0]; }
 
   const ICData& unary_checks() const { return unary_checks_; }
 
-  virtual Instruction* Canonicalize();
+  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const ICData& unary_checks_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassInstr);
 };
 
 
@@ skipping 12 matching lines @@
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual bool AffectedBySideEffect() const { return false; }
 
-  virtual Instruction* Canonicalize();
+  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
   Value* value() const { return inputs_[0]; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
 };
 
 
 class CheckArrayBoundInstr : public TemplateInstruction<2> {
  public:
@@ skipping 246 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_