V8. ASM-2-WASM. Enforces source code layout.

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 <string>
 
 #include "src/v8.h"
 
 #include "src/asmjs/asm-types.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/base/bits.h"
 #include "src/codegen.h"
@@ skipping 442 matching lines @@
   if (assign->op() != Token::INIT) {
     // Done with initializers.
     return nullptr;
   }
   return assign;
 }
 
 }  // namespace
 
 // 6.1 ValidateModule
+namespace {
+// SourceLayoutTracker keeps track of the start and end positions of each
+// section in the asm.js source. The sections should not overlap, otherwise the
+// asm.js source is invalid.
+class SourceLayoutTracker {
+ public:
+  SourceLayoutTracker() = default;
+
+  bool IsValid() const {
+    const Section* kAllSections[] = {&use_asm_, &globals_, &functions_,
+                                     &tables_, &exports_};
+    for (size_t ii = 0; ii < arraysize(kAllSections); ++ii) {
+      const auto& curr_section = *kAllSections[ii];
+      for (size_t jj = ii + 1; jj < arraysize(kAllSections); ++jj) {
+        if (curr_section.OverlapsWith(*kAllSections[jj])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  void AddUseAsm(const AstNode& node) { use_asm_.AddNewElement(node); }
+
+  void AddGlobal(const AstNode& node) { globals_.AddNewElement(node); }
+
+  void AddFunction(const AstNode& node) { functions_.AddNewElement(node); }
+
+  void AddTable(const AstNode& node) { tables_.AddNewElement(node); }
+
+  void AddExport(const AstNode& node) { exports_.AddNewElement(node); }
+
+ private:
+  class Section {
+   public:
+    Section() = default;
+    Section(const Section&) = default;
+    Section& operator=(const Section&) = default;
+
+    void AddNewElement(const AstNode& node) {
+      const int node_pos = node.position();
+      if (start_ == kNoSourcePosition) {
+        start_ = node_pos;
+      } else {
+        start_ = std::max(start_, node_pos);
+      }
+      if (end_ == kNoSourcePosition) {
+        end_ = node_pos;
+      } else {
+        end_ = std::max(end_, node_pos);
+      }
+    }
+
+    bool OverlapsWith(const Section& other) const {
+      if (start_ == kNoSourcePosition) {
+        DCHECK_EQ(end_, kNoSourcePosition);
+        return false;
+      }
+      if (other.start_ == kNoSourcePosition) {
+        DCHECK_EQ(other.end_, kNoSourcePosition);
+        return false;
+      }
+      return other.start_ < end_ || other.end_ < start_;
+    }
+
+   private:
+    int start_ = kNoSourcePosition;
+    int end_ = kNoSourcePosition;
+  };
+
+  Section use_asm_;
+  Section globals_;
+  Section functions_;
+  Section tables_;
+  Section exports_;
+
+  DISALLOW_COPY_AND_ASSIGN(SourceLayoutTracker);
+};
+}  // namespace
+
 AsmType* AsmTyper::ValidateModule(FunctionLiteral* fun) {
+  SourceLayoutTracker source_layout;
+
   Scope* scope = fun->scope();
   if (!scope->is_function_scope()) FAIL(fun, "Not at function scope.");
   if (!ValidAsmIdentifier(fun->name()))
     FAIL(fun, "Invalid asm.js identifier in module name.");
   module_name_ = fun->name();
 
   // Allowed parameters: Stdlib, FFI, Mem
   static const uint32_t MaxModuleParameters = 3;
   if (scope->num_parameters() > MaxModuleParameters) {
     FAIL(fun, "asm.js modules may not have more than three parameters.");
@@ skipping 20 matching lines @@
       FAIL(fun, "Redeclared identifier in module parameter.");
     }
   }
 
   ZoneVector<Assignment*> function_pointer_tables(zone_);
   FlattenedStatements iter(zone_, fun->body());
   auto* use_asm_directive = iter.Next();
   if (use_asm_directive == nullptr || !IsUseAsmDirective(use_asm_directive)) {
     FAIL(fun, "Missing \"use asm\".");
   }
+  source_layout.AddUseAsm(*use_asm_directive);
   ReturnStatement* module_return = nullptr;
 
   // *VIOLATION* The spec states that globals should be followed by function
   // declarations, which should be followed by function pointer tables, followed
   // by the module export (return) statement. Our AST might be rearraged by the
   // parser, so we can't rely on it being in source code order.
   while (Statement* current = iter.Next()) {
     if (auto* assign = ExtractInitializerExpression(current)) {
       if (assign->value()->IsArrayLiteral()) {
         // Save function tables for later validation.
         function_pointer_tables.push_back(assign);
       } else {
         RECURSE(ValidateGlobalDeclaration(assign));
+        source_layout.AddGlobal(*assign);
       }
       continue;
     }
 
     if (auto* current_as_return = current->AsReturnStatement()) {
       if (module_return != nullptr) {
         FAIL(fun, "Multiple export statements.");
       }
       module_return = current_as_return;
+      source_layout.AddExport(*module_return);
       continue;
     }
 
     FAIL(current, "Invalid top-level statement in asm.js module.");
   }
 
   ZoneList<Declaration*>* decls = scope->declarations();
 
   for (int ii = 0; ii < decls->length(); ++ii) {
     Declaration* decl = decls->at(ii);
 
     if (FunctionDeclaration* fun_decl = decl->AsFunctionDeclaration()) {
       RECURSE(ValidateFunction(fun_decl));
+      source_layout.AddFunction(*fun_decl);
       continue;
     }
   }
 
   for (auto* function_table : function_pointer_tables) {
     RECURSE(ValidateFunctionTable(function_table));
+    source_layout.AddTable(*function_table);
   }
 
   for (int ii = 0; ii < decls->length(); ++ii) {
     Declaration* decl = decls->at(ii);
 
     if (decl->IsFunctionDeclaration()) {
       continue;
     }
 
     VariableDeclaration* var_decl = decl->AsVariableDeclaration();
@@ skipping 18 matching lines @@
 
   for (auto* forward_def : forward_definitions_) {
     if (forward_def->missing_definition()) {
       FAIL(forward_def->first_forward_use(),
            "Missing definition for forward declared identifier.");
     }
   }
 
   RECURSE(ValidateExport(module_return));
 
+  if (!source_layout.IsValid()) {
+    FAIL(fun, "Invalid asm.js source code layout.");
+  }
+
   return AsmType::Int();  // Any type that is not AsmType::None();
 }
 
 namespace {
 bool IsDoubleAnnotation(BinaryOperation* binop) {
   // *VIOLATION* The parser replaces uses of +x with x*1.0.
   if (binop->op() != Token::MUL) {
     return false;
   }
 
@@ skipping 2036 matching lines @@
     return true;
   }
 
   *error_message = typer.error_message();
   return false;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8