Refactor branch instructions to enable further optimizations.

runtime/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 208 matching lines @@
   virtual ComparisonComp* AsComparison() { return NULL; }
 
   // Create a location summary for this computation.
   // TODO(fschneider): Temporarily returns NULL for instructions
   // that are not yet converted to the location based code generation.
   virtual LocationSummary* MakeLocationSummary() const = 0;
 
   // TODO(fschneider): Make EmitNativeCode and locs const.
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) = 0;
 
+  virtual void EmitBranchCode(FlowGraphCompiler* compiler,
+                              BranchInstr* branch) {
+    UNREACHABLE();
+  }
+
   static LocationSummary* MakeCallSummary();
 
   // Declare an enum value used to define kind-test predicates.
   enum ComputationKind {
 #define DECLARE_COMPUTATION_KIND(ShortName, ClassName) k##ShortName,
 
   FOR_EACH_COMPUTATION(DECLARE_COMPUTATION_KIND)
 
 #undef DECLARE_COMPUTATION_KIND
   };
 
   virtual ComputationKind computation_kind() const = 0;
 
   virtual Representation representation() const {
     return kTagged;
   }
 
   // Declare predicate for each computation.
 #define DECLARE_PREDICATE(ShortName, ClassName)                                \
   inline bool Is##ShortName() const;                                           \
   inline const ClassName* As##ShortName() const;                               \
   inline ClassName* As##ShortName();
 FOR_EACH_COMPUTATION(DECLARE_PREDICATE)
 #undef DECLARE_PREDICATE
 
  private:
+  friend class BranchInstr;
+
   intptr_t deopt_id_;
   const ICData* ic_data_;
   LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(Computation);
 };
 
 
 // An embedded container with N elements of type T.  Used (with partial
 // specialization for N=0) because embedded arrays cannot have size 0.
@@ skipping 539 matching lines @@
   DECLARE_COMPUTATION(StrictCompare)
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Definition* TryReplace(BindInstr* instr) const;
 
   virtual intptr_t ResultCid() const { return kBoolCid; }
 
+  virtual void EmitBranchCode(FlowGraphCompiler* compiler,
+                              BranchInstr* branch);
+
  private:
   DISALLOW_COPY_AND_ASSIGN(StrictCompareComp);
 };
 
 
 class EqualityCompareComp : public ComparisonComp {
  public:
   EqualityCompareComp(intptr_t token_pos,
                       intptr_t try_index,
                       Token::Kind kind,
@@ skipping 13 matching lines @@
 
   // Receiver class id is computed from collected ICData.
   void set_receiver_class_id(intptr_t value) { receiver_class_id_ = value; }
   intptr_t receiver_class_id() const { return receiver_class_id_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
   virtual intptr_t ResultCid() const;
 
+  virtual void EmitBranchCode(FlowGraphCompiler* compiler,
+                              BranchInstr* branch);
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   intptr_t receiver_class_id_;  // Set by optimizer.
 
   DISALLOW_COPY_AND_ASSIGN(EqualityCompareComp);
 };
 
 
 class RelationalOpComp : public ComparisonComp {
@@ skipping 21 matching lines @@
     operands_class_id_ = value;
   }
 
   intptr_t operands_class_id() const { return operands_class_id_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
   virtual intptr_t ResultCid() const;
 
+  virtual void EmitBranchCode(FlowGraphCompiler* compiler,
+                              BranchInstr* branch);
+
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   intptr_t operands_class_id_;  // class id of both operands.
 
   DISALLOW_COPY_AND_ASSIGN(RelationalOpComp);
 };
 
 
 class StaticCallComp : public TemplateComputation<0> {
@@ skipping 1297 matching lines @@
   M(Phi)                                                                       \
   M(Bind)                                                                      \
   M(Parameter)                                                                 \
   M(ParallelMove)                                                              \
   M(PushArgument)                                                              \
   M(Return)                                                                    \
   M(Throw)                                                                     \
   M(ReThrow)                                                                   \
   M(Goto)                                                                      \
   M(Branch)                                                                    \
-  M(StrictCompareAndBranch)
 
 
 // Forward declarations for Instruction classes.
 class BlockEntryInstr;
 class FlowGraphBuilder;
 class Environment;
 
 #define FORWARD_DECLARATION(type) class type##Instr;
 FOR_EACH_INSTRUCTION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
@@ skipping 989 matching lines @@
                              Condition true_condition);
 
  private:
   TargetEntryInstr* true_successor_;
   TargetEntryInstr* false_successor_;
 
   DISALLOW_COPY_AND_ASSIGN(ControlInstruction);
 };
 
 
-template<intptr_t N>
-class TemplateControlInstruction: public ControlInstruction {
+class BranchInstr : public ControlInstruction {
  public:
-  TemplateControlInstruction<N>() : locs_(NULL) { }
-
-  virtual intptr_t InputCount() const { return N; }
-  virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
-  virtual void SetInputAt(intptr_t i, Value* value) {
-    ASSERT(value != NULL);
-    inputs_[i] = value;
-  }
-
-  virtual LocationSummary* locs() {
-    if (locs_ == NULL) {
-      locs_ = MakeLocationSummary();
-    }
-    return locs_;
-  }
-
-  virtual LocationSummary* MakeLocationSummary() const = 0;
-
- protected:
-  EmbeddedArray<Value*, N> inputs_;
-
- private:
-  LocationSummary* locs_;
-};
-
-
-class BranchInstr : public TemplateControlInstruction<2> {
- public:
-  BranchInstr(intptr_t token_pos,
-              intptr_t try_index,
-              Value* left,
-              Value* right,
-              Token::Kind kind)
-      : deopt_id_(Isolate::kNoDeoptId),
-        ic_data_(NULL),
-        token_pos_(token_pos),
-        try_index_(try_index),
-        kind_(kind) {
-    ASSERT(left != NULL);
-    ASSERT(right != NULL);
-    inputs_[0] = left;
-    inputs_[1] = right;
-    ASSERT(!Token::IsStrictEqualityOperator(kind));
-    ASSERT(Token::IsEqualityOperator(kind) ||
-           Token::IsRelationalOperator(kind) ||
-           Token::IsTypeTestOperator(kind));
-    Isolate* isolate = Isolate::Current();
-    deopt_id_ = isolate->GetNextDeoptId();
-    ic_data_ = isolate->GetICDataForDeoptId(deopt_id_);
-  }
+  explicit BranchInstr(ComparisonComp* computation)
+      : computation_(computation), locs_(NULL) { }
 
   DECLARE_INSTRUCTION(Branch)
 
-  Value* left() const { return inputs_[0]; }
-  Value* right() const { return inputs_[1]; }
+  virtual intptr_t ArgumentCount() const {
+    return computation()->ArgumentCount();
+  }
+  intptr_t InputCount() const { return computation()->InputCount(); }
 
-  virtual intptr_t ArgumentCount() const { return 0; }
+  Value* InputAt(intptr_t i) const { return computation()->InputAt(i); }
 
-  Token::Kind kind() const { return kind_; }
-
-  intptr_t deopt_id() const { return deopt_id_; }
-
-  const ICData* ic_data() const { return ic_data_; }
-  bool HasICData() const {
-    return (ic_data() != NULL) && !ic_data()->IsNull();
+  void SetInputAt(intptr_t i, Value* value) {
+    computation()->SetInputAt(i, value);
   }
 
-  intptr_t token_pos() const { return token_pos_;}
-  intptr_t try_index() const { return try_index_; }
+  virtual bool CanDeoptimize() const { return computation()->CanDeoptimize(); }
 
-  virtual LocationSummary* MakeLocationSummary() const;
+  ComparisonComp* computation() const { return computation_; }
+  void set_computation(ComparisonComp* value) { computation_ = value; }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
-  virtual bool CanDeoptimize() const { return true; }
+  virtual LocationSummary* locs() {
+    if (computation_->locs_ == NULL) {
+      LocationSummary* summary = computation_->MakeLocationSummary();
+      // Branches don't produce a result.
+      summary->set_out(Location::NoLocation());
+      computation_->locs_ = summary;
+    }
+    return computation_->locs_;
+  }
 
  private:
-  intptr_t deopt_id_;
-  const ICData* ic_data_;
-  const intptr_t token_pos_;
-  const intptr_t try_index_;
-  const Token::Kind kind_;
+  ComparisonComp* computation_;
+  LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 
-class StrictCompareAndBranchInstr : public TemplateControlInstruction<2> {
- public:
-  StrictCompareAndBranchInstr(Value* left, Value* right, Token::Kind kind)
-        : kind_(kind) {
-    ASSERT(left != NULL);
-    ASSERT(right != NULL);
-    inputs_[0] = left;
-    inputs_[1] = right;
-    ASSERT(Token::IsStrictEqualityOperator(kind));
-  }
-
-  DECLARE_INSTRUCTION(StrictCompareAndBranch)
-
-  Value* left() const { return inputs_[0]; }
-  Value* right() const { return inputs_[1]; }
-
-  virtual intptr_t ArgumentCount() const { return 0; }
-
-  Token::Kind kind() const { return kind_; }
-
-  virtual LocationSummary* MakeLocationSummary() const;
-
-  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
-
-  virtual bool CanDeoptimize() const { return false; }
-
- private:
-  const Token::Kind kind_;
-
-  DISALLOW_COPY_AND_ASSIGN(StrictCompareAndBranchInstr);
-};
-
-
 #undef DECLARE_INSTRUCTION
 
 
 class Environment : public ZoneAllocated {
  public:
   // Construct an environment by constructing uses from an array of definitions.
   Environment(const GrowableArray<Definition*>& definitions,
               intptr_t fixed_parameter_count);
 
   void set_locations(Location* locations) {
@@ skipping 76 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_