1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
//===- MCSymbolWasm.h - ----------------------------------------*- 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
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_MC_MCSYMBOLWASM_H
#define LLVM_MC_MCSYMBOLWASM_H
#include "llvm/BinaryFormat/Wasm.h"
#include "llvm/MC/MCSymbol.h"
namespace llvm {
class MCSymbolWasm : public MCSymbol {
Optional<wasm::WasmSymbolType> Type;
bool IsWeak = false;
bool IsHidden = false;
bool IsComdat = false;
bool OmitFromLinkingSection = false;
mutable bool IsUsedInInitArray = false;
mutable bool IsUsedInGOT = false;
Optional<StringRef> ImportModule;
Optional<StringRef> ImportName;
Optional<StringRef> ExportName;
wasm::WasmSignature *Signature = nullptr;
Optional<wasm::WasmGlobalType> GlobalType;
Optional<wasm::WasmTableType> TableType;
/// An expression describing how to calculate the size of a symbol. If a
/// symbol has no size this field will be NULL.
const MCExpr *SymbolSize = nullptr;
public:
MCSymbolWasm(const StringMapEntry<bool> *Name, bool isTemporary)
: MCSymbol(SymbolKindWasm, Name, isTemporary) {}
static bool classof(const MCSymbol *S) { return S->isWasm(); }
const MCExpr *getSize() const { return SymbolSize; }
void setSize(const MCExpr *SS) { SymbolSize = SS; }
bool isFunction() const { return Type == wasm::WASM_SYMBOL_TYPE_FUNCTION; }
// Data is the default value if not set.
bool isData() const { return !Type || Type == wasm::WASM_SYMBOL_TYPE_DATA; }
bool isGlobal() const { return Type == wasm::WASM_SYMBOL_TYPE_GLOBAL; }
bool isTable() const { return Type == wasm::WASM_SYMBOL_TYPE_TABLE; }
bool isSection() const { return Type == wasm::WASM_SYMBOL_TYPE_SECTION; }
bool isTag() const { return Type == wasm::WASM_SYMBOL_TYPE_TAG; }
Optional<wasm::WasmSymbolType> getType() const { return Type; }
void setType(wasm::WasmSymbolType type) { Type = type; }
bool isExported() const {
return getFlags() & wasm::WASM_SYMBOL_EXPORTED;
}
void setExported() const {
modifyFlags(wasm::WASM_SYMBOL_EXPORTED, wasm::WASM_SYMBOL_EXPORTED);
}
bool isNoStrip() const {
return getFlags() & wasm::WASM_SYMBOL_NO_STRIP;
}
void setNoStrip() const {
modifyFlags(wasm::WASM_SYMBOL_NO_STRIP, wasm::WASM_SYMBOL_NO_STRIP);
}
bool isTLS() const { return getFlags() & wasm::WASM_SYMBOL_TLS; }
void setTLS() const {
modifyFlags(wasm::WASM_SYMBOL_TLS, wasm::WASM_SYMBOL_TLS);
}
bool isWeak() const { return IsWeak; }
void setWeak(bool isWeak) { IsWeak = isWeak; }
bool isHidden() const { return IsHidden; }
void setHidden(bool isHidden) { IsHidden = isHidden; }
bool isComdat() const { return IsComdat; }
void setComdat(bool isComdat) { IsComdat = isComdat; }
// wasm-ld understands a finite set of symbol types. This flag allows the
// compiler to avoid emitting symbol table entries that would confuse the
// linker, unless the user specifically requests the feature.
bool omitFromLinkingSection() const { return OmitFromLinkingSection; }
void setOmitFromLinkingSection() { OmitFromLinkingSection = true; }
bool hasImportModule() const { return ImportModule.hasValue(); }
StringRef getImportModule() const {
if (ImportModule.hasValue())
return ImportModule.getValue();
// Use a default module name of "env" for now, for compatibility with
// existing tools.
// TODO(sbc): Find a way to specify a default value in the object format
// without picking a hardcoded value like this.
return "env";
}
void setImportModule(StringRef Name) { ImportModule = Name; }
bool hasImportName() const { return ImportName.hasValue(); }
StringRef getImportName() const {
if (ImportName.hasValue())
return ImportName.getValue();
return getName();
}
void setImportName(StringRef Name) { ImportName = Name; }
bool hasExportName() const { return ExportName.hasValue(); }
StringRef getExportName() const { return ExportName.getValue(); }
void setExportName(StringRef Name) { ExportName = Name; }
bool isFunctionTable() const {
return isTable() && hasTableType() &&
getTableType().ElemType == wasm::WASM_TYPE_FUNCREF;
}
void setFunctionTable() {
setType(wasm::WASM_SYMBOL_TYPE_TABLE);
setTableType(wasm::ValType::FUNCREF);
}
void setUsedInGOT() const { IsUsedInGOT = true; }
bool isUsedInGOT() const { return IsUsedInGOT; }
void setUsedInInitArray() const { IsUsedInInitArray = true; }
bool isUsedInInitArray() const { return IsUsedInInitArray; }
const wasm::WasmSignature *getSignature() const { return Signature; }
void setSignature(wasm::WasmSignature *Sig) { Signature = Sig; }
const wasm::WasmGlobalType &getGlobalType() const {
assert(GlobalType.hasValue());
return GlobalType.getValue();
}
void setGlobalType(wasm::WasmGlobalType GT) { GlobalType = GT; }
bool hasTableType() const { return TableType.hasValue(); }
const wasm::WasmTableType &getTableType() const {
assert(hasTableType());
return TableType.getValue();
}
void setTableType(wasm::WasmTableType TT) { TableType = TT; }
void setTableType(wasm::ValType VT) {
// Declare a table with element type VT and no limits (min size 0, no max
// size).
wasm::WasmLimits Limits = {wasm::WASM_LIMITS_FLAG_NONE, 0, 0};
setTableType({uint8_t(VT), Limits});
}
};
} // end namespace llvm
#endif // LLVM_MC_MCSYMBOLWASM_H
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
|
