VM-codegen: Add IL instruction to check if a Smi is in a constant range

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 397 matching lines @@
   M(LoadField)                                                                 \
   M(LoadUntagged)                                                              \
   M(LoadClassId)                                                               \
   M(InstantiateType)                                                           \
   M(InstantiateTypeArguments)                                                  \
   M(AllocateContext)                                                           \
   M(AllocateUninitializedContext)                                              \
   M(CloneContext)                                                              \
   M(BinarySmiOp)                                                               \
   M(CheckedSmiComparison)                                                      \
+  M(SmiRangeComparison)                                                        \
   M(CheckedSmiOp)                                                              \
   M(BinaryInt32Op)                                                             \
   M(UnarySmiOp)                                                                \
   M(UnaryDoubleOp)                                                             \
   M(CheckStackOverflow)                                                        \
   M(SmiToDouble)                                                               \
   M(Int32ToDouble)                                                             \
   M(MintToDouble)                                                              \
   M(DoubleToInteger)                                                           \
   M(DoubleToSmi)                                                               \
@@ skipping 6529 matching lines @@
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
  private:
   InstanceCallInstr* call_;
   bool is_negated_;
   DISALLOW_COPY_AND_ASSIGN(CheckedSmiComparisonInstr);
 };
 
 
+// Instruction that checks whether a Smi input is in a constant
+// inclusive range.
+class SmiRangeComparisonInstr : public TemplateComparison<1, NoThrow, Pure> {
+ public:
+  SmiRangeComparisonInstr(TokenPosition token_pos,
+                          Value* input,
+                          intptr_t from,
+                          intptr_t to)
+      : TemplateComparison(token_pos, Token::kIS, Thread::kNoDeoptId),

[Vyacheslav Egorov (Google), 2017/06/28 13:53:47]

Please comment here why Token::kIS makes sense for this instruction. 

[erikcorry, 2017/07/03 08:59:55]

Done.

+        from_(from),
+        to_(to),
+        is_negated_(false) {
+    SetInputAt(0, input);
+  }
+
+  virtual bool ComputeCanDeoptimize() const { return false; }
+
+  virtual void NegateComparison() {
+    ComparisonInstr::NegateComparison();
+    is_negated_ = !is_negated_;
+  }
+
+  Value* input() const { return inputs_[0]; }
+
+  intptr_t from() { return from_; }
+  intptr_t to() { return to_; }
+  bool is_negated() const { return is_negated_; }

[Vyacheslav Egorov (Google), 2017/06/28 13:53:47]

I think you don't need is_negated_ member:

is_negated() => op_kind() == Token::kIS_NOT;

[erikcorry, 2017/07/03 08:59:55]

Done.

+
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+
+  virtual CompileType ComputeType() const;
+
+  PRINT_OPERANDS_TO_SUPPORT
+
+  DECLARE_COMPARISON_INSTRUCTION(SmiRangeComparison)
+
+  virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
+
+  virtual Representation RequiredInputRepresentation(intptr_t idx) const {
+    return kTagged;
+  }
+
+ private:
+  intptr_t from_;

[Vyacheslav Egorov (Google), 2017/06/28 13:53:47]

const intptr_t from_; 
const intptr_t to_;

Also you need to override AttributesEqual otherwise CSE will think that all
SmiRangeComparisonInstr are the same.

[erikcorry, 2017/07/03 08:59:55]

Done.

+  intptr_t to_;
+  bool is_negated_;
+  DISALLOW_COPY_AND_ASSIGN(SmiRangeComparisonInstr);
+};
+
+
 class BinaryIntegerOpInstr : public TemplateDefinition<2, NoThrow, Pure> {
  public:
   BinaryIntegerOpInstr(Token::Kind op_kind,
                        Value* left,
                        Value* right,
                        intptr_t deopt_id)
       : TemplateDefinition(deopt_id),
         op_kind_(op_kind),
         can_overflow_(true),
         is_truncating_(false) {
@@ skipping 1279 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_