[wasm] allow array access with unsigned indices

src/asmjs/typing-asm.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/asmjs/typing-asm.h"
 
 #include <limits>
 
 #include "src/v8.h"
 
@@ skipping 745 matching lines @@
     // Literal* right = bin->right()->AsLiteral();
     // if (right == nullptr || right->raw_value()->ContainsDot()) {
     //   FAIL(right, "call mask must be integer");
     // }
     // RECURSE(VisitWithExpectation(bin->right(), cache_.kAsmSigned,
     //                              "call mask expected to be integer"));
     // if (static_cast<size_t>(right->raw_value()->AsNumber()) != size - 1) {
     //   FAIL(right, "call mask must match function table");
     // }
     // bin->set_bounds(Bounds(cache_.kAsmSigned));
-    RECURSE(VisitWithExpectation(expr->key(), cache_.kAsmSigned,
-                                 "must be integer"));
+    RECURSE(
+        VisitWithExpectation(expr->key(), cache_.kAsmSigned, "must be int"));
     RECURSE(IntersectResult(expr, type));
   } else {
     Literal* literal = expr->key()->AsLiteral();
     if (literal) {
-      RECURSE(VisitWithExpectation(literal, cache_.kAsmSigned,
-                                   "array index expected to be integer"));
+      RECURSE(VisitWithExpectation(literal, cache_.kAsmUnsigned,
+                                   "array index expected to be unsigned"));
     } else {
       int expected_shift = ElementShiftSize(type);
       if (expected_shift == 0) {
         RECURSE(Visit(expr->key()));
       } else {
         BinaryOperation* bin = expr->key()->AsBinaryOperation();
         if (bin == nullptr || bin->op() != Token::SAR) {
           FAIL(expr->key(), "expected >> in heap access");
         }
-        RECURSE(VisitWithExpectation(bin->left(), cache_.kAsmSigned,
+        RECURSE(VisitWithExpectation(bin->left(), cache_.kAsmInt,
                                      "array index expected to be integer"));
         Literal* right = bin->right()->AsLiteral();
         if (right == nullptr || right->raw_value()->ContainsDot()) {
           FAIL(bin->right(), "heap access shift must be integer");
         }
-        RECURSE(VisitWithExpectation(bin->right(), cache_.kAsmSigned,
-                                     "array shift expected to be integer"));
+        RECURSE(VisitWithExpectation(bin->right(), cache_.kAsmFixnum,
+                                     "array shift expected to be Fixnum"));
         int n = static_cast<int>(right->raw_value()->AsNumber());
         if (expected_shift < 0 || n != expected_shift) {
           FAIL(right, "heap access shift must match element size");
         }
       }
-      bounds_.set(expr->key(), Bounds(cache_.kAsmSigned));
+      bounds_.set(expr->key(), Bounds(cache_.kAsmUnsigned));
     }
     Type* result_type;
     if (type->Is(cache_.kAsmIntArrayElement)) {
       result_type = cache_.kAsmIntQ;
       intish_ = kMaxUncombinedAdditiveSteps;
     } else if (type->Is(cache_.kAsmFloat)) {
       if (assigning) {
         result_type = cache_.kAsmFloatDoubleQ;
       } else {
         result_type = cache_.kAsmFloatQ;
@@ skipping 790 matching lines @@
   }
   expected_type_ = save;
 }
 
 void AsmTyper::VisitRewritableExpression(RewritableExpression* expr) {
   RECURSE(Visit(expr->expression()));
 }
 
 }  // namespace internal
 }  // namespace v8