function-body-decoder.h 6.55 KB
Newer Older
1 2 3 4
// 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.

5 6 7 8
#if !V8_ENABLE_WEBASSEMBLY
#error This header should only be included if WebAssembly is enabled.
#endif  // !V8_ENABLE_WEBASSEMBLY

9 10
#ifndef V8_WASM_FUNCTION_BODY_DECODER_H_
#define V8_WASM_FUNCTION_BODY_DECODER_H_
11

12
#include "src/base/compiler-specific.h"
13
#include "src/base/iterator.h"
14
#include "src/common/globals.h"
15
#include "src/wasm/decoder.h"
16 17 18 19 20 21
#include "src/wasm/wasm-opcodes.h"
#include "src/wasm/wasm-result.h"

namespace v8 {
namespace internal {

22 23
class BitVector;  // forward declaration

24 25
namespace wasm {

26
class WasmFeatures;
27
struct WasmModule;  // forward declaration of module interface.
28

29
// A wrapper around the signature and bytes of a function.
30
struct FunctionBody {
31 32 33 34
  const FunctionSig* sig;  // function signature
  uint32_t offset;         // offset in the module bytes, for error reporting
  const byte* start;       // start of the function body
  const byte* end;         // end of the function body
35

36
  FunctionBody(const FunctionSig* sig, uint32_t offset, const byte* start,
37 38 39
               const byte* end)
      : sig(sig), offset(offset), start(start), end(end) {}
};
40

41
enum class LoadTransformationKind : uint8_t { kSplat, kExtend, kZeroExtend };
42

43 44 45 46 47
V8_EXPORT_PRIVATE DecodeResult VerifyWasmCode(AccountingAllocator* allocator,
                                              const WasmFeatures& enabled,
                                              const WasmModule* module,
                                              WasmFeatures* detected,
                                              const FunctionBody& body);
48

49 50
enum PrintLocals { kPrintLocals, kOmitLocals };
V8_EXPORT_PRIVATE
51
bool PrintRawWasmCode(AccountingAllocator* allocator, const FunctionBody& body,
52
                      const WasmModule* module, PrintLocals print_locals);
53

54 55
V8_EXPORT_PRIVATE
bool PrintRawWasmCode(AccountingAllocator* allocator, const FunctionBody& body,
56
                      const WasmModule* module, PrintLocals print_locals,
57 58
                      std::ostream& out,
                      std::vector<int>* line_numbers = nullptr);
59

60
// A simplified form of AST printing, e.g. from a debugger.
61
void PrintRawWasmCode(const byte* start, const byte* end);
62

63
struct BodyLocalDecls {
64
  // The size of the encoded declarations.
65
  uint32_t encoded_size = 0;  // size of encoded declarations
66

67
  ZoneVector<ValueType> type_list;
68

69
  explicit BodyLocalDecls(Zone* zone) : type_list(zone) {}
70 71
};

72 73
V8_EXPORT_PRIVATE bool DecodeLocalDecls(const WasmFeatures& enabled,
                                        BodyLocalDecls* decls,
74
                                        const WasmModule* module,
75
                                        const byte* start, const byte* end);
76

77 78
V8_EXPORT_PRIVATE BitVector* AnalyzeLoopAssignmentForTesting(
    Zone* zone, uint32_t num_locals, const byte* start, const byte* end);
79

80
// Computes the length of the opcode at the given address.
81
V8_EXPORT_PRIVATE unsigned OpcodeLength(const byte* pc, const byte* end);
82

83 84 85 86 87
// Computes the stack effect of the opcode at the given address.
// Returns <pop count, push count>.
// Be cautious with control opcodes: This function only covers their immediate,
// local stack effect (e.g. BrIf pops 1, Br pops 0). Those opcodes can have
// non-local stack effect though, which are not covered here.
88 89 90 91
// TODO(clemensb): This is only used by the interpreter; move there.
V8_EXPORT_PRIVATE std::pair<uint32_t, uint32_t> StackEffect(
    const WasmModule* module, const FunctionSig* sig, const byte* pc,
    const byte* end);
92

93 94 95
// Checks if the underlying hardware supports the Wasm SIMD proposal.
V8_EXPORT_PRIVATE bool CheckHardwareSupportsSimd();

96
// A simple forward iterator for bytecodes.
97
class V8_EXPORT_PRIVATE BytecodeIterator : public NON_EXPORTED_BASE(Decoder) {
98 99
  // Base class for both iterators defined below.
  class iterator_base {
100
   public:
101
    inline iterator_base& operator++() {
102 103 104 105
      DCHECK_LT(ptr_, end_);
      ptr_ += OpcodeLength(ptr_, end_);
      return *this;
    }
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
    inline bool operator==(const iterator_base& that) {
      return this->ptr_ == that.ptr_;
    }
    inline bool operator!=(const iterator_base& that) {
      return this->ptr_ != that.ptr_;
    }

   protected:
    const byte* ptr_;
    const byte* end_;
    iterator_base(const byte* ptr, const byte* end) : ptr_(ptr), end_(end) {}
  };

 public:
  // If one wants to iterate over the bytecode without looking at {pc_offset()}.
  class opcode_iterator
      : public iterator_base,
123
        public base::iterator<std::input_iterator_tag, WasmOpcode> {
124
   public:
125 126 127 128
    inline WasmOpcode operator*() {
      DCHECK_LT(ptr_, end_);
      return static_cast<WasmOpcode>(*ptr_);
    }
129 130 131 132 133 134 135 136 137 138

   private:
    friend class BytecodeIterator;
    opcode_iterator(const byte* ptr, const byte* end)
        : iterator_base(ptr, end) {}
  };
  // If one wants to iterate over the instruction offsets without looking at
  // opcodes.
  class offset_iterator
      : public iterator_base,
139
        public base::iterator<std::input_iterator_tag, uint32_t> {
140 141 142 143
   public:
    inline uint32_t operator*() {
      DCHECK_LT(ptr_, end_);
      return static_cast<uint32_t>(ptr_ - start_);
144 145 146
    }

   private:
147
    const byte* start_;
148
    friend class BytecodeIterator;
149 150
    offset_iterator(const byte* start, const byte* ptr, const byte* end)
        : iterator_base(ptr, end), start_(start) {}
151 152 153 154 155 156
  };

  // Create a new {BytecodeIterator}. If the {decls} pointer is non-null,
  // assume the bytecode starts with local declarations and decode them.
  // Otherwise, do not decode local decls.
  BytecodeIterator(const byte* start, const byte* end,
157
                   BodyLocalDecls* decls = nullptr);
158

159 160 161 162 163 164 165 166 167 168
  base::iterator_range<opcode_iterator> opcodes() {
    return base::iterator_range<opcode_iterator>(opcode_iterator(pc_, end_),
                                                 opcode_iterator(end_, end_));
  }

  base::iterator_range<offset_iterator> offsets() {
    return base::iterator_range<offset_iterator>(
        offset_iterator(start_, pc_, end_),
        offset_iterator(start_, end_, end_));
  }
169 170

  WasmOpcode current() {
171
    return static_cast<WasmOpcode>(
172
        read_u8<Decoder::kNoValidation>(pc_, "expected bytecode"));
173 174 175 176 177 178 179 180 181 182
  }

  void next() {
    if (pc_ < end_) {
      pc_ += OpcodeLength(pc_, end_);
      if (pc_ >= end_) pc_ = end_;
    }
  }

  bool has_next() { return pc_ < end_; }
183 184

  WasmOpcode prefixed_opcode() {
185
    return read_prefixed_opcode<Decoder::kNoValidation>(pc_);
186
  }
187 188
};

189 190 191 192
}  // namespace wasm
}  // namespace internal
}  // namespace v8

193
#endif  // V8_WASM_FUNCTION_BODY_DECODER_H_