Optimize expressions of the form (expr === true) when expr has boolean type.

vm/intermediate_language.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 94 matching lines @@
 
 #define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
 FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 // Forward declarations.
 class BindInstr;
 class BranchInstr;
 class BufferFormatter;
 class ComparisonComp;
+class Definition;
 class Instruction;
 class PushArgumentInstr;
 class Value;
 
 class Computation : public ZoneAllocated {
  public:
   Computation() : deopt_id_(Isolate::kNoDeoptId), ic_data_(NULL), locs_(NULL) {
     Isolate* isolate = Isolate::Current();
     deopt_id_ = isolate->GetNextDeoptId();
     ic_data_ = isolate->GetICDataForDeoptId(deopt_id_);
@@ skipping 15 matching lines @@
   virtual Value* InputAt(intptr_t i) const = 0;
   virtual void SetInputAt(intptr_t i, Value* value) = 0;
 
   // Call computations override this function and return the
   // number of pushed arguments.
   virtual intptr_t ArgumentCount() const = 0;
 
   // Returns true, if this computation can deoptimize.
   virtual bool CanDeoptimize() const  = 0;
 
+  // Optimize this computation. Returns a replacement for the instruction
+  // that wraps this computation or NULL if nothing to replace.
+  virtual Definition* TryReplace(BindInstr* instr) { return NULL; }
+
   // Compile time type of the computation, which typically depends on the
   // compile time types (and possibly propagated types) of its inputs.
   virtual RawAbstractType* CompileType() const = 0;
 
   // Mutate assigned_vars to add the local variable index for all
   // frame-allocated locals assigned to by the computation.
   virtual void RecordAssignedVars(BitVector* assigned_vars,
                                   intptr_t fixed_parameter_count);
 
   virtual const char* DebugName() const = 0;
@@ skipping 187 matching lines @@
   UseVal* previous_use() const { return previous_use_; }
   virtual void RemoveFromUseList();
   virtual void RemoveInputUses() { RemoveFromUseList(); }
 
  private:
   void AddToUseList();
   Definition* definition_;
   UseVal* next_use_;
   UseVal* previous_use_;
 
+  friend class Definition;
+
   DISALLOW_COPY_AND_ASSIGN(UseVal);
 };
 
 
 class ConstantVal: public Value {
  public:
   explicit ConstantVal(const Object& value)
       : value_(value) {
     ASSERT(value.IsZoneHandle());
     ASSERT(value.IsSmi() || value.IsOld());
@@ skipping 272 matching lines @@
       : ComparisonComp(kind, left, right) {
     ASSERT((kind == Token::kEQ_STRICT) || (kind == Token::kNE_STRICT));
   }
 
   DECLARE_COMPUTATION(StrictCompare)
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual Definition* TryReplace(BindInstr* instr);
+
  private:
   DISALLOW_COPY_AND_ASSIGN(StrictCompareComp);
 };
 
 
 class EqualityCompareComp : public ComparisonComp {
  public:
   EqualityCompareComp(intptr_t token_pos,
                       intptr_t try_index,
                       Token::Kind kind,
@@ skipping 1708 matching lines @@
     propagated_type_ = propagated_type.raw();
     return changed;
   }
 
   UseVal* use_list() { return use_list_; }
   void set_use_list(UseVal* head) {
     ASSERT(head == NULL || head->previous_use() == NULL);
     use_list_ = head;
   }
 
+  void ReplaceUsesWith(Definition* other);
+
  private:
   intptr_t temp_index_;
   intptr_t ssa_temp_index_;
   // TODO(regis): GrowableArray<const AbstractType*> propagated_types_;
   // For now:
   AbstractType& propagated_type_;
   UseVal* use_list_;
 
   DISALLOW_COPY_AND_ASSIGN(Definition);
 };
@@ skipping 468 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_