Sam Clegg | c94d393 | 2017-11-17 18:14:09 +0000 | [diff] [blame] | 1 | //===- Config.h -------------------------------------------------*- C++ -*-===// |
| 2 | // |
Chandler Carruth | 2946cd7 | 2019-01-19 08:50:56 +0000 | [diff] [blame] | 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 | // See https://llvm.org/LICENSE.txt for license information. |
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
Sam Clegg | c94d393 | 2017-11-17 18:14:09 +0000 | [diff] [blame] | 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | |
| 9 | #ifndef LLD_WASM_CONFIG_H |
| 10 | #define LLD_WASM_CONFIG_H |
| 11 | |
Fangrui Song | 4b2b68d | 2022-07-30 18:11:21 -0700 | [diff] [blame] | 12 | #include "llvm/ADT/SmallVector.h" |
Sam Clegg | c94d393 | 2017-11-17 18:14:09 +0000 | [diff] [blame] | 13 | #include "llvm/ADT/StringRef.h" |
Rui Ueyama | 7d5a137 | 2017-11-29 22:21:37 +0000 | [diff] [blame] | 14 | #include "llvm/ADT/StringSet.h" |
mzukovec | 0367305 | 2024-09-04 17:50:10 +0200 | [diff] [blame] | 15 | #include "llvm/ADT/Twine.h" |
Sam Clegg | c94d393 | 2017-11-17 18:14:09 +0000 | [diff] [blame] | 16 | #include "llvm/BinaryFormat/Wasm.h" |
Sam Clegg | c729c1b | 2018-05-30 18:07:52 +0000 | [diff] [blame] | 17 | #include "llvm/Support/CachePruning.h" |
Kazu Hirata | b9ef564 | 2023-01-02 18:29:04 -0800 | [diff] [blame] | 18 | #include <optional> |
Sam Clegg | c94d393 | 2017-11-17 18:14:09 +0000 | [diff] [blame] | 19 | |
Arthur Eubanks | 0a1aa6c | 2023-09-14 14:10:14 -0700 | [diff] [blame] | 20 | namespace llvm { |
| 21 | enum class CodeGenOptLevel; |
| 22 | } // namespace llvm |
Scott Linder | 45ee0a9 | 2023-02-15 17:12:47 +0000 | [diff] [blame] | 23 | |
Sam Clegg | d32f71a | 2023-03-06 09:55:00 -0800 | [diff] [blame] | 24 | namespace lld::wasm { |
Sam Clegg | c94d393 | 2017-11-17 18:14:09 +0000 | [diff] [blame] | 25 | |
Sam Clegg | 8aef04f | 2023-03-06 09:18:03 -0800 | [diff] [blame] | 26 | class InputFile; |
Sam Clegg | 3c58457 | 2024-01-18 15:53:13 -0800 | [diff] [blame] | 27 | class StubFile; |
| 28 | class ObjFile; |
| 29 | class SharedFile; |
| 30 | class BitcodeFile; |
| 31 | class InputTable; |
| 32 | class InputGlobal; |
| 33 | class InputFunction; |
Sam Clegg | 8aef04f | 2023-03-06 09:18:03 -0800 | [diff] [blame] | 34 | class Symbol; |
Anutosh Bhat | 9cbbb74 | 2025-04-25 20:05:00 +0530 | [diff] [blame] | 35 | class DefinedData; |
| 36 | class GlobalSymbol; |
| 37 | class DefinedFunction; |
| 38 | class UndefinedGlobal; |
| 39 | class TableSymbol; |
Sam Clegg | 8aef04f | 2023-03-06 09:18:03 -0800 | [diff] [blame] | 40 | |
Sam Clegg | 206884b | 2020-05-01 09:14:59 -0700 | [diff] [blame] | 41 | // For --unresolved-symbols. |
Sam Clegg | 86c90f9 | 2020-11-16 10:11:37 -0800 | [diff] [blame] | 42 | enum class UnresolvedPolicy { ReportError, Warn, Ignore, ImportDynamic }; |
Sam Clegg | 206884b | 2020-05-01 09:14:59 -0700 | [diff] [blame] | 43 | |
Derek Schuff | c7af9ae | 2023-03-02 15:52:25 -0800 | [diff] [blame] | 44 | // For --build-id. |
| 45 | enum class BuildIdKind { None, Fast, Sha1, Hexstring, Uuid }; |
| 46 | |
Sam Clegg | a1282a3 | 2019-05-08 16:20:05 +0000 | [diff] [blame] | 47 | // This struct contains the global configuration for the linker. |
| 48 | // Most fields are direct mapping from the command line options |
| 49 | // and such fields have the same name as the corresponding options. |
| 50 | // Most fields are initialized by the driver. |
Fangrui Song | a222d00 | 2024-12-13 19:14:32 -0800 | [diff] [blame] | 51 | struct Config { |
mzukovec | 0367305 | 2024-09-04 17:50:10 +0200 | [diff] [blame] | 52 | bool allowMultipleDefinition; |
Sam Clegg | 2513407 | 2020-10-07 14:48:37 -0700 | [diff] [blame] | 53 | bool bsymbolic; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 54 | bool checkFeatures; |
| 55 | bool compressRelocations; |
| 56 | bool demangle; |
| 57 | bool disableVerify; |
Dan Gohman | 46a3268 | 2020-06-12 12:05:40 -0700 | [diff] [blame] | 58 | bool experimentalPic; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 59 | bool emitRelocs; |
| 60 | bool exportAll; |
| 61 | bool exportDynamic; |
| 62 | bool exportTable; |
Sam Clegg | 4690bf2 | 2022-03-07 15:50:30 -0800 | [diff] [blame] | 63 | bool extendedConst; |
Jacob Gravelle | 92ed86d | 2019-08-27 22:58:21 +0000 | [diff] [blame] | 64 | bool growableTable; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 65 | bool gcSections; |
Sam Clegg | 89d5635 | 2023-05-04 16:04:04 -0700 | [diff] [blame] | 66 | llvm::StringSet<> keepSections; |
Kazu Hirata | b9ef564 | 2023-01-02 18:29:04 -0800 | [diff] [blame] | 67 | std::optional<std::pair<llvm::StringRef, llvm::StringRef>> memoryImport; |
| 68 | std::optional<llvm::StringRef> memoryExport; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 69 | bool sharedMemory; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 70 | bool importTable; |
Sam Clegg | 758633f | 2021-05-27 14:27:10 -0700 | [diff] [blame] | 71 | bool importUndefined; |
Kazu Hirata | b9ef564 | 2023-01-02 18:29:04 -0800 | [diff] [blame] | 72 | std::optional<bool> is64; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 73 | bool mergeDataSegments; |
mzukovec | 0367305 | 2024-09-04 17:50:10 +0200 | [diff] [blame] | 74 | bool noinhibitExec; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 75 | bool pie; |
| 76 | bool printGcSections; |
| 77 | bool relocatable; |
| 78 | bool saveTemps; |
| 79 | bool shared; |
Sam Clegg | 22b7b84 | 2024-07-12 13:26:52 -0700 | [diff] [blame] | 80 | bool shlibSigCheck; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 81 | bool stripAll; |
| 82 | bool stripDebug; |
| 83 | bool stackFirst; |
YAMAMOTO Takashi | 2b6c6bb | 2024-06-12 08:45:53 +0900 | [diff] [blame] | 84 | // Because dyamanic linking under Wasm is still experimental we default to |
| 85 | // static linking |
| 86 | bool isStatic = true; |
Sam Clegg | 9a450a0 | 2024-11-01 16:34:06 -0700 | [diff] [blame] | 87 | bool thinLTOEmitImportsFiles; |
| 88 | bool thinLTOEmitIndexFiles; |
| 89 | bool thinLTOIndexOnly; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 90 | bool trace; |
Thomas Lively | c496d84 | 2020-04-03 16:18:29 -0700 | [diff] [blame] | 91 | uint64_t globalBase; |
SingleAccretion | b2cdf3c | 2023-12-15 21:16:38 +0300 | [diff] [blame] | 92 | uint64_t initialHeap; |
Thomas Lively | c496d84 | 2020-04-03 16:18:29 -0700 | [diff] [blame] | 93 | uint64_t initialMemory; |
| 94 | uint64_t maxMemory; |
SingleAccretion | cb4f94d | 2024-02-25 19:43:11 +0300 | [diff] [blame] | 95 | bool noGrowableMemory; |
Sam Clegg | 184c22d | 2024-01-18 15:01:21 -0800 | [diff] [blame] | 96 | // The table offset at which to place function addresses. We reserve zero |
| 97 | // for the null function pointer. This gets set to 1 for executables and 0 |
| 98 | // for shared libraries (since they always added to a dynamic offset at |
| 99 | // runtime). |
| 100 | uint64_t tableBase; |
Thomas Lively | c496d84 | 2020-04-03 16:18:29 -0700 | [diff] [blame] | 101 | uint64_t zStackSize; |
Nick Fitzgerald | 6018930 | 2025-03-04 09:39:30 -0800 | [diff] [blame] | 102 | uint64_t pageSize; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 103 | unsigned ltoPartitions; |
| 104 | unsigned ltoo; |
Arthur Eubanks | 0a1aa6c | 2023-09-14 14:10:14 -0700 | [diff] [blame] | 105 | llvm::CodeGenOptLevel ltoCgo; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 106 | unsigned optimize; |
Arthur Eubanks | 1314a49 | 2020-12-01 12:22:27 -0800 | [diff] [blame] | 107 | bool ltoDebugPassManager; |
Sam Clegg | 206884b | 2020-05-01 09:14:59 -0700 | [diff] [blame] | 108 | UnresolvedPolicy unresolvedSymbols; |
Derek Schuff | c7af9ae | 2023-03-02 15:52:25 -0800 | [diff] [blame] | 109 | BuildIdKind buildId = BuildIdKind::None; |
Sam Clegg | a1282a3 | 2019-05-08 16:20:05 +0000 | [diff] [blame] | 110 | |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 111 | llvm::StringRef entry; |
Sam Clegg | 9a450a0 | 2024-11-01 16:34:06 -0700 | [diff] [blame] | 112 | llvm::StringRef ltoObjPath; |
Sam Clegg | cc2da55 | 2020-03-27 16:52:27 -0700 | [diff] [blame] | 113 | llvm::StringRef mapFile; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 114 | llvm::StringRef outputFile; |
Sam Clegg | 8e44f03 | 2023-05-26 18:17:45 -0700 | [diff] [blame] | 115 | llvm::StringRef soName; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 116 | llvm::StringRef thinLTOCacheDir; |
Sam Clegg | 9a450a0 | 2024-11-01 16:34:06 -0700 | [diff] [blame] | 117 | llvm::StringRef thinLTOJobs; |
| 118 | llvm::StringRef thinLTOIndexOnlyArg; |
Sam Clegg | b70eb86 | 2024-11-08 16:48:30 -0800 | [diff] [blame] | 119 | std::pair<llvm::StringRef, llvm::StringRef> thinLTOObjectSuffixReplace; |
| 120 | llvm::StringRef thinLTOPrefixReplaceOld; |
| 121 | llvm::StringRef thinLTOPrefixReplaceNew; |
| 122 | llvm::StringRef thinLTOPrefixReplaceNativeObject; |
Sam Clegg | 8aef04f | 2023-03-06 09:18:03 -0800 | [diff] [blame] | 123 | llvm::StringRef whyExtract; |
Sam Clegg | c94d393 | 2017-11-17 18:14:09 +0000 | [diff] [blame] | 124 | |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 125 | llvm::StringSet<> allowUndefinedSymbols; |
| 126 | llvm::StringSet<> exportedSymbols; |
Sam Clegg | a6f4064 | 2021-04-05 08:00:30 -0700 | [diff] [blame] | 127 | std::vector<llvm::StringRef> requiredExports; |
Fangrui Song | 4b2b68d | 2022-07-30 18:11:21 -0700 | [diff] [blame] | 128 | llvm::SmallVector<llvm::StringRef, 0> searchPaths; |
Hood Chatham | 80ea31c | 2025-02-28 20:12:52 +0100 | [diff] [blame] | 129 | llvm::SmallVector<llvm::StringRef, 0> rpath; |
Rui Ueyama | 136d27a | 2019-07-11 05:40:30 +0000 | [diff] [blame] | 130 | llvm::CachePruningPolicy thinLTOCachePolicy; |
Kazu Hirata | b9ef564 | 2023-01-02 18:29:04 -0800 | [diff] [blame] | 131 | std::optional<std::vector<std::string>> features; |
| 132 | std::optional<std::vector<std::string>> extraFeatures; |
Derek Schuff | c7af9ae | 2023-03-02 15:52:25 -0800 | [diff] [blame] | 133 | llvm::SmallVector<uint8_t, 0> buildIdVector; |
Sam Clegg | 184c22d | 2024-01-18 15:01:21 -0800 | [diff] [blame] | 134 | }; |
Sam Clegg | bfb7534 | 2018-11-15 00:37:21 +0000 | [diff] [blame] | 135 | |
Sam Clegg | 184c22d | 2024-01-18 15:01:21 -0800 | [diff] [blame] | 136 | // The Ctx object hold all other (non-configuration) global state. |
| 137 | struct Ctx { |
Fangrui Song | 3792b36 | 2025-01-02 17:08:18 -0800 | [diff] [blame] | 138 | Config arg; |
Fangrui Song | a222d00 | 2024-12-13 19:14:32 -0800 | [diff] [blame] | 139 | |
Sam Clegg | 3c58457 | 2024-01-18 15:53:13 -0800 | [diff] [blame] | 140 | llvm::SmallVector<ObjFile *, 0> objectFiles; |
| 141 | llvm::SmallVector<StubFile *, 0> stubFiles; |
| 142 | llvm::SmallVector<SharedFile *, 0> sharedFiles; |
| 143 | llvm::SmallVector<BitcodeFile *, 0> bitcodeFiles; |
Sam Clegg | 9a450a0 | 2024-11-01 16:34:06 -0700 | [diff] [blame] | 144 | llvm::SmallVector<BitcodeFile *, 0> lazyBitcodeFiles; |
Sam Clegg | 3c58457 | 2024-01-18 15:53:13 -0800 | [diff] [blame] | 145 | llvm::SmallVector<InputFunction *, 0> syntheticFunctions; |
| 146 | llvm::SmallVector<InputGlobal *, 0> syntheticGlobals; |
| 147 | llvm::SmallVector<InputTable *, 0> syntheticTables; |
| 148 | |
Anutosh Bhat | 9cbbb74 | 2025-04-25 20:05:00 +0530 | [diff] [blame] | 149 | // linker-generated symbols |
| 150 | struct WasmSym { |
| 151 | // __global_base |
| 152 | // Symbol marking the start of the global section. |
| 153 | DefinedData *globalBase; |
| 154 | |
| 155 | // __stack_pointer/__stack_low/__stack_high |
| 156 | // Global that holds current value of stack pointer and data symbols marking |
| 157 | // the start and end of the stack region. stackPointer is initialized to |
| 158 | // stackHigh and grows downwards towards stackLow |
| 159 | GlobalSymbol *stackPointer; |
| 160 | DefinedData *stackLow; |
| 161 | DefinedData *stackHigh; |
| 162 | |
| 163 | // __tls_base |
| 164 | // Global that holds the address of the base of the current thread's |
| 165 | // TLS block. |
| 166 | GlobalSymbol *tlsBase; |
| 167 | |
| 168 | // __tls_size |
| 169 | // Symbol whose value is the size of the TLS block. |
| 170 | GlobalSymbol *tlsSize; |
| 171 | |
| 172 | // __tls_size |
| 173 | // Symbol whose value is the alignment of the TLS block. |
| 174 | GlobalSymbol *tlsAlign; |
| 175 | |
| 176 | // __data_end |
| 177 | // Symbol marking the end of the data and bss. |
| 178 | DefinedData *dataEnd; |
| 179 | |
| 180 | // __heap_base/__heap_end |
| 181 | // Symbols marking the beginning and end of the "heap". It starts at the end |
| 182 | // of the data, bss and explicit stack, and extends to the end of the linear |
| 183 | // memory allocated by wasm-ld. This region of memory is not used by the |
| 184 | // linked code, so it may be used as a backing store for `sbrk` or `malloc` |
| 185 | // implementations. |
| 186 | DefinedData *heapBase; |
| 187 | DefinedData *heapEnd; |
| 188 | |
| 189 | // __wasm_first_page_end |
| 190 | // A symbol whose address is the end of the first page in memory (if any). |
| 191 | DefinedData *firstPageEnd; |
| 192 | |
| 193 | // __wasm_init_memory_flag |
| 194 | // Symbol whose contents are nonzero iff memory has already been |
| 195 | // initialized. |
| 196 | DefinedData *initMemoryFlag; |
| 197 | |
| 198 | // __wasm_init_memory |
| 199 | // Function that initializes passive data segments during instantiation. |
| 200 | DefinedFunction *initMemory; |
| 201 | |
| 202 | // __wasm_call_ctors |
| 203 | // Function that directly calls all ctors in priority order. |
| 204 | DefinedFunction *callCtors; |
| 205 | |
| 206 | // __wasm_call_dtors |
| 207 | // Function that calls the libc/etc. cleanup function. |
| 208 | DefinedFunction *callDtors; |
| 209 | |
| 210 | // __wasm_apply_global_relocs |
| 211 | // Function that applies relocations to wasm globals post-instantiation. |
| 212 | // Unlike __wasm_apply_data_relocs this needs to run on every thread. |
| 213 | DefinedFunction *applyGlobalRelocs; |
| 214 | |
| 215 | // __wasm_apply_tls_relocs |
| 216 | // Like __wasm_apply_data_relocs but for TLS section. These must be |
| 217 | // delayed until __wasm_init_tls. |
| 218 | DefinedFunction *applyTLSRelocs; |
| 219 | |
| 220 | // __wasm_apply_global_tls_relocs |
| 221 | // Like applyGlobalRelocs but for globals that hold TLS addresses. These |
| 222 | // must be delayed until __wasm_init_tls. |
| 223 | DefinedFunction *applyGlobalTLSRelocs; |
| 224 | |
| 225 | // __wasm_init_tls |
| 226 | // Function that allocates thread-local storage and initializes it. |
| 227 | DefinedFunction *initTLS; |
| 228 | |
| 229 | // Pointer to the function that is to be used in the start section. |
| 230 | // (normally an alias of initMemory, or applyGlobalRelocs). |
| 231 | DefinedFunction *startFunction; |
| 232 | |
| 233 | // __dso_handle |
| 234 | // Symbol used in calls to __cxa_atexit to determine current DLL |
| 235 | DefinedData *dsoHandle; |
| 236 | |
| 237 | // __table_base |
| 238 | // Used in PIC code for offset of indirect function table |
| 239 | UndefinedGlobal *tableBase; |
| 240 | DefinedData *definedTableBase; |
| 241 | |
| 242 | // __memory_base |
| 243 | // Used in PIC code for offset of global data |
| 244 | UndefinedGlobal *memoryBase; |
| 245 | DefinedData *definedMemoryBase; |
| 246 | |
| 247 | // __indirect_function_table |
| 248 | // Used as an address space for function pointers, with each function that |
| 249 | // is used as a function pointer being allocated a slot. |
| 250 | TableSymbol *indirectFunctionTable; |
| 251 | }; |
| 252 | WasmSym sym; |
| 253 | |
Sam Clegg | bfb7534 | 2018-11-15 00:37:21 +0000 | [diff] [blame] | 254 | // True if we are creating position-independent code. |
Sam Clegg | 2bfa5ca | 2024-01-19 13:51:35 -0800 | [diff] [blame] | 255 | bool isPic = false; |
Sam Clegg | 1a1df72 | 2019-08-27 04:19:34 +0000 | [diff] [blame] | 256 | |
Andy Wingo | 4fc2557 | 2021-02-12 20:01:41 +0100 | [diff] [blame] | 257 | // True if we have an MVP input that uses __indirect_function_table and which |
| 258 | // requires it to be allocated to table number 0. |
| 259 | bool legacyFunctionTable = false; |
| 260 | |
Sam Clegg | 1eb79e7 | 2021-10-26 18:08:07 -0700 | [diff] [blame] | 261 | // Will be set to true if bss data segments should be emitted. In most cases |
| 262 | // this is not necessary. |
| 263 | bool emitBssSegments = false; |
Sam Clegg | 8aef04f | 2023-03-06 09:18:03 -0800 | [diff] [blame] | 264 | |
| 265 | // A tuple of (reference, extractedFile, sym). Used by --why-extract=. |
| 266 | llvm::SmallVector<std::tuple<std::string, const InputFile *, const Symbol &>, |
| 267 | 0> |
| 268 | whyExtractRecords; |
Sam Clegg | 2bfa5ca | 2024-01-19 13:51:35 -0800 | [diff] [blame] | 269 | |
Fangrui Song | a222d00 | 2024-12-13 19:14:32 -0800 | [diff] [blame] | 270 | Ctx(); |
Sam Clegg | 2bfa5ca | 2024-01-19 13:51:35 -0800 | [diff] [blame] | 271 | void reset(); |
Sam Clegg | c94d393 | 2017-11-17 18:14:09 +0000 | [diff] [blame] | 272 | }; |
| 273 | |
Sam Clegg | 184c22d | 2024-01-18 15:01:21 -0800 | [diff] [blame] | 274 | extern Ctx ctx; |
Sam Clegg | c94d393 | 2017-11-17 18:14:09 +0000 | [diff] [blame] | 275 | |
mzukovec | 0367305 | 2024-09-04 17:50:10 +0200 | [diff] [blame] | 276 | void errorOrWarn(const llvm::Twine &msg); |
| 277 | |
Sam Clegg | d32f71a | 2023-03-06 09:55:00 -0800 | [diff] [blame] | 278 | } // namespace lld::wasm |
Sam Clegg | c94d393 | 2017-11-17 18:14:09 +0000 | [diff] [blame] | 279 | |
| 280 | #endif |