[wasm] Check that type intersections don't yield empty.

src/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/typing-asm.h"
 
 #include <limits>
 
 #include "src/v8.h"
 
@@ skipping 490 matching lines @@
 
   Type* type = bounds_.get(expr).upper;
   Type* save_return_type = return_type_;
   return_type_ = type->AsFunction()->Result();
   in_function_ = true;
   local_variable_type_.Clear();
   RECURSE(VisitDeclarations(scope->declarations()));
   RECURSE(VisitStatements(expr->body()));
   in_function_ = false;
   return_type_ = save_return_type;
-  IntersectResult(expr, type);
+  RECURSE(IntersectResult(expr, type));
 }
 
 
 void AsmTyper::VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) {
   FAIL(expr, "function info literal encountered");
 }
 
 
 void AsmTyper::VisitDoExpression(DoExpression* expr) {
   FAIL(expr, "do-expression encountered");
@@ skipping 23 matching lines @@
       "conditional else branch type mismatch with enclosing expression"));
   Type* else_type = StorageType(computed_type_);
   if (intish_ != 0 || !else_type->Is(cache_.kAsmComparable)) {
     FAIL(expr->else_expression(), "invalid type in ? else expression");
   }
 
   if (!then_type->Is(else_type) || !else_type->Is(then_type)) {
     FAIL(expr, "then and else expressions in ? must have the same type");
   }
 
-  IntersectResult(expr, then_type);
+  RECURSE(IntersectResult(expr, then_type));
 }
 
 
 void AsmTyper::VisitVariableProxy(VariableProxy* expr) {
   Variable* var = expr->var();
   VariableInfo* info = GetVariableInfo(var);
   if (!in_function_ && !building_function_tables_ && !visiting_exports_) {
     if (var->location() != VariableLocation::PARAMETER || var->index() >= 3) {
       FAIL(expr, "illegal variable reference in module body");
     }
   }
   if (info == nullptr || info->type == nullptr) {
     if (var->mode() == TEMPORARY) {
       SetType(var, Type::Any());
       info = GetVariableInfo(var);
     } else {
       FAIL(expr, "unbound variable");
     }
   }
   if (property_info_ != nullptr) {
     SetVariableInfo(var, property_info_);
     property_info_ = nullptr;
   }
   Type* type = Type::Intersect(info->type, expected_type_, zone());
   if (type->Is(cache_.kAsmInt)) type = cache_.kAsmInt;
   intish_ = 0;
-  IntersectResult(expr, type);
+  RECURSE(IntersectResult(expr, type));
 }
 
 void AsmTyper::VisitLiteral(Literal* expr, bool is_return) {
   intish_ = 0;
   Handle<Object> value = expr->value();
   if (value->IsNumber()) {
     int32_t i;
     uint32_t u;
     if (expr->raw_value()->ContainsDot()) {
-      IntersectResult(expr, cache_.kAsmDouble);
+      RECURSE(IntersectResult(expr, cache_.kAsmDouble));
     } else if (!is_return && value->ToUint32(&u)) {
       if (u <= 0x7fffffff) {
-        IntersectResult(expr, cache_.kAsmFixnum);
+        RECURSE(IntersectResult(expr, cache_.kAsmFixnum));
       } else {
-        IntersectResult(expr, cache_.kAsmUnsigned);
+        RECURSE(IntersectResult(expr, cache_.kAsmUnsigned));
       }
     } else if (value->ToInt32(&i)) {
-      IntersectResult(expr, cache_.kAsmSigned);
+      RECURSE(IntersectResult(expr, cache_.kAsmSigned));
     } else {
       FAIL(expr, "illegal number");
     }
   } else if (!is_return && value->IsString()) {
-    IntersectResult(expr, Type::String());
+    RECURSE(IntersectResult(expr, Type::String()));
   } else if (value->IsUndefined()) {
-    IntersectResult(expr, Type::Undefined());
+    RECURSE(IntersectResult(expr, Type::Undefined()));
   } else {
     FAIL(expr, "illegal literal");
   }
 }
 
 
 void AsmTyper::VisitLiteral(Literal* expr) { VisitLiteral(expr, false); }
 
 
 void AsmTyper::VisitRegExpLiteral(RegExpLiteral* expr) {
   FAIL(expr, "regular expression encountered");
 }
 
 
 void AsmTyper::VisitObjectLiteral(ObjectLiteral* expr) {
   if (in_function_) {
     FAIL(expr, "object literal in function");
   }
   // Allowed for asm module's export declaration.
   ZoneList<ObjectLiteralProperty*>* props = expr->properties();
   for (int i = 0; i < props->length(); ++i) {
     ObjectLiteralProperty* prop = props->at(i);
     RECURSE(VisitWithExpectation(prop->value(), Type::Any(),
                                  "object property expected to be a function"));
     if (!computed_type_->IsFunction()) {
       FAIL(prop->value(), "non-function in function table");
     }
   }
-  IntersectResult(expr, Type::Object());
+  RECURSE(IntersectResult(expr, Type::Object()));
 }
 
 
 void AsmTyper::VisitArrayLiteral(ArrayLiteral* expr) {
   if (in_function_) {
     FAIL(expr, "array literal inside a function");
   }
   // Allowed for function tables.
   ZoneList<Expression*>* values = expr->values();
   Type* elem_type = Type::None();
   for (int i = 0; i < values->length(); ++i) {
     Expression* value = values->at(i);
     RECURSE(VisitWithExpectation(value, Type::Any(), "UNREACHABLE"));
     if (!computed_type_->IsFunction()) {
       FAIL(value, "array component expected to be a function");
     }
     elem_type = Type::Union(elem_type, computed_type_, zone());
   }
   array_size_ = values->length();
-  IntersectResult(expr, Type::Array(elem_type, zone()));
+  RECURSE(IntersectResult(expr, Type::Array(elem_type, zone())));
 }
 
 
 void AsmTyper::VisitAssignment(Assignment* expr) {
   // Handle function tables and everything else in different passes.
   if (!in_function_) {
     if (expr->value()->IsArrayLiteral()) {
       if (!building_function_tables_) {
         return;
       }
@@ skipping 27 matching lines @@
       }
     }
     if (property_info_ != nullptr) {
       SetVariableInfo(var, property_info_);
       property_info_ = nullptr;
     }
     Type* type = Type::Intersect(info->type, expected_type_, zone());
     if (type->Is(cache_.kAsmInt)) type = cache_.kAsmInt;
     info->type = type;
     intish_ = 0;
-    IntersectResult(proxy, type);
+    RECURSE(IntersectResult(proxy, type));
   } else if (expr->target()->IsProperty()) {
     // Assignment to a property: should be a heap assignment {H[x] = y}.
     int32_t value_intish = intish_;
     Property* property = expr->target()->AsProperty();
     RECURSE(VisitWithExpectation(property->obj(), Type::Any(),
                                  "bad propety object"));
     if (!computed_type_->IsArray()) {
       FAIL(property->obj(), "array expected");
     }
     if (value_intish != 0 && computed_type_->Is(cache_.kFloat64Array)) {
       FAIL(expr, "floatish assignment to double array");
     }
     VisitHeapAccess(property, true, target_type);
   }
-  IntersectResult(expr, target_type);
+  RECURSE(IntersectResult(expr, target_type));
 }
 
 
 void AsmTyper::VisitYield(Yield* expr) {
   FAIL(expr, "yield expression encountered");
 }
 
 
 void AsmTyper::VisitThrow(Throw* expr) {
   FAIL(expr, "throw statement encountered");
@@ skipping 39 matching lines @@
     //   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"));
-    IntersectResult(expr, type);
+    RECURSE(IntersectResult(expr, type));
   } else {
     Literal* literal = expr->key()->AsLiteral();
     if (literal) {
       RECURSE(VisitWithExpectation(literal, cache_.kAsmSigned,
                                    "array index expected to be integer"));
     } else {
       int expected_shift = ElementShiftSize(type);
       if (expected_shift == 0) {
         RECURSE(Visit(expr->key()));
       } else {
@@ skipping 38 matching lines @@
       }
       intish_ = 0;
     } else {
       UNREACHABLE();
     }
     if (assigning) {
       if (!assignment_type->Is(result_type)) {
         FAIL(expr, "illegal type in assignment");
       }
     } else {
-      IntersectResult(expr, expected_type_);
-      IntersectResult(expr, result_type);
+      RECURSE(IntersectResult(expr, expected_type_));
+      RECURSE(IntersectResult(expr, result_type));
     }
   }
 }
 
 
 bool AsmTyper::IsStdlibObject(Expression* expr) {
   VariableProxy* proxy = expr->AsVariableProxy();
   if (proxy == nullptr) {
     return false;
   }
@@ skipping 177 matching lines @@
         if (!computed_type_->Is(cache_.kAsmSigned) &&
             !computed_type_->Is(cache_.kAsmFixnum) &&
             !computed_type_->Is(cache_.kAsmDouble)) {
           FAIL(arg,
                "foreign call argument expected to be int, double, or fixnum");
         }
       }
       intish_ = 0;
       bounds_.set(expr->expression(),
                   Bounds(Type::Function(Type::Any(), zone())));
-      IntersectResult(expr, expected_type);
+      RECURSE(IntersectResult(expr, expected_type));
     } else {
       if (fun_type->Arity() != args->length()) {
         FAIL(expr, "call with wrong arity");
       }
       for (int i = 0; i < args->length(); ++i) {
         Expression* arg = args->at(i);
         RECURSE(VisitWithExpectation(
             arg, fun_type->Parameter(i),
             "call argument expected to match callee parameter"));
         if (standard_member != kNone && standard_member != kMathFround &&
             i == 0) {
           result_type = computed_type_;
         }
       }
       RECURSE(CheckPolymorphicStdlibArguments(standard_member, args));
       intish_ = 0;
-      IntersectResult(expr, result_type);
+      RECURSE(IntersectResult(expr, result_type));
     }
   } else {
     FAIL(expr, "invalid callee");
   }
 }
 
 
 void AsmTyper::VisitCallNew(CallNew* expr) {
   if (in_function_) {
     FAIL(expr, "new not allowed in module function");
   }
   RECURSE(VisitWithExpectation(expr->expression(), Type::Any(),
                                "expected stdlib function"));
   if (computed_type_->IsFunction()) {
     FunctionType* fun_type = computed_type_->AsFunction();
     ZoneList<Expression*>* args = expr->arguments();
     if (fun_type->Arity() != args->length())
       FAIL(expr, "call with wrong arity");
     for (int i = 0; i < args->length(); ++i) {
       Expression* arg = args->at(i);
       RECURSE(VisitWithExpectation(
           arg, fun_type->Parameter(i),
           "constructor argument expected to match callee parameter"));
     }
-    IntersectResult(expr, fun_type->Result());
+    RECURSE(IntersectResult(expr, fun_type->Result()));
     return;
   }
 
   FAIL(expr, "ill-typed new operator");
 }
 
 
 void AsmTyper::VisitCallRuntime(CallRuntime* expr) {
   FAIL(expr, "runtime call not allowed");
 }
 
 
 void AsmTyper::VisitUnaryOperation(UnaryOperation* expr) {
   if (!in_function_) {
     FAIL(expr, "unary operator inside module body");
   }
   switch (expr->op()) {
     case Token::NOT:  // Used to encode != and !==
       RECURSE(VisitWithExpectation(expr->expression(), cache_.kAsmInt,
                                    "operand expected to be integer"));
-      IntersectResult(expr, cache_.kAsmSigned);
+      RECURSE(IntersectResult(expr, cache_.kAsmSigned));
       return;
     case Token::DELETE:
       FAIL(expr, "delete operator encountered");
     case Token::VOID:
       FAIL(expr, "void operator encountered");
     case Token::TYPEOF:
       FAIL(expr, "typeof operator encountered");
     default:
       UNREACHABLE();
   }
@@ skipping 38 matching lines @@
     left_type = right_type;
   }
   if (right_type->Is(cache_.kAsmFixnum) && left_type->Is(cache_.kAsmInt)) {
     right_type = left_type;
   }
   if (!conversion) {
     if (!left_type->Is(cache_.kAsmIntQ) || !right_type->Is(cache_.kAsmIntQ)) {
       FAIL(expr, "ill-typed bitwise operation");
     }
   }
-  IntersectResult(expr, result_type);
+  RECURSE(IntersectResult(expr, result_type));
 }
 
 
 void AsmTyper::VisitBinaryOperation(BinaryOperation* expr) {
   if (!in_function_) {
     if (expr->op() != Token::BIT_OR && expr->op() != Token::MUL) {
       FAIL(expr, "illegal binary operator inside module body");
     }
     if (!(expr->left()->IsProperty() || expr->left()->IsVariableProxy()) ||
         !expr->right()->IsLiteral()) {
@@ skipping 11 matching lines @@
         FAIL(expr, "illegal double annotation value");
       }
     }
   }
   switch (expr->op()) {
     case Token::COMMA: {
       RECURSE(VisitWithExpectation(expr->left(), Type::Any(),
                                    "left comma operand expected to be any"));
       RECURSE(VisitWithExpectation(expr->right(), Type::Any(),
                                    "right comma operand expected to be any"));
-      IntersectResult(expr, computed_type_);
+      RECURSE(IntersectResult(expr, computed_type_));
       return;
     }
     case Token::OR:
     case Token::AND:
       FAIL(expr, "illegal logical operator");
     case Token::BIT_OR: {
       // BIT_OR allows Any since it is used as a type coercion.
       RECURSE(VisitIntegerBitwiseOperator(expr, Type::Any(), cache_.kAsmIntQ,
                                           cache_.kAsmSigned, true));
       if (expr->left()->IsCall() && expr->op() == Token::BIT_OR &&
           Type::Number()->Is(bounds_.get(expr->left()).upper)) {
         // Force the return types of foreign functions.
         bounds_.set(expr->left(), Bounds(cache_.kAsmSigned));
       }
       if (in_function_ &&
           !bounds_.get(expr->left()).upper->Is(cache_.kAsmIntQ)) {
         FAIL(expr->left(), "intish required");
       }
       return;
     }
     case Token::BIT_XOR: {
       // Handle booleans specially to handle de-sugared !
       Literal* left = expr->left()->AsLiteral();
       if (left && left->value()->IsBoolean()) {
         if (left->ToBooleanIsTrue()) {
           bounds_.set(left, Bounds(cache_.kSingletonOne));
           RECURSE(VisitWithExpectation(expr->right(), cache_.kAsmIntQ,
                                        "not operator expects an integer"));
-          IntersectResult(expr, cache_.kAsmSigned);
+          RECURSE(IntersectResult(expr, cache_.kAsmSigned));
           return;
         } else {
           FAIL(left, "unexpected false");
         }
       }
       // BIT_XOR allows Any since it is used as a type coercion (via ~~).
       RECURSE(VisitIntegerBitwiseOperator(expr, Type::Any(), cache_.kAsmIntQ,
                                           cache_.kAsmSigned, true));
       return;
     }
@@ skipping 41 matching lines @@
               FAIL(expr, "intish not allowed in multiply");
             }
           } else {
             FAIL(expr, "multiply must be by an integer literal");
           }
           i = abs(i);
           if (i >= (1 << 20)) {
             FAIL(expr, "multiply must be by value in -2^20 < n < 2^20");
           }
           intish_ = i;
-          IntersectResult(expr, cache_.kAsmInt);
+          RECURSE(IntersectResult(expr, cache_.kAsmInt));
           return;
         } else {
           intish_ = left_intish + right_intish + 1;
           if (expr->op() == Token::ADD || expr->op() == Token::SUB) {
             if (intish_ > kMaxUncombinedAdditiveSteps) {
               FAIL(expr, "too many consecutive additive ops");
             }
           } else {
             if (intish_ > kMaxUncombinedMultiplicativeSteps) {
               FAIL(expr, "too many consecutive multiplicative ops");
             }
           }
-          IntersectResult(expr, cache_.kAsmInt);
+          RECURSE(IntersectResult(expr, cache_.kAsmInt));
           return;
         }
       } else if (expr->op() == Token::MUL && expr->right()->IsLiteral() &&
                  right_type->Is(cache_.kAsmDouble) &&
                  expr->right()->AsLiteral()->raw_value()->ContainsDot() &&
                  expr->right()->AsLiteral()->raw_value()->AsNumber() == 1.0) {
         // For unary +, expressed as x * 1.0
         if (expr->left()->IsCall() &&
             Type::Number()->Is(bounds_.get(expr->left()).upper)) {
           // Force the return types of foreign functions.
           bounds_.set(expr->left(), Bounds(cache_.kAsmDouble));
           left_type = bounds_.get(expr->left()).upper;
         }
         if (!(expr->left()->IsProperty() &&
               Type::Number()->Is(bounds_.get(expr->left()).upper))) {
           if (!left_type->Is(cache_.kAsmSigned) &&
               !left_type->Is(cache_.kAsmUnsigned) &&
               !left_type->Is(cache_.kAsmFixnum) &&
               !left_type->Is(cache_.kAsmFloatQ) &&
               !left_type->Is(cache_.kAsmDoubleQ)) {
             FAIL(
                 expr->left(),
                 "unary + only allowed on signed, unsigned, float?, or double?");
           }
         }
-        IntersectResult(expr, cache_.kAsmDouble);
+        RECURSE(IntersectResult(expr, cache_.kAsmDouble));
         return;
       } else if (expr->op() == Token::MUL && left_type->Is(cache_.kAsmDouble) &&
                  expr->right()->IsLiteral() &&
                  !expr->right()->AsLiteral()->raw_value()->ContainsDot() &&
                  expr->right()->AsLiteral()->raw_value()->AsNumber() == -1.0) {
         // For unary -, expressed as x * -1
         bounds_.set(expr->right(), Bounds(cache_.kAsmDouble));
-        IntersectResult(expr, cache_.kAsmDouble);
+        RECURSE(IntersectResult(expr, cache_.kAsmDouble));
         return;
       } else if (type->Is(cache_.kAsmFloat) && expr->op() != Token::MOD) {
         if (left_intish != 0 || right_intish != 0) {
           FAIL(expr, "float operation before required fround");
         }
-        IntersectResult(expr, cache_.kAsmFloat);
+        RECURSE(IntersectResult(expr, cache_.kAsmFloat));
         intish_ = 1;
         return;
       } else if (type->Is(cache_.kAsmDouble)) {
-        IntersectResult(expr, cache_.kAsmDouble);
+        RECURSE(IntersectResult(expr, cache_.kAsmDouble));
         return;
       } else {
         FAIL(expr, "ill-typed arithmetic operation");
       }
     }
     default:
       UNREACHABLE();
   }
 }
 
@@ skipping 21 matching lines @@
                            "right comparison operand expected to be number"));
   Type* right_type = computed_type_;
   if (!right_type->Is(cache_.kAsmComparable)) {
     FAIL(expr->right(), "bad type on right side of comparison");
   }
 
   if (!left_type->Is(right_type) && !right_type->Is(left_type)) {
     FAIL(expr, "left and right side of comparison must match");
   }
 
-  IntersectResult(expr, cache_.kAsmSigned);
+  RECURSE(IntersectResult(expr, cache_.kAsmSigned));
 }
 
 
 void AsmTyper::VisitThisFunction(ThisFunction* expr) {
   FAIL(expr, "this function not allowed");
 }
 
 
 void AsmTyper::VisitDeclarations(ZoneList<Declaration*>* decls) {
   for (int i = 0; i < decls->length(); ++i) {
@@ skipping 199 matching lines @@
 
 void AsmTyper::SetResult(Expression* expr, Type* type) {
   computed_type_ = type;
   bounds_.set(expr, Bounds(computed_type_));
 }
 
 
 void AsmTyper::IntersectResult(Expression* expr, Type* type) {
   computed_type_ = type;
   Type* bounded_type = Type::Intersect(computed_type_, expected_type_, zone());
+  if (Type::Representation(bounded_type, zone())->Is(Type::None())) {
+#ifdef DEBUG
+    PrintF("Computed type: ");
+    computed_type_->Print();
+    PrintF("Expected type: ");
+    expected_type_->Print();
+#endif
+    FAIL(expr, "type mismatch");
+  }
   bounds_.set(expr, Bounds(bounded_type));
 }
 
 
 void AsmTyper::VisitWithExpectation(Expression* expr, Type* expected_type,
                                     const char* msg) {
   Type* save = expected_type_;
   expected_type_ = expected_type;
   RECURSE(Visit(expr));
   Type* bounded_type = Type::Intersect(computed_type_, expected_type_, zone());
-  if (bounded_type->Is(Type::None())) {
+  if (Type::Representation(bounded_type, zone())->Is(Type::None())) {
 #ifdef DEBUG
     PrintF("Computed type: ");
     computed_type_->Print();
     PrintF("Expected type: ");
     expected_type_->Print();
 #endif
     FAIL(expr, msg);
   }
   expected_type_ = save;
 }
 
 
 void AsmTyper::VisitRewritableExpression(RewritableExpression* expr) {
   RECURSE(Visit(expr->expression()));
 }
 
 
 }  // namespace internal
 }  // namespace v8