LCOV - code coverage report
Current view: top level - src/wasm - function-body-decoder.h (source / functions) Hit Total Coverage
Test: app.info Lines: 12 13 92.3 %
Date: 2017-04-26 Functions: 2 5 40.0 %

          Line data    Source code
       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_FUNCTION_BODY_DECODER_H_
       6             : #define V8_WASM_FUNCTION_BODY_DECODER_H_
       7             : 
       8             : #include <iterator>
       9             : 
      10             : #include "src/base/compiler-specific.h"
      11             : #include "src/base/iterator.h"
      12             : #include "src/globals.h"
      13             : #include "src/signature.h"
      14             : #include "src/wasm/decoder.h"
      15             : #include "src/wasm/wasm-opcodes.h"
      16             : #include "src/wasm/wasm-result.h"
      17             : 
      18             : namespace v8 {
      19             : namespace internal {
      20             : 
      21             : class BitVector;  // forward declaration
      22             : 
      23             : namespace compiler {  // external declarations from compiler.
      24             : class WasmGraphBuilder;
      25             : }
      26             : 
      27             : namespace wasm {
      28             : 
      29             : typedef compiler::WasmGraphBuilder TFBuilder;
      30             : struct WasmModule;  // forward declaration of module interface.
      31             : 
      32             : // A wrapper around the signature and bytes of a function.
      33             : struct FunctionBody {
      34             :   FunctionSig* sig;   // function signature
      35             :   const byte* base;   // base of the module bytes, for error reporting
      36             :   const byte* start;  // start of the function body
      37             :   const byte* end;    // end of the function body
      38             : };
      39             : 
      40             : static inline FunctionBody FunctionBodyForTesting(const byte* start,
      41             :                                                   const byte* end) {
      42           0 :   return {nullptr, start, start, end};
      43             : }
      44             : 
      45             : struct DecodeStruct {
      46             :   int unused;
      47             : };
      48             : typedef Result<DecodeStruct*> DecodeResult;
      49             : inline std::ostream& operator<<(std::ostream& os, const DecodeStruct& tree) {
      50             :   return os;
      51             : }
      52             : 
      53             : V8_EXPORT_PRIVATE DecodeResult VerifyWasmCode(AccountingAllocator* allocator,
      54             :                                               const wasm::WasmModule* module,
      55             :                                               FunctionBody& body);
      56             : DecodeResult BuildTFGraph(AccountingAllocator* allocator, TFBuilder* builder,
      57             :                           FunctionBody& body);
      58             : bool PrintRawWasmCode(AccountingAllocator* allocator, const FunctionBody& body,
      59             :                       const wasm::WasmModule* module);
      60             : 
      61             : // A simplified form of AST printing, e.g. from a debugger.
      62             : void PrintRawWasmCode(const byte* start, const byte* end);
      63             : 
      64             : inline DecodeResult VerifyWasmCode(AccountingAllocator* allocator,
      65             :                                    const WasmModule* module, FunctionSig* sig,
      66             :                                    const byte* start, const byte* end) {
      67             :   FunctionBody body = {sig, nullptr, start, end};
      68             :   return VerifyWasmCode(allocator, module, body);
      69             : }
      70             : 
      71             : inline DecodeResult BuildTFGraph(AccountingAllocator* allocator,
      72             :                                  TFBuilder* builder, FunctionSig* sig,
      73             :                                  const byte* start, const byte* end) {
      74             :   FunctionBody body = {sig, nullptr, start, end};
      75             :   return BuildTFGraph(allocator, builder, body);
      76             : }
      77             : 
      78       24193 : struct BodyLocalDecls {
      79             :   // The size of the encoded declarations.
      80             :   uint32_t encoded_size;  // size of encoded declarations
      81             : 
      82             :   ZoneVector<ValueType> type_list;
      83             : 
      84         178 :   explicit BodyLocalDecls(Zone* zone) : encoded_size(0), type_list(zone) {}
      85             : };
      86             : 
      87             : V8_EXPORT_PRIVATE bool DecodeLocalDecls(BodyLocalDecls* decls,
      88             :                                         const byte* start, const byte* end);
      89             : 
      90             : V8_EXPORT_PRIVATE BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone,
      91             :                                                              size_t num_locals,
      92             :                                                              const byte* start,
      93             :                                                              const byte* end);
      94             : 
      95             : // Computes the length of the opcode at the given address.
      96             : V8_EXPORT_PRIVATE unsigned OpcodeLength(const byte* pc, const byte* end);
      97             : 
      98             : // Computes the stack effect of the opcode at the given address.
      99             : // Returns <pop count, push count>.
     100             : // Be cautious with control opcodes: This function only covers their immediate,
     101             : // local stack effect (e.g. BrIf pops 1, Br pops 0). Those opcodes can have
     102             : // non-local stack effect though, which are not covered here.
     103             : std::pair<uint32_t, uint32_t> StackEffect(const WasmModule* module,
     104             :                                           FunctionSig* sig, const byte* pc,
     105             :                                           const byte* end);
     106             : 
     107             : // A simple forward iterator for bytecodes.
     108       21492 : class V8_EXPORT_PRIVATE BytecodeIterator : public NON_EXPORTED_BASE(Decoder) {
     109             :   // Base class for both iterators defined below.
     110             :   class iterator_base {
     111             :    public:
     112             :     inline iterator_base& operator++() {
     113             :       DCHECK_LT(ptr_, end_);
     114         313 :       ptr_ += OpcodeLength(ptr_, end_);
     115             :       return *this;
     116             :     }
     117             :     inline bool operator==(const iterator_base& that) {
     118             :       return this->ptr_ == that.ptr_;
     119             :     }
     120             :     inline bool operator!=(const iterator_base& that) {
     121             :       return this->ptr_ != that.ptr_;
     122             :     }
     123             : 
     124             :    protected:
     125             :     const byte* ptr_;
     126             :     const byte* end_;
     127             :     iterator_base(const byte* ptr, const byte* end) : ptr_(ptr), end_(end) {}
     128             :   };
     129             : 
     130             :  public:
     131             :   // If one wants to iterate over the bytecode without looking at {pc_offset()}.
     132             :   class opcode_iterator
     133             :       : public iterator_base,
     134             :         public std::iterator<std::input_iterator_tag, WasmOpcode> {
     135             :    public:
     136             :     inline WasmOpcode operator*() {
     137             :       DCHECK_LT(ptr_, end_);
     138             :       return static_cast<WasmOpcode>(*ptr_);
     139             :     }
     140             : 
     141             :    private:
     142             :     friend class BytecodeIterator;
     143             :     opcode_iterator(const byte* ptr, const byte* end)
     144             :         : iterator_base(ptr, end) {}
     145             :   };
     146             :   // If one wants to iterate over the instruction offsets without looking at
     147             :   // opcodes.
     148             :   class offset_iterator
     149             :       : public iterator_base,
     150             :         public std::iterator<std::input_iterator_tag, uint32_t> {
     151             :    public:
     152             :     inline uint32_t operator*() {
     153             :       DCHECK_LT(ptr_, end_);
     154         345 :       return static_cast<uint32_t>(ptr_ - start_);
     155             :     }
     156             : 
     157             :    private:
     158             :     const byte* start_;
     159             :     friend class BytecodeIterator;
     160             :     offset_iterator(const byte* start, const byte* ptr, const byte* end)
     161             :         : iterator_base(ptr, end), start_(start) {}
     162             :   };
     163             : 
     164             :   // Create a new {BytecodeIterator}. If the {decls} pointer is non-null,
     165             :   // assume the bytecode starts with local declarations and decode them.
     166             :   // Otherwise, do not decode local decls.
     167             :   BytecodeIterator(const byte* start, const byte* end,
     168             :                    BodyLocalDecls* decls = nullptr);
     169             : 
     170             :   base::iterator_range<opcode_iterator> opcodes() {
     171             :     return base::iterator_range<opcode_iterator>(opcode_iterator(pc_, end_),
     172             :                                                  opcode_iterator(end_, end_));
     173             :   }
     174             : 
     175             :   base::iterator_range<offset_iterator> offsets() {
     176             :     return base::iterator_range<offset_iterator>(
     177             :         offset_iterator(start_, pc_, end_),
     178          78 :         offset_iterator(start_, end_, end_));
     179             :   }
     180             : 
     181             :   WasmOpcode current() {
     182      236971 :     return static_cast<WasmOpcode>(read_u8<false>(pc_, "expected bytecode"));
     183             :   }
     184             : 
     185      236971 :   void next() {
     186      236971 :     if (pc_ < end_) {
     187      236971 :       pc_ += OpcodeLength(pc_, end_);
     188      236971 :       if (pc_ >= end_) pc_ = end_;
     189             :     }
     190      236971 :   }
     191             : 
     192             :   bool has_next() { return pc_ < end_; }
     193             : };
     194             : 
     195             : }  // namespace wasm
     196             : }  // namespace internal
     197             : }  // namespace v8
     198             : 
     199             : #endif  // V8_WASM_FUNCTION_BODY_DECODER_H_

Generated by: LCOV version 1.10