1 //===--- WebAssembly.cpp - WebAssembly ToolChain Implementation -*- C++ -*-===// 2 // 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 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "WebAssembly.h" 10 #include "CommonArgs.h" 11 #include "clang/Basic/Version.h" 12 #include "clang/Config/config.h" 13 #include "clang/Driver/Compilation.h" 14 #include "clang/Driver/Driver.h" 15 #include "clang/Driver/DriverDiagnostic.h" 16 #include "clang/Driver/Options.h" 17 #include "llvm/Support/FileSystem.h" 18 #include "llvm/Support/Path.h" 19 #include "llvm/Option/ArgList.h" 20 21 using namespace clang::driver; 22 using namespace clang::driver::tools; 23 using namespace clang::driver::toolchains; 24 using namespace clang; 25 using namespace llvm::opt; 26 27 /// Following the conventions in https://wiki.debian.org/Multiarch/Tuples, 28 /// we remove the vendor field to form the multiarch triple. 29 static std::string getMultiarchTriple(const Driver &D, 30 const llvm::Triple &TargetTriple, 31 StringRef SysRoot) { 32 return (TargetTriple.getArchName() + "-" + 33 TargetTriple.getOSAndEnvironmentName()).str(); 34 } 35 36 std::string wasm::Linker::getLinkerPath(const ArgList &Args) const { 37 const ToolChain &ToolChain = getToolChain(); 38 if (const Arg* A = Args.getLastArg(options::OPT_fuse_ld_EQ)) { 39 StringRef UseLinker = A->getValue(); 40 if (!UseLinker.empty()) { 41 if (llvm::sys::path::is_absolute(UseLinker) && 42 llvm::sys::fs::can_execute(UseLinker)) 43 return std::string(UseLinker); 44 45 // Accept 'lld', and 'ld' as aliases for the default linker 46 if (UseLinker != "lld" && UseLinker != "ld") 47 ToolChain.getDriver().Diag(diag::err_drv_invalid_linker_name) 48 << A->getAsString(Args); 49 } 50 } 51 52 return ToolChain.GetProgramPath(ToolChain.getDefaultLinker()); 53 } 54 55 void wasm::Linker::ConstructJob(Compilation &C, const JobAction &JA, 56 const InputInfo &Output, 57 const InputInfoList &Inputs, 58 const ArgList &Args, 59 const char *LinkingOutput) const { 60 61 const ToolChain &ToolChain = getToolChain(); 62 const char *Linker = Args.MakeArgString(getLinkerPath(Args)); 63 ArgStringList CmdArgs; 64 65 CmdArgs.push_back("-m"); 66 if (getToolChain().getTriple().isArch64Bit()) 67 CmdArgs.push_back("wasm64"); 68 else 69 CmdArgs.push_back("wasm32"); 70 71 if (Args.hasArg(options::OPT_s)) 72 CmdArgs.push_back("--strip-all"); 73 74 Args.AddAllArgs(CmdArgs, options::OPT_L); 75 Args.AddAllArgs(CmdArgs, options::OPT_u); 76 ToolChain.AddFilePathLibArgs(Args, CmdArgs); 77 78 const char *Crt1 = "crt1.o"; 79 const char *Entry = NULL; 80 if (const Arg *A = Args.getLastArg(options::OPT_mexec_model_EQ)) { 81 StringRef CM = A->getValue(); 82 if (CM == "command") { 83 // Use default values. 84 } else if (CM == "reactor") { 85 Crt1 = "crt1-reactor.o"; 86 Entry = "_initialize"; 87 } else { 88 ToolChain.getDriver().Diag(diag::err_drv_invalid_argument_to_option) 89 << CM << A->getOption().getName(); 90 } 91 } 92 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) 93 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(Crt1))); 94 if (Entry) { 95 CmdArgs.push_back(Args.MakeArgString("--entry")); 96 CmdArgs.push_back(Args.MakeArgString(Entry)); 97 } 98 99 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA); 100 101 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { 102 if (ToolChain.ShouldLinkCXXStdlib(Args)) 103 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 104 105 if (Args.hasArg(options::OPT_pthread)) { 106 CmdArgs.push_back("-lpthread"); 107 CmdArgs.push_back("--shared-memory"); 108 } 109 110 CmdArgs.push_back("-lc"); 111 AddRunTimeLibs(ToolChain, ToolChain.getDriver(), CmdArgs, Args); 112 } 113 114 CmdArgs.push_back("-o"); 115 CmdArgs.push_back(Output.getFilename()); 116 117 C.addCommand(std::make_unique<Command>( 118 JA, *this, ResponseFileSupport::AtFileCurCP(), Linker, CmdArgs, Inputs)); 119 120 // When optimizing, if wasm-opt is available, run it. 121 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 122 auto WasmOptPath = getToolChain().GetProgramPath("wasm-opt"); 123 if (WasmOptPath != "wasm-opt") { 124 StringRef OOpt = "s"; 125 if (A->getOption().matches(options::OPT_O4) || 126 A->getOption().matches(options::OPT_Ofast)) 127 OOpt = "4"; 128 else if (A->getOption().matches(options::OPT_O0)) 129 OOpt = "0"; 130 else if (A->getOption().matches(options::OPT_O)) 131 OOpt = A->getValue(); 132 133 if (OOpt != "0") { 134 const char *WasmOpt = Args.MakeArgString(WasmOptPath); 135 ArgStringList CmdArgs; 136 CmdArgs.push_back(Output.getFilename()); 137 CmdArgs.push_back(Args.MakeArgString(llvm::Twine("-O") + OOpt)); 138 CmdArgs.push_back("-o"); 139 CmdArgs.push_back(Output.getFilename()); 140 C.addCommand(std::make_unique<Command>( 141 JA, *this, ResponseFileSupport::AtFileCurCP(), WasmOpt, CmdArgs, 142 Inputs)); 143 } 144 } 145 } 146 } 147 148 /// Given a base library directory, append path components to form the 149 /// LTO directory. 150 static std::string AppendLTOLibDir(const std::string &Dir) { 151 // The version allows the path to be keyed to the specific version of 152 // LLVM in used, as the bitcode format is not stable. 153 return Dir + "/llvm-lto/" LLVM_VERSION_STRING; 154 } 155 156 WebAssembly::WebAssembly(const Driver &D, const llvm::Triple &Triple, 157 const llvm::opt::ArgList &Args) 158 : ToolChain(D, Triple, Args) { 159 160 assert(Triple.isArch32Bit() != Triple.isArch64Bit()); 161 162 getProgramPaths().push_back(getDriver().getInstalledDir()); 163 164 auto SysRoot = getDriver().SysRoot; 165 if (getTriple().getOS() == llvm::Triple::UnknownOS) { 166 // Theoretically an "unknown" OS should mean no standard libraries, however 167 // it could also mean that a custom set of libraries is in use, so just add 168 // /lib to the search path. Disable multiarch in this case, to discourage 169 // paths containing "unknown" from acquiring meanings. 170 getFilePaths().push_back(SysRoot + "/lib"); 171 } else { 172 const std::string MultiarchTriple = 173 getMultiarchTriple(getDriver(), Triple, SysRoot); 174 if (D.isUsingLTO()) { 175 // For LTO, enable use of lto-enabled sysroot libraries too, if available. 176 // Note that the directory is keyed to the LLVM revision, as LLVM's 177 // bitcode format is not stable. 178 auto Dir = AppendLTOLibDir(SysRoot + "/lib/" + MultiarchTriple); 179 getFilePaths().push_back(Dir); 180 } 181 getFilePaths().push_back(SysRoot + "/lib/" + MultiarchTriple); 182 } 183 } 184 185 bool WebAssembly::IsMathErrnoDefault() const { return false; } 186 187 bool WebAssembly::IsObjCNonFragileABIDefault() const { return true; } 188 189 bool WebAssembly::UseObjCMixedDispatch() const { return true; } 190 191 bool WebAssembly::isPICDefault() const { return false; } 192 193 bool WebAssembly::isPIEDefault() const { return false; } 194 195 bool WebAssembly::isPICDefaultForced() const { return false; } 196 197 bool WebAssembly::IsIntegratedAssemblerDefault() const { return true; } 198 199 bool WebAssembly::hasBlocksRuntime() const { return false; } 200 201 // TODO: Support profiling. 202 bool WebAssembly::SupportsProfiling() const { return false; } 203 204 bool WebAssembly::HasNativeLLVMSupport() const { return true; } 205 206 void WebAssembly::addClangTargetOptions(const ArgList &DriverArgs, 207 ArgStringList &CC1Args, 208 Action::OffloadKind) const { 209 if (!DriverArgs.hasFlag(clang::driver::options::OPT_fuse_init_array, 210 options::OPT_fno_use_init_array, true)) 211 CC1Args.push_back("-fno-use-init-array"); 212 213 // '-pthread' implies atomics, bulk-memory, mutable-globals, and sign-ext 214 if (DriverArgs.hasFlag(options::OPT_pthread, options::OPT_no_pthread, 215 false)) { 216 if (DriverArgs.hasFlag(options::OPT_mno_atomics, options::OPT_matomics, 217 false)) 218 getDriver().Diag(diag::err_drv_argument_not_allowed_with) 219 << "-pthread" 220 << "-mno-atomics"; 221 if (DriverArgs.hasFlag(options::OPT_mno_bulk_memory, 222 options::OPT_mbulk_memory, false)) 223 getDriver().Diag(diag::err_drv_argument_not_allowed_with) 224 << "-pthread" 225 << "-mno-bulk-memory"; 226 if (DriverArgs.hasFlag(options::OPT_mno_mutable_globals, 227 options::OPT_mmutable_globals, false)) 228 getDriver().Diag(diag::err_drv_argument_not_allowed_with) 229 << "-pthread" 230 << "-mno-mutable-globals"; 231 if (DriverArgs.hasFlag(options::OPT_mno_sign_ext, options::OPT_msign_ext, 232 false)) 233 getDriver().Diag(diag::err_drv_argument_not_allowed_with) 234 << "-pthread" 235 << "-mno-sign-ext"; 236 CC1Args.push_back("-target-feature"); 237 CC1Args.push_back("+atomics"); 238 CC1Args.push_back("-target-feature"); 239 CC1Args.push_back("+bulk-memory"); 240 CC1Args.push_back("-target-feature"); 241 CC1Args.push_back("+mutable-globals"); 242 CC1Args.push_back("-target-feature"); 243 CC1Args.push_back("+sign-ext"); 244 } 245 246 if (DriverArgs.getLastArg(options::OPT_fwasm_exceptions)) { 247 // '-fwasm-exceptions' is not compatible with '-mno-exception-handling' 248 if (DriverArgs.hasFlag(options::OPT_mno_exception_handing, 249 options::OPT_mexception_handing, false)) 250 getDriver().Diag(diag::err_drv_argument_not_allowed_with) 251 << "-fwasm-exceptions" 252 << "-mno-exception-handling"; 253 // '-fwasm-exceptions' is not compatible with '-mno-reference-types' 254 if (DriverArgs.hasFlag(options::OPT_mno_reference_types, 255 options::OPT_mexception_handing, false)) 256 getDriver().Diag(diag::err_drv_argument_not_allowed_with) 257 << "-fwasm-exceptions" 258 << "-mno-reference-types"; 259 // '-fwasm-exceptions' is not compatible with 260 // '-mllvm -enable-emscripten-cxx-exceptions' 261 for (const Arg *A : DriverArgs.filtered(options::OPT_mllvm)) { 262 if (StringRef(A->getValue(0)) == "-enable-emscripten-cxx-exceptions") 263 getDriver().Diag(diag::err_drv_argument_not_allowed_with) 264 << "-fwasm-exceptions" 265 << "-mllvm -enable-emscripten-cxx-exceptions"; 266 } 267 // '-fwasm-exceptions' implies exception-handling and reference-types 268 CC1Args.push_back("-target-feature"); 269 CC1Args.push_back("+exception-handling"); 270 CC1Args.push_back("-target-feature"); 271 CC1Args.push_back("+reference-types"); 272 } 273 } 274 275 ToolChain::RuntimeLibType WebAssembly::GetDefaultRuntimeLibType() const { 276 return ToolChain::RLT_CompilerRT; 277 } 278 279 ToolChain::CXXStdlibType 280 WebAssembly::GetCXXStdlibType(const ArgList &Args) const { 281 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) { 282 StringRef Value = A->getValue(); 283 if (Value != "libc++") 284 getDriver().Diag(diag::err_drv_invalid_stdlib_name) 285 << A->getAsString(Args); 286 } 287 return ToolChain::CST_Libcxx; 288 } 289 290 void WebAssembly::AddClangSystemIncludeArgs(const ArgList &DriverArgs, 291 ArgStringList &CC1Args) const { 292 if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc)) 293 return; 294 295 const Driver &D = getDriver(); 296 297 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { 298 SmallString<128> P(D.ResourceDir); 299 llvm::sys::path::append(P, "include"); 300 addSystemInclude(DriverArgs, CC1Args, P); 301 } 302 303 if (DriverArgs.hasArg(options::OPT_nostdlibinc)) 304 return; 305 306 // Check for configure-time C include directories. 307 StringRef CIncludeDirs(C_INCLUDE_DIRS); 308 if (CIncludeDirs != "") { 309 SmallVector<StringRef, 5> dirs; 310 CIncludeDirs.split(dirs, ":"); 311 for (StringRef dir : dirs) { 312 StringRef Prefix = 313 llvm::sys::path::is_absolute(dir) ? "" : StringRef(D.SysRoot); 314 addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir); 315 } 316 return; 317 } 318 319 if (getTriple().getOS() != llvm::Triple::UnknownOS) { 320 const std::string MultiarchTriple = 321 getMultiarchTriple(D, getTriple(), D.SysRoot); 322 addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/include/" + MultiarchTriple); 323 } 324 addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/include"); 325 } 326 327 void WebAssembly::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, 328 ArgStringList &CC1Args) const { 329 if (!DriverArgs.hasArg(options::OPT_nostdlibinc) && 330 !DriverArgs.hasArg(options::OPT_nostdincxx)) { 331 if (getTriple().getOS() != llvm::Triple::UnknownOS) { 332 const std::string MultiarchTriple = 333 getMultiarchTriple(getDriver(), getTriple(), getDriver().SysRoot); 334 addSystemInclude(DriverArgs, CC1Args, 335 getDriver().SysRoot + "/include/" + MultiarchTriple + 336 "/c++/v1"); 337 } 338 addSystemInclude(DriverArgs, CC1Args, 339 getDriver().SysRoot + "/include/c++/v1"); 340 } 341 } 342 343 void WebAssembly::AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, 344 llvm::opt::ArgStringList &CmdArgs) const { 345 346 switch (GetCXXStdlibType(Args)) { 347 case ToolChain::CST_Libcxx: 348 CmdArgs.push_back("-lc++"); 349 CmdArgs.push_back("-lc++abi"); 350 break; 351 case ToolChain::CST_Libstdcxx: 352 llvm_unreachable("invalid stdlib name"); 353 } 354 } 355 356 SanitizerMask WebAssembly::getSupportedSanitizers() const { 357 SanitizerMask Res = ToolChain::getSupportedSanitizers(); 358 if (getTriple().isOSEmscripten()) { 359 Res |= SanitizerKind::Vptr | SanitizerKind::Leak | SanitizerKind::Address; 360 } 361 return Res; 362 } 363 364 Tool *WebAssembly::buildLinker() const { 365 return new tools::wasm::Linker(*this); 366 } 367