[wasm] Add support for import section.

src/wasm/ast-decoder.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/base/platform/elapsed-timer.h"
 #include "src/signature.h"
 
 #include "src/bit-vector.h"
 #include "src/flags.h"
 #include "src/handles.h"
@@ skipping 157 matching lines @@
   inline bool Validate(const byte* pc, SignatureIndexOperand& operand) {
     ModuleEnv* m = function_env_->module;
     if (m && m->module && operand.index < m->module->signatures->size()) {
       operand.sig = m->module->signatures->at(operand.index);
       return true;
     }
     error(pc, pc + 1, "invalid signature index");
     return false;
   }
 
+  inline bool Validate(const byte* pc, ImportIndexOperand& operand) {
+    ModuleEnv* m = function_env_->module;
+    if (m && m->module && operand.index < m->module->import_table->size()) {
+      operand.sig = m->module->import_table->at(operand.index).sig;
+      return true;
+    }
+    error(pc, pc + 1, "invalid signature index");
+    return false;
+  }
+
   inline bool Validate(const byte* pc, BreakDepthOperand& operand,
                        ZoneVector<Block>& blocks) {
     if (operand.depth < blocks.size()) {
       operand.target = &blocks[blocks.size() - operand.depth - 1];
       return true;
     }
     error(pc, pc + 1, "invalid break depth");
     return false;
   }
 
@@ skipping 66 matching lines @@
         return static_cast<int>(
             function_env_->module->GetFunctionSignature(operand.index)
                 ->parameter_count());
       }
       case kExprCallIndirect: {
         SignatureIndexOperand operand(this, pc);
         return 1 + static_cast<int>(
                        function_env_->module->GetSignature(operand.index)
                            ->parameter_count());
       }
+      case kExprCallImport: {
+        ImportIndexOperand operand(this, pc);
+        return static_cast<int>(
+            function_env_->module->GetImportSignature(operand.index)
+                ->parameter_count());
+      }
       case kExprReturn: {
         return static_cast<int>(function_env_->sig->return_count());
       }
       case kExprTableSwitch: {
         TableSwitchOperand operand(this, pc);
         return 1 + operand.case_count;
       }
 
 #define DECLARE_OPCODE_CASE(name, opcode, sig) \
   case kExpr##name:                            \
@@ skipping 36 matching lines @@
       }
 
       case kExprCallFunction: {
         FunctionIndexOperand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprCallIndirect: {
         SignatureIndexOperand operand(this, pc);
         return 1 + operand.length;
       }
+      case kExprCallImport: {
+        ImportIndexOperand operand(this, pc);
+        return 1 + operand.length;
+      }
 
       case kExprSetLocal:
       case kExprGetLocal: {
         LocalIndexOperand operand(this, pc);
         return 1 + operand.length;
       }
       case kExprTableSwitch: {
         TableSwitchOperand operand(this, pc);
         return 1 + operand.length;
       }
@@ skipping 453 matching lines @@
           SignatureIndexOperand operand(this, pc_);
           if (Validate(pc_, operand)) {
             LocalType type = operand.sig->return_count() == 0
                                  ? kAstStmt
                                  : operand.sig->GetReturn();
             Shift(type, static_cast<int>(1 + operand.sig->parameter_count()));
           }
           len = 1 + operand.length;
           break;
         }
+        case kExprCallImport: {
+          ImportIndexOperand operand(this, pc_);
+          if (Validate(pc_, operand)) {
+            LocalType type = operand.sig->return_count() == 0
+                                 ? kAstStmt
+                                 : operand.sig->GetReturn();
+            Shift(type, static_cast<int>(operand.sig->parameter_count()));
+          }
+          len = 1 + operand.length;
+          break;
+        }
         default:
           error("Invalid opcode");
           return;
       }
       pc_ += len;
       if (pc_ >= limit_) {
         // End of code reached or exceeded.
         if (pc_ > limit_ && ok()) {
           error("Beyond end of code");
         }
@@ skipping 402 matching lines @@
         if (p->done() && build()) {
           uint32_t count = p->tree->count;
           TFNode** buffer = builder_->Buffer(count);
           for (uint32_t i = 0; i < count; i++) {
             buffer[i] = p->tree->children[i]->node;
           }
           p->tree->node = builder_->CallIndirect(operand.index, buffer);
         }
         break;
       }
+      case kExprCallImport: {
+        ImportIndexOperand operand(this, p->pc());
+        CHECK(Validate(p->pc(), operand));
+        if (p->index > 0) {
+          TypeCheckLast(p, operand.sig->GetParam(p->index - 1));
+        }
+        if (p->done() && build()) {
+          uint32_t count = p->tree->count + 1;
+          TFNode** buffer = builder_->Buffer(count);
+          buffer[0] = nullptr;  // reserved for code object.
+          for (uint32_t i = 1; i < count; i++) {
+            buffer[i] = p->tree->children[i - 1]->node;
+          }
+          p->tree->node = builder_->CallImport(operand.index, buffer);
+        }
+        break;
+      }
       default:
         break;
     }
   }
 
   void ReduceBreakToExprBlock(Production* p, Block* block) {
     ReduceBreakToExprBlock(p, block, p->tree->count > 0 ? p->last() : nullptr);
   }
 
   void ReduceBreakToExprBlock(Production* p, Block* block, Tree* val) {
@@ skipping 432 matching lines @@
 
 BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone, FunctionEnv* env,
                                            const byte* start, const byte* end) {
   LoopAssignmentAnalyzer analyzer(zone, env);
   return analyzer.Analyze(start, end);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8