Reduce copying, redundancy & repetition for codegen of comparison instructions

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 518 matching lines @@
 #define DECLARE_INSTRUCTION_BACKEND()                                          \
   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()
 
+#if defined(TARGET_ARCH_DBC)
+#define DECLARE_COMPARISON_METHODS                                             \
+  virtual LocationSummary* MakeLocationSummary(Zone* zone, bool optimizing)    \
+      const;                                                                   \
+  virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,            \
+                                       BranchLabels labels);                   \
+  virtual Condition GetPredictedCondition(FlowGraphCompiler* compiler,         \
+                                          BranchLabels labels);
+#else
+#define DECLARE_COMPARISON_METHODS                                             \
+  virtual LocationSummary* MakeLocationSummary(Zone* zone, bool optimizing)    \
+      const;                                                                   \
+  virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,            \
+                                       BranchLabels labels);
+#endif
+
+#define DECLARE_COMPARISON_INSTRUCTION(type)                                   \
+  DECLARE_INSTRUCTION_NO_BACKEND(type)                                         \
+  DECLARE_COMPARISON_METHODS
+
 #ifndef PRODUCT
 #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;
 #else
@@ skipping 410 matching lines @@
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   LocationSummary* locs_;
   intptr_t inlining_id_;
 
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
+struct BranchLabels {
+  Label* true_label;
+  Label* false_label;
+  Label* fall_through;
+};
+
+
 class PureInstruction : public Instruction {
  public:
   explicit PureInstruction(intptr_t deopt_id) : Instruction(deopt_id) {}
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 };
 
@@ skipping 934 matching lines @@
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   friend class BranchInstr;
   friend class IfThenElseInstr;
 
   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),
@@ skipping 473 matching lines @@
       : 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; }
 
+  virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);

[Vyacheslav Egorov (Google), 2017/06/15 11:32:46]

I think all of these methods should simply go into ComparisonInstr - then you
don't need explicit template instantiations for different variants of
EmitBranchCode.

[Vyacheslav Egorov (Google), 2017/06/15 11:32:46]

Also comment what this does.

[erikcorry, 2017/06/19 07:15:09]

I was sure there was some reason that would not work, but it works. :-)

[erikcorry, 2017/06/19 07:15:09]

Done.

+
+  // Used by EmitBranchCode and EmitNativeCode depending on whether the boolean
+  // is to be turned into branches or instantiated.
+  // May return a valid condition in which case the caller is expected to emit
+  // a branch based on that condition.  May also branch directly to the labels.

[Vyacheslav Egorov (Google), 2017/06/15 11:32:46]

"emit a branch based on that condition" <- specify where the branch can go (e.g.
should it go to false or true?)

[erikcorry, 2017/06/19 07:15:09]

Done.

+  virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
+                                       BranchLabels labels) = 0;
+
+#if defined(TARGET_ARCH_DBC)
+  virtual Condition GetPredictedCondition(FlowGraphCompiler* compiler,

[Vyacheslav Egorov (Google), 2017/06/15 11:32:46]

Comment what this does.

[erikcorry, 2017/06/19 07:15:09]

Done.

+                                          BranchLabels labels) = 0;
+#endif
+
+  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 };
 
 
 class BranchInstr : public Instruction {
  public:
@@ skipping 598 matching lines @@
 
 class StrictCompareInstr : public TemplateComparison<2, NoThrow, Pure> {
  public:
   StrictCompareInstr(TokenPosition token_pos,
                      Token::Kind kind,
                      Value* left,
                      Value* right,
                      bool needs_number_check,
                      intptr_t deopt_id);
 
-  DECLARE_INSTRUCTION(StrictCompare)
+  DECLARE_COMPARISON_INSTRUCTION(StrictCompare)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
-  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
 
  private:
   // True if the comparison must check for double, Mint or Bigint and
   // use value comparison instead.
@@ skipping 10 matching lines @@
   TestSmiInstr(TokenPosition token_pos,
                Token::Kind kind,
                Value* left,
                Value* right)
       : TemplateComparison(token_pos, kind) {
     ASSERT(kind == Token::kEQ || kind == Token::kNE);
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
-  DECLARE_INSTRUCTION(TestSmi);
+  DECLARE_COMPARISON_INSTRUCTION(TestSmi);
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     return kTagged;
   }
 
-  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
 // a result or deoptimizes.  If the cid is not in the list and there is a deopt
 // id, then the instruction deoptimizes.  If there is no deopt id, all the
 // results must be the same (all true or all false) and the instruction returns
 // the opposite for cids not on the list.  The first element in the table must
 // always be the result for the Smi class-id and is allowed to differ from the
 // other results even in the no-deopt case.
 class TestCidsInstr : public TemplateComparison<1, NoThrow, Pure> {
  public:
   TestCidsInstr(TokenPosition token_pos,
                 Token::Kind kind,
                 Value* value,
                 const ZoneGrowableArray<intptr_t>& cid_results,
                 intptr_t deopt_id);
 
   const ZoneGrowableArray<intptr_t>& cid_results() const {
     return cid_results_;
   }
 
-  DECLARE_INSTRUCTION(TestCids);
+  DECLARE_COMPARISON_INSTRUCTION(TestCids);
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool ComputeCanDeoptimize() 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 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_;
   bool licm_hoisted_;
   DISALLOW_COPY_AND_ASSIGN(TestCidsInstr);
 };
 
 
 class EqualityCompareInstr : public TemplateComparison<2, NoThrow, Pure> {
  public:
   EqualityCompareInstr(TokenPosition token_pos,
                        Token::Kind kind,
                        Value* left,
                        Value* right,
                        intptr_t cid,
                        intptr_t deopt_id)
       : TemplateComparison(token_pos, kind, deopt_id) {
     ASSERT(Token::IsEqualityOperator(kind));
     SetInputAt(0, left);
     SetInputAt(1, right);
     set_operation_cid(cid);
   }
 
-  DECLARE_INSTRUCTION(EqualityCompare)
+  DECLARE_COMPARISON_INSTRUCTION(EqualityCompare)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  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(EqualityCompareInstr);
 };
 
 
 class RelationalOpInstr : public TemplateComparison<2, NoThrow, Pure> {
  public:
   RelationalOpInstr(TokenPosition token_pos,
                     Token::Kind kind,
                     Value* left,
                     Value* right,
                     intptr_t cid,
                     intptr_t deopt_id)
       : TemplateComparison(token_pos, kind, deopt_id) {
     ASSERT(Token::IsRelationalOperator(kind));
     SetInputAt(0, left);
     SetInputAt(1, right);
     set_operation_cid(cid);
   }
 
-  DECLARE_INSTRUCTION(RelationalOp)
+  DECLARE_COMPARISON_INSTRUCTION(RelationalOp)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
-  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:
@@ skipping 2100 matching lines @@
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   PRINT_OPERANDS_TO_SUPPORT
 
-  DECLARE_INSTRUCTION(DoubleTestOp)
+  DECLARE_COMPARISON_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);
   }
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
-  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,
@@ skipping 1549 matching lines @@
 
   PRINT_OPERANDS_TO_SUPPORT
 
   DECLARE_INSTRUCTION(CheckedSmiComparison)
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler, BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
+#if defined(TARGET_ARCH_DBC)
+  virtual Condition GetPredictedCondition(FlowGraphCompiler* compiler,
+                                          BranchLabels labels) {
+    UNREACHABLE();
+    return INVALID_CONDITION;
+  }
+#endif
+
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
  private:
   InstanceCallInstr* call_;
   bool is_negated_;
   DISALLOW_COPY_AND_ASSIGN(CheckedSmiComparisonInstr);
 };
 
 
 class BinaryIntegerOpInstr : public TemplateDefinition<2, NoThrow, Pure> {
@@ skipping 1288 matching lines @@
   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_