Fix for running with --throw_on_javascript_int_overflow: recognize pattern (a << b) & mask and test…

runtime/vm/ast.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_AST_H_
 #define VM_AST_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/growable_array.h"
 #include "vm/scopes.h"
 #include "vm/object.h"
 #include "vm/native_entry.h"
 #include "vm/token.h"
 
 namespace dart {
 
 #define NODE_LIST(V)                                                           \
   V(ReturnNode, "return")                                                      \
   V(LiteralNode, "literal")                                                    \
   V(TypeNode, "type")                                                          \
   V(AssignableNode, "assignable")                                              \
   V(BinaryOpNode, "binop")                                                     \
+  V(BinaryOpWithMask32Node, "binop with mask 32")                              \
   V(ComparisonNode, "compare")                                                 \
   V(UnaryOpNode, "unaryop")                                                    \
   V(ConditionalExprNode, "?:")                                                 \
   V(IfNode, "if")                                                              \
   V(SwitchNode, "switch")                                                      \
   V(CaseNode, "case")                                                          \
   V(WhileNode, "while")                                                        \
   V(DoWhileNode, "dowhile")                                                    \
   V(ForNode, "for")                                                            \
   V(JumpNode, "jump")                                                          \
@@ skipping 538 matching lines @@
       : AstNode(token_pos), kind_(kind), left_(left), right_(right) {
     ASSERT(left_ != NULL);
     ASSERT(right_ != NULL);
     ASSERT(IsKindValid());
   }
 
   Token::Kind kind() const { return kind_; }
   AstNode* left() const { return left_; }
   AstNode* right() const { return right_; }
 
+  virtual bool has_mask32() const { return false; }
+  virtual int64_t mask32() const {
+    UNREACHABLE();
+    return 0;
+  }
+
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     left()->Visit(visitor);
     right()->Visit(visitor);
   }
 
   virtual const char* Name() const;
   virtual bool IsPotentiallyConst() const;
   virtual const Instance* EvalConstExpr() const;
 
   DECLARE_COMMON_NODE_FUNCTIONS(BinaryOpNode);
 
  private:
   const Token::Kind kind_;
   AstNode* left_;
   AstNode* right_;
 
   bool IsKindValid() const;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(BinaryOpNode);
 };
 
 
+class BinaryOpWithMask32Node : public BinaryOpNode {
+ public:
+  BinaryOpWithMask32Node(intptr_t token_pos,
+                         Token::Kind kind_value,
+                         AstNode* left,
+                         AstNode* right,
+                         int64_t mask32)
+      : BinaryOpNode(token_pos, kind_value, left, right), mask32_(mask32) {
+    ASSERT(mask32 >= 0 && Utils::IsUint(32, mask32));
+    ASSERT((kind_value != Token::kAND) && (kind_value != Token::kOR));
+  }
+
+  // The optional 32-bit mask must be a an unsigned 32-bit value.
+  virtual bool has_mask32() const { return true; }
+  virtual int64_t mask32() const {
+    ASSERT(has_mask32());
+    return mask32_;
+  }
+
+  virtual const char* Name() const;
+  DECLARE_COMMON_NODE_FUNCTIONS(BinaryOpWithMask32Node);
+
+ private:
+  // Optional unsigned 32 bit mask applied on result. No mask: -1.
+  const int64_t mask32_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(BinaryOpWithMask32Node);
+};
+
+
+
 class UnaryOpNode : public AstNode {
  public:
   // Returns optimized version, e.g., for ('-' '1') ('-1') literal is returned.
   static AstNode* UnaryOpOrLiteral(intptr_t token_pos,
                                    Token::Kind kind,
                                    AstNode* operand);
   UnaryOpNode(intptr_t token_pos,
               Token::Kind kind,
               AstNode* operand)
       : AstNode(token_pos), kind_(kind), operand_(operand) {
@@ skipping 1096 matching lines @@
   const intptr_t try_index_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(InlinedFinallyNode);
 };
 
 }  // namespace dart
 
 #undef DECLARE_COMMON_NODE_FUNCTIONS
 
 #endif  // VM_AST_H_