Home | History | Annotate | Download | only in wasm
      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 #include "src/signature.h"
      6 
      7 #include "src/handles.h"
      8 #include "src/v8.h"
      9 #include "src/zone-containers.h"
     10 
     11 #include "src/wasm/ast-decoder.h"
     12 #include "src/wasm/encoder.h"
     13 #include "src/wasm/leb-helper.h"
     14 #include "src/wasm/wasm-macro-gen.h"
     15 #include "src/wasm/wasm-module.h"
     16 #include "src/wasm/wasm-opcodes.h"
     17 
     18 #include "src/v8memory.h"
     19 
     20 #if DEBUG
     21 #define TRACE(...)                                    \
     22   do {                                                \
     23     if (FLAG_trace_wasm_encoder) PrintF(__VA_ARGS__); \
     24   } while (false)
     25 #else
     26 #define TRACE(...)
     27 #endif
     28 
     29 namespace v8 {
     30 namespace internal {
     31 namespace wasm {
     32 
     33 // Emit a section name and the size as a padded varint that can be patched
     34 // later.
     35 size_t EmitSection(WasmSection::Code code, ZoneBuffer& buffer) {
     36   // Emit the section name.
     37   const char* name = WasmSection::getName(code);
     38   TRACE("emit section: %s\n", name);
     39   size_t length = WasmSection::getNameLength(code);
     40   buffer.write_size(length);  // Section name string size.
     41   buffer.write(reinterpret_cast<const byte*>(name), length);
     42 
     43   // Emit a placeholder for the length.
     44   return buffer.reserve_u32v();
     45 }
     46 
     47 // Patch the size of a section after it's finished.
     48 void FixupSection(ZoneBuffer& buffer, size_t start) {
     49   buffer.patch_u32v(start, static_cast<uint32_t>(buffer.offset() - start -
     50                                                  kPaddedVarInt32Size));
     51 }
     52 
     53 WasmFunctionBuilder::WasmFunctionBuilder(WasmModuleBuilder* builder)
     54     : builder_(builder),
     55       locals_(builder->zone()),
     56       signature_index_(0),
     57       exported_(0),
     58       body_(builder->zone()),
     59       name_(builder->zone()) {}
     60 
     61 void WasmFunctionBuilder::EmitVarInt(uint32_t val) {
     62   byte buffer[8];
     63   byte* ptr = buffer;
     64   LEBHelper::write_u32v(&ptr, val);
     65   for (byte* p = buffer; p < ptr; p++) {
     66     body_.push_back(*p);
     67   }
     68 }
     69 
     70 void WasmFunctionBuilder::SetSignature(FunctionSig* sig) {
     71   DCHECK(!locals_.has_sig());
     72   locals_.set_sig(sig);
     73   signature_index_ = builder_->AddSignature(sig);
     74 }
     75 
     76 uint32_t WasmFunctionBuilder::AddLocal(LocalType type) {
     77   DCHECK(locals_.has_sig());
     78   return locals_.AddLocals(1, type);
     79 }
     80 
     81 void WasmFunctionBuilder::EmitGetLocal(uint32_t local_index) {
     82   EmitWithVarInt(kExprGetLocal, local_index);
     83 }
     84 
     85 void WasmFunctionBuilder::EmitSetLocal(uint32_t local_index) {
     86   EmitWithVarInt(kExprSetLocal, local_index);
     87 }
     88 
     89 void WasmFunctionBuilder::EmitCode(const byte* code, uint32_t code_size) {
     90   for (size_t i = 0; i < code_size; ++i) {
     91     body_.push_back(code[i]);
     92   }
     93 }
     94 
     95 void WasmFunctionBuilder::Emit(WasmOpcode opcode) {
     96   body_.push_back(static_cast<byte>(opcode));
     97 }
     98 
     99 void WasmFunctionBuilder::EmitWithU8(WasmOpcode opcode, const byte immediate) {
    100   body_.push_back(static_cast<byte>(opcode));
    101   body_.push_back(immediate);
    102 }
    103 
    104 void WasmFunctionBuilder::EmitWithU8U8(WasmOpcode opcode, const byte imm1,
    105                                        const byte imm2) {
    106   body_.push_back(static_cast<byte>(opcode));
    107   body_.push_back(imm1);
    108   body_.push_back(imm2);
    109 }
    110 
    111 void WasmFunctionBuilder::EmitWithVarInt(WasmOpcode opcode,
    112                                          uint32_t immediate) {
    113   body_.push_back(static_cast<byte>(opcode));
    114   EmitVarInt(immediate);
    115 }
    116 
    117 void WasmFunctionBuilder::EmitI32Const(int32_t value) {
    118   // TODO(titzer): variable-length signed and unsigned i32 constants.
    119   if (-128 <= value && value <= 127) {
    120     EmitWithU8(kExprI8Const, static_cast<byte>(value));
    121   } else {
    122     byte code[] = {WASM_I32V_5(value)};
    123     EmitCode(code, sizeof(code));
    124   }
    125 }
    126 
    127 void WasmFunctionBuilder::SetExported() { exported_ = true; }
    128 
    129 void WasmFunctionBuilder::SetName(const char* name, int name_length) {
    130   name_.clear();
    131   if (name_length > 0) {
    132     for (int i = 0; i < name_length; ++i) {
    133       name_.push_back(*(name + i));
    134     }
    135   }
    136 }
    137 
    138 void WasmFunctionBuilder::WriteSignature(ZoneBuffer& buffer) const {
    139   buffer.write_u32v(signature_index_);
    140 }
    141 
    142 void WasmFunctionBuilder::WriteExport(ZoneBuffer& buffer,
    143                                       uint32_t func_index) const {
    144   if (exported_) {
    145     buffer.write_u32v(func_index);
    146     buffer.write_size(name_.size());
    147     if (name_.size() > 0) {
    148       buffer.write(reinterpret_cast<const byte*>(&name_[0]), name_.size());
    149     }
    150   }
    151 }
    152 
    153 void WasmFunctionBuilder::WriteBody(ZoneBuffer& buffer) const {
    154   size_t locals_size = locals_.Size();
    155   buffer.write_size(locals_size + body_.size());
    156   buffer.EnsureSpace(locals_size);
    157   byte** ptr = buffer.pos_ptr();
    158   locals_.Emit(*ptr);
    159   (*ptr) += locals_size;  // UGLY: manual bump of position pointer
    160   if (body_.size() > 0) {
    161     buffer.write(&body_[0], body_.size());
    162   }
    163 }
    164 
    165 WasmDataSegmentEncoder::WasmDataSegmentEncoder(Zone* zone, const byte* data,
    166                                                uint32_t size, uint32_t dest)
    167     : data_(zone), dest_(dest) {
    168   for (size_t i = 0; i < size; ++i) {
    169     data_.push_back(data[i]);
    170   }
    171 }
    172 
    173 void WasmDataSegmentEncoder::Write(ZoneBuffer& buffer) const {
    174   buffer.write_u32v(dest_);
    175   buffer.write_u32v(static_cast<uint32_t>(data_.size()));
    176   buffer.write(&data_[0], data_.size());
    177 }
    178 
    179 WasmModuleBuilder::WasmModuleBuilder(Zone* zone)
    180     : zone_(zone),
    181       signatures_(zone),
    182       imports_(zone),
    183       functions_(zone),
    184       data_segments_(zone),
    185       indirect_functions_(zone),
    186       globals_(zone),
    187       signature_map_(zone),
    188       start_function_index_(-1) {}
    189 
    190 uint32_t WasmModuleBuilder::AddFunction() {
    191   functions_.push_back(new (zone_) WasmFunctionBuilder(this));
    192   return static_cast<uint32_t>(functions_.size() - 1);
    193 }
    194 
    195 WasmFunctionBuilder* WasmModuleBuilder::FunctionAt(size_t index) {
    196   if (functions_.size() > index) {
    197     return functions_.at(index);
    198   } else {
    199     return nullptr;
    200   }
    201 }
    202 
    203 void WasmModuleBuilder::AddDataSegment(WasmDataSegmentEncoder* data) {
    204   data_segments_.push_back(data);
    205 }
    206 
    207 bool WasmModuleBuilder::CompareFunctionSigs::operator()(FunctionSig* a,
    208                                                         FunctionSig* b) const {
    209   if (a->return_count() < b->return_count()) return true;
    210   if (a->return_count() > b->return_count()) return false;
    211   if (a->parameter_count() < b->parameter_count()) return true;
    212   if (a->parameter_count() > b->parameter_count()) return false;
    213   for (size_t r = 0; r < a->return_count(); r++) {
    214     if (a->GetReturn(r) < b->GetReturn(r)) return true;
    215     if (a->GetReturn(r) > b->GetReturn(r)) return false;
    216   }
    217   for (size_t p = 0; p < a->parameter_count(); p++) {
    218     if (a->GetParam(p) < b->GetParam(p)) return true;
    219     if (a->GetParam(p) > b->GetParam(p)) return false;
    220   }
    221   return false;
    222 }
    223 
    224 uint32_t WasmModuleBuilder::AddSignature(FunctionSig* sig) {
    225   SignatureMap::iterator pos = signature_map_.find(sig);
    226   if (pos != signature_map_.end()) {
    227     return pos->second;
    228   } else {
    229     uint32_t index = static_cast<uint32_t>(signatures_.size());
    230     signature_map_[sig] = index;
    231     signatures_.push_back(sig);
    232     return index;
    233   }
    234 }
    235 
    236 void WasmModuleBuilder::AddIndirectFunction(uint32_t index) {
    237   indirect_functions_.push_back(index);
    238 }
    239 
    240 uint32_t WasmModuleBuilder::AddImport(const char* name, int name_length,
    241                                       FunctionSig* sig) {
    242   imports_.push_back({AddSignature(sig), name, name_length});
    243   return static_cast<uint32_t>(imports_.size() - 1);
    244 }
    245 
    246 void WasmModuleBuilder::MarkStartFunction(uint32_t index) {
    247   start_function_index_ = index;
    248 }
    249 
    250 uint32_t WasmModuleBuilder::AddGlobal(MachineType type, bool exported) {
    251   globals_.push_back(std::make_pair(type, exported));
    252   return static_cast<uint32_t>(globals_.size() - 1);
    253 }
    254 
    255 void WasmModuleBuilder::WriteTo(ZoneBuffer& buffer) const {
    256   uint32_t exports = 0;
    257 
    258   // == Emit magic =============================================================
    259   TRACE("emit magic\n");
    260   buffer.write_u32(kWasmMagic);
    261   buffer.write_u32(kWasmVersion);
    262 
    263   // == Emit signatures ========================================================
    264   if (signatures_.size() > 0) {
    265     size_t start = EmitSection(WasmSection::Code::Signatures, buffer);
    266     buffer.write_size(signatures_.size());
    267 
    268     for (FunctionSig* sig : signatures_) {
    269       buffer.write_u8(kWasmFunctionTypeForm);
    270       buffer.write_size(sig->parameter_count());
    271       for (size_t j = 0; j < sig->parameter_count(); j++) {
    272         buffer.write_u8(WasmOpcodes::LocalTypeCodeFor(sig->GetParam(j)));
    273       }
    274       buffer.write_size(sig->return_count());
    275       for (size_t j = 0; j < sig->return_count(); j++) {
    276         buffer.write_u8(WasmOpcodes::LocalTypeCodeFor(sig->GetReturn(j)));
    277       }
    278     }
    279     FixupSection(buffer, start);
    280   }
    281 
    282   // == Emit globals ===========================================================
    283   if (globals_.size() > 0) {
    284     size_t start = EmitSection(WasmSection::Code::Globals, buffer);
    285     buffer.write_size(globals_.size());
    286 
    287     for (auto global : globals_) {
    288       buffer.write_u32v(0);  // Length of the global name.
    289       buffer.write_u8(WasmOpcodes::MemTypeCodeFor(global.first));
    290       buffer.write_u8(global.second);
    291     }
    292     FixupSection(buffer, start);
    293   }
    294 
    295   // == Emit imports ===========================================================
    296   if (imports_.size() > 0) {
    297     size_t start = EmitSection(WasmSection::Code::ImportTable, buffer);
    298     buffer.write_size(imports_.size());
    299     for (auto import : imports_) {
    300       buffer.write_u32v(import.sig_index);
    301       buffer.write_u32v(import.name_length);
    302       buffer.write(reinterpret_cast<const byte*>(import.name),
    303                    import.name_length);
    304       buffer.write_u32v(0);
    305     }
    306     FixupSection(buffer, start);
    307   }
    308 
    309   // == Emit function signatures ===============================================
    310   if (functions_.size() > 0) {
    311     size_t start = EmitSection(WasmSection::Code::FunctionSignatures, buffer);
    312     buffer.write_size(functions_.size());
    313     for (auto function : functions_) {
    314       function->WriteSignature(buffer);
    315       if (function->exported()) exports++;
    316     }
    317     FixupSection(buffer, start);
    318   }
    319 
    320   // == emit function table ====================================================
    321   if (indirect_functions_.size() > 0) {
    322     size_t start = EmitSection(WasmSection::Code::FunctionTable, buffer);
    323     buffer.write_size(indirect_functions_.size());
    324 
    325     for (auto index : indirect_functions_) {
    326       buffer.write_u32v(index);
    327     }
    328     FixupSection(buffer, start);
    329   }
    330 
    331   // == emit memory declaration ================================================
    332   {
    333     size_t start = EmitSection(WasmSection::Code::Memory, buffer);
    334     buffer.write_u32v(16);  // min memory size
    335     buffer.write_u32v(16);  // max memory size
    336     buffer.write_u8(0);     // memory export
    337     static_assert(kDeclMemorySize == 3, "memory size must match emit above");
    338     FixupSection(buffer, start);
    339   }
    340 
    341   // == emit exports ===========================================================
    342   if (exports > 0) {
    343     size_t start = EmitSection(WasmSection::Code::ExportTable, buffer);
    344     buffer.write_u32v(exports);
    345     uint32_t index = 0;
    346     for (auto function : functions_) {
    347       function->WriteExport(buffer, index++);
    348     }
    349     FixupSection(buffer, start);
    350   }
    351 
    352   // == emit start function index ==============================================
    353   if (start_function_index_ >= 0) {
    354     size_t start = EmitSection(WasmSection::Code::StartFunction, buffer);
    355     buffer.write_u32v(start_function_index_);
    356     FixupSection(buffer, start);
    357   }
    358 
    359   // == emit code ==============================================================
    360   if (functions_.size() > 0) {
    361     size_t start = EmitSection(WasmSection::Code::FunctionBodies, buffer);
    362     buffer.write_size(functions_.size());
    363     for (auto function : functions_) {
    364       function->WriteBody(buffer);
    365     }
    366     FixupSection(buffer, start);
    367   }
    368 
    369   // == emit data segments =====================================================
    370   if (data_segments_.size() > 0) {
    371     size_t start = EmitSection(WasmSection::Code::DataSegments, buffer);
    372     buffer.write_size(data_segments_.size());
    373 
    374     for (auto segment : data_segments_) {
    375       segment->Write(buffer);
    376     }
    377     FixupSection(buffer, start);
    378   }
    379 }
    380 }  // namespace wasm
    381 }  // namespace internal
    382 }  // namespace v8
    383