CbC/CbC_llvm: lld/wasm/Symbols.h comparison

comparison lld/wasm/Symbols.h @ 207:2e18cbf3894f

LLVM12

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 08 Jun 2021 06:07:14 +0900
parents	0572611fdcc8
children	5f17cb93ff66

comparison

equal deleted inserted replaced

-:0572611fdcc8
+:2e18cbf3894f
 class InputSegment;
 class InputFunction;
 class InputGlobal;
 class InputEvent;
 class InputSection;
+class InputTable;
 class OutputSection;
 #define INVALID_INDEX UINT32_MAX
 // The base class for real symbol classes.
 enum Kind : uint8_t {
 DefinedFunctionKind,
 DefinedDataKind,
 DefinedGlobalKind,
 DefinedEventKind,
+DefinedTableKind,
 SectionKind,
 OutputSectionKind,
 UndefinedFunctionKind,
 UndefinedDataKind,
 UndefinedGlobalKind,
+UndefinedTableKind,
 LazyKind,
 };
 Kind kind() const { return symbolKind; }
 bool isDefined() const { return !isLazy() && !isUndefined(); }
 bool isUndefined() const {
 return symbolKind == UndefinedFunctionKind ||
-symbolKind == UndefinedDataKind || symbolKind == UndefinedGlobalKind;
+symbolKind == UndefinedDataKind ||
+symbolKind == UndefinedGlobalKind ||
+symbolKind == UndefinedTableKind;
 }
 bool isLazy() const { return symbolKind == LazyKind; }
 bool isLocal() const;
 uint32_t getOutputSymbolIndex() const;
 void setOutputSymbolIndex(uint32_t index);
 WasmSymbolType getWasmType() const;
 bool isExported() const;
+bool isExportedExplicit() const;
 // Indicates that the symbol is used in an __attribute__((used)) directive
 // or similar.
 bool isNoStrip() const;
 protected:
 Symbol(StringRef name, Kind k, uint32_t flags, InputFile *f)
 : name(name), file(f), symbolKind(k), referenced(!config->gcSections),
 requiresGOT(false), isUsedInRegularObj(false), forceExport(false),
-canInline(false), traced(false), flags(flags) {}
+canInline(false), traced(false), isStub(false), flags(flags) {}
 StringRef name;
 InputFile *file;
 uint32_t outputSymbolIndex = INVALID_INDEX;
 uint32_t gotIndex = INVALID_INDEX;
 // doesn't know the final contents of the symbol.
 bool canInline : 1;
 // True if this symbol is specified by --trace-symbol option.
 bool traced : 1;
+// True if this symbol is a linker-synthesized stub function (traps when
+// called) and should otherwise be treated as missing/undefined.  See
+// SymbolTable::replaceWithUndefined.
+// These stubs never appear in the table and any table index relocations
+// against them will produce address 0 (The table index representing
+// the null function pointer).
+bool isStub : 1;
 uint32_t flags;
 };
 class FunctionSymbol : public Symbol {
 return s->kind() == UndefinedFunctionKind;
 }
 llvm::Optional<StringRef> importName;
 llvm::Optional<StringRef> importModule;
+DefinedFunction *stubFunction = nullptr;
 bool isCalledDirectly;
 };
 // Section symbols for output sections are different from those for input
 // section.  These are generated by the linker and point the OutputSection
 const OutputSection *section;
 };
 class SectionSymbol : public Symbol {
 public:
-SectionSymbol(uint32_t flags, const InputSection *s, InputFile *f = nullptr)
+SectionSymbol(uint32_t flags, const InputChunk *s, InputFile *f = nullptr)
 : Symbol("", SectionKind, flags, f), section(s) {}
 static bool classof(const Symbol *s) { return s->kind() == SectionKind; }
 const OutputSectionSymbol *getOutputSectionSymbol() const;
-const InputSection *section;
+const InputChunk *section;
 };
 class DataSymbol : public Symbol {
 public:
 static bool classof(const Symbol *s) {
 };
 class DefinedData : public DataSymbol {
 public:
 // Constructor for regular data symbols originating from input files.
-DefinedData(StringRef name, uint32_t flags, InputFile *f,
+DefinedData(StringRef name, uint32_t flags, InputFile *f, InputChunk *segment,
-InputSegment *segment, uint32_t offset, uint32_t size)
+uint64_t value, uint64_t size)
 : DataSymbol(name, DefinedDataKind, flags, f), segment(segment),
-offset(offset), size(size) {}
+value(value), size(size) {}
 // Constructor for linker synthetic data symbols.
 DefinedData(StringRef name, uint32_t flags)
 : DataSymbol(name, DefinedDataKind, flags, nullptr) {}
 static bool classof(const Symbol *s) { return s->kind() == DefinedDataKind; }
 // Returns the output virtual address of a defined data symbol.
-uint32_t getVirtualAddress() const;
+uint64_t getVA() const;
-void setVirtualAddress(uint32_t va);
+void setVA(uint64_t va);
 // Returns the offset of a defined data symbol within its OutputSegment.
-uint32_t getOutputSegmentOffset() const;
+uint64_t getOutputSegmentOffset() const;
-uint32_t getOutputSegmentIndex() const;
+uint64_t getOutputSegmentIndex() const;
-uint32_t getSize() const { return size; }
+uint64_t getSize() const { return size; }
-InputSegment *segment = nullptr;
+InputChunk *segment = nullptr;
+uint64_t value = 0;
 protected:
-uint32_t offset = 0;
+uint64_t size = 0;
-uint32_t size = 0;
 };
 class UndefinedData : public DataSymbol {
 public:
 UndefinedData(StringRef name, uint32_t flags, InputFile *file = nullptr)
 : GlobalSymbol(name, UndefinedGlobalKind, flags, file, type),
 importName(importName), importModule(importModule) {}
 static bool classof(const Symbol *s) {
 return s->kind() == UndefinedGlobalKind;
+}
+llvm::Optional<StringRef> importName;
+llvm::Optional<StringRef> importModule;
+};
+class TableSymbol : public Symbol {
+public:
+static bool classof(const Symbol *s) {
+return s->kind() == DefinedTableKind || s->kind() == UndefinedTableKind;
+}
+const WasmTableType *getTableType() const { return tableType; }
+void setLimits(const WasmLimits &limits);
+// Get/set the table number
+uint32_t getTableNumber() const;
+void setTableNumber(uint32_t number);
+bool hasTableNumber() const;
+protected:
+TableSymbol(StringRef name, Kind k, uint32_t flags, InputFile *f,
+const WasmTableType *type)
+: Symbol(name, k, flags, f), tableType(type) {}
+const WasmTableType *tableType;
+uint32_t tableNumber = INVALID_INDEX;
+};
+class DefinedTable : public TableSymbol {
+public:
+DefinedTable(StringRef name, uint32_t flags, InputFile *file,
+InputTable *table);
+static bool classof(const Symbol *s) { return s->kind() == DefinedTableKind; }
+InputTable *table;
+};
+class UndefinedTable : public TableSymbol {
+public:
+UndefinedTable(StringRef name, llvm::Optional<StringRef> importName,
+llvm::Optional<StringRef> importModule, uint32_t flags,
+InputFile *file, const WasmTableType *type)
+: TableSymbol(name, UndefinedTableKind, flags, file, type),
+importName(importName), importModule(importModule) {}
+static bool classof(const Symbol *s) {
+return s->kind() == UndefinedTableKind;
 }
 llvm::Optional<StringRef> importName;
 llvm::Optional<StringRef> importModule;
 };
 const llvm::object::Archive::Symbol &sym)
 : Symbol(name, LazyKind, flags, file), archiveSymbol(sym) {}
 static bool classof(const Symbol *s) { return s->kind() == LazyKind; }
 void fetch();
+void setWeak();
 MemoryBufferRef getMemberBuffer();
 // Lazy symbols can have a signature because they can replace an
 // UndefinedFunction which which case we need to be able to preserve the
 // signature.
 // __wasm_call_ctors
 // Function that directly calls all ctors in priority order.
 static DefinedFunction *callCtors;
-// __wasm_apply_relocs
+// __wasm_call_dtors
+// Function that calls the libc/etc. cleanup function.
+static DefinedFunction *callDtors;
+// __wasm_apply_data_relocs
 // Function that applies relocations to data segment post-instantiation.
-static DefinedFunction *applyRelocs;
+static DefinedFunction *applyDataRelocs;
+// __wasm_apply_global_relocs
+// Function that applies relocations to data segment post-instantiation.
+// Unlike __wasm_apply_data_relocs this needs to run on every thread.
+static DefinedFunction *applyGlobalRelocs;
 // __wasm_init_tls
 // Function that allocates thread-local storage and initializes it.
 static DefinedFunction *initTLS;
+// Pointer to the function that is to be used in the start section.
+// (normally an alias of initMemory, or applyGlobalRelocs).
+static DefinedFunction *startFunction;
 // __dso_handle
 // Symbol used in calls to __cxa_atexit to determine current DLL
 static DefinedData *dsoHandle;
 // __table_base
 // Used in PIC code for offset of indirect function table
 static UndefinedGlobal *tableBase;
 static DefinedData *definedTableBase;
+// 32-bit copy in wasm64 to work around init expr limitations.
+// These can potentially be removed again once we have
+// https://github.com/WebAssembly/extended-const
+static UndefinedGlobal *tableBase32;
+static DefinedData *definedTableBase32;
 // __memory_base
 // 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
 // object. We allocate memory using this class and instantiate a symbol
 // using the placement new.
 union SymbolUnion {
 alignas(DefinedFunction) char a[sizeof(DefinedFunction)];
 alignas(DefinedData) char b[sizeof(DefinedData)];
 alignas(DefinedGlobal) char c[sizeof(DefinedGlobal)];
 alignas(DefinedEvent) char d[sizeof(DefinedEvent)];
-alignas(LazySymbol) char e[sizeof(LazySymbol)];
+alignas(DefinedTable) char e[sizeof(DefinedTable)];
-alignas(UndefinedFunction) char f[sizeof(UndefinedFunction)];
+alignas(LazySymbol) char f[sizeof(LazySymbol)];
-alignas(UndefinedData) char g[sizeof(UndefinedData)];
+alignas(UndefinedFunction) char g[sizeof(UndefinedFunction)];
-alignas(UndefinedGlobal) char h[sizeof(UndefinedGlobal)];
+alignas(UndefinedData) char h[sizeof(UndefinedData)];
-alignas(SectionSymbol) char i[sizeof(SectionSymbol)];
+alignas(UndefinedGlobal) char i[sizeof(UndefinedGlobal)];
+alignas(UndefinedTable) char j[sizeof(UndefinedTable)];
+alignas(SectionSymbol) char k[sizeof(SectionSymbol)];
 };
 // It is important to keep the size of SymbolUnion small for performance and
 // memory usage reasons. 96 bytes is a soft limit based on the size of
 // UndefinedFunction on a 64-bit system.
-static_assert(sizeof(SymbolUnion) <= 112, "SymbolUnion too large");
+static_assert(sizeof(SymbolUnion) <= 120, "SymbolUnion too large");
 void printTraceSymbol(Symbol *sym);
 void printTraceSymbolUndefined(StringRef name, const InputFile* file);
 template <typename T, typename... ArgT>

Mercurial > hg > CbC > CbC_llvm

comparison lld/wasm/Symbols.h @ 207:2e18cbf3894f