Separate branch on strict compare into a new IL instruction.

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 1972 matching lines @@
 // concatenated.
 #define FOR_EACH_INSTRUCTION(M)                                                \
   M(GraphEntry)                                                                \
   M(JoinEntry)                                                                 \
   M(TargetEntry)                                                               \
   M(Phi)                                                                       \
   M(Bind)                                                                      \
   M(Parameter)                                                                 \
   M(ParallelMove)                                                              \
   M(PushArgument)                                                              \
   M(Return)                                                                    \

[Kevin Millikin (Google), 2012/08/24 12:37:26]

Return, Throw, ReThrow, and Goto should also become control instructions.

That's not completely trivial, so let's do it separately.

   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 941 matching lines @@
 
  private:
   JoinEntryInstr* successor_;
 
   // Parallel move that will be used by linear scan register allocator to
   // connect live ranges at the end of the block and resolve phis.
   ParallelMoveInstr* parallel_move_;
 };
 
 
-class BranchInstr : public TemplateInstruction<2> {
+class ControlInstruction : public Instruction {
+ public:
+  ControlInstruction() : true_successor_(NULL), false_successor_(NULL) { }
+
+  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;
+
+  virtual void DiscoverBlocks(
+      BlockEntryInstr* current_block,
+      GrowableArray<BlockEntryInstr*>* preorder,
+      GrowableArray<BlockEntryInstr*>* postorder,
+      GrowableArray<intptr_t>* parent,
+      GrowableArray<BitVector*>* assigned_vars,
+      intptr_t variable_count,
+      intptr_t fixed_parameter_count);
+
+
+  void EmitBranchOnCondition(FlowGraphCompiler* compiler,
+                             Condition true_condition);
+
+ private:
+  TargetEntryInstr* true_successor_;
+  TargetEntryInstr* false_successor_;
+
+  DISALLOW_COPY_AND_ASSIGN(ControlInstruction);
+};
+
+
+template<intptr_t N>
+class TemplateControlInstruction: 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),
-        true_successor_(NULL),
-        false_successor_(NULL) {
+        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_);
   }
 
   DECLARE_INSTRUCTION(Branch)
 
+  Value* left() const { return inputs_[0]; }
+  Value* right() const { return inputs_[1]; }
+
   virtual intptr_t ArgumentCount() const { return 0; }
 
-  Value* left() const { return inputs_[0]; }
-  Value* right() const { return inputs_[1]; }
   Token::Kind kind() const { return kind_; }
   void set_kind(Token::Kind kind) {
+    ASSERT(!Token::IsStrictEqualityOperator(kind));
     ASSERT(Token::IsEqualityOperator(kind) ||
            Token::IsRelationalOperator(kind) ||
            Token::IsTypeTestOperator(kind));
     kind_ = 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();
   }
 
   intptr_t token_pos() const { return token_pos_;}
   intptr_t try_index() const { return try_index_; }
 
-  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;
-
-  virtual void DiscoverBlocks(
-      BlockEntryInstr* current_block,
-      GrowableArray<BlockEntryInstr*>* preorder,
-      GrowableArray<BlockEntryInstr*>* postorder,
-      GrowableArray<intptr_t>* parent,
-      GrowableArray<BitVector*>* assigned_vars,
-      intptr_t variable_count,
-      intptr_t fixed_parameter_count);
-
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
-  void EmitBranchOnCondition(FlowGraphCompiler* compiler,
-                             Condition true_condition);
-
   virtual bool CanDeoptimize() const { return true; }
 
  private:
   intptr_t deopt_id_;
   ICData* ic_data_;
   const intptr_t token_pos_;
   const intptr_t try_index_;
   Token::Kind kind_;
-  TargetEntryInstr* true_successor_;
-  TargetEntryInstr* false_successor_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 
+class StrictCompareAndBranchInstr : public TemplateControlInstruction<2> {

[srdjan, 2012/08/24 21:35:05]

You could use this to replace BranchInstr in
FlowGraphOptimizer::VisitBranch(BranchInstr* instr) .

[Florian Schneider, 2012/08/27 08:55:30]

Currently it is not very convenient to replace branch instructions because of
updating the control flow graph. I'm doing it in the builder instead, since this
is an optimization that does not rely on type feedback and can therefore also be
done in the non-optimizing case.

+ 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:
+  Token::Kind kind_;

[srdjan, 2012/08/24 18:55:39]

const 

[Florian Schneider, 2012/08/27 08:55:30]

Done.

+
+  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_