Simplify type propagation and IL declarations of TemplateInstruction.

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 VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 613 matching lines @@
     value->set_use_index(i);
     RawSetInputAt(i, value);
   }
 
   // Remove all inputs (including in the environment) from their
   // definition's use lists.
   void UnuseAllInputs();
 
   // Call instructions override this function and return the number of
   // pushed arguments.
-  virtual intptr_t ArgumentCount() const = 0;
+  virtual intptr_t ArgumentCount() const { return 0; }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     UNREACHABLE();
     return NULL;
   }
   inline Definition* ArgumentAt(intptr_t index) const;
 
   // Returns true, if this instruction can deoptimize.
   virtual bool CanDeoptimize() const = 0;
 
   // Visiting support.
@@ skipping 916 matching lines @@
 
   intptr_t value_;
 };
 
 
 // Abstract super-class of all instructions that define a value (Bind, Phi).
 class Definition : public Instruction {
  public:
   explicit Definition(intptr_t deopt_id = Isolate::kNoDeoptId);
 
-  // Overridden by definitions that have pushed arguments.
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   // Overridden by definitions that have call counts.
   virtual intptr_t CallCount() const {
     UNREACHABLE();
     return -1;
   }
 
   intptr_t temp_index() const { return temp_index_; }
   void set_temp_index(intptr_t index) { temp_index_ = index; }
   void ClearTempIndex() { temp_index_ = -1; }
   bool HasTemp() const { return temp_index_ >= 0; }
@@ skipping 13 matching lines @@
     return (representation() == kPairOfTagged) ||
            (representation() == kPairOfUnboxedDouble) ||
            (representation() == kUnboxedMint);
 #endif
   }
 
   // Compile time type of the definition, which may be requested before type
   // propagation during graph building.
   CompileType* Type() {
     if (type_ == NULL) {
-      type_ = ComputeInitialType();
+      type_ = ZoneCompileType::Wrap(ComputeType());
     }
     return type_;
   }
 
-  virtual CompileType* ComputeInitialType() const {
-    return ZoneCompileType::Wrap(ComputeType());
-  }
-
   // Does this define a mint?
   inline bool IsMintDefinition();
 
   bool IsInt32Definition() {
     return IsBinaryInt32Op() ||
            IsBoxInt32() ||
            IsUnboxInt32() ||
            IsUnboxedIntConverter();
   }
 
@@ skipping 204 matching lines @@
     }
   }
 
   // Get the block entry for that instruction.
   virtual BlockEntryInstr* GetBlock() const { return block(); }
   JoinEntryInstr* block() const { return block_; }
 
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   intptr_t InputCount() const { return inputs_.length(); }
 
   Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   // Phi is alive if it reaches a non-environment use.
   bool is_alive() const { return is_alive_; }
@@ skipping 71 matching lines @@
       : index_(index), base_reg_(base_reg), block_(block) { }
 
   DECLARE_INSTRUCTION(Parameter)
 
   intptr_t index() const { return index_; }
   Register base_reg() const { return base_reg_; }
 
   // Get the block entry for that instruction.
   virtual BlockEntryInstr* GetBlock() const { return block_; }
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   intptr_t InputCount() const { return 0; }
   Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
@@ skipping 21 matching lines @@
 
 
 class PushArgumentInstr : public TemplateDefinition<1, NoThrow> {
  public:
   explicit PushArgumentInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(PushArgument)
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   virtual CompileType ComputeType() const;
 
   Value* value() const { return InputAt(0); }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
@@ skipping 10 matching lines @@
 class ReturnInstr : public TemplateInstruction<1, NoThrow> {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
       : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
         token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Return)
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   virtual intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Return instruction might turn into a Goto instruction after inlining.
     // Every Goto must have an environment.
     return true;
   }
 
   virtual bool CanDeoptimize() const { return false; }
@@ skipping 64 matching lines @@
  public:
   explicit GotoInstr(JoinEntryInstr* entry)
     : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
       successor_(entry),
       edge_weight_(0.0),
       parallel_move_(NULL) {
   }
 
   DECLARE_INSTRUCTION(Goto)
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   JoinEntryInstr* successor() const { return successor_; }
   void set_successor(JoinEntryInstr* successor) { successor_ = successor; }
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   double edge_weight() const { return edge_weight_; }
   void set_edge_weight(double weight) { edge_weight_ = weight; }
   void adjust_edge_weight(double scale_factor) { edge_weight_ *= scale_factor; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
@@ skipping 210 matching lines @@
 };
 
 
 class DeoptimizeInstr : public TemplateInstruction<0, NoThrow, Pure> {
  public:
   DeoptimizeInstr(ICData::DeoptReasonId deopt_reason, intptr_t deopt_id)
       : TemplateInstruction(deopt_id),
         deopt_reason_(deopt_reason) {
   }
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool AttributesEqual(Instruction* other) const {
     return true;
   }
 
   DECLARE_INSTRUCTION(Deoptimize)
 
  private:
   const ICData::DeoptReasonId deopt_reason_;
@@ skipping 847 matching lines @@
   virtual intptr_t InputCount() const { return value_ != NULL ? 1 : 0; }
   virtual Value* InputAt(intptr_t i) const {
     ASSERT((value_ != NULL) && (i == 0));
     return value_;
   }
 
   Value* value() const { return value_; }
 
   intptr_t num_temps() const { return num_temps_; }
 
-  virtual CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const {
     UNREACHABLE();  // Eliminated by SSA construction.
     return EffectSet::None();
   }
 
@@ skipping 15 matching lines @@
 
 
 class StoreLocalInstr : public TemplateDefinition<1, NoThrow> {
  public:
   StoreLocalInstr(const LocalVariable& local, Value* value)
       : local_(local), is_dead_(false), is_last_(false) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(StoreLocal)
-  virtual CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   const LocalVariable& local() const { return local_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   void mark_dead() { is_dead_ = true; }
   bool is_dead() const { return is_dead_; }
@@ skipping 57 matching lines @@
                       RawPcDescriptors::Kind stub_kind)
       : token_pos_(token_pos),
         stub_kind_(stub_kind) {
   }
 
   DECLARE_INSTRUCTION(DebugStepCheck)
 
   virtual intptr_t token_pos() const { return token_pos_; }
   virtual bool CanDeoptimize() const { return false; }
   virtual EffectSet Effects() const { return EffectSet::All(); }
-  virtual intptr_t ArgumentCount() const { return 0; }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const intptr_t token_pos_;
   const RawPcDescriptors::Kind stub_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(DebugStepCheckInstr);
 };
 
 
@@ skipping 40 matching lines @@
   enum {
     kInstancePos = 0,
     kValuePos = 1
   };
 
   Value* instance() const { return inputs_[kInstancePos]; }
   Value* value() const { return inputs_[kValuePos]; }
   bool is_initialization() const { return is_initialization_; }
   virtual intptr_t token_pos() const { return token_pos_; }
 
-  virtual CompileType* ComputeInitialType() const;
-
   const Field& field() const { return field_; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
 
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer()
         && (emit_store_barrier_ == kEmitStoreBarrier);
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
@@ skipping 42 matching lines @@
                   intptr_t deopt_id)
     : TemplateInstruction(deopt_id),
       field_(field) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   const Field& field() const { return field_; }
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   virtual bool CanDeoptimize() const { return true; }
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Ensure that we record kDeopt PC descriptor in unoptimized code.
     return true;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const Field& field_;
@@ skipping 72 matching lines @@
       : field_(field) {
     ASSERT(field.IsZoneHandle());
     SetInputAt(kValuePos, value);
   }
 
   enum {
     kValuePos = 0
   };
 
   DECLARE_INSTRUCTION(StoreStaticField)
-  virtual CompileType* ComputeInitialType() const;
 
   const Field& field() const { return field_; }
   Value* value() const { return inputs_[kValuePos]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   // Currently CSE/LICM don't operate on any instructions that can be affected
   // by stores/loads. LoadOptimizer handles loads separately. Hence stores
@@ skipping 739 matching lines @@
       : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
         field_(field) {
     SetInputAt(0, input);
   }
 
   virtual intptr_t token_pos() const { return field_.token_pos(); }
   const Field& field() const { return field_; }
 
   DECLARE_INSTRUCTION(InitStaticField)
 
-  virtual intptr_t ArgumentCount() const { return 0; }
   virtual bool CanDeoptimize() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::All(); }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(InitStaticFieldInstr);
 };
 
@@ skipping 57 matching lines @@
       : TemplateInstruction(deopt_id), licm_hoisted_(false) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   DECLARE_INSTRUCTION(CheckEitherNonSmi)
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
  private:
   bool licm_hoisted_;
@@ skipping 2426 matching lines @@
         token_pos_(token_pos),
         loop_depth_(loop_depth) {
   }
 
   virtual intptr_t token_pos() const { return token_pos_; }
   bool in_loop() const { return loop_depth_ > 0; }
   intptr_t loop_depth() const { return loop_depth_; }
 
   DECLARE_INSTRUCTION(CheckStackOverflow)
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const intptr_t token_pos_;
   const intptr_t loop_depth_;
 
@@ skipping 482 matching lines @@
 
 class CheckClassInstr : public TemplateInstruction<1, NoThrow> {
  public:
   CheckClassInstr(Value* value,
                   intptr_t deopt_id,
                   const ICData& unary_checks,
                   intptr_t token_pos);
 
   DECLARE_INSTRUCTION(CheckClass)
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual intptr_t token_pos() const { return token_pos_; }
 
   Value* value() const { return inputs_[0]; }
 
   const ICData& unary_checks() const { return unary_checks_; }
 
   const GrowableArray<intptr_t>& cids() const { return cids_; }
 
@@ skipping 31 matching lines @@
         token_pos_(token_pos),
         licm_hoisted_(false) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   virtual intptr_t token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(CheckSmi)
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
  private:
   const intptr_t token_pos_;
   bool licm_hoisted_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
 };
 
 
 class CheckClassIdInstr : public TemplateInstruction<1, NoThrow> {
  public:
   CheckClassIdInstr(Value* value, intptr_t cid, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), cid_(cid) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   intptr_t cid() const { return cid_; }
 
   DECLARE_INSTRUCTION(CheckClassId)
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const;
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 13 matching lines @@
         licm_hoisted_(false) {
     SetInputAt(kLengthPos, length);
     SetInputAt(kIndexPos, index);
   }
 
   Value* length() const { return inputs_[kLengthPos]; }
   Value* index() const { return inputs_[kIndexPos]; }
 
   DECLARE_INSTRUCTION(CheckArrayBound)
 
-  virtual intptr_t ArgumentCount() const { return 0; }
-
   virtual bool CanDeoptimize() const { return true; }
 
   bool IsRedundant(const RangeBoundary& length);
 
   void mark_generalized() {
     generalized_ = true;
   }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
@@ skipping 320 matching lines @@
       Isolate* isolate, bool opt) const {                                     \
     UNIMPLEMENTED();                                                          \
     return NULL;                                                              \
   }                                                                           \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_