Initial import of v8-native WASM.

src/wasm/ast-decoder.h

Index: src/wasm/ast-decoder.h
diff --git a/src/wasm/ast-decoder.h b/src/wasm/ast-decoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..f0b14117fe12548f5b8dbe3c6475047919f9cf8c
--- /dev/null
+++ b/src/wasm/ast-decoder.h
@@ -0,0 +1,114 @@
+// 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.
+
+#ifndef V8_WASM_AST_DECODER_H_
+#define V8_WASM_AST_DECODER_H_
+
+#include "src/signature.h"
+#include "src/wasm/wasm-opcodes.h"
+#include "src/wasm/wasm-result.h"
+
+namespace v8 {
+namespace internal {
+
+namespace compiler {  // external declarations from compiler.
+class WasmGraphBuilder;
+}
+
+namespace wasm {
+
+typedef compiler::WasmGraphBuilder TFBuilder;
+struct ModuleEnv;  // forward declaration of module interface.
+
+// Interface the function environment during decoding, include the signature
+// and number of locals.
+struct FunctionEnv {
+  ModuleEnv* module;             // module environment
+  FunctionSig* sig;              // signature of this function
+  uint32_t local_int32_count;    // number of int32 locals
+  uint32_t local_int64_count;    // number of int64 locals
+  uint32_t local_float32_count;  // number of float32 locals
+  uint32_t local_float64_count;  // number of float64 locals
+  uint32_t total_locals;         // sum of parameters and all locals
+
+  bool IsValidLocal(uint32_t index) { return index < total_locals; }
+  uint32_t GetLocalCount() { return total_locals; }
+  LocalType GetLocalType(uint32_t index) {
+    if (index < sig->parameter_count()) return sig->GetParam(index);
+    index -= sig->parameter_count();
+    if (index < local_int32_count) return kAstI32;
+    index -= local_int32_count;
+    if (index < local_int64_count) return kAstI64;
+    index -= local_int64_count;
+    if (index < local_float32_count) return kAstF32;
+    index -= local_float32_count;
+    if (index < local_float64_count) return kAstF64;
+    return kAstStmt;
+  }
+
+  void AddLocals(LocalType type, uint32_t count) {
+    switch (type) {
+      case kAstI32:
+        local_int32_count += count;
+        break;
+      case kAstI64:
+        local_int64_count += count;
+        break;
+      case kAstF32:
+        local_float32_count += count;
+        break;
+      case kAstF64:
+        local_float64_count += count;
+        break;
+      default:
+        UNREACHABLE();
+    }
+    total_locals += count;
+    DCHECK(total_locals ==
+           (sig->parameter_count() + local_int32_count + local_int64_count +
+            local_float32_count + local_float64_count));
+  }
+
+  void SumLocals() {
+    total_locals = static_cast<uint32_t>(sig->parameter_count()) +
+                   local_int32_count + local_int64_count + local_float32_count +
+                   local_float64_count;
+  }
+};
+
+struct Tree;
+typedef Result<Tree*> TreeResult;
+
+std::ostream& operator<<(std::ostream& os, const Tree& tree);
+
+TreeResult VerifyWasmCode(FunctionEnv* env, const byte* base, const byte* start,
+                          const byte* end);
+TreeResult BuildTFGraph(TFBuilder* builder, FunctionEnv* env, const byte* base,
+                        const byte* start, const byte* end);
+
+inline TreeResult VerifyWasmCode(FunctionEnv* env, const byte* start,
+                                 const byte* end) {
+  return VerifyWasmCode(env, nullptr, start, end);
+}
+
+inline TreeResult BuildTFGraph(TFBuilder* builder, FunctionEnv* env,
+                               const byte* start, const byte* end) {
+  return BuildTFGraph(builder, env, nullptr, start, end);
+}
+
+enum ReadUnsignedLEB128ErrorCode { kNoError, kInvalidLEB128, kMissingLEB128 };
+
+ReadUnsignedLEB128ErrorCode ReadUnsignedLEB128Operand(const byte*, const byte*,
+                                                      int*, uint32_t*);
+
+// Computes the length of the opcode at the given address.
+int OpcodeLength(const byte* pc);
+
+// Computes the arity (number of sub-nodes) of the opcode at the given address.
+int OpcodeArity(FunctionEnv* env, const byte* pc);
+}  // namespace wasm
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_WASM_AST_DECODER_H_