Remove Expression::bounds_, in order to conserve memory during parsing.

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 44 matching lines @@
 #undef V
           global_variable_type_(HashMap::PointersMatch,
                                 ZoneHashMap::kDefaultHashMapCapacity,
                                 ZoneAllocationPolicy(zone)),
       local_variable_type_(HashMap::PointersMatch,
                            ZoneHashMap::kDefaultHashMapCapacity,
                            ZoneAllocationPolicy(zone)),
       in_function_(false),
       building_function_tables_(false),
       visiting_exports_(false),
-      cache_(TypeCache::Get()) {
+      cache_(TypeCache::Get()),
+      bounds_(zone) {
   InitializeAstVisitor(isolate);
   InitializeStdlib();
 }
 
 
 bool AsmTyper::Validate() {
   VisitAsmModule(root_);
   return valid_ && !HasStackOverflow();
 }
 
@@ skipping 411 matching lines @@
 }
 
 
 void AsmTyper::VisitFunctionLiteral(FunctionLiteral* expr) {
   if (in_function_) {
     FAIL(expr, "invalid nested function");
   }
   Scope* scope = expr->scope();
   DCHECK(scope->is_function_scope());
 
-  if (!expr->bounds().upper->IsFunction()) {
+  if (!bounds_.get(expr).upper->IsFunction()) {
     FAIL(expr, "invalid function literal");
   }
 
-  Type* type = expr->bounds().upper;
+  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);
 }
@@ skipping 284 matching lines @@
         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"));
         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");
         }
       }
-      expr->key()->set_bounds(Bounds(cache_.kAsmSigned));
+      bounds_.set(expr->key(), Bounds(cache_.kAsmSigned));
     }
     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 130 matching lines @@
   FAIL(expr, "invalid property access");
 }
 
 void AsmTyper::CheckPolymorphicStdlibArguments(
     enum StandardMember standard_member, ZoneList<Expression*>* args) {
   if (args->length() == 0) {
     return;
   }
   // Handle polymorphic stdlib functions specially.
   Expression* arg0 = args->at(0);
-  Type* arg0_type = arg0->bounds().upper;
+  Type* arg0_type = bounds_.get(arg0).upper;
   switch (standard_member) {
     case kMathFround: {
       if (!arg0_type->Is(cache_.kAsmFloat) &&
           !arg0_type->Is(cache_.kAsmDouble) &&
           !arg0_type->Is(cache_.kAsmSigned) &&
           !arg0_type->Is(cache_.kAsmUnsigned)) {
         FAIL(arg0, "illegal function argument type");
       }
       break;
     }
     case kMathCeil:
     case kMathFloor:
     case kMathSqrt: {
       if (!arg0_type->Is(cache_.kAsmFloat) &&
           !arg0_type->Is(cache_.kAsmDouble)) {
         FAIL(arg0, "illegal function argument type");
       }
       break;
     }
     case kMathAbs:
     case kMathMin:
     case kMathMax: {
       if (!arg0_type->Is(cache_.kAsmFloat) &&
           !arg0_type->Is(cache_.kAsmDouble) &&
           !arg0_type->Is(cache_.kAsmSigned)) {
         FAIL(arg0, "illegal function argument type");
       }
       if (args->length() > 1) {
-        Type* other = Type::Intersect(args->at(0)->bounds().upper,
-                                      args->at(1)->bounds().upper, zone());
+        Type* other = Type::Intersect(bounds_.get(args->at(0)).upper,
+                                      bounds_.get(args->at(1)).upper, zone());
         if (!other->Is(cache_.kAsmFloat) && !other->Is(cache_.kAsmDouble) &&
             !other->Is(cache_.kAsmSigned)) {
           FAIL(arg0, "function arguments types don't match");
         }
       }
       break;
     }
     default: { break; }
   }
 }
@@ skipping 26 matching lines @@
         // Checking for asm extern types explicitly, as the type system
         // doesn't correctly check their inheritance relationship.
         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;
-      expr->expression()->set_bounds(
-          Bounds(Type::Function(Type::Any(), zone())));
+      bounds_.set(expr->expression(),
+                  Bounds(Type::Function(Type::Any(), zone())));
       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"));
@@ skipping 145 matching lines @@
       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(expr->left()->bounds().upper)) {
+          Type::Number()->Is(bounds_.get(expr->left()).upper)) {
         // Force the return types of foreign functions.
-        expr->left()->set_bounds(Bounds(cache_.kAsmSigned));
+        bounds_.set(expr->left(), Bounds(cache_.kAsmSigned));
       }
-      if (in_function_ && !expr->left()->bounds().upper->Is(cache_.kAsmIntQ)) {
+      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()) {
-          left->set_bounds(Bounds(cache_.kSingletonOne));
+          bounds_.set(left, Bounds(cache_.kSingletonOne));
           RECURSE(VisitWithExpectation(expr->right(), cache_.kAsmIntQ,
                                        "not operator expects an integer"));
           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,
@@ skipping 66 matching lines @@
           }
           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(expr->left()->bounds().upper)) {
+            Type::Number()->Is(bounds_.get(expr->left()).upper)) {
           // Force the return types of foreign functions.
-          expr->left()->set_bounds(Bounds(cache_.kAsmDouble));
-          left_type = expr->left()->bounds().upper;
+          bounds_.set(expr->left(), Bounds(cache_.kAsmDouble));
+          left_type = bounds_.get(expr->left()).upper;
         }
         if (!(expr->left()->IsProperty() &&
-              Type::Number()->Is(expr->left()->bounds().upper))) {
+              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);
         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
-        expr->right()->set_bounds(Bounds(cache_.kAsmDouble));
+        bounds_.set(expr->right(), Bounds(cache_.kAsmDouble));
         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);
         intish_ = 1;
         return;
       } else if (type->Is(cache_.kAsmDouble)) {
@@ skipping 245 matching lines @@
 AsmTyper::StandardMember AsmTyper::VariableAsStandardMember(
     Variable* variable) {
   VariableInfo* info = GetVariableInfo(variable);
   if (!info) return kNone;
   return info->standard_member;
 }
 
 
 void AsmTyper::SetResult(Expression* expr, Type* type) {
   computed_type_ = type;
-  expr->set_bounds(Bounds(computed_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());
-  expr->set_bounds(Bounds(bounded_type));
+  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())) {
 #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