Remove more feature in product mode

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 581 matching lines @@
 #define DECLARE_INSTRUCTION_BACKEND()                                          \
   virtual LocationSummary* MakeLocationSummary(Zone* zone,                     \
                                                bool optimizing) const;         \
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);                    \
 
 // Functions required in all concrete instruction classes.
 #define DECLARE_INSTRUCTION(type)                                              \
   DECLARE_INSTRUCTION_NO_BACKEND(type)                                         \
   DECLARE_INSTRUCTION_BACKEND()                                                \
 
+#ifndef PRODUCT
+#define PRINT_TO_SUPPORT                                                       \
+    virtual void PrintTo(BufferFormatter* f) const;
+#else
+#define PRINT_TO_SUPPORT
+#endif  // !PRODUCT
+
+#ifndef PRODUCT
+#define PRINT_OPERANDS_TO_SUPPORT                                              \
+    virtual void PrintOperandsTo(BufferFormatter* f) const;
+#else
+#define PRINT_OPERANDS_TO_SUPPORT
+#endif  // !PRODUCT
+
 class Instruction : public ZoneAllocated {
  public:
 #define DECLARE_TAG(type) k##type,
   enum Tag {
     FOR_EACH_INSTRUCTION(DECLARE_TAG)
   };
 #undef DECLARE_TAG
 
   explicit Instruction(intptr_t deopt_id = Thread::kNoDeoptId)
       : deopt_id_(deopt_id),
@@ skipping 85 matching lines @@
   // function.
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   void Goto(JoinEntryInstr* entry);
 
   virtual const char* DebugName() const = 0;
 
   // Printing support.
   const char* ToCString() const;
+#ifndef PRODUCT
   virtual void PrintTo(BufferFormatter* f) const;
   virtual void PrintOperandsTo(BufferFormatter* f) const;
+#endif
 
 #define DECLARE_INSTRUCTION_TYPE_CHECK(Name, Type)                             \
   bool Is##Name() { return (As##Name() != NULL); }                             \
   virtual Type* As##Name() { return NULL; }
 #define INSTRUCTION_TYPE_CHECK(Name)                                           \
   DECLARE_INSTRUCTION_TYPE_CHECK(Name, Name##Instr)
 
 DECLARE_INSTRUCTION_TYPE_CHECK(Definition, Definition)
 FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
 FOR_EACH_ABSTRACT_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
@@ skipping 328 matching lines @@
     moves_.Add(move);
     return move;
   }
 
   MoveOperands* MoveOperandsAt(intptr_t index) const { return moves_[index]; }
 
   intptr_t NumMoves() const { return moves_.length(); }
 
   bool IsRedundant() const;
 
-  virtual void PrintTo(BufferFormatter* f) const;
-
   virtual TokenPosition token_pos() const {
     return TokenPosition::kParallelMove;
   }
 
+  PRINT_TO_SUPPORT
+
  private:
   GrowableArray<MoveOperands*> moves_;   // Elements cannot be null.
 
   DISALLOW_COPY_AND_ASSIGN(ParallelMoveInstr);
 };
 
 
 // Basic block entries are administrative nodes.  There is a distinguished
 // graph entry with no predecessor.  Joins are the only nodes with multiple
 // predecessors.  Targets are all other basic block entries.  The types
@@ skipping 295 matching lines @@
   }
 
   const GrowableArray<CatchBlockEntryInstr*>& catch_entries() const {
     return catch_entries_;
   }
 
   const GrowableArray<IndirectEntryInstr*>& indirect_entries() const {
     return indirect_entries_;
   }
 
-  virtual void PrintTo(BufferFormatter* f) const;
+  PRINT_TO_SUPPORT
 
  private:
   virtual void ClearPredecessors() {}
   virtual void AddPredecessor(BlockEntryInstr* predecessor) { UNREACHABLE(); }
 
   const ParsedFunction& parsed_function_;
   TargetEntryInstr* normal_entry_;
   GrowableArray<CatchBlockEntryInstr*> catch_entries_;
   // Indirect targets are blocks reachable only through indirect gotos.
   GrowableArray<IndirectEntryInstr*> indirect_entries_;
@@ skipping 25 matching lines @@
   intptr_t IndexOfPredecessor(BlockEntryInstr* pred) const;
 
   ZoneGrowableArray<PhiInstr*>* phis() const { return phis_; }
 
   PhiInstr* InsertPhi(intptr_t var_index, intptr_t var_count);
   void RemoveDeadPhis(Definition* replacement);
 
   void InsertPhi(PhiInstr* phi);
   void RemovePhi(PhiInstr* phi);
 
-  virtual void PrintTo(BufferFormatter* f) const;
-
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
+  PRINT_TO_SUPPORT
+
  private:
   // Classes that have access to predecessors_ when inlining.
   friend class BlockEntryInstr;
   friend class InlineExitCollector;
   friend class PolymorphicInliner;
   friend class IndirectEntryInstr;  // Access in il_printer.cc.
 
   // Direct access to phis_ in order to resize it due to phi elimination.
   friend class ConstantPropagator;
   friend class DeadCodeElimination;
@@ skipping 46 matching lines @@
   void adjust_edge_weight(double scale_factor) { edge_weight_ *= scale_factor; }
 
   virtual intptr_t PredecessorCount() const {
     return (predecessor_ == NULL) ? 0 : 1;
   }
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const {
     ASSERT((index == 0) && (predecessor_ != NULL));
     return predecessor_;
   }
 
-  virtual void PrintTo(BufferFormatter* f) const;
+  PRINT_TO_SUPPORT
 
  private:
   friend class BlockEntryInstr;  // Access to predecessor_ when inlining.
 
   virtual void ClearPredecessors() { predecessor_ = NULL; }
   virtual void AddPredecessor(BlockEntryInstr* predecessor) {
     ASSERT(predecessor_ == NULL);
     predecessor_ = predecessor;
   }
 
   BlockEntryInstr* predecessor_;
   double edge_weight_;
 
   DISALLOW_COPY_AND_ASSIGN(TargetEntryInstr);
 };
 
 
 class IndirectEntryInstr : public JoinEntryInstr {
  public:
   IndirectEntryInstr(intptr_t block_id,
                      intptr_t indirect_id,
                      intptr_t try_index)
       : JoinEntryInstr(block_id, try_index),
         indirect_id_(indirect_id) { }
 
   DECLARE_INSTRUCTION(IndirectEntry)
 
-  virtual void PrintTo(BufferFormatter* f) const;
+  intptr_t indirect_id() const { return indirect_id_; }
 
-  intptr_t indirect_id() const { return indirect_id_; }
+  PRINT_TO_SUPPORT
 
  private:
   const intptr_t indirect_id_;
 };
 
 
 class CatchBlockEntryInstr : public BlockEntryInstr {
  public:
   CatchBlockEntryInstr(intptr_t block_id,
                        intptr_t try_index,
@@ skipping 27 matching lines @@
 
   // Returns try index for the try block to which this catch handler
   // corresponds.
   intptr_t catch_try_index() const {
     return catch_try_index_;
   }
   GrowableArray<Definition*>* initial_definitions() {
     return &initial_definitions_;
   }
 
-  virtual void PrintTo(BufferFormatter* f) const;
+  PRINT_TO_SUPPORT
 
  private:
   friend class BlockEntryInstr;  // Access to predecessor_ when inlining.
 
   virtual void ClearPredecessors() { predecessor_ = NULL; }
   virtual void AddPredecessor(BlockEntryInstr* predecessor) {
     ASSERT(predecessor_ == NULL);
     predecessor_ = predecessor;
   }
 
@@ skipping 121 matching lines @@
   // building).
   virtual CompileType ComputeType() const {
     return CompileType::Dynamic();
   }
 
   // Update CompileType of the definition. Returns true if the type has changed.
   virtual bool RecomputeType() {
     return false;
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+  PRINT_TO_SUPPORT
+
   bool UpdateType(CompileType new_type) {
     if (type_ == NULL) {
       type_ = ZoneCompileType::Wrap(new_type);
       return true;
     }
 
     if (type_->IsNone() || !type_->IsEqualTo(&new_type)) {
       *type_ = new_type;
       return true;
     }
@@ skipping 21 matching lines @@
   // Precondition: use lists must be properly calculated.
   // Postcondition: use lists and use values are still valid.
   void ReplaceUsesWith(Definition* other);
 
   // Replace this definition and all uses with another definition.  If
   // replacing during iteration, pass the iterator so that the instruction
   // can be replaced without affecting iteration order, otherwise pass a
   // NULL iterator.
   void ReplaceWith(Definition* other, ForwardInstructionIterator* iterator);
 
-  // Printing support. These functions are sometimes overridden for custom
-  // formatting. Otherwise, it prints in the format "opcode(op1, op2, op3)".
-  virtual void PrintTo(BufferFormatter* f) const;
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   // A value in the constant propagation lattice.
   //    - non-constant sentinel
   //    - a constant (any non-sentinel value)
   //    - unknown sentinel
   Object& constant_value();
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   Range* range() const { return range_; }
   void set_range(const Range&);
@@ skipping 159 matching lines @@
     representation_ = r;
   }
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
   DECLARE_INSTRUCTION(Phi)
 
-  virtual void PrintTo(BufferFormatter* f) const;
-
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   BitVector* reaching_defs() const {
     return reaching_defs_;
   }
 
   void set_reaching_defs(BitVector* reaching_defs) {
     reaching_defs_ = reaching_defs;
   }
 
   virtual bool MayThrow() const { return false; }
 
   // A phi is redundant if all input operands are the same.
   bool IsRedundant() const;
 
   void set_induction_variable_info(InductionVariableInfo* info) {
     loop_variable_info_ = info;
   }
 
   InductionVariableInfo* induction_variable_info() {
     return loop_variable_info_;
   }
 
+  PRINT_TO_SUPPORT
+
  private:
   // Direct access to inputs_ in order to resize it due to unreachable
   // predecessors.
   friend class ConstantPropagator;
 
   void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 
   JoinEntryInstr* block_;
   GrowableArray<Value*> inputs_;
   bool is_alive_;
@@ skipping 30 matching lines @@
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual CompileType ComputeType() const;
 
   virtual bool MayThrow() const { return false; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   const intptr_t index_;
   const Register base_reg_;
   BlockEntryInstr* block_;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
 class PushArgumentInstr : public TemplateDefinition<1, NoThrow> {
  public:
   explicit PushArgumentInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(PushArgument)
 
   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;
 
   virtual TokenPosition token_pos() const {
     return TokenPosition::kPushArgument;
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
 
 inline Definition* Instruction::ArgumentAt(intptr_t index) const {
   return PushArgumentAt(index)->value()->definition();
 }
 
 
@@ skipping 152 matching lines @@
     return HasParallelMove() && !parallel_move()->IsRedundant();
   }
 
   ParallelMoveInstr* GetParallelMove() {
     if (parallel_move_ == NULL) {
       parallel_move_ = new ParallelMoveInstr();
     }
     return parallel_move_;
   }
 
-  virtual void PrintTo(BufferFormatter* f) const;
-
   virtual TokenPosition token_pos() const {
     return TokenPosition::kControlFlow;
   }
 
+  PRINT_TO_SUPPORT
+
  private:
   BlockEntryInstr* block_;
   JoinEntryInstr* successor_;
   double edge_weight_;
 
   // Parallel move that will be used by linear scan register allocator to
   // connect live ranges at the end of the block and resolve phis.
   ParallelMoveInstr* parallel_move_;
 };
 
@@ skipping 37 matching lines @@
   virtual TargetEntryInstr* SuccessorAt(intptr_t index) const {
     ASSERT(index < SuccessorCount());
     return successors_[index];
   }
 
   virtual bool CanDeoptimize() const { return false; }
   virtual bool CanBecomeDeoptimizationTarget() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
-  virtual void PrintTo(BufferFormatter* f) const;
-
   Value* offset() const { return inputs_[0]; }
   void ComputeOffsetTable();
 
+  PRINT_TO_SUPPORT
+
  private:
   GrowableArray<TargetEntryInstr*> successors_;
   TypedData& offsets_;
 };
 
 
 class ComparisonInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
@@ skipping 106 matching lines @@
   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);
 
-  virtual void PrintTo(BufferFormatter* f) const;
-
   // 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_;
@@ skipping 15 matching lines @@
 
   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_;
@@ skipping 61 matching lines @@
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual bool AttributesEqual(Instruction* other) const {
     UNREACHABLE();
     return false;
   }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   Value* value() const { return inputs_[0]; }
   Range* constraint() const { return constraint_; }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   // Constraints for branches have their target block stored in order
   // to find the the comparsion that generated the constraint:
   // target->predecessor->last_instruction->comparison.
   void set_target(TargetEntryInstr* target) {
     target_ = target;
   }
   TargetEntryInstr* target() const {
     return target_;
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   Range* constraint_;
   TargetEntryInstr* target_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstraintInstr);
 };
 
 
 class ConstantInstr : public TemplateDefinition<0, NoThrow, Pure> {
  public:
   ConstantInstr(const Object& value,
                 TokenPosition token_pos = TokenPosition::kConstant);
 
   DECLARE_INSTRUCTION(Constant)
   virtual CompileType ComputeType() const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   const Object& value() const { return value_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const Object& value_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstantInstr);
 };
 
 
 // Merged ConstantInstr -> UnboxedXXX into UnboxedConstantInstr.
 // TODO(srdjan): Implemented currently for doubles only, should implement
@@ skipping 45 matching lines @@
   Value* value() const { return inputs_[0]; }
   Value* instantiator_type_arguments() const { return inputs_[1]; }
 
   virtual TokenPosition 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_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // AssertAssignable instructions that are specialized by the optimizer
     // (e.g. replaced with CheckClass) need a deoptimization descriptor before.
     return true;
   }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const;
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const TokenPosition token_pos_;
   AbstractType& dst_type_;
   const String& dst_name_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
 };
 
 
 class AssertBooleanInstr : public TemplateDefinition<1, Throws, Pure> {
  public:
   AssertBooleanInstr(TokenPosition token_pos, Value* value)
       : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(AssertBoolean)
   virtual CompileType ComputeType() const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
 
 // Denotes the current context, normally held in a register.  This is
 // a computation, not a value, because it's mutable.
 class CurrentContextInstr : public TemplateDefinition<0, NoThrow> {
@@ skipping 35 matching lines @@
   }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   // TODO(kmillikin): implement exact call counts for closure calls.
   virtual intptr_t CallCount() const { return 1; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const ClosureCallNode& ast_node_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallInstr);
 };
 
 
 class InstanceCallInstr : public TemplateDefinition<0, Throws> {
  public:
@@ skipping 41 matching lines @@
   virtual TokenPosition token_pos() const { return token_pos_; }
   const String& function_name() const { return function_name_; }
   Token::Kind token_kind() const { return token_kind_; }
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
   const Array& argument_names() const { return argument_names_; }
   intptr_t checked_argument_count() const { return checked_argument_count_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Instance calls that are specialized by the optimizer need a
     // deoptimization descriptor before the call.
     return true;
   }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  protected:
   friend class FlowGraphOptimizer;
   void set_ic_data(ICData* value) { ic_data_ = value; }
 
  private:
   const ICData* ic_data_;
   const TokenPosition token_pos_;
   const String& function_name_;
   const Token::Kind token_kind_;  // Binary op, unary op, kGET or kILLEGAL.
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
@@ skipping 37 matching lines @@
   virtual intptr_t CallCount() const { return ic_data().AggregateCount(); }
 
   DECLARE_INSTRUCTION(PolymorphicInstanceCall)
 
   const ICData& ic_data() const { return ic_data_; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
+  PRINT_OPERANDS_TO_SUPPORT
 
  private:
   InstanceCallInstr* instance_call_;
   const ICData& ic_data_;
   const bool with_checks_;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallInstr);
 };
 
 
 class StrictCompareInstr : public ComparisonInstr {
  public:
   StrictCompareInstr(TokenPosition token_pos,
                      Token::Kind kind,
                      Value* left,
                      Value* right,
                      bool needs_number_check);
 
   DECLARE_INSTRUCTION(StrictCompare)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   bool needs_number_check() const { return needs_number_check_; }
   void set_needs_number_check(bool value) { needs_number_check_ = value; }
 
   bool AttributesEqual(Instruction* other) const;
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   // True if the comparison must check for double, Mint or Bigint and
   // use value comparison instead.
   bool needs_number_check_;
 
   DISALLOW_COPY_AND_ASSIGN(StrictCompareInstr);
 };
 
 
 // Comparison instruction that is equivalent to the (left & right) == 0
@@ skipping 69 matching lines @@
   }
 
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
+  PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const ZoneGrowableArray<intptr_t>& cid_results_;
   DISALLOW_COPY_AND_ASSIGN(TestCidsInstr);
 };
 
 
 class EqualityCompareInstr : public ComparisonInstr {
  public:
   EqualityCompareInstr(TokenPosition token_pos,
                        Token::Kind kind,
                        Value* left,
                        Value* right,
                        intptr_t cid,
                        intptr_t deopt_id)
       : ComparisonInstr(token_pos, kind, left, right, deopt_id) {
     ASSERT(Token::IsEqualityOperator(kind));
     set_operation_cid(cid);
   }
 
   DECLARE_INSTRUCTION(EqualityCompare)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (operation_cid() == kDoubleCid) return kUnboxedDouble;
     if (operation_cid() == kMintCid) return kUnboxedMint;
     return kTagged;
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(EqualityCompareInstr);
 };
 
 
 class RelationalOpInstr : public ComparisonInstr {
  public:
   RelationalOpInstr(TokenPosition token_pos,
                     Token::Kind kind,
                     Value* left,
                     Value* right,
                     intptr_t cid,
                     intptr_t deopt_id)
       : ComparisonInstr(token_pos, kind, left, right, deopt_id) {
     ASSERT(Token::IsRelationalOperator(kind));
     set_operation_cid(cid);
   }
 
   DECLARE_INSTRUCTION(RelationalOp)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (operation_cid() == kDoubleCid) return kUnboxedDouble;
     if (operation_cid() == kMintCid) return kUnboxedMint;
     return kTagged;
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(RelationalOpInstr);
 };
 
 
 // TODO(vegorov): ComparisonInstr should be switched to use IfTheElseInstr for
 // materialization of true and false constants.
 class IfThenElseInstr : public Definition {
  public:
   IfThenElseInstr(ComparisonInstr* comparison,
@@ skipping 29 matching lines @@
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     return comparison()->DeoptimizationTarget();
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return comparison()->RequiredInputRepresentation(i);
   }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual CompileType ComputeType() const;
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   ComparisonInstr* comparison() const { return comparison_; }
   intptr_t if_true() const { return if_true_; }
   intptr_t if_false() const { return if_false_; }
 
   virtual bool AllowsCSE() const { return comparison()->AllowsCSE(); }
   virtual EffectSet Effects() const { return comparison()->Effects(); }
   virtual EffectSet Dependencies() const {
     return comparison()->Dependencies();
   }
   virtual bool AttributesEqual(Instruction* other) const {
     IfThenElseInstr* other_if_then_else = other->AsIfThenElse();
     return (comparison()->tag() == other_if_then_else->comparison()->tag()) &&
            comparison()->AttributesEqual(other_if_then_else->comparison()) &&
            (if_true_ == other_if_then_else->if_true_) &&
            (if_false_ == other_if_then_else->if_false_);
   }
 
   virtual bool MayThrow() const { return comparison()->MayThrow(); }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     comparison()->RawSetInputAt(i, value);
   }
 
   ComparisonInstr* comparison_;
   const intptr_t if_true_;
   const intptr_t if_false_;
 
   DISALLOW_COPY_AND_ASSIGN(IfThenElseInstr);
@@ skipping 38 matching lines @@
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual intptr_t CallCount() const {
     return ic_data() == NULL ? 0 : ic_data()->AggregateCount();
   }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Static calls that are specialized by the optimizer (e.g. sqrt) need a
     // deoptimization descriptor before the call.
     return true;
   }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
   void set_result_cid(intptr_t value) { result_cid_ = value; }
 
   bool is_known_list_constructor() const { return is_known_list_constructor_; }
   void set_is_known_list_constructor(bool value) {
     is_known_list_constructor_ = value;
   }
 
   bool is_native_list_factory() const { return is_native_list_factory_; }
   void set_is_native_list_factory(bool value) {
     is_native_list_factory_ = value;
   }
 
   bool IsRecognizedFactory() const {
     return is_known_list_constructor() || is_native_list_factory();
   }
 
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const ICData* ic_data_;
   const TokenPosition token_pos_;
   const Function& function_;
   const Array& argument_names_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   intptr_t result_cid_;  // For some library functions we know the result.
 
   // 'True' for recognized list constructors.
   bool is_known_list_constructor_;
   bool is_native_list_factory_;
 
   AliasIdentity identity_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallInstr);
 };
 
 
 class LoadLocalInstr : public TemplateDefinition<0, NoThrow> {
  public:
   LoadLocalInstr(const LocalVariable& local,
                  TokenPosition token_pos)
       : local_(local), is_last_(false), token_pos_(token_pos) { }
 
   DECLARE_INSTRUCTION(LoadLocal)
   virtual CompileType ComputeType() const;
 
   const LocalVariable& local() const { return local_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const {
     UNREACHABLE();  // Eliminated by SSA construction.
     return EffectSet::None();
   }
 
   void mark_last() { is_last_ = true; }
   bool is_last() const { return is_last_; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const LocalVariable& local_;
   bool is_last_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadLocalInstr);
 };
 
 
 class PushTempInstr : public TemplateDefinition<1, NoThrow> {
@@ skipping 40 matching lines @@
     ASSERT((value_ != NULL) && (i == 0));
     return value_;
   }
 
   Value* value() const { return value_; }
 
   intptr_t num_temps() const { return num_temps_; }
 
   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();
   }
 
   virtual bool MayThrow() const {
     UNREACHABLE();
     return false;
   }
 
   virtual TokenPosition token_pos() const {
     return TokenPosition::kTempMove;
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     value_ = value;
   }
 
   const intptr_t num_temps_;
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(DropTempsInstr);
 };
 
 
 class StoreLocalInstr : public TemplateDefinition<1, NoThrow> {
  public:
   StoreLocalInstr(const LocalVariable& local,
                   Value* value,
                   TokenPosition token_pos)
       : local_(local), is_dead_(false), is_last_(false), token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(StoreLocal)
   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_; }
 
   void mark_last() { is_last_ = true; }
   bool is_last() const { return is_last_; }
 
   virtual EffectSet Effects() const {
     UNREACHABLE();  // Eliminated by SSA construction.
     return EffectSet::None();
   }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const LocalVariable& local_;
   bool is_dead_;
   bool is_last_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalInstr);
 };
 
 
@@ skipping 21 matching lines @@
   }
 
   bool is_bootstrap_native() const {
     return is_bootstrap_native_;
   }
 
   bool link_lazily() const {
     return ast_node_.link_lazily();
   }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
   void SetupNative();
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   void set_native_c_function(NativeFunction value) {
     native_c_function_ = value;
   }
 
   void set_is_bootstrap_native(bool value) { is_bootstrap_native_ = value; }
 
   const NativeBodyNode& ast_node_;
   NativeFunction native_c_function_;
   bool is_bootstrap_native_;
@@ skipping 88 matching lines @@
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   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;
-
   virtual bool CanDeoptimize() const { return false; }
 
   // May require a deoptimization target for input conversions.
   virtual intptr_t DeoptimizationTarget() const {
     return GetDeoptId();
   }
 
   // Currently CSE/LICM don't operate on any instructions that can be affected
   // by stores/loads. LoadOptimizer handles loads separately. Hence stores
   // are marked as having no side-effects.
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   bool IsUnboxedStore() const;
 
   bool IsPotentialUnboxedStore() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t index) const;
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   friend class FlowGraphOptimizer;  // For ASSERT(initialization_).
 
   bool CanValueBeSmi() const {
     const intptr_t cid = value()->Type()->ToNullableCid();
     // Write barrier is skipped for nullable and non-nullable smis.
     ASSERT(cid != kSmiCid);
     return (cid == kDynamicCid);
   }
 
@@ skipping 24 matching lines @@
   Value* value() const { return inputs_[0]; }
 
   const Field& field() const { return field_; }
 
   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;
+  PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(GuardFieldInstr);
 };
 
 
 class GuardFieldClassInstr : public GuardFieldInstr {
  public:
@@ skipping 39 matching lines @@
     SetInputAt(0, field_value);
   }
 
   DECLARE_INSTRUCTION(LoadStaticField)
   virtual CompileType ComputeType() const;
 
   const Field& StaticField() const;
 
   Value* field_value() const { return inputs_[0]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool AllowsCSE() const { return StaticField().is_final(); }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
 };
 
 
 class StoreStaticFieldInstr : public TemplateDefinition<1, NoThrow> {
  public:
   StoreStaticFieldInstr(const Field& field,
                         Value* value,
                         TokenPosition token_pos)
       : field_(field),
         token_pos_(token_pos) {
     ASSERT(field.IsZoneHandle());
     SetInputAt(kValuePos, value);
   }
 
   enum {
     kValuePos = 0
   };
 
   DECLARE_INSTRUCTION(StoreStaticField)
 
   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
   // are marked as having no side-effects.
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   bool CanValueBeSmi() const {
     const intptr_t cid = value()->Type()->ToNullableCid();
     // Write barrier is skipped for nullable and non-nullable smis.
     ASSERT(cid != kSmiCid);
     return (cid == kDynamicCid);
   }
 
   const Field& field_;
   const TokenPosition token_pos_;
@@ skipping 320 matching lines @@
   DECLARE_INSTRUCTION(InstanceOf)
   virtual CompileType ComputeType() const;
 
   Value* value() const { return inputs_[0]; }
   Value* instantiator_type_arguments() const { return inputs_[1]; }
 
   bool negate_result() const { return negate_result_; }
   const AbstractType& type() const { return type_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const TokenPosition token_pos_;
   Value* value_;
   Value* type_arguments_;
   const AbstractType& type_;
   const bool negate_result_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceOfInstr);
 };
 
@@ skipping 21 matching lines @@
   }
 
   const Class& cls() const { return cls_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   const Function& closure_function() const { return closure_function_; }
   void set_closure_function(const Function& function) {
     closure_function_ ^= function.raw();
   }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const TokenPosition token_pos_;
   const Class& cls_;
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   AliasIdentity identity_;
   Function& closure_function_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectInstr);
 };
 
 
 class AllocateUninitializedContextInstr
     : public TemplateDefinition<0, NoThrow> {
  public:
   AllocateUninitializedContextInstr(TokenPosition token_pos,
                                     intptr_t num_context_variables)
       : token_pos_(token_pos),
         num_context_variables_(num_context_variables),
         identity_(AliasIdentity::Unknown()) {}
 
   DECLARE_INSTRUCTION(AllocateUninitializedContext)
   virtual CompileType ComputeType() const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const TokenPosition token_pos_;
   const intptr_t num_context_variables_;
   AliasIdentity identity_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateUninitializedContextInstr);
 };
 
 
 // This instruction captures the state of the object which had its allocation
@@ skipping 48 matching lines @@
     return slots_[i]->IsField()
         ? Field::Cast(*slots_[i]).Offset()
         : Smi::Cast(*slots_[i]).Value();
   }
 
   const Location& LocationAt(intptr_t i) {
     return locations_[i];
   }
 
   DECLARE_INSTRUCTION(MaterializeObject)
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual intptr_t InputCount() const {
     return values_->length();
   }
 
   virtual Value* InputAt(intptr_t i) const {
     return (*values_)[i];
   }
 
   // SelectRepresentations pass is run once more while MaterializeObject
@@ skipping 15 matching lines @@
   virtual bool MayThrow() const { return false; }
 
   void RemapRegisters(intptr_t* cpu_reg_slots,
                       intptr_t* fpu_reg_slots);
 
   bool was_visited_for_liveness() const { return visited_for_liveness_; }
   void mark_visited_for_liveness() {
     visited_for_liveness_ = true;
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*values_)[i] = value;
   }
 
   Definition* allocation_;
   const Class& cls_;
   intptr_t num_variables_;
   const ZoneGrowableArray<const Object*>& slots_;
   ZoneGrowableArray<Value*>* values_;
@@ skipping 170 matching lines @@
     recognized_kind_ = kind;
   }
 
   MethodRecognizer::Kind recognized_kind() const {
     return recognized_kind_;
   }
 
   DECLARE_INSTRUCTION(LoadField)
   virtual CompileType ComputeType() const;
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   bool IsImmutableLengthLoad() const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   static MethodRecognizer::Kind RecognizedKindFromArrayCid(intptr_t cid);
 
   static bool IsFixedLengthArrayCid(intptr_t cid);
 
   virtual bool AllowsCSE() const { return immutable_; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
   intptr_t result_cid_;
   bool immutable_;
 
   MethodRecognizer::Kind recognized_kind_;
   const Field* field_;
   const TokenPosition token_pos_;
 
@@ skipping 16 matching lines @@
   }
 
   DECLARE_INSTRUCTION(InstantiateType)
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractType& type() const { return type_;
   }
   const Class& instantiator_class() const { return instantiator_class_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const TokenPosition token_pos_;
   const AbstractType& type_;
   const Class& instantiator_class_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeInstr);
 };
 
 
 class InstantiateTypeArgumentsInstr : public TemplateDefinition<1, Throws> {
@@ skipping 12 matching lines @@
 
   DECLARE_INSTRUCTION(InstantiateTypeArguments)
 
   Value* instantiator() const { return inputs_[0]; }
   const TypeArguments& type_arguments() const {
     return type_arguments_;
   }
   const Class& instantiator_class() const { return instantiator_class_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const TokenPosition token_pos_;
   const TypeArguments& type_arguments_;
   const Class& instantiator_class_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsInstr);
 };
 
 
 class AllocateContextInstr : public TemplateDefinition<0, NoThrow> {
  public:
   AllocateContextInstr(TokenPosition token_pos,
                        intptr_t num_context_variables)
       : token_pos_(token_pos),
         num_context_variables_(num_context_variables) { }
 
   DECLARE_INSTRUCTION(AllocateContext)
   virtual CompileType ComputeType() const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const TokenPosition token_pos_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
 
 class InitStaticFieldInstr : public TemplateInstruction<1, Throws> {
  public:
@@ skipping 335 matching lines @@
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     UnboxIntegerInstr* other_unbox = other->AsUnboxInteger();
     return UnboxInstr::AttributesEqual(other) &&
         (other_unbox->is_truncating_ == is_truncating_);
   }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
+  DEFINE_INSTRUCTION_TYPE_CHECK(UnboxInteger)
 
-  DEFINE_INSTRUCTION_TYPE_CHECK(UnboxInteger)
+  PRINT_OPERANDS_TO_SUPPORT
 
  private:
   bool is_truncating_;
 
   DISALLOW_COPY_AND_ASSIGN(UnboxIntegerInstr);
 };
 
 
 class UnboxInteger32Instr : public UnboxIntegerInstr {
  public:
@@ skipping 85 matching lines @@
   };
   MathUnaryInstr(MathUnaryKind kind, Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id), kind_(kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   MathUnaryKind kind() const { return kind_; }
   const RuntimeEntry& TargetFunction() const;
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(MathUnary)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return kind() == other->AsMathUnary()->kind();
   }
 
   Definition* Canonicalize(FlowGraph* flow_graph);
 
   static const char* KindToCString(MathUnaryKind kind);
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const MathUnaryKind kind_;
 
   DISALLOW_COPY_AND_ASSIGN(MathUnaryInstr);
 };
 
 
 // Calls into the runtime and performs a case-insensitive comparison of the
 // UTF16 strings (i.e. TwoByteString or ExternalTwoByteString) located at
 // str[lhs_index:lhs_index + length] and str[rhs_index:rhs_index + length].
@@ skipping 121 matching lines @@
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
   DECLARE_INSTRUCTION(BinaryDoubleOp)
   virtual CompileType ComputeType() const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsBinaryDoubleOp()->op_kind();
   }
 
  private:
@@ skipping 13 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(BinaryFloat32x4Op)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsBinaryFloat32x4Op()->op_kind();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryFloat32x4OpInstr);
 };
 
 
 class Simd32x4ShuffleInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Simd32x4ShuffleInstr(MethodRecognizer::Kind op_kind, Value* value,
                        intptr_t mask,
                        intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind), mask_(mask) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   intptr_t mask() const { return mask_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     if ((op_kind_ == MethodRecognizer::kFloat32x4ShuffleX) ||
         (op_kind_ == MethodRecognizer::kFloat32x4ShuffleY) ||
         (op_kind_ == MethodRecognizer::kFloat32x4ShuffleZ) ||
         (op_kind_ == MethodRecognizer::kFloat32x4ShuffleW)) {
       return kUnboxedDouble;
     }
     if ((op_kind_ == MethodRecognizer::kInt32x4Shuffle)) {
@@ skipping 15 matching lines @@
     ASSERT((op_kind_ == MethodRecognizer::kInt32x4Shuffle));
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
   DECLARE_INSTRUCTION(Simd32x4Shuffle)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return (op_kind() == other->AsSimd32x4Shuffle()->op_kind()) &&
            (mask() == other->AsSimd32x4Shuffle()->mask());
   }
 
  private:
   const MethodRecognizer::Kind op_kind_;
@@ skipping 12 matching lines @@
     SetInputAt(1, zw);
   }
 
   Value* xy() const { return inputs_[0]; }
   Value* zw() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   intptr_t mask() const { return mask_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     if (op_kind() == MethodRecognizer::kInt32x4ShuffleMix) {
       return kUnboxedInt32x4;
     }
     ASSERT(op_kind() == MethodRecognizer::kFloat32x4ShuffleMix);
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (op_kind() == MethodRecognizer::kInt32x4ShuffleMix) {
       return kUnboxedInt32x4;
     }
     ASSERT(op_kind() == MethodRecognizer::kFloat32x4ShuffleMix);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
   DECLARE_INSTRUCTION(Simd32x4ShuffleMix)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return (op_kind() == other->AsSimd32x4ShuffleMix()->op_kind()) &&
            (mask() == other->AsSimd32x4ShuffleMix()->mask());
   }
 
  private:
   const MethodRecognizer::Kind op_kind_;
@@ skipping 15 matching lines @@
     SetInputAt(1, value1);
     SetInputAt(2, value2);
     SetInputAt(3, value3);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx >= 0 && idx < 4);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4Constructor)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ConstructorInstr);
 };
 
 
 class Float32x4SplatInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float32x4SplatInstr(Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4Splat)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4SplatInstr);
 };
 
 
 // TODO(vegorov) replace with UnboxedConstantInstr.
 class Float32x4ZeroInstr : public TemplateDefinition<0, NoThrow, Pure> {
  public:
   Float32x4ZeroInstr() { }
 
@@ skipping 22 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedInt32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4Comparison)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat32x4Comparison()->op_kind();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4ComparisonInstr);
 };
 
 
 class Float32x4MinMaxInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   Float32x4MinMaxInstr(MethodRecognizer::Kind op_kind,
                        Value* left,
                        Value* right,
                        intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4MinMax)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat32x4MinMax()->op_kind();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4MinMaxInstr);
 };
 
 
 class Float32x4ScaleInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   Float32x4ScaleInstr(MethodRecognizer::Kind op_kind,
                       Value* left,
                       Value* right,
                       intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (idx == 0) {
       return kUnboxedDouble;
     }
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4Scale)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat32x4Scale()->op_kind();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4ScaleInstr);
 };
 
 
 class Float32x4SqrtInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float32x4SqrtInstr(MethodRecognizer::Kind op_kind,
                      Value* left,
                      intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4Sqrt)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat32x4Sqrt()->op_kind();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4SqrtInstr);
 };
 
 
 // TODO(vegorov) rename to Unary to match naming convention for arithmetic.
 class Float32x4ZeroArgInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float32x4ZeroArgInstr(MethodRecognizer::Kind op_kind,
                         Value* left,
                         intptr_t deopt_id)
       : TemplateDefinition(deopt_id),
         op_kind_(op_kind) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4ZeroArg)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat32x4ZeroArg()->op_kind();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4ZeroArgInstr);
 };
 
 
 class Float32x4ClampInstr : public TemplateDefinition<3, NoThrow, Pure> {
  public:
   Float32x4ClampInstr(Value* left,
                       Value* lower,
                       Value* upper,
                       intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
     SetInputAt(1, lower);
     SetInputAt(2, upper);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* lower() const { return inputs_[1]; }
   Value* upper() const { return inputs_[2]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1) || (idx == 2));
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4Clamp)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ClampInstr);
 };
 
 
 class Float32x4WithInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   Float32x4WithInstr(MethodRecognizer::Kind op_kind,
                      Value* left,
                      Value* replacement,
                      intptr_t deopt_id)
       : TemplateDefinition(deopt_id),
         op_kind_(op_kind) {
     SetInputAt(0, replacement);
     SetInputAt(1, left);
   }
 
   Value* left() const { return inputs_[1]; }
   Value* replacement() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (idx == 0) {
       return kUnboxedDouble;
     }
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4With)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat32x4With()->op_kind();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4WithInstr);
 };
 
 
 class Simd64x2ShuffleInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Simd64x2ShuffleInstr(MethodRecognizer::Kind op_kind,
                        Value* value,
                        intptr_t mask,
                        intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind), mask_(mask) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   intptr_t mask() const { return mask_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     if ((op_kind_ == MethodRecognizer::kFloat64x2GetX) ||
         (op_kind_ == MethodRecognizer::kFloat64x2GetY)) {
       return kUnboxedDouble;
     }
     UNIMPLEMENTED();
     return kUnboxedDouble;
   }
@@ skipping 15 matching lines @@
   }
 
   DECLARE_INSTRUCTION(Simd64x2Shuffle)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return (op_kind() == other->AsSimd64x2Shuffle()->op_kind()) &&
            (mask() == other->AsSimd64x2Shuffle()->mask());
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const MethodRecognizer::Kind op_kind_;
   const intptr_t mask_;
 
   DISALLOW_COPY_AND_ASSIGN(Simd64x2ShuffleInstr);
 };
 
 
 class Float32x4ToInt32x4Instr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float32x4ToInt32x4Instr(Value* left, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedInt32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4ToInt32x4)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ToInt32x4Instr);
 };
 
 
 class Float32x4ToFloat64x2Instr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float32x4ToFloat64x2Instr(Value* left, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat64x2;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4ToFloat64x2)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ToFloat64x2Instr);
 };
 
 
 class Float64x2ToFloat32x4Instr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float64x2ToFloat32x4Instr(Value* left, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat64x2;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float64x2ToFloat32x4)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float64x2ToFloat32x4Instr);
 };
 
 
 class Float64x2ConstructorInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   Float64x2ConstructorInstr(Value* value0, Value* value1, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat64x2;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx >= 0 && idx < 2);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
   DECLARE_INSTRUCTION(Float64x2Constructor)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Float64x2ConstructorInstr);
 };
 
 
 class Float64x2SplatInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float64x2SplatInstr(Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat64x2;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float64x2Splat)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float64x2SplatInstr);
 };
 
 
 class Float64x2ZeroInstr : public TemplateDefinition<0, NoThrow, Pure> {
  public:
   Float64x2ZeroInstr() { }
 
   virtual bool CanDeoptimize() const { return false; }
@@ skipping 19 matching lines @@
                         Value* left,
                         intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     if (op_kind() == MethodRecognizer::kFloat64x2GetSignMask) {
       // Smi.
       return kTagged;
     }
     return kUnboxedFloat64x2;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat64x2;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
   DECLARE_INSTRUCTION(Float64x2ZeroArg)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat64x2ZeroArg()->op_kind();
   }
 
  private:
   const MethodRecognizer::Kind op_kind_;
 
@@ skipping 10 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat64x2;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     if (idx == 0) {
       return kUnboxedFloat64x2;
     }
     ASSERT(idx == 1);
     if ((op_kind() == MethodRecognizer::kFloat64x2WithX) ||
         (op_kind() == MethodRecognizer::kFloat64x2WithY) ||
         (op_kind() == MethodRecognizer::kFloat64x2Scale)) {
       return kUnboxedDouble;
     }
     return kUnboxedFloat64x2;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
   DECLARE_INSTRUCTION(Float64x2OneArg)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat64x2OneArg()->op_kind();
   }
 
  private:
   const MethodRecognizer::Kind op_kind_;
 
@@ skipping 13 matching lines @@
     SetInputAt(1, value1);
     SetInputAt(2, value2);
     SetInputAt(3, value3);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedInt32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx >= 0) && (idx < 4));
     return kUnboxedInt32;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Int32x4Constructor)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32x4ConstructorInstr);
 };
 
 
 class Int32x4BoolConstructorInstr
     : public TemplateDefinition<4, NoThrow, Pure> {
  public:
   Int32x4BoolConstructorInstr(Value* value0,
                               Value* value1,
                               Value* value2,
                               Value* value3,
                               intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
     SetInputAt(2, value2);
     SetInputAt(3, value3);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedInt32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx >= 0) && (idx < 4));
     return kTagged;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Int32x4BoolConstructor)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32x4BoolConstructorInstr);
 };
 
 
 class Int32x4GetFlagInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Int32x4GetFlagInstr(MethodRecognizer::Kind op_kind,
                       Value* value,
                       intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
       return kTagged;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Int32x4GetFlag)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsInt32x4GetFlag()->op_kind();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Int32x4GetFlagInstr);
 };
 
 
 class Simd32x4GetSignMaskInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Simd32x4GetSignMaskInstr(MethodRecognizer::Kind op_kind,
                            Value* value,
                            intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kTagged;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     if (op_kind_ == MethodRecognizer::kFloat32x4GetSignMask) {
       return kUnboxedFloat32x4;
     }
     ASSERT(op_kind_ == MethodRecognizer::kInt32x4GetSignMask);
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Simd32x4GetSignMask)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsSimd32x4GetSignMask()->op_kind() == op_kind();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Simd32x4GetSignMaskInstr);
 };
 
 
 class Int32x4SelectInstr : public TemplateDefinition<3, NoThrow, Pure> {
  public:
   Int32x4SelectInstr(Value* mask,
                      Value* trueValue,
                      Value* falseValue,
                      intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, mask);
     SetInputAt(1, trueValue);
     SetInputAt(2, falseValue);
   }
 
   Value* mask() const { return inputs_[0]; }
   Value* trueValue() const { return inputs_[1]; }
   Value* falseValue() const { return inputs_[2]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
       return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1) || (idx == 2));
     if (idx == 0) {
       return kUnboxedInt32x4;
     }
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Int32x4Select)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32x4SelectInstr);
 };
 
 
 class Int32x4SetFlagInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   Int32x4SetFlagInstr(MethodRecognizer::Kind op_kind,
                       Value* value,
                       Value* flagValue,
                       intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
     SetInputAt(1, flagValue);
   }
 
   Value* value() const { return inputs_[0]; }
   Value* flagValue() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
       return kUnboxedInt32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (idx == 1) {
       return kTagged;
     }
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Int32x4SetFlag)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsInt32x4SetFlag()->op_kind();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Int32x4SetFlagInstr);
 };
 
 
 class Int32x4ToFloat32x4Instr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Int32x4ToFloat32x4Instr(Value* left, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Int32x4ToFloat32x4)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32x4ToFloat32x4Instr);
 };
 
 
 class BinaryInt32x4OpInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   BinaryInt32x4OpInstr(Token::Kind op_kind,
                         Value* left,
                         Value* right,
                         intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedInt32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(BinaryInt32x4Op)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsBinaryInt32x4Op()->op_kind();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryInt32x4OpInstr);
 };
 
 
 class BinaryFloat64x2OpInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   BinaryFloat64x2OpInstr(Token::Kind op_kind,
@@ skipping 14 matching lines @@
 
   virtual Representation representation() const {
     return kUnboxedFloat64x2;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat64x2;
   }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(BinaryFloat64x2Op)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsBinaryFloat64x2Op()->op_kind();
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryFloat64x2OpInstr);
 };
 
 
 class UnaryIntegerOpInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   UnaryIntegerOpInstr(Token::Kind op_kind,
@@ skipping 17 matching lines @@
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsUnaryIntegerOp()->op_kind() == op_kind();
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
+  PRINT_OPERANDS_TO_SUPPORT
 
   RawInteger* Evaluate(const Integer& value) const;
 
   DEFINE_INSTRUCTION_TYPE_CHECK(UnaryIntegerOp)
 
  private:
   const Token::Kind op_kind_;
 };
 
 
@@ skipping 138 matching lines @@
 
       default:
         return false;
     }
   }
 
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
+
+  PRINT_OPERANDS_TO_SUPPORT
 
   DEFINE_INSTRUCTION_TYPE_CHECK(BinaryIntegerOp)
 
  protected:
   void InferRangeHelper(const Range* left_range,
                         const Range* right_range,
                         Range* range);
 
  private:
   Definition* CreateConstantResult(FlowGraph* graph, const Integer& result);
@@ skipping 222 matching lines @@
                      Value* value,
                      intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     ASSERT(op_kind == Token::kNEGATE);
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   Token::Kind op_kind() const { return op_kind_; }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   DECLARE_INSTRUCTION(UnaryDoubleOp)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(UnaryDoubleOpInstr);
 };
 
 
 class CheckStackOverflowInstr : public TemplateInstruction<0, NoThrow> {
  public:
   CheckStackOverflowInstr(TokenPosition token_pos, intptr_t loop_depth)
       : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         loop_depth_(loop_depth) {
   }
 
   virtual TokenPosition 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 bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
+  PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   const intptr_t loop_depth_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowInstr);
 };
 
 
 // TODO(vegorov): remove this instruction in favor of Int32ToDouble.
@@ skipping 271 matching lines @@
   static intptr_t ArgumentCountFor(MethodRecognizer::Kind recognized_kind_);
 
   const RuntimeEntry& TargetFunction() const;
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(InvokeMathCFunction)
   virtual CompileType ComputeType() const;
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((0 <= idx) && (idx < InputCount()));
     return kUnboxedDouble;
@@ skipping 13 matching lines @@
     InvokeMathCFunctionInstr* other_invoke = other->AsInvokeMathCFunction();
     return other_invoke->recognized_kind() == recognized_kind();
   }
 
   virtual bool MayThrow() const { return false; }
 
   static const intptr_t kSavedSpTempIndex = 0;
   static const intptr_t kObjectTempIndex = 1;
   static const intptr_t kDoubleTempIndex = 2;
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*inputs_)[i] = value;
   }
 
   ZoneGrowableArray<Value*>* inputs_;
   const MethodRecognizer::Kind recognized_kind_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(InvokeMathCFunctionInstr);
@@ skipping 11 matching lines @@
         definition_rep_(definition_rep),
         definition_cid_(definition_cid) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(ExtractNthOutput)
 
   virtual CompileType ComputeType() const;
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
   virtual bool CanDeoptimize() const { return false; }
 
   intptr_t index() const { return index_; }
 
   virtual Representation representation() const {
     return definition_rep_;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     if (representation() == kTagged) {
       return kPairOfTagged;
     } else if (representation() == kUnboxedDouble) {
       return kPairOfUnboxedDouble;
     }
     UNREACHABLE();
     return definition_rep_;
   }
 
   virtual bool AttributesEqual(Instruction* other) const {
     ExtractNthOutputInstr* other_extract = other->AsExtractNthOutput();
     return (other_extract->representation() == representation()) &&
            (other_extract->index() == index());
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const intptr_t index_;
   const Representation definition_rep_;
   const intptr_t definition_cid_;
   DISALLOW_COPY_AND_ASSIGN(ExtractNthOutputInstr);
 };
 
 
 class MergedMathInstr : public PureDefinition {
  public:
@@ skipping 22 matching lines @@
   virtual intptr_t InputCount() const { return inputs_->length(); }
 
   virtual Value* InputAt(intptr_t i) const {
     return (*inputs_)[i];
   }
 
   static intptr_t OutputIndexOf(intptr_t kind);
   static intptr_t OutputIndexOf(Token::Kind token);
 
   virtual CompileType ComputeType() const;
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const {
     if (kind_ == kTruncDivMod) {
       return true;
     } else if (kind_ == kSinCos) {
       return false;
     } else {
       UNIMPLEMENTED();
       return false;
     }
@@ skipping 33 matching lines @@
 
   virtual bool MayThrow() const { return false; }
 
   static const char* KindToCString(MergedMathInstr::Kind kind) {
     if (kind == kTruncDivMod) return "TruncDivMod";
     if (kind == kSinCos) return "SinCos";
     UNIMPLEMENTED();
     return "";
   }
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*inputs_)[i] = value;
   }
   ZoneGrowableArray<Value*>* inputs_;
   MergedMathInstr::Kind kind_;
   DISALLOW_COPY_AND_ASSIGN(MergedMathInstr);
 };
 
 
@@ skipping 11 matching lines @@
   virtual TokenPosition 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_; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   bool IsNullCheck() const {
     return  DeoptIfNull() || DeoptIfNotNull();
   }
 
   bool DeoptIfNull() const;
   bool DeoptIfNotNull() const;
 
   bool IsDenseSwitch() const;
   intptr_t ComputeCidMask() const;
   static bool IsDenseMask(intptr_t mask);
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const;
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const;
 
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
   static bool IsImmutableClassId(intptr_t cid);
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const ICData& unary_checks_;
   GrowableArray<intptr_t> cids_;  // Sorted, lowest first.
   bool licm_hoisted_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassInstr);
 };
 
 
@@ skipping 41 matching lines @@
 
   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;
+  PRINT_OPERANDS_TO_SUPPORT
 
  private:
   intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassIdInstr);
 };
 
 
 class CheckArrayBoundInstr : public TemplateInstruction<2, NoThrow, Pure> {
  public:
@@ skipping 89 matching lines @@
   virtual bool AttributesEqual(Instruction* other) const {
     ASSERT(other->IsUnboxedIntConverter());
     UnboxedIntConverterInstr* converter = other->AsUnboxedIntConverter();
     return (converter->from() == from()) &&
         (converter->to() == to()) &&
         (converter->is_truncating() == is_truncating());
   }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
   virtual CompileType ComputeType() const {
     // TODO(vegorov) use range information to improve type.
     return CompileType::Int();
   }
 
   DECLARE_INSTRUCTION(UnboxedIntConverter);
 
+  PRINT_OPERANDS_TO_SUPPORT
+
  private:
   const Representation from_representation_;
   const Representation to_representation_;
   bool is_truncating_;
 
   DISALLOW_COPY_AND_ASSIGN(UnboxedIntConverterInstr);
 };
 
 
 class GrowRegExpStackInstr : public TemplateDefinition<1, Throws> {
@@ skipping 269 matching lines @@
   LocationSummary* Name::MakeLocationSummary(Zone* zone, bool opt) const {    \
     UNIMPLEMENTED();                                                          \
     return NULL;                                                              \
   }                                                                           \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_