59 changes: 0 additions & 59 deletions lld/wasm/Driver.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,6 @@
#include "Config.h"
#include "InputChunks.h"
#include "InputGlobal.h"
#include "InputTable.h"
#include "MarkLive.h"
#include "SymbolTable.h"
#include "Writer.h"
Expand Down Expand Up @@ -788,58 +787,6 @@ static void wrapSymbols(ArrayRef<WrappedSymbol> wrapped) {
symtab->wrap(w.sym, w.real, w.wrap);
}

static TableSymbol *createDefinedIndirectFunctionTable(StringRef name) {
const uint32_t invalidIndex = -1;
WasmLimits limits{0, 0, 0}; // Set by the writer.
WasmTableType type{uint8_t(ValType::FUNCREF), limits};
WasmTable desc{invalidIndex, type, name};
InputTable *table = make<InputTable>(desc, nullptr);
uint32_t flags = config->exportTable ? 0 : WASM_SYMBOL_VISIBILITY_HIDDEN;
TableSymbol *sym = symtab->addSyntheticTable(name, flags, table);
sym->markLive();
sym->forceExport = config->exportTable;
return sym;
}

static TableSymbol *createUndefinedIndirectFunctionTable(StringRef name) {
WasmLimits limits{0, 0, 0}; // Set by the writer.
WasmTableType *type = make<WasmTableType>();
type->ElemType = uint8_t(ValType::FUNCREF);
type->Limits = limits;
StringRef module(defaultModule);
uint32_t flags = config->exportTable ? 0 : WASM_SYMBOL_VISIBILITY_HIDDEN;
flags |= WASM_SYMBOL_UNDEFINED;
Symbol *sym =
symtab->addUndefinedTable(name, name, module, flags, nullptr, type);
sym->markLive();
sym->forceExport = config->exportTable;
return cast<TableSymbol>(sym);
}

static TableSymbol *resolveIndirectFunctionTable() {
// Even though we may not need a table, if the user explicitly specified
// --import-table or --export-table, ensure a table is residualized.
if (config->importTable)
return createUndefinedIndirectFunctionTable(functionTableName);
if (config->exportTable)
return createDefinedIndirectFunctionTable(functionTableName);

// Otherwise, check to the symtab to find the indirect function table.
if (Symbol *sym = symtab->find(functionTableName)) {
if (sym->isLive()) {
if (auto *t = dyn_cast<TableSymbol>(sym)) {
return t->isDefined()
? t
: createDefinedIndirectFunctionTable(functionTableName);
}
}
}

// An indirect function table will only be present in the symbol table if
// needed by a reloc; if we get here, we don't need one.
return nullptr;
}

void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
WasmOptTable parser;
opt::InputArgList args = parser.parse(argsArr.slice(1));
Expand Down Expand Up @@ -1029,12 +976,6 @@ void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
// Do size optimizations: garbage collection
markLive();

// Provide the indirect funciton table if needed.
WasmSym::indirectFunctionTable = resolveIndirectFunctionTable();

if (errorCount())
return;

// Write the result to the file.
writeResult();
}
Expand Down
75 changes: 0 additions & 75 deletions lld/wasm/InputFiles.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -310,71 +310,6 @@ static void setRelocs(const std::vector<T *> &chunks,
}
}

// Since LLVM 12, we expect that if an input file defines or uses a table, it
// declares the tables using symbols and records each use with a relocation.
// This way when the linker combines inputs, it can collate the tables used by
// the inputs, assigning them distinct table numbers, and renumber all the uses
// as appropriate. At the same time, the linker has special logic to build the
// indirect function table if it is needed.
//
// However, object files produced by LLVM 11 and earlier neither write table
// symbols nor record relocations, and yet still use tables via call_indirect,
// and via function pointer bitcasts. We can detect these object files, as they
// declare tables as imports or define them locally, but don't have table
// symbols. synthesizeTableSymbols serves as a shim when loading these older
// input files, defining the missing symbols to allow the indirect function
// table to be built.
//
// Table uses in these older files won't be relocated, as they have no
// relocations. In practice this isn't a problem, as these object files
// typically just declare a single table named __indirect_function_table and
// having table number 0, so relocation would be idempotent anyway.
void ObjFile::synthesizeTableSymbols() {
uint32_t tableNumber = 0;
const WasmGlobalType *globalType = nullptr;
const WasmEventType *eventType = nullptr;
const WasmSignature *signature = nullptr;
if (wasmObj->getNumImportedTables()) {
for (const auto &import : wasmObj->imports()) {
if (import.Kind == WASM_EXTERNAL_TABLE) {
auto *info = make<WasmSymbolInfo>();
info->Name = import.Field;
info->Kind = WASM_SYMBOL_TYPE_TABLE;
info->ImportModule = import.Module;
info->ImportName = import.Field;
info->Flags = WASM_SYMBOL_UNDEFINED;
info->Flags |= WASM_SYMBOL_NO_STRIP;
info->ElementIndex = tableNumber++;
LLVM_DEBUG(dbgs() << "Synthesizing symbol for table import: "
<< info->Name << "\n");
auto *wasmSym = make<WasmSymbol>(*info, globalType, &import.Table,
eventType, signature);
symbols.push_back(createUndefined(*wasmSym, false));
// Because there are no TABLE_NUMBER relocs in this case, we can't
// compute accurate liveness info; instead, just mark the symbol as
// always live.
symbols.back()->markLive();
}
}
}
for (const auto &table : tables) {
auto *info = make<llvm::wasm::WasmSymbolInfo>();
// Empty name.
info->Kind = WASM_SYMBOL_TYPE_TABLE;
info->Flags = WASM_SYMBOL_BINDING_LOCAL;
info->Flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
info->Flags |= WASM_SYMBOL_NO_STRIP;
info->ElementIndex = tableNumber++;
LLVM_DEBUG(dbgs() << "Synthesizing symbol for table definition: "
<< info->Name << "\n");
auto *wasmSym = make<WasmSymbol>(*info, globalType, &table->getType(),
eventType, signature);
symbols.push_back(createDefined(*wasmSym));
// Mark live, for the same reasons as for imported tables.
symbols.back()->markLive();
}
}

void ObjFile::parse(bool ignoreComdats) {
// Parse a memory buffer as a wasm file.
LLVM_DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
Expand Down Expand Up @@ -489,11 +424,8 @@ void ObjFile::parse(bool ignoreComdats) {

// Populate `Symbols` based on the symbols in the object.
symbols.reserve(wasmObj->getNumberOfSymbols());
bool haveTableSymbol = false;
for (const SymbolRef &sym : wasmObj->symbols()) {
const WasmSymbol &wasmSym = wasmObj->getWasmSymbol(sym.getRawDataRefImpl());
if (wasmSym.isTypeTable())
haveTableSymbol = true;
if (wasmSym.isDefined()) {
// createDefined may fail if the symbol is comdat excluded in which case
// we fall back to creating an undefined symbol
Expand All @@ -505,13 +437,6 @@ void ObjFile::parse(bool ignoreComdats) {
size_t idx = symbols.size();
symbols.push_back(createUndefined(wasmSym, isCalledDirectly[idx]));
}

// As a stopgap measure while implementing table support, if the object file
// has table definitions or imports but no table symbols, synthesize symbols
// for those tables. Mark as NO_STRIP to ensure they reach the output file,
// even if there are no TABLE_NUMBER relocs against them.
if (!haveTableSymbol)
synthesizeTableSymbols();
}

bool ObjFile::isExcludedByComdat(InputChunk *chunk) const {
Expand Down
1 change: 0 additions & 1 deletion lld/wasm/InputFiles.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -157,7 +157,6 @@ class ObjFile : public InputFile {
Symbol *createUndefined(const WasmSymbol &sym, bool isCalledDirectly);

bool isExcludedByComdat(InputChunk *chunk) const;
void synthesizeTableSymbols();

std::unique_ptr<WasmObjectFile> wasmObj;
};
Expand Down
3 changes: 0 additions & 3 deletions lld/wasm/MarkLive.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -177,9 +177,6 @@ void markLive() {
for (InputGlobal *g : symtab->syntheticGlobals)
if (!g->live)
message("removing unused section " + toString(g));
for (InputTable *t : symtab->syntheticTables)
if (!t->live)
message("removing unused section " + toString(t));
}
}

Expand Down
12 changes: 0 additions & 12 deletions lld/wasm/SymbolTable.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -270,18 +270,6 @@ DefinedGlobal *SymbolTable::addOptionalGlobalSymbols(StringRef name,
return replaceSymbol<DefinedGlobal>(s, name, flags, nullptr, global);
}

DefinedTable *SymbolTable::addSyntheticTable(StringRef name, uint32_t flags,
InputTable *table) {
LLVM_DEBUG(dbgs() << "addSyntheticTable: " << name << " -> " << table
<< "\n");
Symbol *s = find(name);
assert(!s || s->isUndefined());
if (!s)
s = insertName(name).first;
syntheticTables.emplace_back(table);
return replaceSymbol<DefinedTable>(s, name, flags, nullptr, table);
}

static bool shouldReplace(const Symbol *existing, InputFile *newFile,
uint32_t newFlags) {
// If existing symbol is undefined, replace it.
Expand Down
3 changes: 0 additions & 3 deletions lld/wasm/SymbolTable.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -93,8 +93,6 @@ class SymbolTable {
DefinedData *addOptionalDataSymbol(StringRef name, uint64_t value = 0);
DefinedGlobal *addOptionalGlobalSymbols(StringRef name, uint32_t flags,
InputGlobal *global);
DefinedTable *addSyntheticTable(StringRef name, uint32_t flags,
InputTable *global);

void handleSymbolVariants();
void handleWeakUndefines();
Expand All @@ -105,7 +103,6 @@ class SymbolTable {
std::vector<BitcodeFile *> bitcodeFiles;
std::vector<InputFunction *> syntheticFunctions;
std::vector<InputGlobal *> syntheticGlobals;
std::vector<InputTable *> syntheticTables;

private:
std::pair<Symbol *, bool> insert(StringRef name, const InputFile *file);
Expand Down
1 change: 0 additions & 1 deletion lld/wasm/Symbols.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -91,7 +91,6 @@ UndefinedGlobal *WasmSym::tableBase;
DefinedData *WasmSym::definedTableBase;
UndefinedGlobal *WasmSym::memoryBase;
DefinedData *WasmSym::definedMemoryBase;
TableSymbol *WasmSym::indirectFunctionTable;

WasmSymbolType Symbol::getWasmType() const {
if (isa<FunctionSymbol>(this))
Expand Down
5 changes: 0 additions & 5 deletions lld/wasm/Symbols.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -568,11 +568,6 @@ struct WasmSym {
// Used in PIC code for offset of global data
static UndefinedGlobal *memoryBase;
static DefinedData *definedMemoryBase;

// __indirect_function_table
// Used as an address space for function pointers, with each function that is
// used as a function pointer being allocated a slot.
static TableSymbol *indirectFunctionTable;
};

// A buffer class that is large enough to hold any Symbol-derived
Expand Down
39 changes: 38 additions & 1 deletion lld/wasm/SyntheticSections.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -92,11 +92,20 @@ void TypeSection::writeBody() {
writeSig(bodyOutputStream, *sig);
}

ImportSection::ImportSection() : SyntheticSection(llvm::wasm::WASM_SEC_IMPORT) {
// FIXME: Remove when we treat __indirect_function_table as any other symbol.
if (config->importTable) {
numImportedTables++;
}
}

uint32_t ImportSection::getNumImports() const {
assert(isSealed);
uint32_t numImports = importedSymbols.size() + gotSymbols.size();
if (config->importMemory)
++numImports;
if (config->importTable)
++numImports;
return numImports;
}

Expand Down Expand Up @@ -145,6 +154,17 @@ void ImportSection::writeBody() {
writeImport(os, import);
}

if (config->importTable) {
uint32_t tableSize = config->tableBase + out.elemSec->numEntries();
WasmImport import;
import.Module = defaultModule;
import.Field = functionTableName;
import.Kind = WASM_EXTERNAL_TABLE;
import.Table.ElemType = WASM_TYPE_FUNCREF;
import.Table.Limits = {0, tableSize, 0};
writeImport(os, import);
}

for (const Symbol *sym : importedSymbols) {
WasmImport import;
if (auto *f = dyn_cast<UndefinedFunction>(sym)) {
Expand Down Expand Up @@ -210,9 +230,26 @@ void FunctionSection::addFunction(InputFunction *func) {
}

void TableSection::writeBody() {
bool hasIndirectFunctionTable = !config->importTable;

uint32_t tableCount = inputTables.size();
if (hasIndirectFunctionTable)
tableCount++;

raw_ostream &os = bodyOutputStream;

writeUleb128(os, inputTables.size(), "table count");
writeUleb128(os, tableCount, "table count");

if (hasIndirectFunctionTable) {
uint32_t tableSize = config->tableBase + out.elemSec->numEntries();
WasmLimits limits;
if (config->growableTable)
limits = {0, tableSize, 0};
else
limits = {WASM_LIMITS_FLAG_HAS_MAX, tableSize, tableSize};
writeTableType(os, WasmTableType{WASM_TYPE_FUNCREF, limits});
}

for (const InputTable *table : inputTables)
writeTableType(os, table->getType());
}
Expand Down
13 changes: 11 additions & 2 deletions lld/wasm/SyntheticSections.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -98,7 +98,7 @@ class TypeSection : public SyntheticSection {

class ImportSection : public SyntheticSection {
public:
ImportSection() : SyntheticSection(llvm::wasm::WASM_SEC_IMPORT) {}
ImportSection();
bool isNeeded() const override { return getNumImports() > 0; }
void writeBody() override;
void addImport(Symbol *sym);
Expand Down Expand Up @@ -150,7 +150,16 @@ class TableSection : public SyntheticSection {
public:
TableSection() : SyntheticSection(llvm::wasm::WASM_SEC_TABLE) {}

bool isNeeded() const override { return inputTables.size() > 0; };
bool isNeeded() const override {
// The linker currently always writes an indirect function table to the
// output, so unless the indirect function table is imported, we need a
// table section. FIXME: Treat __indirect_function_table as a normal
// symbol, and only residualize a table section as needed.
if (!config->importTable)
return true;
return inputTables.size() > 0;
}

void writeBody() override;
void addTable(InputTable *table);

Expand Down
18 changes: 0 additions & 18 deletions lld/wasm/Writer.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -745,19 +745,6 @@ void Writer::createCommandExportWrappers() {
}
}

static void finalizeIndirectFunctionTable() {
if (!WasmSym::indirectFunctionTable)
return;

uint32_t tableSize = config->tableBase + out.elemSec->numEntries();
WasmLimits limits = {0, tableSize, 0};
if (WasmSym::indirectFunctionTable->isDefined() && !config->growableTable) {
limits.Flags |= WASM_LIMITS_FLAG_HAS_MAX;
limits.Maximum = limits.Initial;
}
WasmSym::indirectFunctionTable->setLimits(limits);
}

static void scanRelocations() {
for (ObjFile *file : symtab->objectFiles) {
LLVM_DEBUG(dbgs() << "scanRelocations: " << file->getName() << "\n");
Expand Down Expand Up @@ -805,9 +792,6 @@ void Writer::assignIndexes() {
out.tableSec->addTable(table);
}

for (InputTable *table : symtab->syntheticTables)
out.tableSec->addTable(table);

out.globalSec->assignIndexes();
}

Expand Down Expand Up @@ -1357,8 +1341,6 @@ void Writer::run() {

log("-- scanRelocations");
scanRelocations();
log("-- finalizeIndirectFunctionTable");
finalizeIndirectFunctionTable();
log("-- createSyntheticInitFunctions");
createSyntheticInitFunctions();
log("-- assignIndexes");
Expand Down
11 changes: 4 additions & 7 deletions llvm/lib/MC/WasmObjectWriter.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -519,13 +519,6 @@ void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
Sym->setUndefined();
}
Sym->setUsedInReloc();
// Any time we have a TABLE_INDEX relocation against a function symbol, we
// need to ensure that table itself is part of the final output too. In the
// future we may want to define a new kind of reloc against both the
// function and the table, so that the linker can see that the function
// symbol keeps the table alive, but for now manually mark the table as
// live.
Sym->setNoStrip();
Asm.registerSymbol(*Sym);
}

Expand Down Expand Up @@ -1677,6 +1670,10 @@ uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm,
WS.setIndex(InvalidIndex);
continue;
}
if (WS.isTable() && WS.getName() == "__indirect_function_table") {
// For the moment, don't emit table symbols -- wasm-ld can't handle them.
continue;
}
LLVM_DEBUG(dbgs() << "adding to symtab: " << WS << "\n");

uint32_t Flags = 0;
Expand Down
24 changes: 7 additions & 17 deletions llvm/test/MC/WebAssembly/debug-info.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -89,44 +89,44 @@
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 95
; CHECK-NEXT: Size: 91
; CHECK-NEXT: Offset: 731
; CHECK-NEXT: Name: linking
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 9
; CHECK-NEXT: Offset: 840
; CHECK-NEXT: Offset: 836
; CHECK-NEXT: Name: reloc.DATA
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 61
; CHECK-NEXT: Offset: 866
; CHECK-NEXT: Offset: 862
; CHECK-NEXT: Name: reloc..debug_info
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 6
; CHECK-NEXT: Offset: 951
; CHECK-NEXT: Offset: 947
; CHECK-NEXT: Name: reloc..debug_pubnames
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 6
; CHECK-NEXT: Offset: 985
; CHECK-NEXT: Offset: 981
; CHECK-NEXT: Name: reloc..debug_pubtypes
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 6
; CHECK-NEXT: Offset: 1019
; CHECK-NEXT: Offset: 1015
; CHECK-NEXT: Name: reloc..debug_line
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 77
; CHECK-NEXT: Offset: 1049
; CHECK-NEXT: Offset: 1045
; CHECK-NEXT: Name: producers
; CHECK-NEXT: }
; CHECK-NEXT:]
Expand Down Expand Up @@ -238,16 +238,6 @@
; CHECK-NEXT: ]
; CHECK-NEXT: ElementIndex: 0xC
; CHECK-NEXT: }
; CHECK-NEXT: Symbol {
; CHECK-NEXT: Name: __indirect_function_table
; CHECK-NEXT: Type: TABLE (0x5)
; CHECK-NEXT: Flags [ (0x90)
; CHECK-NEXT: NO_STRIP (0x80)
; CHECK-NEXT: UNDEFINED (0x10)
; CHECK-NEXT: ]
; CHECK-NEXT: ImportModule: env
; CHECK-NEXT: ElementIndex: 0x0
; CHECK-NEXT: }
; CHECK-NEXT:]

; generated from the following C code using: clang --target=wasm32 -g -O0 -S -emit-llvm test.c
Expand Down
24 changes: 7 additions & 17 deletions llvm/test/MC/WebAssembly/debug-info64.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -89,44 +89,44 @@
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 95
; CHECK-NEXT: Size: 91
; CHECK-NEXT: Offset: 759
; CHECK-NEXT: Name: linking
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 9
; CHECK-NEXT: Offset: 868
; CHECK-NEXT: Offset: 864
; CHECK-NEXT: Name: reloc.DATA
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 61
; CHECK-NEXT: Offset: 894
; CHECK-NEXT: Offset: 890
; CHECK-NEXT: Name: reloc..debug_info
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 6
; CHECK-NEXT: Offset: 979
; CHECK-NEXT: Offset: 975
; CHECK-NEXT: Name: reloc..debug_pubnames
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 6
; CHECK-NEXT: Offset: 1013
; CHECK-NEXT: Offset: 1009
; CHECK-NEXT: Name: reloc..debug_pubtypes
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 6
; CHECK-NEXT: Offset: 1047
; CHECK-NEXT: Offset: 1043
; CHECK-NEXT: Name: reloc..debug_line
; CHECK-NEXT: }
; CHECK-NEXT: Section {
; CHECK-NEXT: Type: CUSTOM (0x0)
; CHECK-NEXT: Size: 77
; CHECK-NEXT: Offset: 1077
; CHECK-NEXT: Offset: 1073
; CHECK-NEXT: Name: producers
; CHECK-NEXT: }
; CHECK-NEXT: ]
Expand Down Expand Up @@ -238,16 +238,6 @@
; CHECK-NEXT: ]
; CHECK-NEXT: ElementIndex: 0xC
; CHECK-NEXT: }
; CHECK-NEXT: Symbol {
; CHECK-NEXT: Name: __indirect_function_table
; CHECK-NEXT: Type: TABLE (0x5)
; CHECK-NEXT: Flags [ (0x90)
; CHECK-NEXT: NO_STRIP (0x80)
; CHECK-NEXT: UNDEFINED (0x10)
; CHECK-NEXT: ]
; CHECK-NEXT: ImportModule: env
; CHECK-NEXT: ElementIndex: 0x0
; CHECK-NEXT: }
; CHECK-NEXT: ]

; generated from the following C code using: clang --target=wasm64 -g -O0 -S -emit-llvm test.c
Expand Down
10 changes: 0 additions & 10 deletions llvm/test/MC/WebAssembly/function-alias.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -41,14 +41,4 @@ define i8* @func() {
; CHECK-NEXT: ]
; CHECK-NEXT: ElementIndex: 0x0
; CHECK-NEXT: }
; CHECK-NEXT: Symbol {
; CHECK-NEXT: Name: __indirect_function_table
; CHECK-NEXT: Type: TABLE (0x5)
; CHECK-NEXT: Flags [ (0x90)
; CHECK-NEXT: NO_STRIP (0x80)
; CHECK-NEXT: UNDEFINED (0x10)
; CHECK-NEXT: ]
; CHECK-NEXT: ImportModule: env
; CHECK-NEXT: ElementIndex: 0x0
; CHECK-NEXT: }
; CHECK-NEXT: ]
5 changes: 0 additions & 5 deletions llvm/test/MC/WebAssembly/global-ctor-dtor.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -170,11 +170,6 @@ declare void @func3()
; CHECK-NEXT: Name: func0
; CHECK-NEXT: Flags: [ UNDEFINED ]
; CHECK-NEXT: Function: 4
; CHECK-NEXT: - Index: 11
; CHECK-NEXT: Kind: TABLE
; CHECK-NEXT: Name: __indirect_function_table
; CHECK-NEXT: Flags: [ UNDEFINED, NO_STRIP ]
; CHECK-NEXT: Table: 0
; CHECK-NEXT: SegmentInfo:
; CHECK-NEXT: - Index: 0
; CHECK-NEXT: Name: .data.global1
Expand Down
5 changes: 0 additions & 5 deletions llvm/test/MC/WebAssembly/reloc-pic.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -190,11 +190,6 @@ hidden_func:
# CHECK-NEXT: Name: hidden_func
# CHECK-NEXT: Flags: [ BINDING_LOCAL ]
# CHECK-NEXT: Function: 5
# CHECK-NEXT: - Index: 10
# CHECK-NEXT: Kind: TABLE
# CHECK-NEXT: Name: __indirect_function_table
# CHECK-NEXT: Flags: [ UNDEFINED, NO_STRIP ]
# CHECK-NEXT: Table: 0
# CHECK-NEXT: SegmentInfo:
# CHECK-NEXT: - Index: 0
# CHECK-NEXT: Name: .rodata.hidden_data
Expand Down
5 changes: 0 additions & 5 deletions llvm/test/MC/WebAssembly/type-index.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -66,9 +66,4 @@ test0:
# BIN-NEXT: Name: test0
# BIN-NEXT: Flags: [ BINDING_LOCAL ]
# BIN-NEXT: Function: 0
# BIN-NEXT: - Index: 1
# BIN-NEXT: Kind: TABLE
# BIN-NEXT: Name: __indirect_function_table
# BIN-NEXT: Flags: [ UNDEFINED, NO_STRIP ]
# BIN-NEXT: Table: 0
# BIN-NEXT: ...
5 changes: 0 additions & 5 deletions llvm/test/MC/WebAssembly/weak-alias.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -227,11 +227,6 @@ alias_address:
# CHECK-NEXT: Flags: [ BINDING_WEAK, VISIBILITY_HIDDEN, NO_STRIP ]
# CHECK-NEXT: Segment: 0
# CHECK-NEXT: Size: 4
# CHECK-NEXT: - Index: 10
# CHECK-NEXT: Kind: TABLE
# CHECK-NEXT: Name: __indirect_function_table
# CHECK-NEXT: Flags: [ UNDEFINED, NO_STRIP ]
# CHECK-NEXT: Table: 0
# CHECK-NEXT: SegmentInfo:
# CHECK-NEXT: - Index: 0
# CHECK-NEXT: Name: .data.bar
Expand Down