• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_ENCODER_H_
6 #define V8_WASM_ENCODER_H_
7 
8 #include "src/signature.h"
9 #include "src/zone-containers.h"
10 
11 #include "src/base/smart-pointers.h"
12 
13 #include "src/wasm/wasm-module.h"
14 #include "src/wasm/wasm-opcodes.h"
15 #include "src/wasm/wasm-result.h"
16 
17 namespace v8 {
18 namespace internal {
19 namespace wasm {
20 
21 class WasmModuleBuilder;
22 
23 class WasmFunctionEncoder : public ZoneObject {
24  public:
25   uint32_t HeaderSize() const;
26   uint32_t BodySize() const;
27   uint32_t NameSize() const;
28   void Serialize(byte* buffer, byte** header, byte** body) const;
29 
30  private:
31   WasmFunctionEncoder(Zone* zone, LocalType return_type, bool exported,
32                       bool external);
33   friend class WasmFunctionBuilder;
34   uint16_t signature_index_;
35   ZoneVector<LocalType> params_;
36   uint16_t local_int32_count_;
37   uint16_t local_int64_count_;
38   uint16_t local_float32_count_;
39   uint16_t local_float64_count_;
40   bool exported_;
41   bool external_;
42   ZoneVector<uint8_t> body_;
43   ZoneVector<char> name_;
44 
HasLocals()45   bool HasLocals() const {
46     return (local_int32_count_ + local_int64_count_ + local_float32_count_ +
47             local_float64_count_) > 0;
48   }
49 
HasName()50   bool HasName() const { return exported_ && name_.size() > 0; }
51 };
52 
53 class WasmFunctionBuilder : public ZoneObject {
54  public:
55   uint16_t AddParam(LocalType type);
56   uint16_t AddLocal(LocalType type);
57   void ReturnType(LocalType type);
58   void EmitCode(const byte* code, uint32_t code_size);
59   void EmitCode(const byte* code, uint32_t code_size,
60                 const uint32_t* local_indices, uint32_t indices_size);
61   void Emit(WasmOpcode opcode);
62   void EmitWithU8(WasmOpcode opcode, const byte immediate);
63   void EmitWithLocal(WasmOpcode opcode);
64   uint32_t EmitEditableImmediate(const byte immediate);
65   void EditImmediate(uint32_t offset, const byte immediate);
66   void Exported(uint8_t flag);
67   void External(uint8_t flag);
68   void SetName(const unsigned char* name, int name_length);
69   WasmFunctionEncoder* Build(Zone* zone, WasmModuleBuilder* mb) const;
70 
71  private:
72   explicit WasmFunctionBuilder(Zone* zone);
73   friend class WasmModuleBuilder;
74   LocalType return_type_;
75   struct Type;
76   ZoneVector<Type> locals_;
77   uint8_t exported_;
78   uint8_t external_;
79   ZoneVector<uint8_t> body_;
80   ZoneVector<uint32_t> local_indices_;
81   ZoneVector<char> name_;
82   uint16_t AddVar(LocalType type, bool param);
83   void IndexVars(WasmFunctionEncoder* e, uint16_t* var_index) const;
84 };
85 
86 class WasmDataSegmentEncoder : public ZoneObject {
87  public:
88   WasmDataSegmentEncoder(Zone* zone, const byte* data, uint32_t size,
89                          uint32_t dest);
90   uint32_t HeaderSize() const;
91   uint32_t BodySize() const;
92   void Serialize(byte* buffer, byte** header, byte** body) const;
93 
94  private:
95   ZoneVector<byte> data_;
96   uint32_t dest_;
97 };
98 
99 class WasmModuleIndex : public ZoneObject {
100  public:
Begin()101   const byte* Begin() const { return begin_; }
End()102   const byte* End() const { return end_; }
103 
104  private:
105   friend class WasmModuleWriter;
WasmModuleIndex(const byte * begin,const byte * end)106   WasmModuleIndex(const byte* begin, const byte* end)
107       : begin_(begin), end_(end) {}
108   const byte* begin_;
109   const byte* end_;
110 };
111 
112 class WasmModuleWriter : public ZoneObject {
113  public:
114   WasmModuleIndex* WriteTo(Zone* zone) const;
115 
116  private:
117   friend class WasmModuleBuilder;
118   explicit WasmModuleWriter(Zone* zone);
119   ZoneVector<WasmFunctionEncoder*> functions_;
120   ZoneVector<WasmDataSegmentEncoder*> data_segments_;
121   ZoneVector<FunctionSig*> signatures_;
122   ZoneVector<uint16_t> indirect_functions_;
123   ZoneVector<std::pair<MachineType, bool>> globals_;
124 };
125 
126 class WasmModuleBuilder : public ZoneObject {
127  public:
128   explicit WasmModuleBuilder(Zone* zone);
129   uint16_t AddFunction();
130   uint32_t AddGlobal(MachineType type, bool exported);
131   WasmFunctionBuilder* FunctionAt(size_t index);
132   void AddDataSegment(WasmDataSegmentEncoder* data);
133   uint16_t AddSignature(FunctionSig* sig);
134   void AddIndirectFunction(uint16_t index);
135   WasmModuleWriter* Build(Zone* zone);
136 
137  private:
138   struct CompareFunctionSigs {
139     int operator()(FunctionSig* a, FunctionSig* b) const;
140   };
141   typedef ZoneMap<FunctionSig*, uint16_t, CompareFunctionSigs> SignatureMap;
142 
143   Zone* zone_;
144   ZoneVector<FunctionSig*> signatures_;
145   ZoneVector<WasmFunctionBuilder*> functions_;
146   ZoneVector<WasmDataSegmentEncoder*> data_segments_;
147   ZoneVector<uint16_t> indirect_functions_;
148   ZoneVector<std::pair<MachineType, bool>> globals_;
149   SignatureMap signature_map_;
150 };
151 
152 std::vector<uint8_t> UnsignedLEB128From(uint32_t result);
153 }  // namespace wasm
154 }  // namespace internal
155 }  // namespace v8
156 
157 #endif  // V8_WASM_ENCODER_H_
158