V8. ASM-2-WASM. Small fixes.

src/asmjs/asm-typer.cc

 // Copyright 2016 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/asm-typer.h"
 
 #include <limits>
 #include <string>
 
 #include "src/v8.h"
@@ skipping 182 matching lines @@
   auto* sqrt = ceil;
 
   struct StandardMemberInitializer {
     const char* name;
     StandardMember standard_member;
     AsmType* type;
   };
 
   const StandardMemberInitializer stdlib[] = {{"Infinity", kInfinity, d},
                                               {"NaN", kNaN, d},
-#define asm_TYPED_ARRAYS(V) \
+#define ASM_TYPED_ARRAYS(V) \
   V(Uint8)                  \
   V(Int8)                   \
   V(Uint16)                 \
   V(Int16)                  \
   V(Uint32)                 \
   V(Int32)                  \
   V(Float32)                \
   V(Float64)
 
-#define asm_TYPED_ARRAY(TypeName) \
+#define ASM_TYPED_ARRAY(TypeName) \
   {#TypeName "Array", kNone, AsmType::TypeName##Array()},
-                                              asm_TYPED_ARRAYS(asm_TYPED_ARRAY)
-#undef asm_TYPED_ARRAY
+                                              ASM_TYPED_ARRAYS(ASM_TYPED_ARRAY)
+#undef ASM_TYPED_ARRAY
   };
   for (size_t ii = 0; ii < arraysize(stdlib); ++ii) {
     stdlib_types_[stdlib[ii].name] = new (zone_) VariableInfo(stdlib[ii].type);
     stdlib_types_[stdlib[ii].name]->set_standard_member(
         stdlib[ii].standard_member);
     stdlib_types_[stdlib[ii].name]->set_mutability(
         VariableInfo::kImmutableGlobal);
   }
 
   const StandardMemberInitializer math[] = {
@@ skipping 1389 matching lines @@
     }
 
     return value_type;
   }
 
   if (auto* target_as_property = assignment->target()->AsProperty()) {
     AsmType* allowed_store_types;
     RECURSE(allowed_store_types =
                 ValidateHeapAccess(target_as_property, StoreToHeap));
 
-    // TODO(jpp): Change FloatishDoubleQ and FloatQDoubleQ so that they are base
-    // classes for Floatish, DoubleQ, and FloatQ.
-    if (allowed_store_types == AsmType::FloatishDoubleQ()) {
-      if (!value_type->IsA(AsmType::Floatish()) &&
-          !value_type->IsA(AsmType::DoubleQ())) {
-        FAIL(assignment, "Type mismatch in heap assignment.");
-      }
-    } else if (allowed_store_types == AsmType::FloatQDoubleQ()) {
-      if (!value_type->IsA(AsmType::FloatQ()) &&
-          !value_type->IsA(AsmType::DoubleQ())) {
-        FAIL(assignment, "Type mismatch in heap assignment.");
-      }
-    } else {
-      if (!value_type->IsA(allowed_store_types)) {
-        FAIL(assignment, "Type mismatch in heap assignment.");
-      }
+    if (!value_type->IsA(allowed_store_types)) {
+      FAIL(assignment, "Type mismatch in heap assignment.");
     }
 
     return value_type;
   }
 
   FAIL(assignment, "Invalid asm.js assignment.");
 }
 
 // 6.8.7 UnaryExpression
 AsmType* AsmTyper::ValidateUnaryExpression(UnaryOperation* unop) {
@@ skipping 635 matching lines @@
   if (as_literal == nullptr) {
     return false;
   }
 
   if (as_literal->raw_value()->ContainsDot()) {
     return false;
   }
 
   return as_literal->value()->ToUint32(value);
 }
+
+// Returns whether index is too large to access a heap with the given type.
+bool LiteralIndexOutOfBounds(AsmType* obj_type, uint32_t index) {
+  switch (obj_type->ElementSizeInBytes()) {
+    case 1:
+      return false;
+    case 2:
+      return (index & 0x80000000u) != 0;
+    case 4:
+      return (index & 0xC0000000u) != 0;
+    case 8:
+      return (index & 0xE0000000u) != 0;
+  }
+  UNREACHABLE();
+  return true;
+}
+
 }  // namespace
 
 AsmType* AsmTyper::ValidateHeapAccess(Property* heap,
                                       HeapAccessType access_type) {
   auto* obj = heap->obj()->AsVariableProxy();
   if (obj == nullptr) {
     FAIL(heap, "Invalid heap access.");
   }
 
   auto* obj_info = Lookup(obj->var());
   if (obj_info == nullptr) {
     FAIL(heap, "Undeclared identifier in heap access.");
   }
 
   auto* obj_type = obj_info->type();
   if (!obj_type->IsA(AsmType::Heap())) {
     FAIL(heap, "Identifier does not represent a heap view.");
   }
   SetTypeOf(obj, obj_type);
 
   if (auto* key_as_literal = heap->key()->AsLiteral()) {
     if (key_as_literal->raw_value()->ContainsDot()) {
-      FAIL(key_as_literal, "Heap access index must be intish.");
+      FAIL(key_as_literal, "Heap access index must be int.");
     }
 
-    uint32_t _;
-    if (!key_as_literal->value()->ToUint32(&_)) {
+    uint32_t index;
+    if (!key_as_literal->value()->ToUint32(&index)) {
       FAIL(key_as_literal,
            "Heap access index must be a 32-bit unsigned integer.");
     }
 
+    if (LiteralIndexOutOfBounds(obj_type, index)) {
+      FAIL(key_as_literal, "Heap access index is out of bounds");
+    }
+
     if (access_type == LoadFromHeap) {
       return obj_type->LoadType();
     }
     return obj_type->StoreType();
   }
 
   if (auto* key_as_binop = heap->key()->AsBinaryOperation()) {
     uint32_t shift;
     if (key_as_binop->op() == Token::SAR &&
         ExtractHeapAccessShift(key_as_binop->right(), &shift) &&
@@ skipping 283 matching lines @@
     return true;
   }
 
   *error_message = typer.error_message();
   return false;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8