Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- Wasm.h - Wasm object file format -------------------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file defines manifest constants for the wasm object file format.

// See: https://github.com/WebAssembly/design/blob/main/BinaryEncoding.md

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_BINARYFORMAT_WASM_H

#define LLVM_BINARYFORMAT_WASM_H

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringRef.h"

#include <optional>

namespace llvm {

namespace wasm {

// Object file magic string.

const char WasmMagic[] = {'\0', 'a', 's', 'm'};

// Wasm binary format version

const uint32_t WasmVersion = 0x1;

// Wasm linking metadata version

const uint32_t WasmMetadataVersion = 0x2;

// Wasm uses a 64k page size

const uint32_t WasmPageSize = 65536;

struct WasmObjectHeader {

  StringRef Magic;

  uint32_t Version;

};

struct WasmDylinkImportInfo {

  StringRef Module;

  StringRef Field;

  uint32_t Flags;

};

struct WasmDylinkExportInfo {

  StringRef Name;

  uint32_t Flags;

};

struct WasmDylinkInfo {

  uint32_t MemorySize; // Memory size in bytes

  uint32_t MemoryAlignment;  // P2 alignment of memory

  uint32_t TableSize;  // Table size in elements

  uint32_t TableAlignment;  // P2 alignment of table

  std::vector<StringRef> Needed; // Shared library dependencies

  std::vector<WasmDylinkImportInfo> ImportInfo;

  std::vector<WasmDylinkExportInfo> ExportInfo;

};

struct WasmProducerInfo {

  std::vector<std::pair<std::string, std::string>> Languages;

  std::vector<std::pair<std::string, std::string>> Tools;

  std::vector<std::pair<std::string, std::string>> SDKs;

};

struct WasmFeatureEntry {

  uint8_t Prefix;

  std::string Name;

};

struct WasmExport {

  StringRef Name;

  uint8_t Kind;

  uint32_t Index;

};

struct WasmLimits {

  uint8_t Flags;

  uint64_t Minimum;

  uint64_t Maximum;

};

struct WasmTableType {

  uint8_t ElemType;

  WasmLimits Limits;

};

struct WasmTable {

  uint32_t Index;

  WasmTableType Type;

  StringRef SymbolName; // from the "linking" section

};

struct WasmInitExprMVP {

  uint8_t Opcode;

  union {

    int32_t Int32;

    int64_t Int64;

    uint32_t Float32;

    uint64_t Float64;

    uint32_t Global;

  } Value;

};

struct WasmInitExpr {

  uint8_t Extended; // Set to non-zero if extended const is used (i.e. more than

                    // one instruction)

  WasmInitExprMVP Inst;

  ArrayRef<uint8_t> Body;

};

struct WasmGlobalType {

  uint8_t Type;

  bool Mutable;

};

struct WasmGlobal {

  uint32_t Index;

  WasmGlobalType Type;

  WasmInitExpr InitExpr;

  StringRef SymbolName; // from the "linking" section

};

struct WasmTag {

  uint32_t Index;

  uint32_t SigIndex;

  StringRef SymbolName; // from the "linking" section

};

struct WasmImport {

  StringRef Module;

  StringRef Field;

  uint8_t Kind;

  union {

    uint32_t SigIndex;

    WasmGlobalType Global;

    WasmTableType Table;

    WasmLimits Memory;

  };

};

struct WasmLocalDecl {

  uint8_t Type;

  uint32_t Count;

};

struct WasmFunction {

  uint32_t Index;

  uint32_t SigIndex;

  std::vector<WasmLocalDecl> Locals;

  ArrayRef<uint8_t> Body;

  uint32_t CodeSectionOffset;

  uint32_t Size;

  uint32_t CodeOffset;  // start of Locals and Body

  std::optional<StringRef> ExportName; // from the "export" section

  StringRef SymbolName; // from the "linking" section

  StringRef DebugName;  // from the "name" section

  uint32_t Comdat;      // from the "comdat info" section

};

struct WasmDataSegment {

  uint32_t InitFlags;

  // Present if InitFlags & WASM_DATA_SEGMENT_HAS_MEMINDEX.

  uint32_t MemoryIndex;

  // Present if InitFlags & WASM_DATA_SEGMENT_IS_PASSIVE == 0.

  WasmInitExpr Offset;

  ArrayRef<uint8_t> Content;

  StringRef Name; // from the "segment info" section

  uint32_t Alignment;

  uint32_t LinkingFlags;

  uint32_t Comdat; // from the "comdat info" section

};

struct WasmElemSegment {

  uint32_t Flags;

  uint32_t TableNumber;

  uint8_t ElemKind;

  WasmInitExpr Offset;

  std::vector<uint32_t> Functions;

};

// Represents the location of a Wasm data symbol within a WasmDataSegment, as

// the index of the segment, and the offset and size within the segment.

struct WasmDataReference {

  uint32_t Segment;

  uint64_t Offset;

  uint64_t Size;

};

struct WasmRelocation {

  uint8_t Type;    // The type of the relocation.

  uint32_t Index;  // Index into either symbol or type index space.

  uint64_t Offset; // Offset from the start of the section.

  int64_t Addend;  // A value to add to the symbol.

};

struct WasmInitFunc {

  uint32_t Priority;

  uint32_t Symbol;

};

struct WasmSymbolInfo {

  StringRef Name;

  uint8_t Kind;

  uint32_t Flags;

  // For undefined symbols the module of the import

  std::optional<StringRef> ImportModule;

  // For undefined symbols the name of the import

  std::optional<StringRef> ImportName;

  // For symbols to be exported from the final module

  std::optional<StringRef> ExportName;

  union {

    // For function, table, or global symbols, the index in function, table, or

    // global index space.

    uint32_t ElementIndex;

    // For a data symbols, the address of the data relative to segment.

    WasmDataReference DataRef;

  };

};

enum class NameType {

  FUNCTION,

  GLOBAL,

  DATA_SEGMENT,

};

struct WasmDebugName {

  NameType Type;

  uint32_t Index;

  StringRef Name;

};

struct WasmLinkingData {

  uint32_t Version;

  std::vector<WasmInitFunc> InitFunctions;

  std::vector<StringRef> Comdats;

  std::vector<WasmSymbolInfo> SymbolTable;

};

enum : unsigned {

  WASM_SEC_CUSTOM = 0,     // Custom / User-defined section

  WASM_SEC_TYPE = 1,       // Function signature declarations

  WASM_SEC_IMPORT = 2,     // Import declarations

  WASM_SEC_FUNCTION = 3,   // Function declarations

  WASM_SEC_TABLE = 4,      // Indirect function table and other tables

  WASM_SEC_MEMORY = 5,     // Memory attributes

  WASM_SEC_GLOBAL = 6,     // Global declarations

  WASM_SEC_EXPORT = 7,     // Exports

  WASM_SEC_START = 8,      // Start function declaration

  WASM_SEC_ELEM = 9,       // Elements section

  WASM_SEC_CODE = 10,      // Function bodies (code)

  WASM_SEC_DATA = 11,      // Data segments

  WASM_SEC_DATACOUNT = 12, // Data segment count

  WASM_SEC_TAG = 13,       // Tag declarations

  WASM_SEC_LAST_KNOWN = WASM_SEC_TAG,

};

// Type immediate encodings used in various contexts.

enum : unsigned {

  WASM_TYPE_I32 = 0x7F,

  WASM_TYPE_I64 = 0x7E,

  WASM_TYPE_F32 = 0x7D,

  WASM_TYPE_F64 = 0x7C,

  WASM_TYPE_V128 = 0x7B,

  WASM_TYPE_FUNCREF = 0x70,

  WASM_TYPE_EXTERNREF = 0x6F,

  WASM_TYPE_FUNC = 0x60,

  WASM_TYPE_NORESULT = 0x40, // for blocks with no result values

};

// Kinds of externals (for imports and exports).

enum : unsigned {

  WASM_EXTERNAL_FUNCTION = 0x0,

  WASM_EXTERNAL_TABLE = 0x1,

  WASM_EXTERNAL_MEMORY = 0x2,

  WASM_EXTERNAL_GLOBAL = 0x3,

  WASM_EXTERNAL_TAG = 0x4,

};

// Opcodes used in initializer expressions.

enum : unsigned {

  WASM_OPCODE_END = 0x0b,

  WASM_OPCODE_CALL = 0x10,

  WASM_OPCODE_LOCAL_GET = 0x20,

  WASM_OPCODE_LOCAL_SET = 0x21,

  WASM_OPCODE_LOCAL_TEE = 0x22,

  WASM_OPCODE_GLOBAL_GET = 0x23,

  WASM_OPCODE_GLOBAL_SET = 0x24,

  WASM_OPCODE_I32_STORE = 0x36,

  WASM_OPCODE_I64_STORE = 0x37,

  WASM_OPCODE_I32_CONST = 0x41,

  WASM_OPCODE_I64_CONST = 0x42,

  WASM_OPCODE_F32_CONST = 0x43,

  WASM_OPCODE_F64_CONST = 0x44,

  WASM_OPCODE_I32_ADD = 0x6a,

  WASM_OPCODE_I32_SUB = 0x6b,

  WASM_OPCODE_I32_MUL = 0x6c,

  WASM_OPCODE_I64_ADD = 0x7c,

  WASM_OPCODE_I64_SUB = 0x7d,

  WASM_OPCODE_I64_MUL = 0x7e,

  WASM_OPCODE_REF_NULL = 0xd0,

};

// Opcodes used in synthetic functions.

enum : unsigned {

  WASM_OPCODE_BLOCK = 0x02,

  WASM_OPCODE_BR = 0x0c,

  WASM_OPCODE_BR_TABLE = 0x0e,

  WASM_OPCODE_RETURN = 0x0f,

  WASM_OPCODE_DROP = 0x1a,

  WASM_OPCODE_MISC_PREFIX = 0xfc,

  WASM_OPCODE_MEMORY_INIT = 0x08,

  WASM_OPCODE_MEMORY_FILL = 0x0b,

  WASM_OPCODE_DATA_DROP = 0x09,

  WASM_OPCODE_ATOMICS_PREFIX = 0xfe,

  WASM_OPCODE_ATOMIC_NOTIFY = 0x00,

  WASM_OPCODE_I32_ATOMIC_WAIT = 0x01,

  WASM_OPCODE_I32_ATOMIC_STORE = 0x17,

  WASM_OPCODE_I32_RMW_CMPXCHG = 0x48,

};

enum : unsigned {

  WASM_LIMITS_FLAG_NONE = 0x0,

  WASM_LIMITS_FLAG_HAS_MAX = 0x1,

  WASM_LIMITS_FLAG_IS_SHARED = 0x2,

  WASM_LIMITS_FLAG_IS_64 = 0x4,

};

enum : unsigned {

  WASM_DATA_SEGMENT_IS_PASSIVE = 0x01,

  WASM_DATA_SEGMENT_HAS_MEMINDEX = 0x02,

};

enum : unsigned {

  WASM_ELEM_SEGMENT_IS_PASSIVE = 0x01,

  WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER = 0x02,

  WASM_ELEM_SEGMENT_HAS_INIT_EXPRS = 0x04,

};

const unsigned WASM_ELEM_SEGMENT_MASK_HAS_ELEM_KIND = 0x3;

// Feature policy prefixes used in the custom "target_features" section

enum : uint8_t {

  WASM_FEATURE_PREFIX_USED = '+',

  WASM_FEATURE_PREFIX_REQUIRED = '=',

  WASM_FEATURE_PREFIX_DISALLOWED = '-',

};

// Kind codes used in the custom "name" section

enum : unsigned {

  WASM_NAMES_FUNCTION = 1,

  WASM_NAMES_LOCAL = 2,

  WASM_NAMES_GLOBAL = 7,

  WASM_NAMES_DATA_SEGMENT = 9,

};

// Kind codes used in the custom "linking" section

enum : unsigned {

  WASM_SEGMENT_INFO = 0x5,

  WASM_INIT_FUNCS = 0x6,

  WASM_COMDAT_INFO = 0x7,

  WASM_SYMBOL_TABLE = 0x8,

};

// Kind codes used in the custom "dylink" section

enum : unsigned {

  WASM_DYLINK_MEM_INFO = 0x1,

  WASM_DYLINK_NEEDED = 0x2,

  WASM_DYLINK_EXPORT_INFO = 0x3,

  WASM_DYLINK_IMPORT_INFO = 0x4,

};

// Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO

enum : unsigned {

  WASM_COMDAT_DATA = 0x0,

  WASM_COMDAT_FUNCTION = 0x1,

  // GLOBAL, TAG, and TABLE are in here but LLVM doesn't use them yet.

  WASM_COMDAT_SECTION = 0x5,

};

// Kind codes used in the custom "linking" section in the WASM_SYMBOL_TABLE

enum WasmSymbolType : unsigned {

  WASM_SYMBOL_TYPE_FUNCTION = 0x0,

  WASM_SYMBOL_TYPE_DATA = 0x1,

  WASM_SYMBOL_TYPE_GLOBAL = 0x2,

  WASM_SYMBOL_TYPE_SECTION = 0x3,

  WASM_SYMBOL_TYPE_TAG = 0x4,

  WASM_SYMBOL_TYPE_TABLE = 0x5,

};

enum WasmSegmentFlag : unsigned {

  WASM_SEG_FLAG_STRINGS = 0x1,

  WASM_SEG_FLAG_TLS = 0x2,

};

// Kinds of tag attributes.

enum WasmTagAttribute : uint8_t {

  WASM_TAG_ATTRIBUTE_EXCEPTION = 0x0,

};

const unsigned WASM_SYMBOL_BINDING_MASK = 0x3;

const unsigned WASM_SYMBOL_VISIBILITY_MASK = 0xc;

const unsigned WASM_SYMBOL_BINDING_GLOBAL = 0x0;

const unsigned WASM_SYMBOL_BINDING_WEAK = 0x1;

const unsigned WASM_SYMBOL_BINDING_LOCAL = 0x2;

const unsigned WASM_SYMBOL_VISIBILITY_DEFAULT = 0x0;

const unsigned WASM_SYMBOL_VISIBILITY_HIDDEN = 0x4;

const unsigned WASM_SYMBOL_UNDEFINED = 0x10;

const unsigned WASM_SYMBOL_EXPORTED = 0x20;

const unsigned WASM_SYMBOL_EXPLICIT_NAME = 0x40;

const unsigned WASM_SYMBOL_NO_STRIP = 0x80;

const unsigned WASM_SYMBOL_TLS = 0x100;

#define WASM_RELOC(name, value) name = value,

enum : unsigned {

#include "WasmRelocs.def"

};

#undef WASM_RELOC

// Subset of types that a value can have

enum class ValType {

  I32 = WASM_TYPE_I32,

  I64 = WASM_TYPE_I64,

  F32 = WASM_TYPE_F32,

  F64 = WASM_TYPE_F64,

  V128 = WASM_TYPE_V128,

  FUNCREF = WASM_TYPE_FUNCREF,

  EXTERNREF = WASM_TYPE_EXTERNREF,

};

struct WasmSignature {

  SmallVector<ValType, 1> Returns;

  SmallVector<ValType, 4> Params;

  // Support empty and tombstone instances, needed by DenseMap.

  enum { Plain, Empty, Tombstone } State = Plain;

  WasmSignature(SmallVector<ValType, 1> &&InReturns,

                SmallVector<ValType, 4> &&InParams)

      : Returns(InReturns), Params(InParams) {}

  WasmSignature() = default;

};

// Useful comparison operators

inline bool operator==(const WasmSignature &LHS, const WasmSignature &RHS) {

  return LHS.State == RHS.State && LHS.Returns == RHS.Returns &&

         LHS.Params == RHS.Params;

}

inline bool operator!=(const WasmSignature &LHS, const WasmSignature &RHS) {

  return !(LHS == RHS);

}

inline bool operator==(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {

  return LHS.Type == RHS.Type && LHS.Mutable == RHS.Mutable;

}

inline bool operator!=(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {

  return !(LHS == RHS);

}

inline bool operator==(const WasmLimits &LHS, const WasmLimits &RHS) {

  return LHS.Flags == RHS.Flags && LHS.Minimum == RHS.Minimum &&

         (LHS.Flags & WASM_LIMITS_FLAG_HAS_MAX ? LHS.Maximum == RHS.Maximum

                                               : true);

}

inline bool operator==(const WasmTableType &LHS, const WasmTableType &RHS) {

  return LHS.ElemType == RHS.ElemType && LHS.Limits == RHS.Limits;

}

llvm::StringRef toString(WasmSymbolType type);

llvm::StringRef relocTypetoString(uint32_t type);

llvm::StringRef sectionTypeToString(uint32_t type);

bool relocTypeHasAddend(uint32_t type);

} // end namespace wasm

} // end namespace llvm

#endif