llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang-driver Author: Matt Arsenault (arsenm) <details> <summary>Changes</summary> All of the offload languages were essentially doing the same thing, with overcomplicated conditions conditional on the language. --- Full diff: https://github.com/llvm/llvm-project/pull/196551.diff 2 Files Affected: - (modified) clang/include/clang/Driver/Action.h (+3) - (modified) clang/lib/Driver/ToolChains/Clang.cpp (+41-51) ``````````diff diff --git a/clang/include/clang/Driver/Action.h b/clang/include/clang/Driver/Action.h index dbf1187da4db9..67937b00f6bcf 100644 --- a/clang/include/clang/Driver/Action.h +++ b/clang/include/clang/Driver/Action.h @@ -96,6 +96,9 @@ class Action { OFK_OpenMP = 0x04, OFK_HIP = 0x08, OFK_SYCL = 0x10, + + OFK_DeviceFirst = OFK_Cuda, + OFK_DeviceLast = OFK_SYCL }; static const char *getClassName(ActionClass AC); diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index bdffa4fdd7e6b..92b3045dceff2 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -4997,18 +4997,9 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, } } - const llvm::Triple *AuxTriple = - (IsCuda || IsHIP || IsSYCL) ? TC.getAuxTriple() : nullptr; - bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment(); bool IsUEFI = RawTriple.isUEFI(); bool IsIAMCU = RawTriple.isOSIAMCU(); - // Adjust IsWindowsXYZ for CUDA/HIP/SYCL compilations. Even when compiling in - // device mode (i.e., getToolchain().getTriple() is NVPTX/AMDGCN, not - // Windows), we need to pass Windows-specific flags to cc1. - if (IsCuda || IsHIP || IsSYCL) - IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment(); - // C++ is not supported for IAMCU. if (IsIAMCU && types::isCXX(Input.getType())) D.Diag(diag::err_drv_clang_unsupported) << "C++ for IAMCU"; @@ -5022,6 +5013,34 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-triple"); CmdArgs.push_back(Args.MakeArgStringRef(TripleStr)); + bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment(); + + const llvm::Triple *AuxTriple = TC.getAuxTriple(); + if (AuxTriple) { + CmdArgs.push_back("-aux-triple"); + CmdArgs.push_back(Args.MakeArgStringRef(AuxTriple->str())); + + // Adjust IsWindowsXYZ for CUDA/HIP/SYCL compilations. Even when compiling + // in device mode (i.e., getToolchain().getTriple() is NVPTX/AMDGCN, not + // Windows), we need to pass Windows-specific flags to cc1. + IsWindowsMSVC |= AuxTriple->isWindowsMSVCEnvironment(); + } else if (JA.getOffloadingHostActiveKinds() != Action::OFK_None) { + // Figure out the device side triple for the host-side compilation. + for (unsigned I = Action::OFK_DeviceFirst; I <= Action::OFK_DeviceLast; + ++I) { + Compilation::const_offload_toolchains_range OffloadToolChains = + C.getOffloadToolChains(static_cast<Action::OffloadKind>(I)); + if (OffloadToolChains.first == OffloadToolChains.second) + continue; + + const llvm::Triple &DeviceAuxTriple = + OffloadToolChains.first->second->getTriple(); + CmdArgs.push_back("-aux-triple"); + CmdArgs.push_back(Args.MakeArgStringRef(DeviceAuxTriple.str())); + break; + } + } + if (const Arg *MJ = Args.getLastArg(options::OPT_MJ)) { DumpCompilationDatabase(C, MJ->getValue(), TripleStr, Output, Input, Args); Args.ClaimAllArgs(options::OPT_MJ); @@ -5032,38 +5051,17 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path); } - if (IsCuda || IsHIP) { - CmdArgs.push_back("-aux-triple"); - - // We have to pass the triple of the host if compiling for a CUDA/HIP device - // and vice-versa. - if (IsCudaDevice || IsHIPDevice) { - StringRef AuxTripleStr = - C.getSingleOffloadToolChain<Action::OFK_Host>()->getTriple().str(); - CmdArgs.push_back(Args.MakeArgStringRef(AuxTripleStr)); - } else { - // Host-side compilation. - StringRef AuxTripleStr = - (IsCuda ? C.getOffloadToolChains(Action::OFK_Cuda).first->second - : C.getOffloadToolChains(Action::OFK_HIP).first->second) - ->getTriple() - .str(); - CmdArgs.push_back(Args.MakeArgStringRef(AuxTripleStr)); - } - - if (JA.isDeviceOffloading(Action::OFK_HIP) && - (getToolChain().getTriple().isAMDGPU() || - (getToolChain().getTriple().isSPIRV() && - getToolChain().getTriple().getVendor() == llvm::Triple::AMD))) { - // Device side compilation printf - if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) { - CmdArgs.push_back(Args.MakeArgString( - "-mprintf-kind=" + - Args.getLastArgValue(options::OPT_mprintf_kind_EQ))); - // Force compiler error on invalid conversion specifiers - CmdArgs.push_back( - Args.MakeArgStringRef("-Werror=format-invalid-specifier")); - } + if ((getToolChain().getTriple().isAMDGPU() || + (getToolChain().getTriple().isSPIRV() && + getToolChain().getTriple().getVendor() == llvm::Triple::AMD))) { + // Device side compilation printf + if (Args.getLastArg(options::OPT_mprintf_kind_EQ)) { + CmdArgs.push_back(Args.MakeArgString( + "-mprintf-kind=" + + Args.getLastArgValue(options::OPT_mprintf_kind_EQ))); + // Force compiler error on invalid conversion specifiers + CmdArgs.push_back( + Args.MakeArgStringRef("-Werror=format-invalid-specifier")); } } @@ -5095,12 +5093,6 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, if (IsSYCL) { if (IsSYCLDevice) { - // Host triple is needed when doing SYCL device compilations. - llvm::Triple AuxT = C.getDefaultToolChain().getTriple(); - std::string NormalizedTriple = AuxT.normalize(); - CmdArgs.push_back("-aux-triple"); - CmdArgs.push_back(Args.MakeArgString(NormalizedTriple)); - // We want to compile sycl kernels. CmdArgs.push_back("-fsycl-is-device"); @@ -6150,12 +6142,10 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, // Prepare `-aux-target-cpu` and `-aux-target-feature` unless // `--gpu-use-aux-triple-only` is specified. - if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) && - (IsCudaDevice || IsHIPDevice || IsSYCLDevice)) { + if (AuxTriple && !Args.getLastArg(options::OPT_gpu_use_aux_triple_only)) { const ArgList &HostArgs = C.getArgsForToolChain(nullptr, StringRef(), Action::OFK_None); - std::string HostCPU = - getCPUName(D, HostArgs, *TC.getAuxTriple(), /*FromAs*/ false); + std::string HostCPU = getCPUName(D, HostArgs, *AuxTriple, /*FromAs*/ false); if (!HostCPU.empty()) { CmdArgs.push_back("-aux-target-cpu"); CmdArgs.push_back(Args.MakeArgString(HostCPU)); `````````` </details> https://github.com/llvm/llvm-project/pull/196551 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
