1 // Copyright 2015 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef V8_WASM_MODULE_H_
6 #define V8_WASM_MODULE_H_
7 
8 #include "src/wasm/wasm-opcodes.h"
9 #include "src/wasm/wasm-result.h"
10 
11 #include "src/api.h"
12 #include "src/handles.h"
13 
14 namespace v8 {
15 namespace internal {
16 
17 namespace compiler {
18 class CallDescriptor;
19 }
20 
21 namespace wasm {
22 const size_t kMaxModuleSize = 1024 * 1024 * 1024;
23 const size_t kMaxFunctionSize = 128 * 1024;
24 const size_t kMaxStringSize = 256;
25 
26 enum WasmSectionDeclCode {
27   kDeclMemory = 0x00,
28   kDeclSignatures = 0x01,
29   kDeclFunctions = 0x02,
30   kDeclGlobals = 0x03,
31   kDeclDataSegments = 0x04,
32   kDeclFunctionTable = 0x05,
33   kDeclWLL = 0x11,
34   kDeclEnd = 0x06,
35 };
36 
37 static const int kMaxModuleSectionCode = 6;
38 
39 enum WasmFunctionDeclBit {
40   kDeclFunctionName = 0x01,
41   kDeclFunctionImport = 0x02,
42   kDeclFunctionLocals = 0x04,
43   kDeclFunctionExport = 0x08
44 };
45 
46 // Constants for fixed-size elements within a module.
47 static const size_t kDeclMemorySize = 3;
48 static const size_t kDeclGlobalSize = 6;
49 static const size_t kDeclDataSegmentSize = 13;
50 
51 // Static representation of a wasm function.
52 struct WasmFunction {
53   FunctionSig* sig;      // signature of the function.
54   uint16_t sig_index;    // index into the signature table.
55   uint32_t name_offset;  // offset in the module bytes of the name, if any.
56   uint32_t code_start_offset;    // offset in the module bytes of code start.
57   uint32_t code_end_offset;      // offset in the module bytes of code end.
58   uint16_t local_int32_count;    // number of int32 local variables.
59   uint16_t local_int64_count;    // number of int64 local variables.
60   uint16_t local_float32_count;  // number of float32 local variables.
61   uint16_t local_float64_count;  // number of float64 local variables.
62   bool exported;                 // true if this function is exported.
63   bool external;  // true if this function is externally supplied.
64 };
65 
66 struct ModuleEnv;  // forward declaration of decoder interface.
67 
68 // Static representation of a wasm global variable.
69 struct WasmGlobal {
70   uint32_t name_offset;  // offset in the module bytes of the name, if any.
71   MachineType type;      // type of the global.
72   uint32_t offset;       // offset from beginning of globals area.
73   bool exported;         // true if this global is exported.
74 };
75 
76 // Static representation of a wasm data segment.
77 struct WasmDataSegment {
78   uint32_t dest_addr;      // destination memory address of the data.
79   uint32_t source_offset;  // start offset in the module bytes.
80   uint32_t source_size;    // end offset in the module bytes.
81   bool init;               // true if loaded upon instantiation.
82 };
83 
84 // Static representation of a module.
85 struct WasmModule {
86   static const uint8_t kMinMemSize = 12;  // Minimum memory size = 4kb
87   static const uint8_t kMaxMemSize = 30;  // Maximum memory size = 1gb
88 
89   Isolate* shared_isolate;    // isolate for storing shared code.
90   const byte* module_start;   // starting address for the module bytes.
91   const byte* module_end;     // end address for the module bytes.
92   uint8_t min_mem_size_log2;  // minimum size of the memory (log base 2).
93   uint8_t max_mem_size_log2;  // maximum size of the memory (log base 2).
94   bool mem_export;            // true if the memory is exported.
95   bool mem_external;          // true if the memory is external.
96 
97   std::vector<WasmGlobal>* globals;             // globals in this module.
98   std::vector<FunctionSig*>* signatures;        // signatures in this module.
99   std::vector<WasmFunction>* functions;         // functions in this module.
100   std::vector<WasmDataSegment>* data_segments;  // data segments in this module.
101   std::vector<uint16_t>* function_table;        // function table.
102 
103   WasmModule();
104   ~WasmModule();
105 
106   // Get a pointer to a string stored in the module bytes representing a name.
GetNameWasmModule107   const char* GetName(uint32_t offset) {
108     CHECK(BoundsCheck(offset, offset + 1));
109     if (offset == 0) return "<?>";  // no name.
110     return reinterpret_cast<const char*>(module_start + offset);
111   }
112 
113   // Checks the given offset range is contained within the module bytes.
BoundsCheckWasmModule114   bool BoundsCheck(uint32_t start, uint32_t end) {
115     size_t size = module_end - module_start;
116     return start < size && end < size;
117   }
118 
119   // Creates a new instantiation of the module in the given isolate.
120   MaybeHandle<JSObject> Instantiate(Isolate* isolate, Handle<JSObject> ffi,
121                                     Handle<JSArrayBuffer> memory);
122 };
123 
124 // forward declaration.
125 class WasmLinker;
126 
127 // Interface provided to the decoder/graph builder which contains only
128 // minimal information about the globals, functions, and function tables.
129 struct ModuleEnv {
130   uintptr_t globals_area;  // address of the globals area.
131   uintptr_t mem_start;     // address of the start of linear memory.
132   uintptr_t mem_end;       // address of the end of linear memory.
133 
134   WasmModule* module;
135   WasmLinker* linker;
136   std::vector<Handle<Code>>* function_code;
137   Handle<FixedArray> function_table;
138   Handle<JSArrayBuffer> memory;
139   Handle<Context> context;
140   bool asm_js;  // true if the module originated from asm.js.
141 
IsValidGlobalModuleEnv142   bool IsValidGlobal(uint32_t index) {
143     return module && index < module->globals->size();
144   }
IsValidFunctionModuleEnv145   bool IsValidFunction(uint32_t index) {
146     return module && index < module->functions->size();
147   }
IsValidSignatureModuleEnv148   bool IsValidSignature(uint32_t index) {
149     return module && index < module->signatures->size();
150   }
GetGlobalTypeModuleEnv151   MachineType GetGlobalType(uint32_t index) {
152     DCHECK(IsValidGlobal(index));
153     return module->globals->at(index).type;
154   }
GetFunctionSignatureModuleEnv155   FunctionSig* GetFunctionSignature(uint32_t index) {
156     DCHECK(IsValidFunction(index));
157     return module->functions->at(index).sig;
158   }
GetSignatureModuleEnv159   FunctionSig* GetSignature(uint32_t index) {
160     DCHECK(IsValidSignature(index));
161     return module->signatures->at(index);
162   }
FunctionTableSizeModuleEnv163   size_t FunctionTableSize() {
164     return module ? module->function_table->size() : 0;
165   }
166 
167   Handle<Code> GetFunctionCode(uint32_t index);
168   Handle<FixedArray> GetFunctionTable();
169 
170   compiler::CallDescriptor* GetWasmCallDescriptor(Zone* zone, FunctionSig* sig);
171   compiler::CallDescriptor* GetCallDescriptor(Zone* zone, uint32_t index);
172 };
173 
174 std::ostream& operator<<(std::ostream& os, const WasmModule& module);
175 std::ostream& operator<<(std::ostream& os, const WasmFunction& function);
176 
177 typedef Result<WasmModule*> ModuleResult;
178 typedef Result<WasmFunction*> FunctionResult;
179 
180 // For testing. Decode, verify, and run the last exported function in the
181 // given encoded module.
182 int32_t CompileAndRunWasmModule(Isolate* isolate, const byte* module_start,
183                                 const byte* module_end, bool asm_js = false);
184 
185 // For testing. Decode, verify, and run the last exported function in the
186 // given decoded module.
187 int32_t CompileAndRunWasmModule(Isolate* isolate, WasmModule* module);
188 }  // namespace wasm
189 }  // namespace internal
190 }  // namespace v8
191 
192 #endif  // V8_WASM_MODULE_H_
193