[wasm][asm.js] Confirm literals are Numbers before using AsNumber, refactor.

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 <algorithm>
 #include <limits>
 #include <memory>
 #include <string>
@@ skipping 433 matching lines @@
   DCHECK_NE(type, AsmType::None());
   if (in_function_) {
     DCHECK(function_node_types_.find(node) == function_node_types_.end());
     function_node_types_.insert(std::make_pair(node, type));
   } else {
     DCHECK(module_node_types_.find(node) == module_node_types_.end());
     module_node_types_.insert(std::make_pair(node, type));
   }
 }
 
+namespace {
+bool IsLiteralDouble(Literal* literal) {
+  return literal->raw_value()->IsNumber() &&
+         literal->raw_value()->ContainsDot();
+}
+
+bool IsLiteralInt(Literal* literal) {
+  return literal->raw_value()->IsNumber() &&
+         !literal->raw_value()->ContainsDot();
+}
+
+bool IsLiteralMinus1(Literal* literal) {
+  return IsLiteralInt(literal) && literal->raw_value()->AsNumber() == -1.0;
+}
+
+bool IsLiteral1Dot0(Literal* literal) {
+  return IsLiteralDouble(literal) && literal->raw_value()->AsNumber() == 1.0;
+}
+
+bool IsLiteral0(Literal* literal) {
+  return IsLiteralInt(literal) && literal->raw_value()->AsNumber() == 0.0;
+}
+}  // namespace
+
 AsmType* AsmTyper::TypeOf(AstNode* node) const {
   auto node_type_iter = function_node_types_.find(node);
   if (node_type_iter != function_node_types_.end()) {
     return node_type_iter->second;
   }
   node_type_iter = module_node_types_.find(node);
   if (node_type_iter != module_node_types_.end()) {
     return node_type_iter->second;
   }
 
   // Sometimes literal nodes are not added to the node_type_ map simply because
   // their are not visited with ValidateExpression().
   if (auto* literal = node->AsLiteral()) {
-    if (literal->raw_value()->ContainsDot()) {
+    if (IsLiteralDouble(literal)) {
       return AsmType::Double();
     }
+    if (!IsLiteralInt(literal)) {
+      return AsmType::None();
+    }
     uint32_t u;
     if (literal->value()->ToUint32(&u)) {
       if (u > LargestFixNum) {
         return AsmType::Unsigned();
       }
       return AsmType::FixNum();
     }
     int32_t i;
     if (literal->value()->ToInt32(&i)) {
       return AsmType::Signed();
@@ skipping 247 matching lines @@
   // *VIOLATION* The parser replaces uses of +x with x*1.0.
   if (binop->op() != Token::MUL) {
     return false;
   }
 
   auto* right_as_literal = binop->right()->AsLiteral();
   if (right_as_literal == nullptr) {
     return false;
   }
 
-  return right_as_literal->raw_value()->ContainsDot() &&
-         right_as_literal->raw_value()->AsNumber() == 1.0;
+  return IsLiteral1Dot0(right_as_literal);
 }
 
 bool IsIntAnnotation(BinaryOperation* binop) {
   if (binop->op() != Token::BIT_OR) {
     return false;
   }
 
   auto* right_as_literal = binop->right()->AsLiteral();
   if (right_as_literal == nullptr) {
     return false;
   }
 
-  return !right_as_literal->raw_value()->ContainsDot() &&
-         right_as_literal->raw_value()->AsNumber() == 0.0;
+  return IsLiteral0(right_as_literal);
 }
 }  // namespace
 
 AsmType* AsmTyper::ValidateGlobalDeclaration(Assignment* assign) {
   DCHECK(!assign->is_compound());
   if (assign->is_compound()) {
     FAIL(assign,
          "Compound assignment not supported when declaring global variables.");
   }
 
@@ skipping 696 matching lines @@
 
 // 6.6 ValidateCase
 namespace {
 bool ExtractInt32CaseLabel(CaseClause* clause, int32_t* lbl) {
   auto* lbl_expr = clause->label()->AsLiteral();
 
   if (lbl_expr == nullptr) {
     return false;
   }
 
-  if (lbl_expr->raw_value()->ContainsDot()) {
+  if (!IsLiteralInt(lbl_expr)) {
     return false;
   }
 
   return lbl_expr->value()->ToInt32(lbl);
 }
 }  // namespace
 
 AsmType* AsmTyper::ValidateCase(CaseClause* label, int32_t* case_lbl) {
   if (!ExtractInt32CaseLabel(label, case_lbl)) {
     FAIL(label, "Case label must be a 32-bit signed integer.");
@@ skipping 76 matching lines @@
 bool IsInvert(BinaryOperation* binop) {
   if (binop->op() != Token::BIT_XOR) {
     return false;
   }
 
   auto* right_as_literal = binop->right()->AsLiteral();
   if (right_as_literal == nullptr) {
     return false;
   }
 
-  return !right_as_literal->raw_value()->ContainsDot() &&
-         right_as_literal->raw_value()->AsNumber() == -1.0;
+  return IsLiteralMinus1(right_as_literal);
 }
 
 bool IsUnaryMinus(BinaryOperation* binop) {
   // *VIOLATION* The parser replaces uses of -x with x*-1.
   if (binop->op() != Token::MUL) {
     return false;
   }
 
   auto* right_as_literal = binop->right()->AsLiteral();
   if (right_as_literal == nullptr) {
     return false;
   }
 
-  return !right_as_literal->raw_value()->ContainsDot() &&
-         right_as_literal->raw_value()->AsNumber() == -1.0;
+  return IsLiteralMinus1(right_as_literal);
 }
 }  // namespace
 
 AsmType* AsmTyper::ValidateBinaryOperation(BinaryOperation* expr) {
 #define UNOP_OVERLOAD(Src, Dest)          \
   do {                                    \
     if (left_type->IsA(AsmType::Src())) { \
       return AsmType::Dest();             \
     }                                     \
   } while (0)
@@ skipping 108 matching lines @@
 }
 
 // 6.8.2 NumericLiteral
 AsmType* AsmTyper::ValidateNumericLiteral(Literal* literal) {
   // *VIOLATION* asm.js does not allow the use of undefined, but our parser
   // inserts them, so we have to handle them.
   if (literal->IsUndefinedLiteral()) {
     return AsmType::Void();
   }
 
-  if (literal->raw_value()->ContainsDot()) {
+  if (IsLiteralDouble(literal)) {
     return AsmType::Double();
   }
 
   // The parser collapses expressions like !0 and !123 to true/false.
   // We therefore need to permit these as alternate versions of 0 / 1.
   if (literal->raw_value()->IsTrue() || literal->raw_value()->IsFalse()) {
     return AsmType::Int();
   }
 
   uint32_t value;
@@ skipping 159 matching lines @@
 }
 
 // 6.8.8 MultiplicativeExpression
 namespace {
 bool IsIntishLiteralFactor(Expression* expr, int32_t* factor) {
   auto* literal = expr->AsLiteral();
   if (literal == nullptr) {
     return false;
   }
 
-  if (literal->raw_value()->ContainsDot()) {
+  if (!IsLiteralInt(literal)) {
     return false;
   }
 
   if (!literal->value()->ToInt32(factor)) {
     return false;
   }
   static const int32_t kIntishBound = 1 << 20;
   return -kIntishBound < *factor && *factor < kIntishBound;
 }
 }  // namespace
@@ skipping 388 matching lines @@
 }
 
 // 6.9 ValidateCall
 namespace {
 bool ExtractIndirectCallMask(Expression* expr, uint32_t* value) {
   auto* as_literal = expr->AsLiteral();
   if (as_literal == nullptr) {
     return false;
   }
 
-  if (as_literal->raw_value()->ContainsDot()) {
+  if (!IsLiteralInt(as_literal)) {
     return false;
   }
 
   if (!as_literal->value()->ToUint32(value)) {
     return false;
   }
 
   return base::bits::IsPowerOfTwo32(1 + *value);
 }
 }  // namespace
@@ skipping 163 matching lines @@
 }
 
 // 6.10 ValidateHeapAccess
 namespace {
 bool ExtractHeapAccessShift(Expression* expr, uint32_t* value) {
   auto* as_literal = expr->AsLiteral();
   if (as_literal == nullptr) {
     return false;
   }
 
-  if (as_literal->raw_value()->ContainsDot()) {
+  if (!IsLiteralInt(as_literal)) {
     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:
@@ skipping 23 matching lines @@
     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()) {
+    if (!IsLiteralInt(key_as_literal)) {
       FAIL(key_as_literal, "Heap access index must be int.");
     }
 
     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)) {
@@ skipping 163 matching lines @@
 
   if (auto* call = ret_expr->AsCall()) {
     if (IsCallToFround(call)) {
       return AsmType::Float();
     }
     FAIL(statement, "Invalid function call in return statement.");
   }
 
   if (auto* literal = ret_expr->AsLiteral()) {
     int32_t _;
-    if (literal->raw_value()->ContainsDot()) {
+    if (IsLiteralDouble(literal)) {
       return AsmType::Double();
-    } else if (literal->value()->ToInt32(&_)) {
+    } else if (IsLiteralInt(literal) && literal->value()->ToInt32(&_)) {
       return AsmType::Signed();
     } else if (literal->IsUndefinedLiteral()) {
       // *VIOLATION* The parser changes
       //
       // return;
       //
       // into
       //
       // return undefined
       return AsmType::Void();
@@ skipping 20 matching lines @@
   }
 
   FAIL(statement, "Invalid return type expression.");
 }
 
 // 5.4 VariableTypeAnnotations
 // Also used for 5.5 GlobalVariableTypeAnnotations
 AsmType* AsmTyper::VariableTypeAnnotations(
     Expression* initializer, VariableInfo::Mutability mutability_type) {
   if (auto* literal = initializer->AsLiteral()) {
-    if (literal->raw_value()->ContainsDot()) {
+    if (IsLiteralDouble(literal)) {
       SetTypeOf(initializer, AsmType::Double());
       return AsmType::Double();
     }
+    if (!IsLiteralInt(literal)) {
+      FAIL(initializer, "Invalid type annotation - forbidden literal.");
+    }
     int32_t i32;
     uint32_t u32;
-
     AsmType* initializer_type = nullptr;
     if (literal->value()->ToUint32(&u32)) {
       if (u32 > LargestFixNum) {
         initializer_type = AsmType::Unsigned();
         SetTypeOf(initializer, initializer_type);
       } else {
         initializer_type = AsmType::FixNum();
         SetTypeOf(initializer, initializer_type);
         initializer_type = AsmType::Signed();
       }
@@ skipping 107 matching lines @@
     return true;
   }
 
   *error_message = typer.error_message();
   return false;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8