VM: Re-format to use at most one newline between functions

runtime/vm/intermediate_language.h

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 #define RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/flags.h"
@@ skipping 160 matching lines @@
  private:
   bool CanComputeIsInstanceOf(const AbstractType& type,
                               bool is_nullable,
                               bool* is_instance);
 
   bool is_nullable_;
   intptr_t cid_;
   const AbstractType* type_;
 };
 
-
 class EffectSet : public ValueObject {
  public:
   enum Effects {
     kNoEffects = 0,
     kExternalization = 1,
     kLastEffect = kExternalization
   };
 
   EffectSet(const EffectSet& other) : ValueObject(), effects_(other.effects_) {}
 
   bool IsNone() const { return effects_ == kNoEffects; }
 
   static EffectSet None() { return EffectSet(kNoEffects); }
   static EffectSet All() {
     ASSERT(EffectSet::kLastEffect == 1);
     return EffectSet(kExternalization);
   }
 
   static EffectSet Externalization() { return EffectSet(kExternalization); }
 
   bool ToInt() { return effects_; }
 
  private:
   explicit EffectSet(intptr_t effects) : effects_(effects) {}
 
   intptr_t effects_;
 };
 
-
 class Value : public ZoneAllocated {
  public:
   // A forward iterator that allows removing the current value from the
   // underlying use list during iteration.
   class Iterator {
    public:
     explicit Iterator(Value* head) : next_(head) { Advance(); }
     Value* Current() const { return current_; }
     bool Done() const { return current_ == NULL; }
     void Advance() {
@@ skipping 83 matching lines @@
   Value* previous_use_;
   Value* next_use_;
   Instruction* instruction_;
   intptr_t use_index_;
 
   CompileType* reaching_type_;
 
   DISALLOW_COPY_AND_ASSIGN(Value);
 };
 
-
 // An embedded container with N elements of type T.  Used (with partial
 // specialization for N=0) because embedded arrays cannot have size 0.
 template <typename T, intptr_t N>
 class EmbeddedArray {
  public:
   EmbeddedArray() : elements_() {}
 
   intptr_t length() const { return N; }
 
   const T& operator[](intptr_t i) const {
     ASSERT(i < length());
     return elements_[i];
   }
 
   T& operator[](intptr_t i) {
     ASSERT(i < length());
     return elements_[i];
   }
 
   const T& At(intptr_t i) const { return (*this)[i]; }
 
   void SetAt(intptr_t i, const T& val) { (*this)[i] = val; }
 
  private:
   T elements_[N];
 };
 
-
 template <typename T>
 class EmbeddedArray<T, 0> {
  public:
   intptr_t length() const { return 0; }
   const T& operator[](intptr_t i) const {
     UNREACHABLE();
     static T sentinel = 0;
     return sentinel;
   }
   T& operator[](intptr_t i) {
     UNREACHABLE();
     static T sentinel = 0;
     return sentinel;
   }
 };
 
-
 // Instructions.
 
 // M is a single argument macro.  It is applied to each concrete instruction
 // type name.  The concrete instruction classes are the name with Instr
 // concatenated.
 #define FOR_EACH_INSTRUCTION(M)                                                \
   M(GraphEntry)                                                                \
   M(JoinEntry)                                                                 \
   M(TargetEntry)                                                               \
   M(IndirectEntry)                                                             \
@@ skipping 192 matching lines @@
 #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
 
-
 // Represents a range of class-ids for use in class checks and polymorphic
 // dispatches.
 struct CidRange : public ZoneAllocated {
   CidRange(const CidRange& o)
       : ZoneAllocated(), cid_start(o.cid_start), cid_end(o.cid_end) {}
   CidRange(intptr_t cid_start_arg, intptr_t cid_end_arg)
       : cid_start(cid_start_arg), cid_end(cid_end_arg) {}
 
   bool IsSingleCid() const { return cid_start == cid_end; }
   bool Contains(intptr_t cid) { return cid_start <= cid && cid <= cid_end; }
   int32_t Extent() const { return cid_end - cid_start; }
 
   intptr_t cid_start;
   intptr_t cid_end;
 };
 
-
 // Together with CidRange, this represents a mapping from a range of class-ids
 // to a method for a given selector (method name).  Also can contain an
 // indication of how frequently a given method has been called at a call site.
 // This information can be harvested from the inline caches (ICs).
 struct TargetInfo : public CidRange {
   TargetInfo(intptr_t cid_start_arg,
              intptr_t cid_end_arg,
              const Function* target_arg,
              intptr_t count_arg)
       : CidRange(cid_start_arg, cid_end_arg),
         target(target_arg),
         count(count_arg) {
     ASSERT(target->IsZoneHandle());
   }
   const Function* target;
   intptr_t count;
 };
 
-
 // A set of class-ids, arranged in ranges. Used for the CheckClass
 // and PolymorphicInstanceCall instructions.
 class Cids : public ZoneAllocated {
  public:
   explicit Cids(Zone* zone) : zone_(zone) {}
   // Creates the off-heap Cids object that reflects the contents
   // of the on-VM-heap IC data.
   static Cids* Create(Zone* zone, const ICData& ic_data, int argument_number);
   static Cids* CreateMonomorphic(Zone* zone, intptr_t cid);
 
@@ skipping 28 matching lines @@
                     const ICData& ic_data,
                     int argument_number,
                     bool include_targets);
   GrowableArray<CidRange*> cid_ranges_;
   Zone* zone_;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Cids);
 };
 
-
 class CallTargets : public Cids {
  public:
   explicit CallTargets(Zone* zone) : Cids(zone) {}
   // Creates the off-heap CallTargets object that reflects the contents
   // of the on-VM-heap IC data.
   static CallTargets* Create(Zone* zone, const ICData& ic_data);
 
   // This variant also expands the class-ids to neighbouring classes that
   // inherit the same method.
   static CallTargets* CreateAndExpand(Zone* zone, const ICData& ic_data);
 
   TargetInfo* TargetAt(int i) const { return static_cast<TargetInfo*>(At(i)); }
 
   intptr_t AggregateCallCount() const;
 
   bool HasSingleTarget() const;
   bool HasSingleRecognizedTarget() const;
   const Function& FirstTarget() const;
   const Function& MostPopularTarget() const;
 
  private:
   void MergeIntoRanges();
 };
 
-
 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),
         lifetime_position_(kNoPlaceId),
         previous_(NULL),
@@ skipping 285 matching lines @@
   };
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   LocationSummary* locs_;
   intptr_t inlining_id_;
 
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
-
 struct BranchLabels {
   Label* true_label;
   Label* false_label;
   Label* fall_through;
 };
 
-
 class PureInstruction : public Instruction {
  public:
   explicit PureInstruction(intptr_t deopt_id) : Instruction(deopt_id) {}
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 };
 
-
 // Types to be used as ThrowsTrait for TemplateInstruction/TemplateDefinition.
 struct Throws {
   static const bool kCanThrow = true;
 };
 
-
 struct NoThrow {
   static const bool kCanThrow = false;
 };
 
-
 // Types to be used as CSETrait for TemplateInstruction/TemplateDefinition.
 // Pure instructions are those that allow CSE and have no effects and
 // no dependencies.
 template <typename DefaultBase, typename PureBase>
 struct Pure {
   typedef PureBase Base;
 };
 
-
 template <typename DefaultBase, typename PureBase>
 struct NoCSE {
   typedef DefaultBase Base;
 };
 
-
 template <intptr_t N,
           typename ThrowsTrait,
           template <typename Default, typename Pure> class CSETrait = NoCSE>
 class TemplateInstruction
     : public CSETrait<Instruction, PureInstruction>::Base {
  public:
   explicit TemplateInstruction(intptr_t deopt_id = Thread::kNoDeoptId)
       : CSETrait<Instruction, PureInstruction>::Base(deopt_id), inputs_() {}
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   virtual bool MayThrow() const { return ThrowsTrait::kCanThrow; }
 
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 };
 
-
 class MoveOperands : public ZoneAllocated {
  public:
   MoveOperands(Location dest, Location src) : dest_(dest), src_(src) {}
 
   Location src() const { return src_; }
   Location dest() const { return dest_; }
 
   Location* src_slot() { return &src_; }
   Location* dest_slot() { return &dest_; }
 
@@ skipping 37 matching lines @@
     return src_.IsInvalid();
   }
 
  private:
   Location dest_;
   Location src_;
 
   DISALLOW_COPY_AND_ASSIGN(MoveOperands);
 };
 
-
 class ParallelMoveInstr : public TemplateInstruction<0, NoThrow> {
  public:
   ParallelMoveInstr() : moves_(4) {}
 
   DECLARE_INSTRUCTION(ParallelMove)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
@@ skipping 24 matching lines @@
   }
 
   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
 // enforce edge-split form---joins are forbidden as the successors of
 // branches.
 class BlockEntryInstr : public Instruction {
  public:
   virtual intptr_t PredecessorCount() const = 0;
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const = 0;
 
@@ skipping 163 matching lines @@
   // connect live ranges at the start of the block.
   ParallelMoveInstr* parallel_move_;
 
   // Bit vector containing loop blocks for a loop header indexed by block
   // preorder number.
   BitVector* loop_info_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockEntryInstr);
 };
 
-
 class ForwardInstructionIterator : public ValueObject {
  public:
   explicit ForwardInstructionIterator(BlockEntryInstr* block_entry)
       : current_(block_entry) {
     Advance();
   }
 
   void Advance() {
     ASSERT(!Done());
     current_ = current_->next();
   }
 
   bool Done() const { return current_ == NULL; }
 
   // Removes 'current_' from graph and sets 'current_' to previous instruction.
   void RemoveCurrentFromGraph();
 
   Instruction* Current() const { return current_; }
 
  private:
   Instruction* current_;
 };
 
-
 class BackwardInstructionIterator : public ValueObject {
  public:
   explicit BackwardInstructionIterator(BlockEntryInstr* block_entry)
       : block_entry_(block_entry), current_(block_entry->last_instruction()) {
     ASSERT(block_entry_->previous() == NULL);
   }
 
   void Advance() {
     ASSERT(!Done());
     current_ = current_->previous();
   }
 
   bool Done() const { return current_ == block_entry_; }
 
   void RemoveCurrentFromGraph();
 
   Instruction* Current() const { return current_; }
 
  private:
   BlockEntryInstr* block_entry_;
   Instruction* current_;
 };
 
-
 class GraphEntryInstr : public BlockEntryInstr {
  public:
   GraphEntryInstr(const ParsedFunction& parsed_function,
                   TargetEntryInstr* normal_entry,
                   intptr_t osr_id);
 
   DECLARE_INSTRUCTION(GraphEntry)
 
   virtual intptr_t PredecessorCount() const { return 0; }
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const {
@@ skipping 62 matching lines @@
   GrowableArray<IndirectEntryInstr*> indirect_entries_;
   GrowableArray<Definition*> initial_definitions_;
   const intptr_t osr_id_;
   intptr_t entry_count_;
   intptr_t spill_slot_count_;
   intptr_t fixed_slot_count_;  // For try-catch in optimized code.
 
   DISALLOW_COPY_AND_ASSIGN(GraphEntryInstr);
 };
 
-
 class JoinEntryInstr : public BlockEntryInstr {
  public:
   JoinEntryInstr(intptr_t block_id, intptr_t try_index, intptr_t deopt_id)
       : BlockEntryInstr(block_id, try_index, deopt_id),
         predecessors_(2),  // Two is the assumed to be the common case.
         phis_(NULL) {}
 
   DECLARE_INSTRUCTION(JoinEntry)
 
   virtual intptr_t PredecessorCount() const { return predecessors_.length(); }
@@ skipping 30 matching lines @@
 
   virtual void ClearPredecessors() { predecessors_.Clear(); }
   virtual void AddPredecessor(BlockEntryInstr* predecessor);
 
   GrowableArray<BlockEntryInstr*> predecessors_;
   ZoneGrowableArray<PhiInstr*>* phis_;
 
   DISALLOW_COPY_AND_ASSIGN(JoinEntryInstr);
 };
 
-
 class PhiIterator : public ValueObject {
  public:
   explicit PhiIterator(JoinEntryInstr* join) : phis_(join->phis()), index_(0) {}
 
   void Advance() {
     ASSERT(!Done());
     index_++;
   }
 
   bool Done() const { return (phis_ == NULL) || (index_ >= phis_->length()); }
 
   PhiInstr* Current() const { return (*phis_)[index_]; }
 
  private:
   ZoneGrowableArray<PhiInstr*>* phis_;
   intptr_t index_;
 };
 
-
 class TargetEntryInstr : public BlockEntryInstr {
  public:
   TargetEntryInstr(intptr_t block_id, intptr_t try_index, intptr_t deopt_id)
       : BlockEntryInstr(block_id, try_index, deopt_id),
         predecessor_(NULL),
         edge_weight_(0.0) {}
 
   DECLARE_INSTRUCTION(TargetEntry)
 
   double edge_weight() const { return edge_weight_; }
@@ skipping 18 matching lines @@
     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,
                      intptr_t deopt_id)
       : JoinEntryInstr(block_id, try_index, deopt_id),
         indirect_id_(indirect_id) {}
 
   DECLARE_INSTRUCTION(IndirectEntry)
 
   intptr_t indirect_id() const { return indirect_id_; }
 
   PRINT_TO_SUPPORT
 
  private:
   const intptr_t indirect_id_;
 };
 
-
 class CatchBlockEntryInstr : public BlockEntryInstr {
  public:
   CatchBlockEntryInstr(TokenPosition handler_token_pos,
                        bool is_generated,
                        intptr_t block_id,
                        intptr_t try_index,
                        GraphEntryInstr* graph_entry,
                        const Array& handler_types,
                        intptr_t catch_try_index,
                        const LocalVariable& exception_var,
@@ skipping 65 matching lines @@
   const LocalVariable& exception_var_;
   const LocalVariable& stacktrace_var_;
   const bool needs_stacktrace_;
   const bool should_restore_closure_context_;
   TokenPosition handler_token_pos_;
   bool is_generated_;
 
   DISALLOW_COPY_AND_ASSIGN(CatchBlockEntryInstr);
 };
 
-
 // If the result of the allocation is not stored into any field, passed
 // as an argument or used in a phi then it can't alias with any other
 // SSA value.
 class AliasIdentity : public ValueObject {
  public:
   // It is unknown if value has aliases.
   static AliasIdentity Unknown() { return AliasIdentity(kUnknown); }
 
   // It is known that value can have aliases.
   static AliasIdentity Aliased() { return AliasIdentity(kAliased); }
@@ skipping 32 matching lines @@
     kAllocationSinkingCandidate = 3,
   };
 
   COMPILE_ASSERT((kUnknown & kNotAliased) == 0);
   COMPILE_ASSERT((kAliased & kNotAliased) == 0);
   COMPILE_ASSERT((kAllocationSinkingCandidate & kNotAliased) != 0);
 
   intptr_t value_;
 };
 
-
 // Abstract super-class of all instructions that define a value (Bind, Phi).
 class Definition : public Instruction {
  public:
   explicit Definition(intptr_t deopt_id = Thread::kNoDeoptId);
 
   // Overridden by definitions that have call counts.
   virtual intptr_t CallCount() const {
     UNREACHABLE();
     return -1;
   }
@@ skipping 60 matching lines @@
 
     return false;
   }
 
   bool HasUses() const {
     return (input_use_list_ != NULL) || (env_use_list_ != NULL);
   }
   bool HasOnlyUse(Value* use) const;
   bool HasOnlyInputUse(Value* use) const;
 
-
   Value* input_use_list() const { return input_use_list_; }
   void set_input_use_list(Value* head) { input_use_list_ = head; }
 
   Value* env_use_list() const { return env_use_list_; }
   void set_env_use_list(Value* head) { env_use_list_ = head; }
 
   void AddInputUse(Value* value) { Value::AddToList(value, &input_use_list_); }
   void AddEnvUse(Value* value) { Value::AddToList(value, &env_use_list_); }
 
   // Replace uses of this definition with uses of other definition or value.
@@ skipping 58 matching lines @@
   intptr_t temp_index_;
   intptr_t ssa_temp_index_;
   Value* input_use_list_;
   Value* env_use_list_;
 
   Object* constant_value_;
 
   DISALLOW_COPY_AND_ASSIGN(Definition);
 };
 
-
 // Change a value's definition after use lists have been computed.
 inline void Value::BindTo(Definition* def) {
   RemoveFromUseList();
   set_definition(def);
   def->AddInputUse(this);
 }
 
-
 inline void Value::BindToEnvironment(Definition* def) {
   RemoveFromUseList();
   set_definition(def);
   def->AddEnvUse(this);
 }
 
-
 class PureDefinition : public Definition {
  public:
   explicit PureDefinition(intptr_t deopt_id) : Definition(deopt_id) {}
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 };
 
-
 template <intptr_t N,
           typename ThrowsTrait,
           template <typename Impure, typename Pure> class CSETrait = NoCSE>
 class TemplateDefinition : public CSETrait<Definition, PureDefinition>::Base {
  public:
   explicit TemplateDefinition(intptr_t deopt_id = Thread::kNoDeoptId)
       : CSETrait<Definition, PureDefinition>::Base(deopt_id), inputs_() {}
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   virtual bool MayThrow() const { return ThrowsTrait::kCanThrow; }
 
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   friend class BranchInstr;
   friend class IfThenElseInstr;
 
   virtual void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 };
 
-
 class InductionVariableInfo;
 
-
 class PhiInstr : public Definition {
  public:
   PhiInstr(JoinEntryInstr* block, intptr_t num_inputs)
       : block_(block),
         inputs_(num_inputs),
         representation_(kTagged),
         reaching_defs_(NULL),
         loop_variable_info_(NULL),
         is_alive_(false),
         is_receiver_(kUnknownReceiver) {
@@ skipping 79 matching lines @@
   GrowableArray<Value*> inputs_;
   Representation representation_;
   BitVector* reaching_defs_;
   InductionVariableInfo* loop_variable_info_;
   bool is_alive_;
   int8_t is_receiver_;
 
   DISALLOW_COPY_AND_ASSIGN(PhiInstr);
 };
 
-
 class ParameterInstr : public Definition {
  public:
   ParameterInstr(intptr_t index,
                  BlockEntryInstr* block,
                  Register base_reg = FPREG)
       : index_(index), base_reg_(base_reg), block_(block) {}
 
   DECLARE_INSTRUCTION(Parameter)
 
   intptr_t index() const { return index_; }
@@ skipping 27 matching lines @@
  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 ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   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();
 }
 
-
 class ReturnInstr : public TemplateInstruction<1, NoThrow> {
  public:
   ReturnInstr(TokenPosition token_pos, Value* value, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Return)
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Return instruction might turn into a Goto instruction after inlining.
     // Every Goto must have an environment.
     return true;
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
-
 class ThrowInstr : public TemplateInstruction<0, Throws> {
  public:
   explicit ThrowInstr(TokenPosition token_pos, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), token_pos_(token_pos) {}
 
   DECLARE_INSTRUCTION(Throw)
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
-
 class ReThrowInstr : public TemplateInstruction<0, Throws> {
  public:
   // 'catch_try_index' can be CatchClauseNode::kInvalidTryIndex if the
   // rethrow has been artificially generated by the parser.
   ReThrowInstr(TokenPosition token_pos,
                intptr_t catch_try_index,
                intptr_t deopt_id)
       : TemplateInstruction(deopt_id),
         token_pos_(token_pos),
         catch_try_index_(catch_try_index) {}
 
   DECLARE_INSTRUCTION(ReThrow)
 
   virtual intptr_t ArgumentCount() const { return 2; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   intptr_t catch_try_index() const { return catch_try_index_; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const TokenPosition token_pos_;
   const intptr_t catch_try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
-
 class StopInstr : public TemplateInstruction<0, NoThrow> {
  public:
   explicit StopInstr(const char* message) : message_(message) {
     ASSERT(message != NULL);
   }
 
   const char* message() const { return message_; }
 
   DECLARE_INSTRUCTION(Stop);
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
  private:
   const char* message_;
 
   DISALLOW_COPY_AND_ASSIGN(StopInstr);
 };
 
-
 class GotoInstr : public TemplateInstruction<0, NoThrow> {
  public:
   explicit GotoInstr(JoinEntryInstr* entry, intptr_t deopt_id)
       : TemplateInstruction(deopt_id),
         block_(NULL),
         successor_(entry),
         edge_weight_(0.0),
         parallel_move_(NULL) {}
 
   DECLARE_INSTRUCTION(Goto)
@@ skipping 44 matching lines @@
  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_;
 };
 
-
 // IndirectGotoInstr represents a dynamically computed jump. Only
 // IndirectEntryInstr targets are valid targets of an indirect goto. The
 // concrete target to jump to is given as a parameter to the indirect goto.
 //
 // In order to preserve split-edge form, an indirect goto does not itself point
 // to its targets. Instead, for each possible target, the successors_ field
 // will contain an ordinary goto instruction that jumps to the target.
 // TODO(zerny): Implement direct support instead of embedding gotos.
 //
 // Byte offsets of all possible targets are stored in the offsets_ array. The
@@ skipping 35 matching lines @@
   Value* offset() const { return inputs_[0]; }
   void ComputeOffsetTable();
 
   PRINT_TO_SUPPORT
 
  private:
   GrowableArray<TargetEntryInstr*> successors_;
   TypedData& offsets_;
 };
 
-
 class ComparisonInstr : public Definition {
  public:
   Value* left() const { return InputAt(0); }
   Value* right() const { return InputAt(1); }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   Token::Kind kind() const { return kind_; }
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right) = 0;
 
@@ skipping 54 matching lines @@
         operation_cid_(kIllegalCid) {}
 
  private:
   const TokenPosition token_pos_;
   Token::Kind kind_;
   intptr_t operation_cid_;  // Set by optimizer.
 
   DISALLOW_COPY_AND_ASSIGN(ComparisonInstr);
 };
 
-
 class PureComparison : public ComparisonInstr {
  public:
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  protected:
   PureComparison(TokenPosition token_pos, Token::Kind kind, intptr_t deopt_id)
       : ComparisonInstr(token_pos, kind, deopt_id) {}
 };
 
-
 template <intptr_t N,
           typename ThrowsTrait,
           template <typename Impure, typename Pure> class CSETrait = NoCSE>
 class TemplateComparison
     : public CSETrait<ComparisonInstr, PureComparison>::Base {
  public:
   TemplateComparison(TokenPosition token_pos,
                      Token::Kind kind,
                      intptr_t deopt_id = Thread::kNoDeoptId)
       : CSETrait<ComparisonInstr, PureComparison>::Base(token_pos,
                                                         kind,
                                                         deopt_id),
         inputs_() {}
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   virtual bool MayThrow() const { return ThrowsTrait::kCanThrow; }
 
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 };
 
-
 class BranchInstr : public Instruction {
  public:
   explicit BranchInstr(ComparisonInstr* comparison, intptr_t deopt_id)
       : Instruction(deopt_id), comparison_(comparison), constant_target_(NULL) {
     ASSERT(comparison->env() == NULL);
     for (intptr_t i = comparison->InputCount() - 1; i >= 0; --i) {
       comparison->InputAt(i)->set_instruction(this);
     }
   }
 
@@ skipping 59 matching lines @@
   }
 
   TargetEntryInstr* true_successor_;
   TargetEntryInstr* false_successor_;
   ComparisonInstr* comparison_;
   TargetEntryInstr* constant_target_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
-
 class DeoptimizeInstr : public TemplateInstruction<0, NoThrow, Pure> {
  public:
   DeoptimizeInstr(ICData::DeoptReasonId deopt_reason, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), deopt_reason_(deopt_reason) {}
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   DECLARE_INSTRUCTION(Deoptimize)
 
  private:
   const ICData::DeoptReasonId deopt_reason_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptimizeInstr);
 };
 
-
 class RedefinitionInstr : public TemplateDefinition<1, NoThrow> {
  public:
   explicit RedefinitionInstr(Value* value) : constrained_type_(NULL) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Redefinition)
 
   Value* value() const { return inputs_[0]; }
 
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   void set_constrained_type(CompileType* type) { constrained_type_ = type; }
   CompileType* constrained_type() const { return constrained_type_; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   CompileType* constrained_type_;
   DISALLOW_COPY_AND_ASSIGN(RedefinitionInstr);
 };
 
-
 class ConstraintInstr : public TemplateDefinition<1, NoThrow> {
  public:
   ConstraintInstr(Value* value, Range* constraint)
       : constraint_(constraint), target_(NULL) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Constraint)
 
   virtual CompileType ComputeType() const;
@@ skipping 20 matching lines @@
 
   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 bool ComputeCanDeoptimize() 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
 // for other unboxing instructions.
 class UnboxedConstantInstr : public ConstantInstr {
  public:
   explicit UnboxedConstantInstr(const Object& value,
                                 Representation representation);
 
   virtual Representation representation() const { return representation_; }
 
   // Either NULL or the address of the unboxed constant.
   uword constant_address() const { return constant_address_; }
 
   DECLARE_INSTRUCTION(UnboxedConstant)
 
  private:
   const Representation representation_;
   uword constant_address_;  // Either NULL or points to the untagged constant.
 
   DISALLOW_COPY_AND_ASSIGN(UnboxedConstantInstr);
 };
 
-
 class AssertAssignableInstr : public TemplateDefinition<3, Throws, Pure> {
  public:
   AssertAssignableInstr(TokenPosition token_pos,
                         Value* value,
                         Value* instantiator_type_arguments,
                         Value* function_type_arguments,
                         const AbstractType& dst_type,
                         const String& dst_name,
                         intptr_t deopt_id)
       : TemplateDefinition(deopt_id),
@@ skipping 39 matching lines @@
   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, intptr_t deopt_id)
       : TemplateDefinition(deopt_id), 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 bool ComputeCanDeoptimize() 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 a special parameter, currently either the context of a closure
 // or the type arguments of a generic function.
 class SpecialParameterInstr : public TemplateDefinition<0, NoThrow> {
  public:
   enum SpecialParameterKind { kContext, kTypeArgs };
   SpecialParameterInstr(SpecialParameterKind kind, intptr_t deopt_id)
       : TemplateDefinition(deopt_id), kind_(kind) {}
 
   DECLARE_INSTRUCTION(SpecialParameter)
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return kind() == other->AsSpecialParameter()->kind();
   }
   SpecialParameterKind kind() const { return kind_; }
 
  private:
   const SpecialParameterKind kind_;
   DISALLOW_COPY_AND_ASSIGN(SpecialParameterInstr);
 };
 
-
 struct ArgumentsInfo {
   ArgumentsInfo(intptr_t type_args_len,
                 intptr_t pushed_argc,
                 const Array& argument_names)
       : type_args_len(type_args_len),
         pushed_argc(pushed_argc),
         argument_names(argument_names) {}
 
   RawArray* ToArgumentsDescriptor() const {
     return ArgumentsDescriptor::New(type_args_len,
                                     pushed_argc - (type_args_len > 0 ? 1 : 0),
                                     argument_names);
   }
 
   intptr_t type_args_len;
   intptr_t pushed_argc;
   const Array& argument_names;
 };
 
-
 template <intptr_t kInputCount>
 class TemplateDartCall : public TemplateDefinition<kInputCount, Throws> {
  public:
   TemplateDartCall(intptr_t deopt_id,
                    intptr_t type_args_len,
                    const Array& argument_names,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments,
                    TokenPosition token_pos)
       : TemplateDefinition<kInputCount, Throws>(deopt_id),
         type_args_len_(type_args_len),
@@ skipping 22 matching lines @@
 
  private:
   intptr_t type_args_len_;
   const Array& argument_names_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(TemplateDartCall);
 };
 
-
 class ClosureCallInstr : public TemplateDartCall<1> {
  public:
   ClosureCallInstr(Value* function,
                    ClosureCallNode* node,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments,
                    intptr_t deopt_id)
       : TemplateDartCall(deopt_id,
                          node->arguments()->type_args_len(),
                          node->arguments()->names(),
                          arguments,
@@ skipping 25 matching lines @@
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ClosureCallInstr);
 };
 
-
 class InstanceCallInstr : public TemplateDartCall<0> {
  public:
   InstanceCallInstr(TokenPosition token_pos,
                     const String& function_name,
                     Token::Kind token_kind,
                     ZoneGrowableArray<PushArgumentInstr*>* arguments,
                     intptr_t type_args_len,
                     const Array& argument_names,
                     intptr_t checked_argument_count,
                     const ZoneGrowableArray<const ICData*>& ic_data_array,
@@ skipping 65 matching lines @@
  private:
   const ICData* ic_data_;
   const String& function_name_;
   const Token::Kind token_kind_;  // Binary op, unary op, kGET or kILLEGAL.
   const intptr_t checked_argument_count_;
   bool has_unique_selector_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceCallInstr);
 };
 
-
 class PolymorphicInstanceCallInstr : public TemplateDefinition<0, Throws> {
  public:
   PolymorphicInstanceCallInstr(InstanceCallInstr* instance_call,
                                const CallTargets& targets,
                                bool complete)
       : TemplateDefinition(instance_call->deopt_id()),
         instance_call_(instance_call),
         targets_(targets),
         complete_(complete) {
     ASSERT(instance_call_ != NULL);
@@ skipping 56 matching lines @@
   InstanceCallInstr* instance_call_;
   const CallTargets& targets_;
   const bool complete_;
   intptr_t total_call_count_;
 
   friend class PolymorphicInliner;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallInstr);
 };
 
-
 class StrictCompareInstr : public TemplateComparison<2, NoThrow, Pure> {
  public:
   StrictCompareInstr(TokenPosition token_pos,
                      Token::Kind kind,
                      Value* left,
                      Value* right,
                      bool needs_number_check,
                      intptr_t deopt_id);
 
   DECLARE_COMPARISON_INSTRUCTION(StrictCompare)
@@ skipping 14 matching lines @@
   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
 // comparison pattern.
 class TestSmiInstr : public TemplateComparison<2, NoThrow, Pure> {
  public:
   TestSmiInstr(TokenPosition token_pos,
                Token::Kind kind,
                Value* left,
                Value* right)
       : TemplateComparison(token_pos, kind) {
     ASSERT(kind == Token::kEQ || kind == Token::kNE);
@@ skipping 10 matching lines @@
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     return kTagged;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestSmiInstr);
 };
 
-
 // Checks the input value cid against cids stored in a table and returns either
 // a result or deoptimizes.  If the cid is not in the list and there is a deopt
 // id, then the instruction deoptimizes.  If there is no deopt id, all the
 // results must be the same (all true or all false) and the instruction returns
 // the opposite for cids not on the list.  The first element in the table must
 // always be the result for the Smi class-id and is allowed to differ from the
 // other results even in the no-deopt case.
 class TestCidsInstr : public TemplateComparison<1, NoThrow, Pure> {
  public:
   TestCidsInstr(TokenPosition token_pos,
@@ skipping 27 matching lines @@
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const ZoneGrowableArray<intptr_t>& cid_results_;
   bool licm_hoisted_;
   DISALLOW_COPY_AND_ASSIGN(TestCidsInstr);
 };
 
-
 class EqualityCompareInstr : public TemplateComparison<2, NoThrow, Pure> {
  public:
   EqualityCompareInstr(TokenPosition token_pos,
                        Token::Kind kind,
                        Value* left,
                        Value* right,
                        intptr_t cid,
                        intptr_t deopt_id)
       : TemplateComparison(token_pos, kind, deopt_id) {
     ASSERT(Token::IsEqualityOperator(kind));
@@ skipping 16 matching lines @@
     if (operation_cid() == kMintCid) return kUnboxedMint;
     return kTagged;
   }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EqualityCompareInstr);
 };
 
-
 class RelationalOpInstr : public TemplateComparison<2, NoThrow, Pure> {
  public:
   RelationalOpInstr(TokenPosition token_pos,
                     Token::Kind kind,
                     Value* left,
                     Value* right,
                     intptr_t cid,
                     intptr_t deopt_id)
       : TemplateComparison(token_pos, kind, deopt_id) {
     ASSERT(Token::IsRelationalOperator(kind));
@@ skipping 16 matching lines @@
     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,
                   Value* if_true,
                   Value* if_false,
                   intptr_t deopt_id)
       : Definition(deopt_id),
         comparison_(comparison),
@@ skipping 62 matching lines @@
     comparison()->RawSetInputAt(i, value);
   }
 
   ComparisonInstr* comparison_;
   const intptr_t if_true_;
   const intptr_t if_false_;
 
   DISALLOW_COPY_AND_ASSIGN(IfThenElseInstr);
 };
 
-
 class StaticCallInstr : public TemplateDartCall<0> {
  public:
   StaticCallInstr(TokenPosition token_pos,
                   const Function& function,
                   intptr_t type_args_len,
                   const Array& argument_names,
                   ZoneGrowableArray<PushArgumentInstr*>* arguments,
                   const ZoneGrowableArray<const ICData*>& ic_data_array,
                   intptr_t deopt_id)
       : TemplateDartCall(deopt_id,
@@ skipping 98 matching lines @@
   intptr_t result_cid_;  // For some library functions we know the result.
 
   // 'True' for recognized list constructors.
   bool is_known_list_constructor_;
 
   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_; }
 
@@ skipping 12 matching lines @@
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const LocalVariable& local_;
   bool is_last_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadLocalInstr);
 };
 
-
 class DropTempsInstr : public Definition {
  public:
   DropTempsInstr(intptr_t num_temps, Value* value)
       : num_temps_(num_temps), value_(NULL) {
     if (value != NULL) {
       SetInputAt(0, value);
     }
   }
 
   DECLARE_INSTRUCTION(DropTemps)
@@ skipping 28 matching lines @@
 
  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)
@@ skipping 21 matching lines @@
 
  private:
   const LocalVariable& local_;
   bool is_dead_;
   bool is_last_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalInstr);
 };
 
-
 class NativeCallInstr : public TemplateDefinition<0, Throws> {
  public:
   explicit NativeCallInstr(NativeBodyNode* node)
       : native_name_(&node->native_c_function_name()),
         function_(&node->function()),
         native_c_function_(NULL),
         is_bootstrap_native_(false),
         link_lazily_(node->link_lazily()),
         token_pos_(node->token_pos()) {}
 
@@ skipping 39 matching lines @@
   const Function* function_;
   NativeFunction native_c_function_;
   bool is_bootstrap_native_;
   bool is_auto_scope_;
   bool link_lazily_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallInstr);
 };
 
-
 class DebugStepCheckInstr : public TemplateInstruction<0, NoThrow> {
  public:
   DebugStepCheckInstr(TokenPosition token_pos,
                       RawPcDescriptors::Kind stub_kind,
                       intptr_t deopt_id)
       : TemplateInstruction<0, NoThrow>(deopt_id),
         token_pos_(token_pos),
         stub_kind_(stub_kind) {}
 
   DECLARE_INSTRUCTION(DebugStepCheck)
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   virtual bool ComputeCanDeoptimize() const { return false; }
   virtual EffectSet Effects() const { return EffectSet::All(); }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const TokenPosition token_pos_;
   const RawPcDescriptors::Kind stub_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(DebugStepCheckInstr);
 };
 
-
 enum StoreBarrierType { kNoStoreBarrier, kEmitStoreBarrier };
 
-
 class StoreInstanceFieldInstr : public TemplateDefinition<2, NoThrow> {
  public:
   StoreInstanceFieldInstr(const Field& field,
                           Value* instance,
                           Value* value,
                           StoreBarrierType emit_store_barrier,
                           TokenPosition token_pos)
       : field_(field),
         offset_in_bytes_(field.Offset()),
         emit_store_barrier_(emit_store_barrier),
@@ skipping 69 matching lines @@
   const Field& field_;
   intptr_t offset_in_bytes_;
   const StoreBarrierType emit_store_barrier_;
   const TokenPosition token_pos_;
   // Marks initializing stores. E.g. in the constructor.
   bool is_initialization_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldInstr);
 };
 
-
 class GuardFieldInstr : public TemplateInstruction<1, NoThrow, Pure> {
  public:
   GuardFieldInstr(Value* value, const Field& field, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), field_(field) {
     SetInputAt(0, value);
     CheckField(field);
   }
 
   Value* value() const { return inputs_[0]; }
 
   const Field& field() const { return field_; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Ensure that we record kDeopt PC descriptor in unoptimized code.
     return true;
   }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(GuardFieldInstr);
 };
 
-
 class GuardFieldClassInstr : public GuardFieldInstr {
  public:
   GuardFieldClassInstr(Value* value, const Field& field, intptr_t deopt_id)
       : GuardFieldInstr(value, field, deopt_id) {
     CheckField(field);
   }
 
   DECLARE_INSTRUCTION(GuardFieldClass)
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GuardFieldClassInstr);
 };
 
-
 class GuardFieldLengthInstr : public GuardFieldInstr {
  public:
   GuardFieldLengthInstr(Value* value, const Field& field, intptr_t deopt_id)
       : GuardFieldInstr(value, field, deopt_id) {
     CheckField(field);
   }
 
   DECLARE_INSTRUCTION(GuardFieldLength)
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GuardFieldLengthInstr);
 };
 
-
 class LoadStaticFieldInstr : public TemplateDefinition<1, NoThrow> {
  public:
   LoadStaticFieldInstr(Value* field_value, TokenPosition token_pos)
       : token_pos_(token_pos) {
     ASSERT(field_value->BindsToConstant());
     SetInputAt(0, field_value);
   }
 
   DECLARE_INSTRUCTION(LoadStaticField)
   virtual CompileType ComputeType() const;
@@ skipping 12 matching lines @@
   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);
     CheckField(field);
   }
@@ skipping 78 matching lines @@
 
  private:
   const intptr_t index_scale_;
   const intptr_t class_id_;
   const AlignmentType alignment_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadIndexedInstr);
 };
 
-
 // Loads the specified number of code units from the given string, packing
 // multiple code units into a single datatype. In essence, this is a specialized
 // version of LoadIndexedInstr which accepts only string targets and can load
 // multiple elements at once. The result datatype differs depending on the
 // string type, element count, and architecture; if possible, the result is
 // packed into a Smi, falling back to a Mint otherwise.
 // TODO(zerny): Add support for loading into UnboxedInt32x4.
 class LoadCodeUnitsInstr : public TemplateDefinition<2, NoThrow> {
  public:
   LoadCodeUnitsInstr(Value* str,
@@ skipping 49 matching lines @@
 
  private:
   const intptr_t class_id_;
   const TokenPosition token_pos_;
   const intptr_t element_count_;
   Representation representation_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadCodeUnitsInstr);
 };
 
-
 class OneByteStringFromCharCodeInstr
     : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   explicit OneByteStringFromCharCodeInstr(Value* char_code) {
     SetInputAt(0, char_code);
   }
 
   DECLARE_INSTRUCTION(OneByteStringFromCharCode)
   virtual CompileType ComputeType() const;
 
   Value* char_code() const { return inputs_[0]; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OneByteStringFromCharCodeInstr);
 };
 
-
 class StringToCharCodeInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   StringToCharCodeInstr(Value* str, intptr_t cid) : cid_(cid) {
     ASSERT(str != NULL);
     SetInputAt(0, str);
   }
 
   DECLARE_INSTRUCTION(StringToCharCode)
   virtual CompileType ComputeType() const;
 
   Value* str() const { return inputs_[0]; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsStringToCharCode()->cid_ == cid_;
   }
 
  private:
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(StringToCharCodeInstr);
 };
 
-
 class StringInterpolateInstr : public TemplateDefinition<1, Throws> {
  public:
   StringInterpolateInstr(Value* value,
                          TokenPosition token_pos,
                          intptr_t deopt_id)
       : TemplateDefinition(deopt_id),
         token_pos_(token_pos),
         function_(Function::ZoneHandle()) {
     SetInputAt(0, value);
   }
@@ skipping 12 matching lines @@
 
   DECLARE_INSTRUCTION(StringInterpolate)
 
  private:
   const TokenPosition token_pos_;
   Function& function_;
 
   DISALLOW_COPY_AND_ASSIGN(StringInterpolateInstr);
 };
 
-
 class StoreIndexedInstr : public TemplateDefinition<3, NoThrow> {
  public:
   StoreIndexedInstr(Value* array,
                     Value* index,
                     Value* value,
                     StoreBarrierType emit_store_barrier,
                     intptr_t index_scale,
                     intptr_t class_id,
                     AlignmentType alignment,
                     intptr_t deopt_id,
@@ skipping 34 matching lines @@
  private:
   const StoreBarrierType emit_store_barrier_;
   const intptr_t index_scale_;
   const intptr_t class_id_;
   const AlignmentType alignment_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedInstr);
 };
 
-
 // Note overrideable, built-in: value ? false : true.
 class BooleanNegateInstr : public TemplateDefinition<1, NoThrow> {
  public:
   explicit BooleanNegateInstr(Value* value) { SetInputAt(0, value); }
 
   DECLARE_INSTRUCTION(BooleanNegate)
   virtual CompileType ComputeType() const;
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateInstr);
 };
 
-
 class InstanceOfInstr : public TemplateDefinition<3, Throws> {
  public:
   InstanceOfInstr(TokenPosition token_pos,
                   Value* value,
                   Value* instantiator_type_arguments,
                   Value* function_type_arguments,
                   const AbstractType& type,
                   intptr_t deopt_id)
       : TemplateDefinition(deopt_id), token_pos_(token_pos), type_(type) {
     ASSERT(!type.IsNull());
@@ skipping 20 matching lines @@
 
  private:
   const TokenPosition token_pos_;
   Value* value_;
   Value* type_arguments_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceOfInstr);
 };
 
-
 class AllocateObjectInstr : public TemplateDefinition<0, NoThrow> {
  public:
   AllocateObjectInstr(TokenPosition token_pos,
                       const Class& cls,
                       ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : token_pos_(token_pos),
         cls_(cls),
         arguments_(arguments),
         identity_(AliasIdentity::Unknown()),
         closure_function_(Function::ZoneHandle()) {
@@ skipping 29 matching lines @@
  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)
@@ skipping 12 matching lines @@
   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
 // removed during the AllocationSinking pass.
 // It does not produce any real code only deoptimization information.
 class MaterializeObjectInstr : public Definition {
  public:
   MaterializeObjectInstr(AllocateObjectInstr* allocation,
                          const ZoneGrowableArray<const Object*>& slots,
                          ZoneGrowableArray<Value*>* values)
       : allocation_(allocation),
         cls_(allocation->cls()),
@@ skipping 82 matching lines @@
   const ZoneGrowableArray<const Object*>& slots_;
   ZoneGrowableArray<Value*>* values_;
   Location* locations_;
 
   bool visited_for_liveness_;
   bool registers_remapped_;
 
   DISALLOW_COPY_AND_ASSIGN(MaterializeObjectInstr);
 };
 
-
 class CreateArrayInstr : public TemplateDefinition<2, Throws> {
  public:
   CreateArrayInstr(TokenPosition token_pos,
                    Value* element_type,
                    Value* num_elements,
                    intptr_t deopt_id)
       : TemplateDefinition(deopt_id),
         token_pos_(token_pos),
         identity_(AliasIdentity::Unknown()) {
     SetInputAt(kElementTypePos, element_type);
@@ skipping 18 matching lines @@
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
  private:
   const TokenPosition token_pos_;
   AliasIdentity identity_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateArrayInstr);
 };
 
-
 // Note: this instruction must not be moved without the indexed access that
 // depends on it (e.g. out of loops). GC may cause collect
 // the array while the external data-array is still accessed.
 // TODO(vegorov) enable LICMing this instruction by ensuring that array itself
 // is kept alive.
 class LoadUntaggedInstr : public TemplateDefinition<1, NoThrow> {
  public:
   LoadUntaggedInstr(Value* object, intptr_t offset) : offset_(offset) {
     SetInputAt(0, object);
   }
@@ skipping 15 matching lines @@
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   intptr_t offset_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadUntaggedInstr);
 };
 
-
 class LoadClassIdInstr : public TemplateDefinition<1, NoThrow> {
  public:
   explicit LoadClassIdInstr(Value* object) { SetInputAt(0, object); }
 
   virtual Representation representation() const { return kTagged; }
   DECLARE_INSTRUCTION(LoadClassId)
   virtual CompileType ComputeType() const;
 
   Value* object() const { return inputs_[0]; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const {
     return EffectSet::Externalization();
   }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LoadClassIdInstr);
 };
 
-
 class LoadFieldInstr : public TemplateDefinition<1, NoThrow> {
  public:
   LoadFieldInstr(Value* instance,
                  intptr_t offset_in_bytes,
                  const AbstractType& type,
                  TokenPosition token_pos)
       : offset_in_bytes_(offset_in_bytes),
         type_(type),
         result_cid_(kDynamicCid),
         immutable_(false),
@@ skipping 89 matching lines @@
   intptr_t result_cid_;
   bool immutable_;
 
   MethodRecognizer::Kind recognized_kind_;
   const Field* field_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadFieldInstr);
 };
 
-
 class InstantiateTypeInstr : public TemplateDefinition<2, Throws> {
  public:
   InstantiateTypeInstr(TokenPosition token_pos,
                        const AbstractType& type,
                        Value* instantiator_type_arguments,
                        Value* function_type_arguments,
                        intptr_t deopt_id)
       : TemplateDefinition(deopt_id), token_pos_(token_pos), type_(type) {
     ASSERT(type.IsZoneHandle() || type.IsReadOnlyHandle());
     SetInputAt(0, instantiator_type_arguments);
@@ skipping 13 matching lines @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeInstr);
 };
 
-
 class InstantiateTypeArgumentsInstr : public TemplateDefinition<2, Throws> {
  public:
   InstantiateTypeArgumentsInstr(TokenPosition token_pos,
                                 const TypeArguments& type_arguments,
                                 const Class& instantiator_class,
                                 Value* instantiator_type_arguments,
                                 Value* function_type_arguments,
                                 intptr_t deopt_id)
       : TemplateDefinition(deopt_id),
         token_pos_(token_pos),
@@ skipping 21 matching lines @@
   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 bool ComputeCanDeoptimize() 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:
   InitStaticFieldInstr(Value* input, const Field& field, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), field_(field) {
     SetInputAt(0, input);
     CheckField(field);
   }
 
   virtual TokenPosition token_pos() const { return field_.token_pos(); }
   const Field& field() const { return field_; }
 
   DECLARE_INSTRUCTION(InitStaticField)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::All(); }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(InitStaticFieldInstr);
 };
 
-
 class CloneContextInstr : public TemplateDefinition<1, NoThrow> {
  public:
   CloneContextInstr(TokenPosition token_pos,
                     Value* context_value,
                     intptr_t deopt_id)
       : TemplateDefinition(deopt_id), token_pos_(token_pos) {
     SetInputAt(0, context_value);
   }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   Value* context_value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(CloneContext)
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CloneContextInstr);
 };
 
-
 class CheckEitherNonSmiInstr : public TemplateInstruction<2, NoThrow, Pure> {
  public:
   CheckEitherNonSmiInstr(Value* left, Value* right, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), licm_hoisted_(false) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   DECLARE_INSTRUCTION(CheckEitherNonSmi)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
  private:
   bool licm_hoisted_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckEitherNonSmiInstr);
 };
 
-
 class Boxing : public AllStatic {
  public:
   static bool Supports(Representation rep) {
     switch (rep) {
       case kUnboxedDouble:
       case kUnboxedFloat32x4:
       case kUnboxedFloat64x2:
       case kUnboxedInt32x4:
       case kUnboxedMint:
       case kUnboxedInt32:
@@ skipping 39 matching lines @@
         return kFloat64x2Cid;
       case kUnboxedInt32x4:
         return kInt32x4Cid;
       default:
         UNREACHABLE();
         return kIllegalCid;
     }
   }
 };
 
-
 class BoxInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   static BoxInstr* Create(Representation from, Value* value);
 
   Value* value() const { return inputs_[0]; }
   Representation from_representation() const { return from_representation_; }
 
   DECLARE_INSTRUCTION(Box)
   virtual CompileType ComputeType() const;
 
@@ skipping 22 matching lines @@
  private:
   intptr_t ValueOffset() const {
     return Boxing::ValueOffset(from_representation());
   }
 
   const Representation from_representation_;
 
   DISALLOW_COPY_AND_ASSIGN(BoxInstr);
 };
 
-
 class BoxIntegerInstr : public BoxInstr {
  public:
   BoxIntegerInstr(Representation representation, Value* value)
       : BoxInstr(representation, value) {}
 
   virtual bool ValueFitsSmi() const;
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   DEFINE_INSTRUCTION_TYPE_CHECK(BoxInteger)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxIntegerInstr);
 };
 
-
 class BoxInteger32Instr : public BoxIntegerInstr {
  public:
   BoxInteger32Instr(Representation representation, Value* value)
       : BoxIntegerInstr(representation, value) {}
 
   DECLARE_INSTRUCTION_BACKEND()
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxInteger32Instr);
 };
 
-
 class BoxInt32Instr : public BoxInteger32Instr {
  public:
   explicit BoxInt32Instr(Value* value)
       : BoxInteger32Instr(kUnboxedInt32, value) {}
 
   DECLARE_INSTRUCTION_NO_BACKEND(BoxInt32)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxInt32Instr);
 };
 
-
 class BoxUint32Instr : public BoxInteger32Instr {
  public:
   explicit BoxUint32Instr(Value* value)
       : BoxInteger32Instr(kUnboxedUint32, value) {}
 
   DECLARE_INSTRUCTION_NO_BACKEND(BoxUint32)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxUint32Instr);
 };
 
-
 class BoxInt64Instr : public BoxIntegerInstr {
  public:
   explicit BoxInt64Instr(Value* value) : BoxIntegerInstr(kUnboxedMint, value) {}
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   DECLARE_INSTRUCTION(BoxInt64)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxInt64Instr);
 };
 
-
 class UnboxInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   static UnboxInstr* Create(Representation to, Value* value, intptr_t deopt_id);
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool ComputeCanDeoptimize() const {
     const intptr_t value_cid = value()->Type()->ToCid();
 
     if (CanConvertSmi() && (value()->Type()->ToCid() == kSmiCid)) {
@@ skipping 31 matching lines @@
 
   intptr_t BoxCid() const { return Boxing::BoxCid(representation_); }
 
   intptr_t ValueOffset() const { return Boxing::ValueOffset(representation_); }
 
   const Representation representation_;
 
   DISALLOW_COPY_AND_ASSIGN(UnboxInstr);
 };
 
-
 class UnboxIntegerInstr : public UnboxInstr {
  public:
   enum TruncationMode { kTruncate, kNoTruncation };
 
   UnboxIntegerInstr(Representation representation,
                     TruncationMode truncation_mode,
                     Value* value,
                     intptr_t deopt_id)
       : UnboxInstr(representation, value, deopt_id),
         is_truncating_(truncation_mode == kTruncate) {}
@@ skipping 13 matching lines @@
   DEFINE_INSTRUCTION_TYPE_CHECK(UnboxInteger)
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   bool is_truncating_;
 
   DISALLOW_COPY_AND_ASSIGN(UnboxIntegerInstr);
 };
 
-
 class UnboxInteger32Instr : public UnboxIntegerInstr {
  public:
   UnboxInteger32Instr(Representation representation,
                       TruncationMode truncation_mode,
                       Value* value,
                       intptr_t deopt_id)
       : UnboxIntegerInstr(representation, truncation_mode, value, deopt_id) {}
 
   DECLARE_INSTRUCTION_BACKEND()
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxInteger32Instr);
 };
 
-
 class UnboxUint32Instr : public UnboxInteger32Instr {
  public:
   UnboxUint32Instr(Value* value, intptr_t deopt_id)
       : UnboxInteger32Instr(kUnboxedUint32, kTruncate, value, deopt_id) {
     ASSERT(is_truncating());
   }
 
   virtual bool ComputeCanDeoptimize() const;
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   DECLARE_INSTRUCTION_NO_BACKEND(UnboxUint32)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxUint32Instr);
 };
 
-
 class UnboxInt32Instr : public UnboxInteger32Instr {
  public:
   UnboxInt32Instr(TruncationMode truncation_mode,
                   Value* value,
                   intptr_t deopt_id)
       : UnboxInteger32Instr(kUnboxedInt32, truncation_mode, value, deopt_id) {}
 
   virtual bool ComputeCanDeoptimize() const;
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   DECLARE_INSTRUCTION_NO_BACKEND(UnboxInt32)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxInt32Instr);
 };
 
-
 class UnboxInt64Instr : public UnboxIntegerInstr {
  public:
   UnboxInt64Instr(Value* value, intptr_t deopt_id)
       : UnboxIntegerInstr(kUnboxedMint, kNoTruncation, value, deopt_id) {}
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   DECLARE_INSTRUCTION_NO_BACKEND(UnboxInt64)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxInt64Instr);
 };
 
-
 bool Definition::IsMintDefinition() {
   return (Type()->ToCid() == kMintCid) || IsBinaryMintOp() || IsUnaryMintOp() ||
          IsShiftMintOp() || IsBoxInt64() || IsUnboxInt64();
 }
 
-
 class MathUnaryInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   enum MathUnaryKind {
     kIllegal,
     kSqrt,
     kDoubleSquare,
   };
   MathUnaryInstr(MathUnaryKind kind, Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id), kind_(kind) {
     SetInputAt(0, value);
@@ skipping 29 matching lines @@
   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].
 //
 // TODO(zerny): Remove this once (if) functions inherited from unibrow
 // are moved to dart code.
 class CaseInsensitiveCompareUC16Instr
     : public TemplateDefinition<4, NoThrow, Pure> {
  public:
   CaseInsensitiveCompareUC16Instr(Value* str,
@@ skipping 30 matching lines @@
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsCaseInsensitiveCompareUC16()->cid_ == cid_;
   }
 
  private:
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(CaseInsensitiveCompareUC16Instr);
 };
 
-
 // Represents Math's static min and max functions.
 class MathMinMaxInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   MathMinMaxInstr(MethodRecognizer::Kind op_kind,
                   Value* left_value,
                   Value* right_value,
                   intptr_t deopt_id,
                   intptr_t result_cid)
       : TemplateDefinition(deopt_id),
         op_kind_(op_kind),
@@ skipping 38 matching lines @@
   virtual CompileType ComputeType() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   const MethodRecognizer::Kind op_kind_;
   const intptr_t result_cid_;
 
   DISALLOW_COPY_AND_ASSIGN(MathMinMaxInstr);
 };
 
-
 class BinaryDoubleOpInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   BinaryDoubleOpInstr(Token::Kind op_kind,
                       Value* left,
                       Value* right,
                       intptr_t deopt_id,
                       TokenPosition token_pos)
       : TemplateDefinition(deopt_id), op_kind_(op_kind), token_pos_(token_pos) {
     SetInputAt(0, left);
     SetInputAt(1, right);
@@ skipping 32 matching lines @@
     return op_kind() == other->AsBinaryDoubleOp()->op_kind();
   }
 
  private:
   const Token::Kind op_kind_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryDoubleOpInstr);
 };
 
-
 class DoubleTestOpInstr : public TemplateComparison<1, NoThrow, Pure> {
  public:
   DoubleTestOpInstr(MethodRecognizer::Kind op_kind,
                     Value* value,
                     intptr_t deopt_id,
                     TokenPosition token_pos)
       : TemplateComparison(token_pos, Token::kEQ, deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
   }
 
@@ skipping 22 matching lines @@
   }
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleTestOpInstr);
 };
 
-
 class BinaryFloat32x4OpInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   BinaryFloat32x4OpInstr(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);
   }
@@ skipping 26 matching lines @@
   }
 
   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);
   }
 
@@ skipping 48 matching lines @@
            (mask() == other->AsSimd32x4Shuffle()->mask());
   }
 
  private:
   const MethodRecognizer::Kind op_kind_;
   const intptr_t mask_;
 
   DISALLOW_COPY_AND_ASSIGN(Simd32x4ShuffleInstr);
 };
 
-
 class Simd32x4ShuffleMixInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   Simd32x4ShuffleMixInstr(MethodRecognizer::Kind op_kind,
                           Value* xy,
                           Value* zw,
                           intptr_t mask,
                           intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind), mask_(mask) {
     SetInputAt(0, xy);
     SetInputAt(1, zw);
@@ skipping 41 matching lines @@
            (mask() == other->AsSimd32x4ShuffleMix()->mask());
   }
 
  private:
   const MethodRecognizer::Kind op_kind_;
   const intptr_t mask_;
 
   DISALLOW_COPY_AND_ASSIGN(Simd32x4ShuffleMixInstr);
 };
 
-
 class Float32x4ConstructorInstr : public TemplateDefinition<4, NoThrow, Pure> {
  public:
   Float32x4ConstructorInstr(Value* value0,
                             Value* value1,
                             Value* value2,
                             Value* value3,
                             intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
@@ skipping 25 matching lines @@
   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 bool ComputeCanDeoptimize() const { return false; }
@@ skipping 15 matching lines @@
   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() {}
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   DECLARE_INSTRUCTION(Float32x4Zero)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ZeroInstr);
 };
 
-
 class Float32x4ComparisonInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   Float32x4ComparisonInstr(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);
   }
@@ skipping 26 matching lines @@
   }
 
   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);
   }
@@ skipping 26 matching lines @@
   }
 
   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);
   }
@@ skipping 29 matching lines @@
   }
 
   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]; }
@@ skipping 23 matching lines @@
   }
 
   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);
   }
 
@@ skipping 24 matching lines @@
   }
 
   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);
@@ skipping 22 matching lines @@
   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);
   }
@@ skipping 29 matching lines @@
   }
 
   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);
   }
 
@@ skipping 40 matching lines @@
 
   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 bool ComputeCanDeoptimize() const { return false; }
@@ skipping 15 matching lines @@
   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 bool ComputeCanDeoptimize() const { return false; }
@@ skipping 15 matching lines @@
   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 bool ComputeCanDeoptimize() const { return false; }
@@ skipping 15 matching lines @@
   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]; }
@@ skipping 17 matching lines @@
 
   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 bool ComputeCanDeoptimize() const { return false; }
@@ skipping 15 matching lines @@
   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 ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedFloat64x2; }
 
   DECLARE_INSTRUCTION(Float64x2Zero)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Float64x2ZeroInstr);
 };
 
-
 // TODO(vegorov) rename to Unary to match arithmetic instructions.
 class Float64x2ZeroArgInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   Float64x2ZeroArgInstr(MethodRecognizer::Kind op_kind,
                         Value* left,
                         intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
   }
 
@@ skipping 30 matching lines @@
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat64x2ZeroArg()->op_kind();
   }
 
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float64x2ZeroArgInstr);
 };
 
-
 class Float64x2OneArgInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   Float64x2OneArgInstr(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);
   }
@@ skipping 34 matching lines @@
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat64x2OneArg()->op_kind();
   }
 
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float64x2OneArgInstr);
 };
 
-
 class Int32x4ConstructorInstr : public TemplateDefinition<4, NoThrow, Pure> {
  public:
   Int32x4ConstructorInstr(Value* value0,
                           Value* value1,
                           Value* value2,
                           Value* value3,
                           intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
@@ skipping 25 matching lines @@
   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);
@@ skipping 26 matching lines @@
   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]; }
@@ skipping 23 matching lines @@
   }
 
   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]; }
@@ skipping 27 matching lines @@
   }
 
   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);
@@ skipping 25 matching lines @@
   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);
   }
@@ skipping 29 matching lines @@
   }
 
   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 bool ComputeCanDeoptimize() const { return false; }
@@ skipping 15 matching lines @@
   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);
   }
@@ skipping 26 matching lines @@
   }
 
   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,
                          Value* left,
                          Value* right,
                          intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
@@ skipping 26 matching lines @@
   }
 
   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, Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     ASSERT((op_kind == Token::kNEGATE) || (op_kind == Token::kBIT_NOT));
     SetInputAt(0, value);
   }
 
   static UnaryIntegerOpInstr* Make(Representation representation,
                                    Token::Kind op_kind,
@@ skipping 17 matching lines @@
   PRINT_OPERANDS_TO_SUPPORT
 
   RawInteger* Evaluate(const Integer& value) const;
 
   DEFINE_INSTRUCTION_TYPE_CHECK(UnaryIntegerOp)
 
  private:
   const Token::Kind op_kind_;
 };
 
-
 // Handles both Smi operations: BIT_OR and NEGATE.
 class UnarySmiOpInstr : public UnaryIntegerOpInstr {
  public:
   UnarySmiOpInstr(Token::Kind op_kind, Value* value, intptr_t deopt_id)
       : UnaryIntegerOpInstr(op_kind, value, deopt_id) {}
 
   virtual bool ComputeCanDeoptimize() const {
     return op_kind() == Token::kNEGATE;
   }
 
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(UnarySmiOp)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnarySmiOpInstr);
 };
 
-
 class UnaryUint32OpInstr : public UnaryIntegerOpInstr {
  public:
   UnaryUint32OpInstr(Token::Kind op_kind, Value* value, intptr_t deopt_id)
       : UnaryIntegerOpInstr(op_kind, value, deopt_id) {
     ASSERT(op_kind == Token::kBIT_NOT);
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual CompileType ComputeType() const;
 
   virtual Representation representation() const { return kUnboxedUint32; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedUint32;
   }
 
   DECLARE_INSTRUCTION(UnaryUint32Op)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnaryUint32OpInstr);
 };
 
-
 class UnaryMintOpInstr : public UnaryIntegerOpInstr {
  public:
   UnaryMintOpInstr(Token::Kind op_kind, Value* value, intptr_t deopt_id)
       : UnaryIntegerOpInstr(op_kind, value, deopt_id) {
     ASSERT(op_kind == Token::kBIT_NOT);
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual CompileType ComputeType() const;
 
   virtual Representation representation() const { return kUnboxedMint; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedMint;
   }
 
   DECLARE_INSTRUCTION(UnaryMintOp)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnaryMintOpInstr);
 };
 
-
 class CheckedSmiOpInstr : public TemplateDefinition<2, Throws> {
  public:
   CheckedSmiOpInstr(Token::Kind op_kind,
                     Value* left,
                     Value* right,
                     InstanceCallInstr* call)
       : TemplateDefinition(call->deopt_id()), call_(call), op_kind_(op_kind) {
     ASSERT(call->type_args_len() == 0);
     SetInputAt(0, left);
     SetInputAt(1, right);
@@ skipping 13 matching lines @@
   PRINT_OPERANDS_TO_SUPPORT
 
   DECLARE_INSTRUCTION(CheckedSmiOp)
 
  private:
   InstanceCallInstr* call_;
   const Token::Kind op_kind_;
   DISALLOW_COPY_AND_ASSIGN(CheckedSmiOpInstr);
 };
 
-
 class CheckedSmiComparisonInstr : public TemplateComparison<2, Throws> {
  public:
   CheckedSmiComparisonInstr(Token::Kind op_kind,
                             Value* left,
                             Value* right,
                             InstanceCallInstr* call)
       : TemplateComparison(call->token_pos(), op_kind, call->deopt_id()),
         call_(call),
         is_negated_(false) {
     ASSERT(call->type_args_len() == 0);
@@ skipping 34 matching lines @@
 #endif
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
  private:
   InstanceCallInstr* call_;
   bool is_negated_;
   DISALLOW_COPY_AND_ASSIGN(CheckedSmiComparisonInstr);
 };
 
-
 class BinaryIntegerOpInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   BinaryIntegerOpInstr(Token::Kind op_kind,
                        Value* left,
                        Value* right,
                        intptr_t deopt_id)
       : TemplateDefinition(deopt_id),
         op_kind_(op_kind),
         can_overflow_(true),
         is_truncating_(false) {
@@ skipping 31 matching lines @@
   bool RightIsPowerOfTwoConstant() const;
 
   RawInteger* Evaluate(const Integer& left, const Integer& right) const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
-
   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);
 
   const Token::Kind op_kind_;
 
   bool can_overflow_;
   bool is_truncating_;
 };
 
-
 class BinarySmiOpInstr : public BinaryIntegerOpInstr {
  public:
   BinarySmiOpInstr(Token::Kind op_kind,
                    Value* left,
                    Value* right,
                    intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id),
         right_range_(NULL) {}
 
   virtual bool ComputeCanDeoptimize() const;
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(BinarySmiOp)
 
   Range* right_range() const { return right_range_; }
 
  private:
   Range* right_range_;
 
   DISALLOW_COPY_AND_ASSIGN(BinarySmiOpInstr);
 };
 
-
 class BinaryInt32OpInstr : public BinaryIntegerOpInstr {
  public:
   BinaryInt32OpInstr(Token::Kind op_kind,
                      Value* left,
                      Value* right,
                      intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
@@ skipping 36 matching lines @@
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(BinaryInt32Op)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BinaryInt32OpInstr);
 };
 
-
 class BinaryUint32OpInstr : public BinaryIntegerOpInstr {
  public:
   BinaryUint32OpInstr(Token::Kind op_kind,
                       Value* left,
                       Value* right,
                       intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id) {
     mark_truncating();
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation representation() const { return kUnboxedUint32; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedUint32;
   }
 
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(BinaryUint32Op)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BinaryUint32OpInstr);
 };
 
-
 class ShiftUint32OpInstr : public BinaryIntegerOpInstr {
  public:
   ShiftUint32OpInstr(Token::Kind op_kind,
                      Value* left,
                      Value* right,
                      intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id) {
     ASSERT((op_kind == Token::kSHR) || (op_kind == Token::kSHL));
   }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Representation representation() const { return kUnboxedUint32; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return (idx == 0) ? kUnboxedUint32 : kTagged;
   }
 
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(ShiftUint32Op)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShiftUint32OpInstr);
 };
 
-
 class BinaryMintOpInstr : public BinaryIntegerOpInstr {
  public:
   BinaryMintOpInstr(Token::Kind op_kind,
                     Value* left,
                     Value* right,
                     intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id) {
     if (FLAG_limit_ints_to_64_bits) {
       mark_truncating();
     }
@@ skipping 27 matching lines @@
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(BinaryMintOp)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BinaryMintOpInstr);
 };
 
-
 class ShiftMintOpInstr : public BinaryIntegerOpInstr {
  public:
   ShiftMintOpInstr(Token::Kind op_kind,
                    Value* left,
                    Value* right,
                    intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id),
         shift_range_(NULL) {
     ASSERT((op_kind == Token::kSHR) || (op_kind == Token::kSHL));
     if (FLAG_limit_ints_to_64_bits) {
@@ skipping 25 matching lines @@
 
   // Returns true if the shift amount is guranteed to be in
   // [0..kMintShiftCountLimit] range.
   bool IsShiftCountInRange() const;
 
   Range* shift_range_;
 
   DISALLOW_COPY_AND_ASSIGN(ShiftMintOpInstr);
 };
 
-
 // Handles only NEGATE.
 class UnaryDoubleOpInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   UnaryDoubleOpInstr(Token::Kind op_kind, 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]; }
@@ skipping 20 matching lines @@
   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:
   enum Kind {
     // kOsrAndPreemption stack overflow checks are emitted in both unoptimized
     // and optimized versions of the code and they serve as both preemption and
     // OSR entry points.
     kOsrAndPreemption,
 
     // kOsrOnly stack overflow checks are only needed in the unoptimized code
     // because we can't OSR optimized code.
@@ skipping 26 matching lines @@
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   const intptr_t loop_depth_;
   const Kind kind_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowInstr);
 };
 
-
 // TODO(vegorov): remove this instruction in favor of Int32ToDouble.
 class SmiToDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   SmiToDoubleInstr(Value* value, TokenPosition token_pos)
       : token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(SmiToDouble)
   virtual CompileType ComputeType() const;
 
   virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(SmiToDoubleInstr);
 };
 
-
 class Int32ToDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   explicit Int32ToDoubleInstr(Value* value) { SetInputAt(0, value); }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(Int32ToDouble)
   virtual CompileType ComputeType() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t index) const {
     ASSERT(index == 0);
     return kUnboxedInt32;
   }
 
   virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32ToDoubleInstr);
 };
 
-
 class MintToDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   MintToDoubleInstr(Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(MintToDouble)
@@ skipping 12 matching lines @@
     return GetDeoptId();
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MintToDoubleInstr);
 };
 
-
 class DoubleToIntegerInstr : public TemplateDefinition<1, Throws> {
  public:
   DoubleToIntegerInstr(Value* value, InstanceCallInstr* instance_call)
       : TemplateDefinition(instance_call->deopt_id()),
         instance_call_(instance_call) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   DECLARE_INSTRUCTION(DoubleToInteger)
   virtual CompileType ComputeType() const;
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleToIntegerInstr);
 };
 
-
 // Similar to 'DoubleToIntegerInstr' but expects unboxed double as input
 // and creates a Smi.
 class DoubleToSmiInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   DoubleToSmiInstr(Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(DoubleToSmi)
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DoubleToSmiInstr);
 };
 
-
 class DoubleToDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   DoubleToDoubleInstr(Value* value,
                       MethodRecognizer::Kind recognized_kind,
                       intptr_t deopt_id)
       : TemplateDefinition(deopt_id), recognized_kind_(recognized_kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
@@ skipping 17 matching lines @@
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsDoubleToDouble()->recognized_kind() == recognized_kind();
   }
 
  private:
   const MethodRecognizer::Kind recognized_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleToDoubleInstr);
 };
 
-
 class DoubleToFloatInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   DoubleToFloatInstr(Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(DoubleToFloat)
@@ skipping 18 matching lines @@
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DoubleToFloatInstr);
 };
 
-
 class FloatToDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   FloatToDoubleInstr(Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(FloatToDouble)
@@ skipping 12 matching lines @@
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FloatToDoubleInstr);
 };
 
-
 class InvokeMathCFunctionInstr : public PureDefinition {
  public:
   InvokeMathCFunctionInstr(ZoneGrowableArray<Value*>* inputs,
                            intptr_t deopt_id,
                            MethodRecognizer::Kind recognized_kind,
                            TokenPosition token_pos);
 
   static intptr_t ArgumentCountFor(MethodRecognizer::Kind recognized_kind_);
 
   const RuntimeEntry& TargetFunction() const;
@@ skipping 38 matching lines @@
     (*inputs_)[i] = value;
   }
 
   ZoneGrowableArray<Value*>* inputs_;
   const MethodRecognizer::Kind recognized_kind_;
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(InvokeMathCFunctionInstr);
 };
 
-
 class ExtractNthOutputInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   // Extract the Nth output register from value.
   ExtractNthOutputInstr(Value* value,
                         intptr_t n,
                         Representation definition_rep,
                         intptr_t definition_cid)
       : index_(n),
         definition_rep_(definition_rep),
         definition_cid_(definition_cid) {
@@ skipping 28 matching lines @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const intptr_t index_;
   const Representation definition_rep_;
   const intptr_t definition_cid_;
   DISALLOW_COPY_AND_ASSIGN(ExtractNthOutputInstr);
 };
 
-
 class TruncDivModInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   TruncDivModInstr(Value* lhs, Value* rhs, intptr_t deopt_id);
 
   static intptr_t OutputIndexOf(Token::Kind token);
 
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
@@ skipping 21 matching lines @@
     // needs to cache range of the divisor in the operation to prevent
     // bugs when range information gets out of sync with the final decision
     // whether some instruction can deoptimize or not made in
     // EliminateEnvironments().
     return InputAt(1)->definition()->range();
   }
 
   DISALLOW_COPY_AND_ASSIGN(TruncDivModInstr);
 };
 
-
 class CheckClassInstr : public TemplateInstruction<1, NoThrow> {
  public:
   CheckClassInstr(Value* value,
                   intptr_t deopt_id,
                   const Cids& cids,
                   TokenPosition token_pos);
 
   DECLARE_INSTRUCTION(CheckClass)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
@@ skipping 42 matching lines @@
   void EmitBitTest(FlowGraphCompiler* compiler,
                    intptr_t min,
                    intptr_t max,
                    intptr_t mask,
                    Label* deopt);
   void EmitNullCheck(FlowGraphCompiler* compiler, Label* deopt);
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassInstr);
 };
 
-
 class CheckSmiInstr : public TemplateInstruction<1, NoThrow, Pure> {
  public:
   CheckSmiInstr(Value* value, intptr_t deopt_id, TokenPosition token_pos)
       : TemplateInstruction(deopt_id),
         token_pos_(token_pos),
         licm_hoisted_(false) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
@@ skipping 10 matching lines @@
   bool licm_hoisted() const { return licm_hoisted_; }
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
  private:
   const TokenPosition token_pos_;
   bool licm_hoisted_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
 };
 
-
 class CheckClassIdInstr : public TemplateInstruction<1, NoThrow> {
  public:
   CheckClassIdInstr(Value* value, CidRange cids, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), cids_(cids) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   const CidRange& cids() const { return cids_; }
 
@@ skipping 11 matching lines @@
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   bool Contains(intptr_t cid) const;
 
   CidRange cids_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassIdInstr);
 };
 
-
 class CheckArrayBoundInstr : public TemplateInstruction<2, NoThrow, Pure> {
  public:
   CheckArrayBoundInstr(Value* length, Value* index, intptr_t deopt_id)
       : TemplateInstruction(deopt_id),
         generalized_(false),
         licm_hoisted_(false) {
     SetInputAt(kLengthPos, length);
     SetInputAt(kIndexPos, index);
   }
 
@@ skipping 22 matching lines @@
   // Give a name to the location/input indices.
   enum { kLengthPos = 0, kIndexPos = 1 };
 
  private:
   bool generalized_;
   bool licm_hoisted_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckArrayBoundInstr);
 };
 
-
 class GenericCheckBoundInstr : public TemplateInstruction<2, Throws, NoCSE> {
  public:
   GenericCheckBoundInstr(Value* length, Value* index, intptr_t deopt_id)
       : TemplateInstruction(deopt_id) {
     SetInputAt(kLengthPos, length);
     SetInputAt(kIndexPos, index);
   }
 
   Value* length() const { return inputs_[kLengthPos]; }
   Value* index() const { return inputs_[kIndexPos]; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   DECLARE_INSTRUCTION(GenericCheckBound)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   // Give a name to the location/input indices.
   enum { kLengthPos = 0, kIndexPos = 1 };
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GenericCheckBoundInstr);
 };
 
-
 class UnboxedIntConverterInstr : public TemplateDefinition<1, NoThrow> {
  public:
   UnboxedIntConverterInstr(Representation from,
                            Representation to,
                            Value* value,
                            intptr_t deopt_id)
       : TemplateDefinition(deopt_id),
         from_representation_(from),
         to_representation_(to),
         is_truncating_(to == kUnboxedUint32) {
@@ skipping 45 matching lines @@
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const Representation from_representation_;
   const Representation to_representation_;
   bool is_truncating_;
 
   DISALLOW_COPY_AND_ASSIGN(UnboxedIntConverterInstr);
 };
 
-
 #undef DECLARE_INSTRUCTION
 
 class Environment : public ZoneAllocated {
  public:
   // Iterate the non-NULL values in the innermost level of an environment.
   class ShallowIterator : public ValueObject {
    public:
     explicit ShallowIterator(Environment* environment)
         : environment_(environment), index_(0) {}
 
@@ skipping 190 matching lines @@
               intptr_t deopt_id,
               const ParsedFunction& parsed_function,
               Environment* outer)
       : values_(length),
         locations_(NULL),
         fixed_parameter_count_(fixed_parameter_count),
         deopt_id_(deopt_id),
         parsed_function_(parsed_function),
         outer_(outer) {}
 
-
   GrowableArray<Value*> values_;
   Location* locations_;
   const intptr_t fixed_parameter_count_;
   intptr_t deopt_id_;
   const ParsedFunction& parsed_function_;
   Environment* outer_;
 
   DISALLOW_COPY_AND_ASSIGN(Environment);
 };
 
-
 // Visitor base class to visit each instruction and computation in a flow
 // graph as defined by a reversed list of basic blocks.
 class FlowGraphVisitor : public ValueObject {
  public:
   explicit FlowGraphVisitor(const GrowableArray<BlockEntryInstr*>& block_order)
       : current_iterator_(NULL), block_order_(block_order) {}
   virtual ~FlowGraphVisitor() {}
 
   ForwardInstructionIterator* current_iterator() const {
     return current_iterator_;
@@ skipping 13 matching lines @@
 #undef DECLARE_VISIT_INSTRUCTION
 
  protected:
   ForwardInstructionIterator* current_iterator_;
 
  private:
   const GrowableArray<BlockEntryInstr*>& block_order_;
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
-
 // Helper macros for platform ports.
 #define DEFINE_UNIMPLEMENTED_INSTRUCTION(Name)                                 \
   LocationSummary* Name::MakeLocationSummary(Zone* zone, bool opt) const {     \
     UNIMPLEMENTED();                                                           \
     return NULL;                                                               \
   }                                                                            \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
-
 }  // namespace dart
 
 #endif  // RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_