clang-format runtime/vm

runtime/vm/intermediate_language.h

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 #define RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 35 matching lines @@
 //
 // Values of CompileType form a lattice with a None type as a bottom and a
 // nullable Dynamic type as a top element. Method Union provides a join
 // operation for the lattice.
 class CompileType : public ValueObject {
  public:
   static const bool kNullable = true;
   static const bool kNonNullable = false;
 
   CompileType(bool is_nullable, intptr_t cid, const AbstractType* type)
-      : is_nullable_(is_nullable), cid_(cid), type_(type) { }
+      : is_nullable_(is_nullable), cid_(cid), type_(type) {}
 
   CompileType(const CompileType& other)
       : ValueObject(),
         is_nullable_(other.is_nullable_),
         cid_(other.cid_),
-        type_(other.type_) { }
+        type_(other.type_) {}
 
   CompileType& operator=(const CompileType& other) {
     is_nullable_ = other.is_nullable_;
     cid_ = other.cid_;
-    type_ =  other.type_;
+    type_ = other.type_;
     return *this;
   }
 
   bool is_nullable() const { return is_nullable_; }
 
   // Return type such that concrete value's type in runtime is guaranteed to
   // be subtype of it.
   const AbstractType* ToAbstractType();
 
   // Return class id such that it is either kDynamicCid or in runtime
@@ skipping 11 matching lines @@
   // Returns true if the value is known to be always null.
   bool IsNull();
 
   // Returns true if this type is more specific than given type.
   bool IsMoreSpecificThan(const AbstractType& other);
 
   // Returns true if value of this type is assignable to a location of the
   // given type.
   bool IsAssignableTo(const AbstractType& type) {
     bool is_instance;
-    return CanComputeIsInstanceOf(type, kNullable, &is_instance) &&
-           is_instance;
+    return CanComputeIsInstanceOf(type, kNullable, &is_instance) && is_instance;
   }
 
   // Create a new CompileType representing given combination of class id and
   // abstract type. The pair is assumed to be coherent.
   static CompileType Create(intptr_t cid, const AbstractType& type);
 
   CompileType CopyNonNullable() const {
     return CompileType(kNonNullable, cid_, type_);
   }
 
@@ skipping 33 matching lines @@
 
   // Create non-nullable String type.
   static CompileType String();
 
   // Perform a join operation over the type lattice.
   void Union(CompileType* other);
 
   // Returns true if this and other types are the same.
   bool IsEqualTo(CompileType* other) {
     return (is_nullable_ == other->is_nullable_) &&
-        (ToNullableCid() == other->ToNullableCid()) &&
-        (ToAbstractType()->Equals(*other->ToAbstractType()));
+           (ToNullableCid() == other->ToNullableCid()) &&
+           (ToAbstractType()->Equals(*other->ToAbstractType()));
   }
 
-  bool IsNone() const {
-    return (cid_ == kIllegalCid) && (type_ == NULL);
-  }
+  bool IsNone() const { return (cid_ == kIllegalCid) && (type_ == NULL); }
 
   bool IsInt() {
-    return !is_nullable() &&
-      ((ToCid() == kSmiCid) ||
-       (ToCid() == kMintCid) ||
-       ((type_ != NULL) && (type_->Equals(Type::Handle(Type::IntType())))));
+    return !is_nullable() && ((ToCid() == kSmiCid) || (ToCid() == kMintCid) ||
+                              ((type_ != NULL) &&
+                               (type_->Equals(Type::Handle(Type::IntType())))));
   }
 
   void PrintTo(BufferFormatter* f) const;
   const char* ToCString() const;
 
  private:
   bool CanComputeIsInstanceOf(const AbstractType& type,
                               bool is_nullable,
                               bool* is_instance);
 
   bool is_nullable_;
   intptr_t cid_;
   const AbstractType* type_;
 };
 
 
 // Zone allocated wrapper for the CompileType value.
 class ZoneCompileType : public ZoneAllocated {
  public:
   static CompileType* Wrap(const CompileType& type) {
     ZoneCompileType* zone_type = new ZoneCompileType(type);
     return zone_type->ToCompileType();
   }
 
-  CompileType* ToCompileType() {
-    return &type_;
-  }
+  CompileType* ToCompileType() { return &type_; }
 
  protected:
-  explicit ZoneCompileType(const CompileType& type) : type_(type) { }
+  explicit ZoneCompileType(const CompileType& type) : type_(type) {}
 
   CompileType type_;
 };
 
 
 // ConstrainedCompileType represents a compile type that is computed from
 // another compile type.
 class ConstrainedCompileType : public ZoneCompileType {
  public:
-  virtual ~ConstrainedCompileType() { }
+  virtual ~ConstrainedCompileType() {}
 
   // Recompute compile type.
   virtual void Update() = 0;
 
  protected:
   explicit ConstrainedCompileType(const CompileType& type)
-      : ZoneCompileType(type) { }
+      : ZoneCompileType(type) {}
 };
 
 
 // NotNullConstrainedCompileType represents not-null constraint applied to
 // the source compile type. Result is non-nullable version of the incoming
 // compile type. It is used to represent compile type propagated downwards
 // from strict comparison with the null constant.
 class NotNullConstrainedCompileType : public ConstrainedCompileType {
  public:
   explicit NotNullConstrainedCompileType(CompileType* source)
-      : ConstrainedCompileType(source->CopyNonNullable()), source_(source) { }
+      : ConstrainedCompileType(source->CopyNonNullable()), source_(source) {}
 
-  virtual void Update() {
-    type_ = source_->CopyNonNullable();
-  }
+  virtual void Update() { type_ = source_->CopyNonNullable(); }
 
  private:
   CompileType* source_;
 };
 
 
 class EffectSet : public ValueObject {
  public:
   enum Effects {
     kNoEffects = 0,
     kExternalization = 1,
     kLastEffect = kExternalization
   };
 
-  EffectSet(const EffectSet& other)
-      : ValueObject(), effects_(other.effects_) {
-  }
+  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);
-  }
+  static EffectSet Externalization() { return EffectSet(kExternalization); }
 
   bool ToInt() { return effects_; }
 
  private:
-  explicit EffectSet(intptr_t effects) : effects_(effects) { }
+  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() {
       // Pre-fetch next on advance and cache it.
       current_ = next_;
       if (next_ != NULL) next_ = next_->next_use();
     }
+
    private:
     Value* current_;
     Value* next_;
   };
 
   explicit Value(Definition* definition)
       : definition_(definition),
         previous_use_(NULL),
         next_use_(NULL),
         instruction_(NULL),
         use_index_(-1),
-        reaching_type_(NULL) { }
+        reaching_type_(NULL) {}
 
   Definition* definition() const { return definition_; }
   void set_definition(Definition* definition) { definition_ = definition; }
 
   Value* previous_use() const { return previous_use_; }
   void set_previous_use(Value* previous) { previous_use_ = previous; }
 
   Value* next_use() const { return next_use_; }
   void set_next_use(Value* next) { next_use_ = next; }
 
   bool IsSingleUse() const {
     return (next_use_ == NULL) && (previous_use_ == NULL);
   }
 
   Instruction* instruction() const { return instruction_; }
   void set_instruction(Instruction* instruction) { instruction_ = instruction; }
 
   intptr_t use_index() const { return use_index_; }
   void set_use_index(intptr_t index) { use_index_ = index; }
 
   static void AddToList(Value* value, Value** list);
   void RemoveFromUseList();
 
   // Change the definition after use lists have been computed.
   inline void BindTo(Definition* definition);
   inline void BindToEnvironment(Definition* definition);
 
-  Value* Copy(Zone* zone) { return new(zone) Value(definition_); }
+  Value* Copy(Zone* zone) { return new (zone) Value(definition_); }
 
   // This function must only be used when the new Value is dominated by
   // the original Value.
   Value* CopyWithType() {
     Value* copy = new Value(definition_);
     copy->reaching_type_ = reaching_type_;
     return copy;
   }
 
   CompileType* Type();
 
-  void SetReachingType(CompileType* type) {
-    reaching_type_ = type;
-  }
+  void SetReachingType(CompileType* type) { reaching_type_ = type; }
 
   void PrintTo(BufferFormatter* f) const;
 
   const char* ToCString() const;
 
   bool IsSmiValue() { return Type()->ToCid() == kSmiCid; }
 
   // Return true if the value represents a constant.
   bool BindsToConstant() const;
 
@@ skipping 19 matching lines @@
   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>
+template <typename T, intptr_t N>
 class EmbeddedArray {
  public:
-  EmbeddedArray() : elements_() { }
+  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];
-  }
+  const T& At(intptr_t i) const { return (*this)[i]; }
 
-  void SetAt(intptr_t i, const T& val) {
-    (*this)[i] = val;
-  }
+  void SetAt(intptr_t i, const T& val) { (*this)[i] = val; }
 
  private:
   T elements_[N];
 };
 
 
-template<typename T>
+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();
@@ skipping 149 matching lines @@
   M(UnboxedIntConverter)                                                       \
   M(GrowRegExpStack)                                                           \
   M(Deoptimize)
 
 #define FOR_EACH_ABSTRACT_INSTRUCTION(M)                                       \
   M(BlockEntry)                                                                \
   M(BoxInteger)                                                                \
   M(UnboxInteger)                                                              \
   M(Comparison)                                                                \
   M(UnaryIntegerOp)                                                            \
-  M(BinaryIntegerOp)                                                           \
+  M(BinaryIntegerOp)
 
 #define FORWARD_DECLARATION(type) class type##Instr;
 FOR_EACH_INSTRUCTION(FORWARD_DECLARATION)
 FOR_EACH_ABSTRACT_INSTRUCTION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 #define DEFINE_INSTRUCTION_TYPE_CHECK(type)                                    \
   virtual type##Instr* As##type() { return this; }                             \
-  virtual const char* DebugName() const { return #type; }                      \
+  virtual const char* DebugName() const { return #type; }
 
 // Functions required in all concrete instruction classes.
 #define DECLARE_INSTRUCTION_NO_BACKEND(type)                                   \
   virtual Tag tag() const { return k##type; }                                  \
   virtual void Accept(FlowGraphVisitor* visitor);                              \
   DEFINE_INSTRUCTION_TYPE_CHECK(type)
 
 #define DECLARE_INSTRUCTION_BACKEND()                                          \
-  virtual LocationSummary* MakeLocationSummary(Zone* zone,                     \
-                                               bool optimizing) const;         \
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);                    \
+  virtual LocationSummary* MakeLocationSummary(Zone* zone, bool optimizing)    \
+      const;                                                                   \
+  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
 // Functions required in all concrete instruction classes.
 #define DECLARE_INSTRUCTION(type)                                              \
   DECLARE_INSTRUCTION_NO_BACKEND(type)                                         \
-  DECLARE_INSTRUCTION_BACKEND()                                                \
+  DECLARE_INSTRUCTION_BACKEND()
 
 #ifndef PRODUCT
-#define PRINT_TO_SUPPORT                                                       \
-    virtual void PrintTo(BufferFormatter* f) const;
+#define PRINT_TO_SUPPORT virtual void PrintTo(BufferFormatter* f) const;
 #else
 #define PRINT_TO_SUPPORT
 #endif  // !PRODUCT
 
 #ifndef PRODUCT
 #define PRINT_OPERANDS_TO_SUPPORT                                              \
-    virtual void PrintOperandsTo(BufferFormatter* f) const;
+  virtual void PrintOperandsTo(BufferFormatter* f) const;
 #else
 #define PRINT_OPERANDS_TO_SUPPORT
 #endif  // !PRODUCT
 
 class Instruction : public ZoneAllocated {
  public:
 #define DECLARE_TAG(type) k##type,
-  enum Tag {
-    FOR_EACH_INSTRUCTION(DECLARE_TAG)
-  };
+  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),
         next_(NULL),
         env_(NULL),
         locs_(NULL),
-        inlining_id_(-1) { }
+        inlining_id_(-1) {}
 
-  virtual ~Instruction() { }
+  virtual ~Instruction() {}
 
   virtual Tag tag() const = 0;
 
   intptr_t deopt_id() const {
     ASSERT(CanDeoptimize() || CanBecomeDeoptimizationTarget());
     return GetDeoptId();
   }
 
   const ICData* GetICData(
       const ZoneGrowableArray<const ICData*>& ic_data_array) const;
 
-  virtual TokenPosition token_pos() const {
-    return TokenPosition::kNoSource;
-  }
+  virtual TokenPosition token_pos() const { return TokenPosition::kNoSource; }
 
   virtual intptr_t InputCount() const = 0;
   virtual Value* InputAt(intptr_t i) const = 0;
   void SetInputAt(intptr_t i, Value* value) {
     ASSERT(value != NULL);
     value->set_instruction(this);
     value->set_use_index(i);
     RawSetInputAt(i, value);
   }
 
@@ skipping 74 matching lines @@
   virtual void PrintTo(BufferFormatter* f) const;
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 #endif
 
 #define DECLARE_INSTRUCTION_TYPE_CHECK(Name, Type)                             \
   bool Is##Name() { return (As##Name() != NULL); }                             \
   virtual Type* As##Name() { return NULL; }
 #define INSTRUCTION_TYPE_CHECK(Name)                                           \
   DECLARE_INSTRUCTION_TYPE_CHECK(Name, Name##Instr)
 
-DECLARE_INSTRUCTION_TYPE_CHECK(Definition, Definition)
-FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
-FOR_EACH_ABSTRACT_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
+  DECLARE_INSTRUCTION_TYPE_CHECK(Definition, Definition)
+  FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
+  FOR_EACH_ABSTRACT_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
 
 #undef INSTRUCTION_TYPE_CHECK
 #undef DECLARE_INSTRUCTION_TYPE_CHECK
 
   // Returns structure describing location constraints required
   // to emit native code for this instruction.
   LocationSummary* locs() {
     ASSERT(locs_ != NULL);
     return locs_;
   }
 
   bool HasLocs() const { return locs_ != NULL; }
 
   virtual LocationSummary* MakeLocationSummary(Zone* zone,
                                                bool is_optimizing) const = 0;
 
   void InitializeLocationSummary(Zone* zone, bool optimizing) {
     ASSERT(locs_ == NULL);
     locs_ = MakeLocationSummary(zone, optimizing);
   }
 
   static LocationSummary* MakeCallSummary(Zone* zone);
 
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
-    UNIMPLEMENTED();
-  }
+  virtual void EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
   Environment* env() const { return env_; }
   void SetEnvironment(Environment* deopt_env);
   void RemoveEnvironment();
 
   intptr_t lifetime_position() const { return lifetime_position_; }
-  void set_lifetime_position(intptr_t pos) {
-    lifetime_position_ = pos;
-  }
+  void set_lifetime_position(intptr_t pos) { lifetime_position_ = pos; }
 
   bool HasUnmatchedInputRepresentations() const;
 
   // Returns representation expected for the input operand at the given index.
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     return kTagged;
   }
 
   // Representation of the value produced by this computation.
-  virtual Representation representation() const {
-    return kTagged;
-  }
+  virtual Representation representation() const { return kTagged; }
 
-  bool WasEliminated() const {
-    return next() == NULL;
-  }
+  bool WasEliminated() const { return next() == NULL; }
 
   // Returns deoptimization id that corresponds to the deoptimization target
   // that input operands conversions inserted for this instruction can jump
   // to.
   virtual intptr_t DeoptimizationTarget() const {
     UNREACHABLE();
     return Thread::kNoDeoptId;
   }
 
   // Returns a replacement for the instruction or NULL if the instruction can
   // be eliminated.  By default returns the this instruction which means no
   // change.
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   // Insert this instruction before 'next' after use lists are computed.
   // Instructions cannot be inserted before a block entry or any other
   // instruction without a previous instruction.
   void InsertBefore(Instruction* next) { InsertAfter(next->previous()); }
 
   // Insert this instruction after 'prev' after use lists are computed.
   void InsertAfter(Instruction* prev);
 
   // Append an instruction to the current one and return the tail.
   // This function updated def-use chains of the newly appended
   // instruction.
   Instruction* AppendInstruction(Instruction* tail);
 
-  virtual bool AllowsDCE() const {
-    return false;
-  }
+  virtual bool AllowsDCE() const { return false; }
 
   // Returns true if CSE and LICM are allowed for this instruction.
-  virtual bool AllowsCSE() const {
-    return false;
-  }
+  virtual bool AllowsCSE() const { return false; }
 
   // Returns set of effects created by this instruction.
   virtual EffectSet Effects() const = 0;
 
   // Returns set of effects that affect this instruction.
   virtual EffectSet Dependencies() const {
     UNREACHABLE();
     return EffectSet::All();
   }
 
@@ skipping 28 matching lines @@
     UNREACHABLE();
     return false;
   }
 
   virtual void InheritDeoptTarget(Zone* zone, Instruction* other);
 
   bool NeedsEnvironment() const {
     return CanDeoptimize() || CanBecomeDeoptimizationTarget();
   }
 
-  virtual bool CanBecomeDeoptimizationTarget() const {
-    return false;
-  }
+  virtual bool CanBecomeDeoptimizationTarget() const { return false; }
 
   void InheritDeoptTargetAfter(FlowGraph* flow_graph,
                                Definition* call,
                                Definition* result);
 
   virtual bool MayThrow() const = 0;
 
   bool IsDominatedBy(Instruction* dom);
 
   void ClearEnv() { env_ = NULL; }
 
   void Unsupported(FlowGraphCompiler* compiler);
 
  protected:
   // GetDeoptId and/or CopyDeoptIdFrom.
   friend class CallSiteInliner;
   friend class LICM;
   friend class ComparisonInstr;
   friend class Scheduler;
   friend class BlockEntryInstr;
   friend class CatchBlockEntryInstr;  // deopt_id_
 
   // Fetch deopt id without checking if this computation can deoptimize.
-  intptr_t GetDeoptId() const {
-    return deopt_id_;
-  }
+  intptr_t GetDeoptId() const { return deopt_id_; }
 
   void CopyDeoptIdFrom(const Instruction& instr) {
     deopt_id_ = instr.deopt_id_;
   }
 
  private:
-  friend class BranchInstr;  // For RawSetInputAt.
+  friend class BranchInstr;      // For RawSetInputAt.
   friend class IfThenElseInstr;  // For RawSetInputAt.
 
   virtual void RawSetInputAt(intptr_t i, Value* value) = 0;
 
-  enum {
-    kNoPlaceId = -1
-  };
+  enum { kNoPlaceId = -1 };
 
   intptr_t deopt_id_;
   union {
     intptr_t lifetime_position_;  // Position used by register allocator.
     intptr_t place_id_;
   };
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   LocationSummary* locs_;
   intptr_t inlining_id_;
 
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 class PureInstruction : public Instruction {
  public:
-  explicit PureInstruction(intptr_t deopt_id)
-      : Instruction(deopt_id) { }
+  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>
+template <typename DefaultBase, typename PureBase>
 struct Pure {
   typedef PureBase Base;
 };
 
 
-template<typename DefaultBase, typename PureBase>
+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 {
+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_() { }
+      : 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;
-  }
+  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) { }
+  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_; }
 
   void set_src(const Location& value) { src_ = value; }
   void set_dest(const Location& value) { dest_ = value; }
 
@@ skipping 37 matching lines @@
  private:
   Location dest_;
   Location src_;
 
   DISALLOW_COPY_AND_ASSIGN(MoveOperands);
 };
 
 
 class ParallelMoveInstr : public TemplateInstruction<0, NoThrow> {
  public:
-  ParallelMoveInstr() : moves_(4) { }
+  ParallelMoveInstr() : moves_(4) {}
 
   DECLARE_INSTRUCTION(ParallelMove)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const {
     UNREACHABLE();  // This instruction never visited by optimization passes.
     return EffectSet::None();
@@ skipping 16 matching lines @@
 
   bool IsRedundant() const;
 
   virtual TokenPosition token_pos() const {
     return TokenPosition::kParallelMove;
   }
 
   PRINT_TO_SUPPORT
 
  private:
-  GrowableArray<MoveOperands*> moves_;   // Elements cannot be null.
+  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;
 
   intptr_t preorder_number() const { return preorder_number_; }
   void set_preorder_number(intptr_t number) { preorder_number_ = number; }
 
   intptr_t postorder_number() const { return postorder_number_; }
   void set_postorder_number(intptr_t number) { postorder_number_ = number; }
 
   intptr_t block_id() const { return block_id_; }
 
   // NOTE: These are SSA positions and not token positions. These are used by
   // the register allocator.
   void set_start_pos(intptr_t pos) { start_pos_ = pos; }
   intptr_t start_pos() const { return start_pos_; }
-  void  set_end_pos(intptr_t pos) { end_pos_ = pos; }
+  void set_end_pos(intptr_t pos) { end_pos_ = pos; }
   intptr_t end_pos() const { return end_pos_; }
 
   BlockEntryInstr* dominator() const { return dominator_; }
   BlockEntryInstr* ImmediateDominator() const;
 
   const GrowableArray<BlockEntryInstr*>& dominated_blocks() {
     return dominated_blocks_;
   }
 
   void AddDominatedBlock(BlockEntryInstr* block) {
     block->set_dominator(this);
     dominated_blocks_.Add(block);
   }
   void ClearDominatedBlocks() { dominated_blocks_.Clear(); }
 
   bool Dominates(BlockEntryInstr* other) const;
 
   Instruction* last_instruction() const { return last_instruction_; }
   void set_last_instruction(Instruction* instr) { last_instruction_ = instr; }
 
-  ParallelMoveInstr* parallel_move() const {
-    return parallel_move_;
-  }
+  ParallelMoveInstr* parallel_move() const { return parallel_move_; }
 
-  bool HasParallelMove() const {
-    return parallel_move_ != NULL;
-  }
+  bool HasParallelMove() const { return parallel_move_ != NULL; }
 
   bool HasNonRedundantParallelMove() const {
     return HasParallelMove() && !parallel_move()->IsRedundant();
   }
 
   ParallelMoveInstr* GetParallelMove() {
     if (parallel_move_ == NULL) {
       parallel_move_ = new ParallelMoveInstr();
     }
     return parallel_move_;
   }
 
   // Discover basic-block structure of the current block.  Must be called
   // on all graph blocks in preorder to yield valid results.  As a side effect,
   // the block entry instructions in the graph are assigned preorder numbers.
   // The array 'preorder' maps preorder block numbers to the block entry
   // instruction with that number.  The depth first spanning tree is recorded
   // in the array 'parent', which maps preorder block numbers to the preorder
   // number of the block's spanning-tree parent.  As a side effect of this
   // function, the set of basic block predecessors (e.g., block entry
   // instructions of predecessor blocks) and also the last instruction in the
   // block is recorded in each entry instruction.  Returns true when called the
   // first time on this particular block within one graph traversal, and false
   // on all successive calls.
-  bool DiscoverBlock(
-      BlockEntryInstr* predecessor,
-      GrowableArray<BlockEntryInstr*>* preorder,
-      GrowableArray<intptr_t>* parent);
+  bool DiscoverBlock(BlockEntryInstr* predecessor,
+                     GrowableArray<BlockEntryInstr*>* preorder,
+                     GrowableArray<intptr_t>* parent);
 
   // Perform a depth first search to prune code not reachable from an OSR
   // entry point.
   bool PruneUnreachable(GraphEntryInstr* graph_entry,
                         Instruction* parent,
                         intptr_t osr_id,
                         BitVector* block_marks);
 
   virtual intptr_t InputCount() const { return 0; }
   virtual Value* InputAt(intptr_t i) const {
@@ skipping 10 matching lines @@
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   virtual bool MayThrow() const { return false; }
 
   intptr_t try_index() const { return try_index_; }
-  void set_try_index(intptr_t index) {
-    try_index_ = index;
-  }
+  void set_try_index(intptr_t index) { try_index_ = index; }
 
   // True for blocks inside a try { } region.
   bool InsideTryBlock() const {
     return try_index_ != CatchClauseNode::kInvalidTryIndex;
   }
 
   BitVector* loop_info() const { return loop_info_; }
-  void set_loop_info(BitVector* loop_info) {
-    loop_info_ = loop_info;
-  }
+  void set_loop_info(BitVector* loop_info) { loop_info_ = loop_info; }
 
-  virtual BlockEntryInstr* GetBlock() {
-    return this;
-  }
+  virtual BlockEntryInstr* GetBlock() { return this; }
 
   virtual TokenPosition token_pos() const {
     return TokenPosition::kControlFlow;
   }
 
   // Helper to mutate the graph during inlining. This block should be
   // replaced with new_block as a predecessor of all of this block's
   // successors.
   void ReplaceAsPredecessorWith(BlockEntryInstr* new_block);
 
@@ skipping 13 matching lines @@
       : Instruction(Thread::Current()->GetNextDeoptId()),
         block_id_(block_id),
         try_index_(try_index),
         preorder_number_(-1),
         postorder_number_(-1),
         dominator_(NULL),
         dominated_blocks_(1),
         last_instruction_(NULL),
         offset_(-1),
         parallel_move_(NULL),
-        loop_info_(NULL) {
-  }
+        loop_info_(NULL) {}
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   virtual void ClearPredecessors() = 0;
   virtual void AddPredecessor(BlockEntryInstr* predecessor) = 0;
 
   void set_dominator(BlockEntryInstr* instr) { dominator_ = instr; }
 
   intptr_t block_id_;
@@ skipping 115 matching lines @@
   // Number of stack slots reserved for compiling try-catch. For functions
   // without try-catch, this is 0. Otherwise, it is the number of local
   // variables.
   intptr_t fixed_slot_count() const { return fixed_slot_count_; }
   void set_fixed_slot_count(intptr_t count) {
     ASSERT(count >= 0);
     fixed_slot_count_ = count;
   }
   TargetEntryInstr* normal_entry() const { return normal_entry_; }
 
-  const ParsedFunction& parsed_function() const {
-    return parsed_function_;
-  }
+  const ParsedFunction& parsed_function() const { return parsed_function_; }
 
   const GrowableArray<CatchBlockEntryInstr*>& catch_entries() const {
     return catch_entries_;
   }
 
   const GrowableArray<IndirectEntryInstr*>& indirect_entries() const {
     return indirect_entries_;
   }
 
   PRINT_TO_SUPPORT
@@ skipping 15 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(GraphEntryInstr);
 };
 
 
 class JoinEntryInstr : public BlockEntryInstr {
  public:
   JoinEntryInstr(intptr_t block_id, intptr_t try_index)
       : BlockEntryInstr(block_id, try_index),
         predecessors_(2),  // Two is the assumed to be the common case.
-        phis_(NULL) { }
+        phis_(NULL) {}
 
   DECLARE_INSTRUCTION(JoinEntry)
 
   virtual intptr_t PredecessorCount() const { return predecessors_.length(); }
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const {
     return predecessors_[index];
   }
 
   // Returns -1 if pred is not in the list.
   intptr_t IndexOfPredecessor(BlockEntryInstr* pred) const;
@@ skipping 27 matching lines @@
 
   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) { }
+  explicit PhiIterator(JoinEntryInstr* join) : phis_(join->phis()), index_(0) {}
 
   void Advance() {
     ASSERT(!Done());
     index_++;
   }
 
-  bool Done() const {
-    return (phis_ == NULL) || (index_ >= phis_->length());
-  }
+  bool Done() const { return (phis_ == NULL) || (index_ >= phis_->length()); }
 
-  PhiInstr* Current() const {
-    return (*phis_)[index_];
-  }
+  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)
       : BlockEntryInstr(block_id, try_index),
         predecessor_(NULL),
-        edge_weight_(0.0) { }
+        edge_weight_(0.0) {}
 
   DECLARE_INSTRUCTION(TargetEntry)
 
   double edge_weight() const { return edge_weight_; }
   void set_edge_weight(double weight) { edge_weight_ = weight; }
   void adjust_edge_weight(double scale_factor) { edge_weight_ *= scale_factor; }
 
   virtual intptr_t PredecessorCount() const {
     return (predecessor_ == NULL) ? 0 : 1;
   }
@@ skipping 18 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TargetEntryInstr);
 };
 
 
 class IndirectEntryInstr : public JoinEntryInstr {
  public:
   IndirectEntryInstr(intptr_t block_id,
                      intptr_t indirect_id,
                      intptr_t try_index)
-      : JoinEntryInstr(block_id, try_index),
-        indirect_id_(indirect_id) { }
+      : JoinEntryInstr(block_id, try_index), indirect_id_(indirect_id) {}
 
   DECLARE_INSTRUCTION(IndirectEntry)
 
   intptr_t indirect_id() const { return indirect_id_; }
 
   PRINT_TO_SUPPORT
 
  private:
   const intptr_t indirect_id_;
 };
@@ skipping 35 matching lines @@
 
   GraphEntryInstr* graph_entry() const { return graph_entry_; }
 
   const LocalVariable& exception_var() const { return exception_var_; }
   const LocalVariable& stacktrace_var() const { return stacktrace_var_; }
 
   bool needs_stacktrace() const { return needs_stacktrace_; }
 
   // Returns try index for the try block to which this catch handler
   // corresponds.
-  intptr_t catch_try_index() const {
-    return catch_try_index_;
-  }
+  intptr_t catch_try_index() const { return catch_try_index_; }
   GrowableArray<Definition*>* initial_definitions() {
     return &initial_definitions_;
   }
 
   PRINT_TO_SUPPORT
 
  private:
   friend class BlockEntryInstr;  // Access to predecessor_ when inlining.
 
   virtual void ClearPredecessors() { predecessor_ = NULL; }
@@ skipping 43 matching lines @@
   }
 
   bool IsUnknown() const { return value_ == kUnknown; }
   bool IsAliased() const { return value_ == kAliased; }
   bool IsNotAliased() const { return (value_ & kNotAliased) != 0; }
   bool IsAllocationSinkingCandidate() const {
     return value_ == kAllocationSinkingCandidate;
   }
 
   AliasIdentity(const AliasIdentity& other)
-      : ValueObject(), value_(other.value_) {
-  }
+      : ValueObject(), value_(other.value_) {}
 
   AliasIdentity& operator=(const AliasIdentity& other) {
     value_ = other.value_;
     return *this;
   }
 
  private:
-  explicit AliasIdentity(intptr_t value) : value_(value) { }
+  explicit AliasIdentity(intptr_t value) : value_(value) {}
 
   enum {
     kUnknown = 0,
     kNotAliased = 1,
     kAliased = 2,
     kAllocationSinkingCandidate = 3,
   };
 
   COMPILE_ASSERT((kUnknown & kNotAliased) == 0);
   COMPILE_ASSERT((kAliased & kNotAliased) == 0);
@@ skipping 43 matching lines @@
     if (type_ == NULL) {
       type_ = ZoneCompileType::Wrap(ComputeType());
     }
     return type_;
   }
 
   // Does this define a mint?
   inline bool IsMintDefinition();
 
   bool IsInt32Definition() {
-    return IsBinaryInt32Op() ||
-           IsBoxInt32() ||
-           IsUnboxInt32() ||
+    return IsBinaryInt32Op() || IsBoxInt32() || IsUnboxInt32() ||
            IsUnboxedIntConverter();
   }
 
   // Compute compile type for this definition. It is safe to use this
   // approximation even before type propagator was run (e.g. during graph
   // building).
-  virtual CompileType ComputeType() const {
-    return CompileType::Dynamic();
-  }
+  virtual CompileType ComputeType() const { return CompileType::Dynamic(); }
 
   // Update CompileType of the definition. Returns true if the type has changed.
-  virtual bool RecomputeType() {
-    return false;
-  }
+  virtual bool RecomputeType() { return false; }
 
   PRINT_OPERANDS_TO_SUPPORT
   PRINT_TO_SUPPORT
 
   bool UpdateType(CompileType new_type) {
     if (type_ == NULL) {
       type_ = ZoneCompileType::Wrap(new_type);
       return true;
     }
 
@@ skipping 57 matching lines @@
     return this;
   }
 
   void SetReplacement(Definition* other) {
     ASSERT(ssa_temp_index_ >= 0);
     ASSERT(WasEliminated());
     ssa_temp_index_ = kReplacementMarker;
     temp_index_ = reinterpret_cast<intptr_t>(other);
   }
 
-  virtual AliasIdentity Identity() const {
-    return AliasIdentity::Unknown();
-  }
+  virtual AliasIdentity Identity() const { return AliasIdentity::Unknown(); }
 
-  virtual void SetIdentity(AliasIdentity identity) {
-    UNREACHABLE();
-  }
+  virtual void SetIdentity(AliasIdentity identity) { UNREACHABLE(); }
 
   Definition* OriginalDefinition();
 
   virtual Definition* AsDefinition() { return this; }
 
  protected:
   friend class RangeAnalysis;
   friend class Value;
 
   Range* range_;
@@ skipping 21 matching lines @@
 
 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) { }
+  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>
+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_() { }
+      : 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;
-  }
+  virtual void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 };
 
 
 struct BranchLabels {
   Label* true_label;
   Label* false_label;
   Label* fall_through;
 };
 
 
 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) {
+      : block_(block),
+        inputs_(num_inputs),
+        representation_(kTagged),
+        reaching_defs_(NULL),
+        loop_variable_info_(NULL),
+        is_alive_(false),
+        is_receiver_(kUnknownReceiver) {
     for (intptr_t i = 0; i < num_inputs; ++i) {
       inputs_.Add(NULL);
     }
   }
 
   // Get the block entry for that instruction.
   virtual BlockEntryInstr* GetBlock() { return block(); }
   JoinEntryInstr* block() const { return block_; }
 
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
   intptr_t InputCount() const { return inputs_.length(); }
 
   Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   // Phi is alive if it reaches a non-environment use.
   bool is_alive() const { return is_alive_; }
   void mark_alive() { is_alive_ = true; }
   void mark_dead() { is_alive_ = false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return representation_;
   }
 
-  virtual Representation representation() const {
-    return representation_;
-  }
+  virtual Representation representation() const { return representation_; }
 
-  virtual void set_representation(Representation r) {
-    representation_ = r;
-  }
+  virtual void set_representation(Representation r) { representation_ = r; }
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
   DECLARE_INSTRUCTION(Phi)
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
-  BitVector* reaching_defs() const {
-    return reaching_defs_;
-  }
+  BitVector* reaching_defs() const { return reaching_defs_; }
 
   void set_reaching_defs(BitVector* reaching_defs) {
     reaching_defs_ = reaching_defs;
   }
 
   virtual bool MayThrow() const { return false; }
 
   // A phi is redundant if all input operands are the same.
   bool IsRedundant() const;
 
   void set_induction_variable_info(InductionVariableInfo* info) {
     loop_variable_info_ = info;
   }
 
   InductionVariableInfo* induction_variable_info() {
     return loop_variable_info_;
   }
 
   PRINT_TO_SUPPORT
 
-  enum ReceiverType {
-    kUnknownReceiver = -1,
-    kNotReceiver = 0,
-    kReceiver = 1
-  };
+  enum ReceiverType { kUnknownReceiver = -1, kNotReceiver = 0, kReceiver = 1 };
 
   ReceiverType is_receiver() const {
     return static_cast<ReceiverType>(is_receiver_);
   }
 
-  void set_is_receiver(ReceiverType is_receiver) {
-    is_receiver_ = is_receiver;
-  }
+  void set_is_receiver(ReceiverType is_receiver) { is_receiver_ = is_receiver; }
 
  private:
   // Direct access to inputs_ in order to resize it due to unreachable
   // predecessors.
   friend class ConstantPropagator;
 
   void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 
   JoinEntryInstr* block_;
   GrowableArray<Value*> inputs_;
   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) { }
+      : index_(index), base_reg_(base_reg), block_(block) {}
 
   DECLARE_INSTRUCTION(Parameter)
 
   intptr_t index() const { return index_; }
   Register base_reg() const { return base_reg_; }
 
   // Get the block entry for that instruction.
   virtual BlockEntryInstr* GetBlock() { return block_; }
 
   intptr_t InputCount() const { return 0; }
@@ skipping 24 matching lines @@
   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);
-  }
+  explicit PushArgumentInstr(Value* value) { SetInputAt(0, value); }
 
   DECLARE_INSTRUCTION(PushArgument)
 
   virtual CompileType ComputeType() const;
 
   Value* value() const { return InputAt(0); }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
@@ skipping 41 matching lines @@
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public TemplateInstruction<0, Throws> {
  public:
   explicit ThrowInstr(TokenPosition token_pos)
       : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
-        token_pos_(token_pos) {
-  }
+        token_pos_(token_pos) {}
 
   DECLARE_INSTRUCTION(Throw)
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() 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 artifically generated by the parser.
   ReThrowInstr(TokenPosition token_pos, intptr_t catch_try_index)
       : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
-        catch_try_index_(catch_try_index) {
-  }
+        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 CanDeoptimize() 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) {
+  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 CanDeoptimize() 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)
-    : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
-      block_(NULL),
-      successor_(entry),
-      edge_weight_(0.0),
-      parallel_move_(NULL) {
-  }
+      : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
+        block_(NULL),
+        successor_(entry),
+        edge_weight_(0.0),
+        parallel_move_(NULL) {}
 
   DECLARE_INSTRUCTION(Goto)
 
   BlockEntryInstr* block() const { return block_; }
   void set_block(BlockEntryInstr* block) { block_ = block; }
 
   JoinEntryInstr* successor() const { return successor_; }
   void set_successor(JoinEntryInstr* successor) { successor_ = successor; }
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   double edge_weight() const { return edge_weight_; }
   void set_edge_weight(double weight) { edge_weight_ = weight; }
   void adjust_edge_weight(double scale_factor) { edge_weight_ *= scale_factor; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Goto instruction can be used as a deoptimization target when LICM
     // hoists instructions out of the loop.
     return true;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
-  ParallelMoveInstr* parallel_move() const {
-    return parallel_move_;
-  }
+  ParallelMoveInstr* parallel_move() const { return parallel_move_; }
 
-  bool HasParallelMove() const {
-    return parallel_move_ != NULL;
-  }
+  bool HasParallelMove() const { return parallel_move_ != NULL; }
 
   bool HasNonRedundantParallelMove() const {
     return HasParallelMove() && !parallel_move()->IsRedundant();
   }
 
   ParallelMoveInstr* GetParallelMove() {
     if (parallel_move_ == NULL) {
       parallel_move_ = new ParallelMoveInstr();
     }
     return parallel_move_;
@@ skipping 23 matching lines @@
 // 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
 // desired offset is looked up while the generated code is executing, and passed
 // to IndirectGoto as an input.
 class IndirectGotoInstr : public TemplateInstruction<1, NoThrow> {
  public:
-  IndirectGotoInstr(TypedData* offsets,
-                    Value* offset_from_start)
-    : offsets_(*offsets) {
+  IndirectGotoInstr(TypedData* offsets, Value* offset_from_start)
+      : offsets_(*offsets) {
     SetInputAt(0, offset_from_start);
   }
 
   DECLARE_INSTRUCTION(IndirectGoto)
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kNoRepresentation;
   }
 
@@ skipping 36 matching lines @@
   Token::Kind kind() const { return kind_; }
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right) = 0;
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch) = 0;
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels) = 0;
 
-  void SetDeoptId(const Instruction& instr) {
-    CopyDeoptIdFrom(instr);
-  }
+  void SetDeoptId(const Instruction& instr) { CopyDeoptIdFrom(instr); }
 
   // Operation class id is computed from collected ICData.
   void set_operation_cid(intptr_t value) { operation_cid_ = value; }
   intptr_t operation_cid() const { return operation_cid_; }
 
-  virtual void NegateComparison() {
-    kind_ = Token::NegateComparison(kind_);
-  }
+  virtual void NegateComparison() { kind_ = Token::NegateComparison(kind_); }
 
   virtual bool CanBecomeDeoptimizationTarget() const { return true; }
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
   virtual bool AttributesEqual(Instruction* other) const {
     ComparisonInstr* other_comparison = other->AsComparison();
     return kind() == other_comparison->kind() &&
-        (operation_cid() == other_comparison->operation_cid());
+           (operation_cid() == other_comparison->operation_cid());
   }
 
   DEFINE_INSTRUCTION_TYPE_CHECK(Comparison)
 
  protected:
   ComparisonInstr(TokenPosition token_pos,
                   Token::Kind kind,
                   intptr_t deopt_id = Thread::kNoDeoptId)
       : Definition(deopt_id),
         token_pos_(token_pos),
         kind_(kind),
-        operation_cid_(kIllegalCid) {
-  }
+        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) { }
+      : 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 {
+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_() { }
+      : 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;
-  }
+  virtual void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 };
 
 
 class BranchInstr : public Instruction {
  public:
   explicit BranchInstr(ComparisonInstr* comparison)
       : Instruction(Thread::Current()->GetNextDeoptId()),
         comparison_(comparison),
         is_checked_(false),
         constrained_type_(NULL),
@@ skipping 19 matching lines @@
   virtual bool CanDeoptimize() const {
     // Branches need a deoptimization info in checked mode if they
     // can throw a type check error.
     return comparison()->CanDeoptimize() || is_checked();
   }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     return comparison()->CanBecomeDeoptimizationTarget();
   }
 
-  virtual EffectSet Effects() const {
-    return comparison()->Effects();
-  }
+  virtual EffectSet Effects() const { return comparison()->Effects(); }
 
   ComparisonInstr* comparison() const { return comparison_; }
   void SetComparison(ComparisonInstr* comp);
 
   void set_is_checked(bool value) { is_checked_ = value; }
   bool is_checked() const { return is_checked_; }
 
   virtual intptr_t DeoptimizationTarget() const {
     return comparison()->DeoptimizationTarget();
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return comparison()->RequiredInputRepresentation(i);
   }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   // Set compile type constrained by the comparison of this branch.
   // FlowGraphPropagator propagates it downwards into either true or false
   // successor.
   void set_constrained_type(ConstrainedCompileType* type) {
     constrained_type_ = type;
   }
 
   // Return compile type constrained by the comparison of this branch.
-  ConstrainedCompileType* constrained_type() const {
-    return constrained_type_;
-  }
+  ConstrainedCompileType* constrained_type() const { return constrained_type_; }
 
   void set_constant_target(TargetEntryInstr* target) {
     ASSERT(target == true_successor() || target == false_successor());
     constant_target_ = target;
   }
-  TargetEntryInstr* constant_target() const {
-    return constant_target_;
-  }
+  TargetEntryInstr* constant_target() const { return constant_target_; }
 
   virtual void InheritDeoptTarget(Zone* zone, Instruction* other);
 
-  virtual bool MayThrow() const {
-    return comparison()->MayThrow();
-  }
+  virtual bool MayThrow() const { return comparison()->MayThrow(); }
 
   TargetEntryInstr* true_successor() const { return true_successor_; }
   TargetEntryInstr* false_successor() const { return false_successor_; }
 
   TargetEntryInstr** true_successor_address() { return &true_successor_; }
   TargetEntryInstr** false_successor_address() { return &false_successor_; }
 
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
@@ skipping 11 matching lines @@
   ConstrainedCompileType* constrained_type_;
   TargetEntryInstr* constant_target_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 
 class DeoptimizeInstr : public TemplateInstruction<0, NoThrow, Pure> {
  public:
   DeoptimizeInstr(ICData::DeoptReasonId deopt_reason, intptr_t deopt_id)
-      : TemplateInstruction(deopt_id),
-        deopt_reason_(deopt_reason) {
-  }
+      : TemplateInstruction(deopt_id), deopt_reason_(deopt_reason) {}
 
   virtual bool CanDeoptimize() const { return true; }
 
-  virtual bool AttributesEqual(Instruction* other) 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) {
-    SetInputAt(0, value);
-  }
+  explicit RedefinitionInstr(Value* value) { SetInputAt(0, value); }
 
   DECLARE_INSTRUCTION(Redefinition)
 
   Value* value() const { return inputs_[0]; }
 
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
   virtual bool CanDeoptimize() const { return false; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RedefinitionInstr);
 };
 
 
 class ConstraintInstr : public TemplateDefinition<1, NoThrow> {
  public:
   ConstraintInstr(Value* value, Range* constraint)
-      : constraint_(constraint),
-        target_(NULL) {
+      : constraint_(constraint), target_(NULL) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Constraint)
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual bool AttributesEqual(Instruction* other) const {
     UNREACHABLE();
     return false;
   }
 
   Value* value() const { return inputs_[0]; }
   Range* constraint() const { return constraint_; }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   // Constraints for branches have their target block stored in order
   // to find the comparison that generated the constraint:
   // target->predecessor->last_instruction->comparison.
-  void set_target(TargetEntryInstr* target) {
-    target_ = target;
-  }
-  TargetEntryInstr* target() const {
-    return target_;
-  }
+  void set_target(TargetEntryInstr* target) { target_ = target; }
+  TargetEntryInstr* target() const { return target_; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   Range* constraint_;
   TargetEntryInstr* target_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstraintInstr);
 };
 
@@ skipping 29 matching lines @@
 
 
 // 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_;
-  }
+  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.
 
@@ skipping 85 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
 
 // Denotes the current context, normally held in a register.  This is
 // a computation, not a value, because it's mutable.
 class CurrentContextInstr : public TemplateDefinition<0, NoThrow> {
  public:
   CurrentContextInstr()
-      : TemplateDefinition(Thread::Current()->GetNextDeoptId()) {
-  }
+      : TemplateDefinition(Thread::Current()->GetNextDeoptId()) {}
 
   DECLARE_INSTRUCTION(CurrentContext)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
@@ skipping 74 matching lines @@
     ic_data_ = GetICData(ic_data_array);
     ASSERT(function_name.IsNotTemporaryScopedHandle());
     ASSERT(!arguments->is_empty());
     ASSERT(argument_names.IsZoneHandle() || argument_names.InVMHeap());
     ASSERT(Token::IsBinaryOperator(token_kind) ||
            Token::IsEqualityOperator(token_kind) ||
            Token::IsRelationalOperator(token_kind) ||
            Token::IsUnaryOperator(token_kind) ||
            Token::IsIndexOperator(token_kind) ||
            Token::IsTypeTestOperator(token_kind) ||
-           Token::IsTypeCastOperator(token_kind) ||
-           token_kind == Token::kGET ||
-           token_kind == Token::kSET ||
-           token_kind == Token::kILLEGAL);
+           Token::IsTypeCastOperator(token_kind) || token_kind == Token::kGET ||
+           token_kind == Token::kSET || token_kind == Token::kILLEGAL);
   }
 
   DECLARE_INSTRUCTION(InstanceCall)
 
   const ICData* ic_data() const { return ic_data_; }
-  bool HasICData() const {
-    return (ic_data() != NULL) && !ic_data()->IsNull();
-  }
+  bool HasICData() const { return (ic_data() != NULL) && !ic_data()->IsNull(); }
 
   // ICData can be replaced by optimizer.
   void set_ic_data(const ICData* value) { ic_data_ = value; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   const String& function_name() const { return function_name_; }
   Token::Kind token_kind() const { return token_kind_; }
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
   const Array& argument_names() const { return argument_names_; }
   intptr_t checked_argument_count() const { return checked_argument_count_; }
 
   bool has_unique_selector() const { return has_unique_selector_; }
-  void set_has_unique_selector(bool b) {
-    has_unique_selector_ = b;
-  }
+  void set_has_unique_selector(bool b) { has_unique_selector_ = b; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Instance calls that are specialized by the optimizer need a
     // deoptimization descriptor before the call.
     return true;
   }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
@@ skipping 89 matching lines @@
   DECLARE_INSTRUCTION(StrictCompare)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
-  virtual void EmitBranchCode(FlowGraphCompiler* compiler,
-                              BranchInstr* branch);
+  virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   bool needs_number_check() const { return needs_number_check_; }
   void set_needs_number_check(bool value) { needs_number_check_ = value; }
 
   bool AttributesEqual(Instruction* other) const;
 
   PRINT_OPERANDS_TO_SUPPORT
@@ skipping 26 matching lines @@
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     return kTagged;
   }
 
-  virtual void EmitBranchCode(FlowGraphCompiler* compiler,
-                              BranchInstr* branch);
+  virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestSmiInstr);
 };
 
 
 // Checks the input value cid against cids stored in a table and returns either
@@ skipping 28 matching lines @@
   virtual bool CanDeoptimize() const {
     return GetDeoptId() != Thread::kNoDeoptId;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     return kTagged;
   }
 
   virtual bool AttributesEqual(Instruction* other) const;
 
-  virtual void EmitBranchCode(FlowGraphCompiler* compiler,
-                              BranchInstr* branch);
+  virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const ZoneGrowableArray<intptr_t>& cid_results_;
@@ skipping 18 matching lines @@
   }
 
   DECLARE_INSTRUCTION(EqualityCompare)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual void EmitBranchCode(FlowGraphCompiler* compiler,
-                              BranchInstr* branch);
+  virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (operation_cid() == kDoubleCid) return kUnboxedDouble;
     if (operation_cid() == kMintCid) return kUnboxedMint;
     return kTagged;
   }
@@ skipping 21 matching lines @@
   }
 
   DECLARE_INSTRUCTION(RelationalOp)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual void EmitBranchCode(FlowGraphCompiler* compiler,
-                              BranchInstr* branch);
+  virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (operation_cid() == kDoubleCid) return kUnboxedDouble;
     if (operation_cid() == kMintCid) return kUnboxedMint;
     return kTagged;
   }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RelationalOpInstr);
 };
 
 
 // TODO(vegorov): ComparisonInstr should be switched to use IfTheElseInstr for
 // materialization of true and false constants.
 class IfThenElseInstr : public Definition {
  public:
-  IfThenElseInstr(ComparisonInstr* comparison,
-                  Value* if_true,
-                  Value* if_false)
+  IfThenElseInstr(ComparisonInstr* comparison, Value* if_true, Value* if_false)
       : Definition(Thread::Current()->GetNextDeoptId()),
         comparison_(comparison),
         if_true_(Smi::Cast(if_true->BoundConstant()).Value()),
         if_false_(Smi::Cast(if_false->BoundConstant()).Value()) {
     // Adjust uses at the comparison.
     ASSERT(comparison->env() == NULL);
     for (intptr_t i = comparison->InputCount() - 1; i >= 0; --i) {
       comparison->InputAt(i)->set_instruction(this);
     }
   }
 
   // Returns true if this combination of comparison and values flowing on
   // the true and false paths is supported on the current platform.
   static bool Supports(ComparisonInstr* comparison, Value* v1, Value* v2);
 
   DECLARE_INSTRUCTION(IfThenElse)
 
   intptr_t InputCount() const { return comparison()->InputCount(); }
 
   Value* InputAt(intptr_t i) const { return comparison()->InputAt(i); }
 
-  virtual bool CanDeoptimize() const {
-    return comparison()->CanDeoptimize();
-  }
+  virtual bool CanDeoptimize() const { return comparison()->CanDeoptimize(); }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     return comparison()->CanBecomeDeoptimizationTarget();
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     return comparison()->DeoptimizationTarget();
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
@@ skipping 50 matching lines @@
         token_pos_(token_pos),
         function_(function),
         argument_names_(argument_names),
         arguments_(arguments),
         result_cid_(kDynamicCid),
         is_known_list_constructor_(false),
         identity_(AliasIdentity::Unknown()) {
     ic_data_ = GetICData(ic_data_array);
     ASSERT(function.IsZoneHandle());
     ASSERT(!function.IsNull());
-    ASSERT(argument_names.IsZoneHandle() ||  argument_names.InVMHeap());
+    ASSERT(argument_names.IsZoneHandle() || argument_names.InVMHeap());
   }
 
   StaticCallInstr(TokenPosition token_pos,
                   const Function& function,
                   const Array& argument_names,
                   ZoneGrowableArray<PushArgumentInstr*>* arguments,
                   intptr_t deopt_id)
       : TemplateDefinition(deopt_id),
         ic_data_(NULL),
         token_pos_(token_pos),
         function_(function),
         argument_names_(argument_names),
         arguments_(arguments),
         result_cid_(kDynamicCid),
         is_known_list_constructor_(false),
         identity_(AliasIdentity::Unknown()) {
     ASSERT(function.IsZoneHandle());
     ASSERT(!function.IsNull());
-    ASSERT(argument_names.IsZoneHandle() ||  argument_names.InVMHeap());
+    ASSERT(argument_names.IsZoneHandle() || argument_names.InVMHeap());
   }
 
   // ICData for static calls carries call count.
   const ICData* ic_data() const { return ic_data_; }
-  bool HasICData() const {
-    return (ic_data() != NULL) && !ic_data()->IsNull();
-  }
+  bool HasICData() const { return (ic_data() != NULL) && !ic_data()->IsNull(); }
 
   DECLARE_INSTRUCTION(StaticCall)
   virtual CompileType ComputeType() const;
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   // Accessors forwarded to the AST node.
   const Function& function() const { return function_; }
   const Array& argument_names() const { return argument_names_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
@@ skipping 16 matching lines @@
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
   void set_result_cid(intptr_t value) { result_cid_ = value; }
 
   bool is_known_list_constructor() const { return is_known_list_constructor_; }
   void set_is_known_list_constructor(bool value) {
     is_known_list_constructor_ = value;
   }
 
-  bool IsRecognizedFactory() const {
-    return is_known_list_constructor();
-  }
+  bool IsRecognizedFactory() const { return is_known_list_constructor(); }
 
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const ICData* ic_data_;
   const TokenPosition token_pos_;
   const Function& function_;
   const Array& argument_names_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   intptr_t result_cid_;  // For some library functions we know the result.
 
   // 'True' for recognized list constructors.
   bool is_known_list_constructor_;
 
   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) { }
+  LoadLocalInstr(const LocalVariable& local, TokenPosition token_pos)
+      : local_(local), is_last_(false), token_pos_(token_pos) {}
 
   DECLARE_INSTRUCTION(LoadLocal)
   virtual CompileType ComputeType() const;
 
   const LocalVariable& local() const { return local_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const {
     UNREACHABLE();  // Eliminated by SSA construction.
@@ skipping 44 matching lines @@
   virtual EffectSet Effects() const {
     UNREACHABLE();  // Eliminated by SSA construction.
     return EffectSet::None();
   }
 
   virtual bool MayThrow() const {
     UNREACHABLE();
     return false;
   }
 
-  virtual TokenPosition token_pos() const {
-    return TokenPosition::kTempMove;
-  }
+  virtual TokenPosition token_pos() const { return TokenPosition::kTempMove; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
-  virtual void RawSetInputAt(intptr_t i, Value* value) {
-    value_ = value;
-  }
+  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:
@@ skipping 38 matching lines @@
 
 
 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()) { }
+        token_pos_(node->token_pos()) {}
 
   NativeCallInstr(const String* name,
                   const Function* function,
                   bool link_lazily,
                   TokenPosition position)
       : native_name_(name),
         function_(function),
         native_c_function_(NULL),
         is_bootstrap_native_(false),
         link_lazily_(link_lazily),
-        token_pos_(position) { }
+        token_pos_(position) {}
 
   DECLARE_INSTRUCTION(NativeCall)
 
   const String& native_name() const { return *native_name_; }
   const Function& function() const { return *function_; }
   NativeFunction native_c_function() const { return native_c_function_; }
   bool is_bootstrap_native() const { return is_bootstrap_native_; }
   bool link_lazily() const { return link_lazily_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
@@ skipping 18 matching lines @@
   bool is_bootstrap_native_;
   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)
-      : token_pos_(token_pos),
-        stub_kind_(stub_kind) {
-  }
+  DebugStepCheckInstr(TokenPosition token_pos, RawPcDescriptors::Kind stub_kind)
+      : token_pos_(token_pos), stub_kind_(stub_kind) {}
 
   DECLARE_INSTRUCTION(DebugStepCheck)
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   virtual bool CanDeoptimize() 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
-};
+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),
@@ skipping 17 matching lines @@
         token_pos_(token_pos),
         is_initialization_(false) {
     SetInputAt(kInstancePos, instance);
     SetInputAt(kValuePos, value);
   }
 
   DECLARE_INSTRUCTION(StoreInstanceField)
 
   void set_is_initialization(bool value) { is_initialization_ = value; }
 
-  enum {
-    kInstancePos = 0,
-    kValuePos = 1
-  };
+  enum { kInstancePos = 0, kValuePos = 1 };
 
   Value* instance() const { return inputs_[kInstancePos]; }
   Value* value() const { return inputs_[kValuePos]; }
   bool is_initialization() const { return is_initialization_; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   const Field& field() const { return field_; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
 
   bool ShouldEmitStoreBarrier() const {
-    return value()->NeedsStoreBuffer()
-        && (emit_store_barrier_ == kEmitStoreBarrier);
+    return value()->NeedsStoreBuffer() &&
+           (emit_store_barrier_ == kEmitStoreBarrier);
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
   // May require a deoptimization target for input conversions.
-  virtual intptr_t DeoptimizationTarget() const {
-    return GetDeoptId();
-  }
+  virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
   // Currently CSE/LICM don't operate on any instructions that can be affected
   // by stores/loads. LoadOptimizer handles loads separately. Hence stores
   // are marked as having no side-effects.
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   bool IsUnboxedStore() const;
 
   bool IsPotentialUnboxedStore() const;
 
@@ skipping 17 matching lines @@
   const TokenPosition token_pos_;
   // Marks initialiing 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) {
+  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 CanDeoptimize() 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)
+  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)
+  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;
 
@@ skipping 33 matching lines @@
 
   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) {
+      : field_(field), token_pos_(token_pos) {
     ASSERT(field.IsZoneHandle());
     SetInputAt(kValuePos, value);
     CheckField(field);
   }
 
-  enum {
-    kValuePos = 0
-  };
+  enum { kValuePos = 0 };
 
   DECLARE_INSTRUCTION(StoreStaticField)
 
   const Field& field() const { return field_; }
   Value* value() const { return inputs_[kValuePos]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   // Currently CSE/LICM don't operate on any instructions that can be affected
   // by stores/loads. LoadOptimizer handles loads separately. Hence stores
@@ skipping 151 matching lines @@
     SetInputAt(0, char_code);
   }
 
   DECLARE_INSTRUCTION(OneByteStringFromCharCode)
   virtual CompileType ComputeType() const;
 
   Value* char_code() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool AttributesEqual(Instruction* other) const {
-    return true;
-  }
+  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);
@@ skipping 55 matching lines @@
                     Value* index,
                     Value* value,
                     StoreBarrierType emit_store_barrier,
                     intptr_t index_scale,
                     intptr_t class_id,
                     AlignmentType alignment,
                     intptr_t deopt_id,
                     TokenPosition token_pos);
   DECLARE_INSTRUCTION(StoreIndexed)
 
-  enum {
-    kArrayPos = 0,
-    kIndexPos = 1,
-    kValuePos = 2
-  };
+  enum { kArrayPos = 0, kIndexPos = 1, kValuePos = 2 };
 
   Value* array() const { return inputs_[kArrayPos]; }
   Value* index() const { return inputs_[kIndexPos]; }
   Value* value() const { return inputs_[kValuePos]; }
 
   intptr_t index_scale() const { return index_scale_; }
   intptr_t class_id() const { return class_id_; }
   bool aligned() const { return alignment_ == kAlignedAccess; }
 
   bool ShouldEmitStoreBarrier() const {
-    return value()->NeedsStoreBuffer()
-        && (emit_store_barrier_ == kEmitStoreBarrier);
+    return value()->NeedsStoreBuffer() &&
+           (emit_store_barrier_ == kEmitStoreBarrier);
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const;
 
   bool IsExternal() const {
     return array()->definition()->representation() == kUntagged;
   }
 
@@ skipping 12 matching lines @@
   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);
-  }
+  explicit BooleanNegateInstr(Value* value) { SetInputAt(0, value); }
 
   DECLARE_INSTRUCTION(BooleanNegate)
   virtual CompileType ComputeType() const;
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
@@ skipping 168 matching lines @@
     ASSERT(slots_.length() == values_->length());
     for (intptr_t i = 0; i < InputCount(); i++) {
       InputAt(i)->set_instruction(this);
       InputAt(i)->set_use_index(i);
     }
   }
 
   Definition* allocation() const { return allocation_; }
   const Class& cls() const { return cls_; }
 
-  intptr_t num_variables() const {
-    return num_variables_;
+  intptr_t num_variables() const { return num_variables_; }
+
+  intptr_t FieldOffsetAt(intptr_t i) const {
+    return slots_[i]->IsField() ? Field::Cast(*slots_[i]).Offset()
+                                : Smi::Cast(*slots_[i]).Value();
   }
 
-  intptr_t FieldOffsetAt(intptr_t i) const {
-    return slots_[i]->IsField()
-        ? Field::Cast(*slots_[i]).Offset()
-        : Smi::Cast(*slots_[i]).Value();
-  }
-
-  const Location& LocationAt(intptr_t i) {
-    return locations_[i];
-  }
+  const Location& LocationAt(intptr_t i) { return locations_[i]; }
 
   DECLARE_INSTRUCTION(MaterializeObject)
 
-  virtual intptr_t InputCount() const {
-    return values_->length();
-  }
+  virtual intptr_t InputCount() const { return values_->length(); }
 
-  virtual Value* InputAt(intptr_t i) const {
-    return (*values_)[i];
-  }
+  virtual Value* InputAt(intptr_t i) const { return (*values_)[i]; }
 
   // SelectRepresentations pass is run once more while MaterializeObject
   // instructions are still in the graph. To avoid any redundant boxing
   // operations inserted by that pass we should indicate that this
   // instruction can cope with any representation as it is essentially
   // an environment use.
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(0 <= idx && idx < InputCount());
     return kNoRepresentation;
   }
 
   virtual bool CanDeoptimize() const { return false; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   Location* locations() { return locations_; }
   void set_locations(Location* locations) { locations_ = locations; }
 
   virtual bool MayThrow() const { return false; }
 
-  void RemapRegisters(intptr_t* cpu_reg_slots,
-                      intptr_t* fpu_reg_slots);
+  void RemapRegisters(intptr_t* cpu_reg_slots, intptr_t* fpu_reg_slots);
 
   bool was_visited_for_liveness() const { return visited_for_liveness_; }
-  void mark_visited_for_liveness() {
-    visited_for_liveness_ = true;
-  }
+  void mark_visited_for_liveness() { visited_for_liveness_ = true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*values_)[i] = value;
   }
 
   Definition* allocation_;
   const Class& cls_;
   intptr_t num_variables_;
   const ZoneGrowableArray<const Object*>& slots_;
   ZoneGrowableArray<Value*>* values_;
   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)
       : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
-        identity_(AliasIdentity::Unknown())  {
+        identity_(AliasIdentity::Unknown()) {
     SetInputAt(kElementTypePos, element_type);
     SetInputAt(kLengthPos, num_elements);
   }
 
-  enum {
-    kElementTypePos = 0,
-    kLengthPos = 1
-  };
+  enum { kElementTypePos = 0, kLengthPos = 1 };
 
   DECLARE_INSTRUCTION(CreateArray)
   virtual CompileType ComputeType() const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   Value* element_type() const { return inputs_[kElementTypePos]; }
   Value* num_elements() const { return inputs_[kLengthPos]; }
 
   // Throw needs environment, which is created only if instruction can
   // deoptimize.
@@ skipping 16 matching lines @@
 // 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);
   }
 
-  virtual Representation representation() const {
-    return kUntagged;
-  }
+  virtual Representation representation() const { return kUntagged; }
   DECLARE_INSTRUCTION(LoadUntagged)
   virtual CompileType ComputeType() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     // The object may be tagged or untagged (for external objects).
     return kNoRepresentation;
   }
 
   Value* object() const { return inputs_[0]; }
   intptr_t offset() const { return offset_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   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);
-  }
+  explicit LoadClassIdInstr(Value* object) { SetInputAt(0, object); }
 
-  virtual Representation representation() const {
-    return kTagged;
-  }
+  virtual Representation representation() const { return kTagged; }
   DECLARE_INSTRUCTION(LoadClassId)
   virtual CompileType ComputeType() const;
 
   Value* object() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const {
     return EffectSet::Externalization();
@@ skipping 56 matching lines @@
   virtual Representation representation() const;
 
   bool IsUnboxedLoad() const;
 
   bool IsPotentialUnboxedLoad() const;
 
   void set_recognized_kind(MethodRecognizer::Kind kind) {
     recognized_kind_ = kind;
   }
 
-  MethodRecognizer::Kind recognized_kind() const {
-    return recognized_kind_;
-  }
+  MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   DECLARE_INSTRUCTION(LoadField)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   bool IsImmutableLengthLoad() const;
 
@@ skipping 34 matching lines @@
         token_pos_(token_pos),
         type_(type),
         instantiator_class_(instantiator_class) {
     ASSERT(type.IsZoneHandle() || type.IsReadOnlyHandle());
     SetInputAt(0, instantiator);
   }
 
   DECLARE_INSTRUCTION(InstantiateType)
 
   Value* instantiator() const { return inputs_[0]; }
-  const AbstractType& type() const { return type_;
-  }
+  const AbstractType& type() const { return type_; }
   const Class& instantiator_class() const { return instantiator_class_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
@@ skipping 15 matching lines @@
         token_pos_(token_pos),
         type_arguments_(type_arguments),
         instantiator_class_(instantiator_class) {
     ASSERT(type_arguments.IsZoneHandle());
     SetInputAt(0, instantiator);
   }
 
   DECLARE_INSTRUCTION(InstantiateTypeArguments)
 
   Value* instantiator() const { return inputs_[0]; }
-  const TypeArguments& type_arguments() const {
-    return type_arguments_;
-  }
+  const TypeArguments& type_arguments() const { return type_arguments_; }
   const Class& instantiator_class() const { return instantiator_class_; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
   const TypeArguments& type_arguments_;
   const Class& instantiator_class_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsInstr);
 };
 
 
 class AllocateContextInstr : public TemplateDefinition<0, NoThrow> {
  public:
-  AllocateContextInstr(TokenPosition token_pos,
-                       intptr_t num_context_variables)
-      : token_pos_(token_pos),
-        num_context_variables_(num_context_variables) { }
+  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 CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
@@ skipping 10 matching lines @@
 
 class InitStaticFieldInstr : public TemplateInstruction<1, Throws> {
  public:
   InitStaticFieldInstr(Value* input, const Field& field)
       : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         field_(field) {
     SetInputAt(0, input);
     CheckField(field);
   }
 
-  virtual TokenPosition token_pos() const {
-    return field_.token_pos();
-  }
+  virtual TokenPosition token_pos() const { return field_.token_pos(); }
   const Field& field() const { return field_; }
 
   DECLARE_INSTRUCTION(InitStaticField)
 
   virtual bool CanDeoptimize() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::All(); }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const Field& field_;
@@ skipping 119 matching lines @@
  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;
 
   virtual bool CanDeoptimize() const { return false; }
-  virtual intptr_t DeoptimizationTarget() const {
-    return Thread::kNoDeoptId;
-  }
+  virtual intptr_t DeoptimizationTarget() const { return Thread::kNoDeoptId; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return from_representation();
   }
 
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsBox()->from_representation() == from_representation();
   }
 
   Definition* Canonicalize(FlowGraph* flow_graph);
 
-  virtual TokenPosition token_pos() const {
-    return TokenPosition::kBox;
-  }
+  virtual TokenPosition token_pos() const { return TokenPosition::kBox; }
 
  protected:
   BoxInstr(Representation from_representation, Value* value)
       : from_representation_(from_representation) {
     SetInputAt(0, value);
   }
 
  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) { }
+      : 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) { }
+      : BoxIntegerInstr(representation, value) {}
 
   DECLARE_INSTRUCTION_BACKEND()
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxInteger32Instr);
 };
 
 
 class BoxInt32Instr : public BoxInteger32Instr {
  public:
   explicit BoxInt32Instr(Value* value)
-      : BoxInteger32Instr(kUnboxedInt32, 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) { }
+      : 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) { }
+  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 CanDeoptimize() const {
     const intptr_t value_cid = value()->Type()->ToCid();
 
-    if (CanConvertSmi() &&
-        (value()->Type()->ToCid() == kSmiCid)) {
+    if (CanConvertSmi() && (value()->Type()->ToCid() == kSmiCid)) {
       return false;
     }
 
     return (value_cid != BoxCid());
   }
 
-  virtual Representation representation() const {
-    return representation_;
-  }
+  virtual Representation representation() const { return representation_; }
 
   DECLARE_INSTRUCTION(Unbox)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return representation() == other->AsUnbox()->representation();
   }
 
   Definition* Canonicalize(FlowGraph* flow_graph);
 
-  virtual intptr_t DeoptimizationTarget() const {
-    return GetDeoptId();
-  }
+  virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
-  virtual TokenPosition token_pos() const {
-    return TokenPosition::kBox;
-  }
+  virtual TokenPosition token_pos() const { return TokenPosition::kBox; }
 
  protected:
-  UnboxInstr(Representation representation,
-             Value* value,
-             intptr_t deopt_id)
-      : TemplateDefinition(deopt_id),
-        representation_(representation) {
+  UnboxInstr(Representation representation, Value* value, intptr_t deopt_id)
+      : TemplateDefinition(deopt_id), representation_(representation) {
     SetInputAt(0, value);
   }
 
  private:
   bool CanConvertSmi() const;
   void EmitLoadFromBox(FlowGraphCompiler* compiler);
   void EmitSmiConversion(FlowGraphCompiler* compiler);
 
-  intptr_t BoxCid() const {
-    return Boxing::BoxCid(representation_);
-  }
+  intptr_t BoxCid() const { return Boxing::BoxCid(representation_); }
 
-  intptr_t ValueOffset() const {
-    return Boxing::ValueOffset(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) {
-  }
+        is_truncating_(truncation_mode == kTruncate) {}
 
   bool is_truncating() const { return is_truncating_; }
 
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     UnboxIntegerInstr* other_unbox = other->AsUnboxInteger();
     return UnboxInstr::AttributesEqual(other) &&
-        (other_unbox->is_truncating_ == is_truncating_);
+           (other_unbox->is_truncating_ == is_truncating_);
   }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   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) { }
+      : UnboxIntegerInstr(representation, truncation_mode, value, deopt_id) {}
 
   DECLARE_INSTRUCTION_BACKEND()
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxInteger32Instr);
 };
 
 
 class UnboxUint32Instr : public UnboxInteger32Instr {
  public:
@@ skipping 11 matching lines @@
  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) {
-  }
+      : UnboxInteger32Instr(kUnboxedInt32, truncation_mode, value, deopt_id) {}
 
   virtual bool CanDeoptimize() 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) {
-  }
+      : 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();
+  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);
   }
 
   Value* value() const { return inputs_[0]; }
   MathUnaryKind kind() const { return kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedDouble;
-  }
+  virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 21 matching lines @@
 
 // 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,
-      Value* lhs_index,
-      Value* rhs_index,
-      Value* length,
-      intptr_t cid)
-    : cid_(cid) {
+  CaseInsensitiveCompareUC16Instr(Value* str,
+                                  Value* lhs_index,
+                                  Value* rhs_index,
+                                  Value* length,
+                                  intptr_t cid)
+      : cid_(cid) {
     ASSERT(cid == kTwoByteStringCid || cid == kExternalTwoByteStringCid);
     ASSERT(index_scale() == 2);
     SetInputAt(0, str);
     SetInputAt(1, lhs_index);
     SetInputAt(2, rhs_index);
     SetInputAt(3, length);
   }
 
   Value* str() const { return inputs_[0]; }
   Value* lhs_index() const { return inputs_[1]; }
   Value* rhs_index() const { return inputs_[2]; }
   Value* length() const { return inputs_[3]; }
 
   const RuntimeEntry& TargetFunction() const;
   bool IsExternal() const { return cid_ == kExternalTwoByteStringCid; }
   intptr_t class_id() const { return cid_; }
   intptr_t index_scale() const { return Instance::ElementSizeFor(cid_); }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kTagged;
-  }
+  virtual Representation representation() const { return kTagged; }
 
   DECLARE_INSTRUCTION(CaseInsensitiveCompareUC16)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsCaseInsensitiveCompareUC16()->cid_ == cid_;
   }
 
  private:
   const intptr_t cid_;
@@ skipping 61 matching lines @@
 };
 
 
 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) {
+      : TemplateDefinition(deopt_id), op_kind_(op_kind), token_pos_(token_pos) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedDouble;
-  }
+  virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 17 matching lines @@
   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) {
+      : TemplateComparison(token_pos, Token::kEQ, deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return InputAt(0); }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   PRINT_OPERANDS_TO_SUPPORT
 
   DECLARE_INSTRUCTION(DoubleTestOp)
   virtual CompileType ComputeType() const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const {
-    return op_kind_ == other->AsDoubleTestOp()->op_kind()
-        && ComparisonInstr::AttributesEqual(other);
+    return op_kind_ == other->AsDoubleTestOp()->op_kind() &&
+           ComparisonInstr::AttributesEqual(other);
   }
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
-  virtual void EmitBranchCode(FlowGraphCompiler* compiler,
-                              BranchInstr* branch);
+  virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
  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);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat32x4;
-  }
+  virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 10 matching lines @@
 
  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,
+  Simd32x4ShuffleInstr(MethodRecognizer::Kind op_kind,
+                       Value* value,
                        intptr_t mask,
                        intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind), mask_(mask) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
@@ skipping 47 matching lines @@
  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)
+  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);
   }
 
   Value* xy() const { return inputs_[0]; }
   Value* zw() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
@@ skipping 56 matching lines @@
     SetInputAt(3, value3);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat32x4;
-  }
+  virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx >= 0 && idx < 4);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 15 matching lines @@
  public:
   Float32x4SplatInstr(Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat32x4;
-  }
+  virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4Splat)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4SplatInstr);
 };
 
 
 // TODO(vegorov) replace with UnboxedConstantInstr.
 class Float32x4ZeroInstr : public TemplateDefinition<0, NoThrow, Pure> {
  public:
-  Float32x4ZeroInstr() { }
+  Float32x4ZeroInstr() {}
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat32x4;
-  }
+  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);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedInt32x4;
-  }
+  virtual Representation representation() const { return kUnboxedInt32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 26 matching lines @@
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat32x4;
-  }
+  virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 26 matching lines @@
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat32x4;
-  }
+  virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (idx == 0) {
       return kUnboxedDouble;
     }
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
@@ skipping 26 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat32x4;
-  }
+  virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 14 matching lines @@
   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) {
+      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat32x4;
-  }
+  virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 26 matching lines @@
     SetInputAt(1, lower);
     SetInputAt(2, upper);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* lower() const { return inputs_[1]; }
   Value* upper() const { return inputs_[2]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat32x4;
-  }
+  virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1) || (idx == 2));
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 10 matching lines @@
   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) {
+      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, replacement);
     SetInputAt(1, left);
   }
 
   Value* left() const { return inputs_[1]; }
   Value* replacement() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat32x4;
-  }
+  virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (idx == 0) {
       return kUnboxedDouble;
     }
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
@@ skipping 83 matching lines @@
  public:
   Float32x4ToInt32x4Instr(Value* left, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedInt32x4;
-  }
+  virtual Representation representation() const { return kUnboxedInt32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 15 matching lines @@
  public:
   Float32x4ToFloat64x2Instr(Value* left, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat64x2;
-  }
+  virtual Representation representation() const { return kUnboxedFloat64x2; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 15 matching lines @@
  public:
   Float64x2ToFloat32x4Instr(Value* left, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat32x4;
-  }
+  virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat64x2;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 17 matching lines @@
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat64x2;
-  }
+  virtual Representation representation() const { return kUnboxedFloat64x2; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx >= 0 && idx < 2);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 15 matching lines @@
  public:
   Float64x2SplatInstr(Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat64x2;
-  }
+  virtual Representation representation() const { return kUnboxedFloat64x2; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float64x2Splat)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Float64x2SplatInstr);
 };
 
 
 class Float64x2ZeroInstr : public TemplateDefinition<0, NoThrow, Pure> {
  public:
-  Float64x2ZeroInstr() { }
+  Float64x2ZeroInstr() {}
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat64x2;
-  }
+  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);
 };
 
@@ skipping 60 matching lines @@
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat64x2;
-  }
+  virtual Representation representation() const { return kUnboxedFloat64x2; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     if (idx == 0) {
       return kUnboxedFloat64x2;
     }
     ASSERT(idx == 1);
     if ((op_kind() == MethodRecognizer::kFloat64x2WithX) ||
         (op_kind() == MethodRecognizer::kFloat64x2WithY) ||
         (op_kind() == MethodRecognizer::kFloat64x2Scale)) {
       return kUnboxedDouble;
@@ skipping 37 matching lines @@
     SetInputAt(3, value3);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedInt32x4;
-  }
+  virtual Representation representation() const { return kUnboxedInt32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx >= 0) && (idx < 4));
     return kUnboxedInt32;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 26 matching lines @@
     SetInputAt(3, value3);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedInt32x4;
-  }
+  virtual Representation representation() const { return kUnboxedInt32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx >= 0) && (idx < 4));
     return kTagged;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 19 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-      return kTagged;
-  }
+  virtual Representation representation() const { return kTagged; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 23 matching lines @@
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kTagged;
-  }
+  virtual Representation representation() const { return kTagged; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     if (op_kind_ == MethodRecognizer::kFloat32x4GetSignMask) {
       return kUnboxedFloat32x4;
     }
     ASSERT(op_kind_ == MethodRecognizer::kInt32x4GetSignMask);
     return kUnboxedInt32x4;
   }
 
@@ skipping 30 matching lines @@
     SetInputAt(1, trueValue);
     SetInputAt(2, falseValue);
   }
 
   Value* mask() const { return inputs_[0]; }
   Value* trueValue() const { return inputs_[1]; }
   Value* falseValue() const { return inputs_[2]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-      return kUnboxedFloat32x4;
-  }
+  virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1) || (idx == 2));
     if (idx == 0) {
       return kUnboxedInt32x4;
     }
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
@@ skipping 25 matching lines @@
     SetInputAt(1, flagValue);
   }
 
   Value* value() const { return inputs_[0]; }
   Value* flagValue() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-      return kUnboxedInt32x4;
-  }
+  virtual Representation representation() const { return kUnboxedInt32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (idx == 1) {
       return kTagged;
     }
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
@@ skipping 22 matching lines @@
  public:
   Int32x4ToFloat32x4Instr(Value* left, intptr_t deopt_id)
       : TemplateDefinition(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat32x4;
-  }
+  virtual Representation representation() const { return kUnboxedFloat32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Int32x4ToFloat32x4)
   virtual CompileType ComputeType() const;
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32x4ToFloat32x4Instr);
 };
 
 
 class BinaryInt32x4OpInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   BinaryInt32x4OpInstr(Token::Kind op_kind,
-                        Value* left,
-                        Value* right,
-                        intptr_t deopt_id)
+                       Value* left,
+                       Value* right,
+                       intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedInt32x4;
-  }
+  virtual Representation representation() const { return kUnboxedInt32x4; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 26 matching lines @@
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedFloat64x2;
-  }
+  virtual Representation representation() const { return kUnboxedFloat64x2; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat64x2;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
@@ skipping 10 matching lines @@
 
  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)
+  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));
+    ASSERT((op_kind == Token::kNEGATE) || (op_kind == Token::kBIT_NOT));
     SetInputAt(0, value);
   }
 
   static UnaryIntegerOpInstr* Make(Representation representation,
                                    Token::Kind op_kind,
                                    Value* value,
                                    intptr_t deopt_id,
                                    Range* range);
 
   Value* value() const { return inputs_[0]; }
@@ skipping 16 matching lines @@
   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)
+  UnarySmiOpInstr(Token::Kind op_kind, Value* value, intptr_t deopt_id)
       : UnaryIntegerOpInstr(op_kind, value, deopt_id) {}
 
   virtual bool CanDeoptimize() 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)
+  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 CanDeoptimize() const { return false; }
 
   virtual CompileType ComputeType() const;
 
-  virtual Representation representation() const {
-    return kUnboxedUint32;
-  }
+  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 CanDeoptimize() const {
-    return false;
-  }
+  virtual bool CanDeoptimize() const { return false; }
 
   virtual CompileType ComputeType() const;
 
-  virtual Representation representation() const {
-    return kUnboxedMint;
-  }
+  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) {
+      : TemplateDefinition(call->deopt_id()), call_(call), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   InstanceCallInstr* call() const { return call_; }
   Token::Kind op_kind() const { return op_kind_; }
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   virtual bool CanDeoptimize() const { return false; }
@@ skipping 38 matching lines @@
   }
 
   bool is_negated() const { return is_negated_; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
   PRINT_OPERANDS_TO_SUPPORT
 
   DECLARE_INSTRUCTION(CheckedSmiComparison)
 
-  virtual void EmitBranchCode(FlowGraphCompiler* compiler,
-                              BranchInstr* branch);
+  virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
  private:
   InstanceCallInstr* call_;
   bool is_negated_;
   DISALLOW_COPY_AND_ASSIGN(CheckedSmiComparisonInstr);
@@ skipping 90 matching lines @@
   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) {
-  }
+      : BinaryIntegerOpInstr(op_kind, left, right, deopt_id) {}
 
   virtual bool CanDeoptimize() const;
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(BinarySmiOp)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BinarySmiOpInstr);
@@ skipping 29 matching lines @@
       default:
         return false;
     }
 #else
     return false;
 #endif
   }
 
   virtual bool CanDeoptimize() const;
 
-  virtual Representation representation() const {
-    return kUnboxedInt32;
-  }
+  virtual Representation representation() const { return kUnboxedInt32; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedInt32;
   }
 
   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 CanDeoptimize() const {
-    return false;
-  }
+  virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedUint32;
-  }
+  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 CanDeoptimize() const { return true; }
 
-  virtual Representation representation() const {
-    return kUnboxedUint32;
-  }
+  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) {
+      : BinaryIntegerOpInstr(op_kind, left, right, deopt_id) {}
+
+  virtual bool CanDeoptimize() const {
+    return (can_overflow() &&
+            ((op_kind() == Token::kADD) || (op_kind() == Token::kSUB))) ||
+           (op_kind() == Token::kMUL);  // Deopt if inputs are not int32.
   }
 
-  virtual bool CanDeoptimize() const {
-    return (can_overflow() && ((op_kind() == Token::kADD) ||
-                               (op_kind() == Token::kSUB)))
-        || (op_kind() == Token::kMUL);  // Deopt if inputs are not int32.
-  }
-
-  virtual Representation representation() const {
-    return kUnboxedMint;
-  }
+  virtual Representation representation() const { return kUnboxedMint; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedMint;
   }
 
   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) {
     ASSERT((op_kind == Token::kSHR) || (op_kind == Token::kSHL));
   }
 
   virtual bool CanDeoptimize() const {
-    return  has_shift_count_check()
-        || (can_overflow() && (op_kind() == Token::kSHL));
+    return has_shift_count_check() ||
+           (can_overflow() && (op_kind() == Token::kSHL));
   }
 
-  virtual Representation representation() const {
-    return kUnboxedMint;
-  }
+  virtual Representation representation() const { return kUnboxedMint; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return (idx == 0) ? kUnboxedMint : kTagged;
   }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(ShiftMintOp)
 
  private:
   bool has_shift_count_check() const;
 
   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)
+  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]; }
   Token::Kind op_kind() const { return op_kind_; }
 
   DECLARE_INSTRUCTION(UnaryDoubleOp)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
-  virtual Representation representation() const {
-    return kUnboxedDouble;
-  }
+  virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(UnaryDoubleOpInstr);
 };
 
 
 class CheckStackOverflowInstr : public TemplateInstruction<0, NoThrow> {
  public:
   CheckStackOverflowInstr(TokenPosition token_pos, intptr_t loop_depth)
       : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
-        loop_depth_(loop_depth) {
-  }
+        loop_depth_(loop_depth) {}
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   bool in_loop() const { return loop_depth_ > 0; }
   intptr_t loop_depth() const { return loop_depth_; }
 
   DECLARE_INSTRUCTION(CheckStackOverflow)
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
@@ skipping 15 matching lines @@
       : 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 Representation representation() const { return kUnboxedDouble; }
 
   virtual bool CanDeoptimize() 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);
-  }
+  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 Representation representation() const { return kUnboxedDouble; }
 
   virtual bool CanDeoptimize() 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)
   virtual CompileType ComputeType() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t index) const {
     ASSERT(index == 0);
     return kUnboxedMint;
   }
 
-  virtual Representation representation() const {
-    return kUnboxedDouble;
-  }
+  virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   virtual bool CanDeoptimize() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
@@ skipping 57 matching lines @@
  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) {
+      : TemplateDefinition(deopt_id), recognized_kind_(recognized_kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   DECLARE_INSTRUCTION(DoubleToDouble)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedDouble;
-  }
+  virtual Representation representation() const { return kUnboxedDouble; }
 
   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 other->AsDoubleToDouble()->recognized_kind() == recognized_kind();
   }
 
  private:
   const MethodRecognizer::Kind recognized_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleToDoubleInstr);
 };
 
 
-class DoubleToFloatInstr: public TemplateDefinition<1, NoThrow, Pure> {
+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 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> {
+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)
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedDouble;
-  }
+  virtual Representation representation() const { return kUnboxedDouble; }
 
   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; }
 
@@ skipping 17 matching lines @@
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(InvokeMathCFunction)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual Representation representation() const {
-    return kUnboxedDouble;
-  }
+  virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((0 <= idx) && (idx < InputCount()));
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
-  virtual intptr_t InputCount() const {
-    return inputs_->length();
-  }
+  virtual intptr_t InputCount() const { return inputs_->length(); }
 
-  virtual Value* InputAt(intptr_t i) const {
-    return (*inputs_)[i];
-  }
+  virtual Value* InputAt(intptr_t i) const { return (*inputs_)[i]; }
 
   virtual bool AttributesEqual(Instruction* other) const {
     InvokeMathCFunctionInstr* other_invoke = other->AsInvokeMathCFunction();
     return other_invoke->recognized_kind() == recognized_kind();
   }
 
   virtual bool MayThrow() const { return false; }
 
   static const intptr_t kSavedSpTempIndex = 0;
   static const intptr_t kObjectTempIndex = 1;
@@ skipping 29 matching lines @@
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(ExtractNthOutput)
 
   virtual CompileType ComputeType() const;
   virtual bool CanDeoptimize() const { return false; }
 
   intptr_t index() const { return index_; }
 
-  virtual Representation representation() const {
-    return definition_rep_;
-  }
+  virtual Representation representation() const { return definition_rep_; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     if (representation() == kTagged) {
       return kPairOfTagged;
     } else if (representation() == kUnboxedDouble) {
       return kPairOfUnboxedDouble;
     }
     UNREACHABLE();
     return definition_rep_;
@@ skipping 34 matching lines @@
     } else {
       UNIMPLEMENTED();
       return -1;
     }
   }
 
   MergedMathInstr::Kind kind() const { return kind_; }
 
   virtual intptr_t InputCount() const { return inputs_->length(); }
 
-  virtual Value* InputAt(intptr_t i) const {
-    return (*inputs_)[i];
-  }
+  virtual Value* InputAt(intptr_t i) const { return (*inputs_)[i]; }
 
   static intptr_t OutputIndexOf(MethodRecognizer::Kind kind);
   static intptr_t OutputIndexOf(Token::Kind token);
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const {
     if (kind_ == kTruncDivMod) {
       return true;
     } else if (kind_ == kSinCos) {
@@ skipping 71 matching lines @@
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   Value* value() const { return inputs_[0]; }
 
   const ICData& unary_checks() const { return unary_checks_; }
 
   const GrowableArray<intptr_t>& cids() const { return cids_; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
-  bool IsNullCheck() const {
-    return  DeoptIfNull() || DeoptIfNotNull();
-  }
+  bool IsNullCheck() const { return DeoptIfNull() || DeoptIfNotNull(); }
 
   bool DeoptIfNull() const;
   bool DeoptIfNotNull() const;
 
   bool IsDenseSwitch() const;
   static bool IsDenseCidRange(const ICData& unary_checks);
   intptr_t ComputeCidMask() const;
   static bool IsDenseMask(intptr_t mask);
 
   virtual bool AllowsCSE() const { return true; }
@@ skipping 90 matching lines @@
 
   Value* length() const { return inputs_[kLengthPos]; }
   Value* index() const { return inputs_[kIndexPos]; }
 
   DECLARE_INSTRUCTION(CheckArrayBound)
 
   virtual bool CanDeoptimize() const { return true; }
 
   bool IsRedundant(const RangeBoundary& length);
 
-  void mark_generalized() {
-    generalized_ = true;
-  }
+  void mark_generalized() { generalized_ = true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   // Returns the length offset for array and string types.
   static intptr_t LengthOffsetFor(intptr_t class_id);
 
   static bool IsFixedLengthArrayType(intptr_t class_id);
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
   // Give a name to the location/input indices.
-  enum {
-    kLengthPos = 0,
-    kIndexPos = 1
-  };
+  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 CanDeoptimize() const { return true; }
 
   // Give a name to the location/input indices.
-  enum {
-    kLengthPos = 0,
-    kIndexPos = 1
-  };
+  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) {
     ASSERT(from != to);
-    ASSERT((from == kUnboxedMint) ||
-           (from == kUnboxedUint32) ||
+    ASSERT((from == kUnboxedMint) || (from == kUnboxedUint32) ||
            (from == kUnboxedInt32));
-    ASSERT((to == kUnboxedMint) ||
-           (to == kUnboxedUint32) ||
+    ASSERT((to == kUnboxedMint) || (to == kUnboxedUint32) ||
            (to == kUnboxedInt32));
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   Representation from() const { return from_representation_; }
   Representation to() const { return to_representation_; }
   bool is_truncating() const { return is_truncating_; }
 
   void mark_truncating() { is_truncating_ = true; }
 
   Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool CanDeoptimize() const;
 
-  virtual Representation representation() const {
-    return to();
-  }
+  virtual Representation representation() const { return to(); }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return from();
   }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     ASSERT(other->IsUnboxedIntConverter());
     UnboxedIntConverterInstr* converter = other->AsUnboxedIntConverter();
-    return (converter->from() == from()) &&
-        (converter->to() == to()) &&
-        (converter->is_truncating() == is_truncating());
+    return (converter->from() == from()) && (converter->to() == to()) &&
+           (converter->is_truncating() == is_truncating());
   }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   virtual CompileType ComputeType() const {
     // TODO(vegorov) use range information to improve type.
     return CompileType::Int();
   }
 
   DECLARE_INSTRUCTION(UnboxedIntConverter);
@@ skipping 28 matching lines @@
 
 
 #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) { }
+        : environment_(environment), index_(0) {}
 
     ShallowIterator(const ShallowIterator& other)
         : ValueObject(),
           environment_(other.environment_),
-          index_(other.index_) { }
+          index_(other.index_) {}
 
     ShallowIterator& operator=(const ShallowIterator& other) {
       environment_ = other.environment_;
       index_ = other.index_;
       return *this;
     }
 
     Environment* environment() const { return environment_; }
 
     void Advance() {
@@ skipping 89 matching lines @@
     locations_ = locations;
   }
 
   void set_deopt_id(intptr_t deopt_id) { deopt_id_ = deopt_id; }
   intptr_t deopt_id() const { return deopt_id_; }
 
   Environment* outer() const { return outer_; }
 
   Environment* Outermost() {
     Environment* result = this;
-    while (result->outer() != NULL) result = result->outer();
+    while (result->outer() != NULL)
+      result = result->outer();
     return result;
   }
 
-  Value* ValueAt(intptr_t ix) const {
-    return values_[ix];
-  }
+  Value* ValueAt(intptr_t ix) const { return values_[ix]; }
 
-  intptr_t Length() const {
-    return values_.length();
-  }
+  intptr_t Length() const { return values_.length(); }
 
   Location LocationAt(intptr_t index) const {
     ASSERT((index >= 0) && (index < values_.length()));
     return locations_[index];
   }
 
   // The use index is the index in the flattened environment.
   Value* ValueAtUseIndex(intptr_t index) const {
     const Environment* env = this;
     while (index >= env->Length()) {
       ASSERT(env->outer_ != NULL);
       index -= env->Length();
       env = env->outer_;
     }
     return env->ValueAt(index);
   }
 
-  intptr_t fixed_parameter_count() const {
-    return fixed_parameter_count_;
-  }
+  intptr_t fixed_parameter_count() const { return fixed_parameter_count_; }
 
   intptr_t CountArgsPushed() {
     intptr_t count = 0;
     for (Environment::DeepIterator it(this); !it.Done(); it.Advance()) {
       if (it.CurrentValue()->definition()->IsPushArgument()) {
         count++;
       }
     }
     return count;
   }
 
   const Function& function() const { return parsed_function_.function(); }
 
-  Environment* DeepCopy(Zone* zone) const {
-    return DeepCopy(zone, Length());
-  }
+  Environment* DeepCopy(Zone* zone) const { return DeepCopy(zone, Length()); }
 
   void DeepCopyTo(Zone* zone, Instruction* instr) const;
   void DeepCopyToOuter(Zone* zone, Instruction* instr) const;
 
   void DeepCopyAfterTo(Zone* zone,
                        Instruction* instr,
                        intptr_t argc,
                        Definition* dead,
                        Definition* result) const;
 
@@ skipping 22 matching lines @@
   Environment(intptr_t length,
               intptr_t fixed_parameter_count,
               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) {
-  }
+        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() { }
+      : current_iterator_(NULL), block_order_(block_order) {}
+  virtual ~FlowGraphVisitor() {}
 
   ForwardInstructionIterator* current_iterator() const {
     return current_iterator_;
   }
 
   // Visit each block in the block order, and for each block its
   // instructions in order from the block entry to exit.
   virtual void VisitBlocks();
 
-  // Visit functions for instruction classes, with an empty default
-  // implementation.
+// Visit functions for instruction classes, with an empty default
+// implementation.
 #define DECLARE_VISIT_INSTRUCTION(ShortName)                                   \
-  virtual void Visit##ShortName(ShortName##Instr* instr) { }
+  virtual void Visit##ShortName(ShortName##Instr* instr) {}
 
   FOR_EACH_INSTRUCTION(DECLARE_VISIT_INSTRUCTION)
 
 #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;                                                              \
-  }                                                                           \
+#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_