RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/Driver_2ToolChains_2Cuda_8cpp_source.html below:

clang: lib/Driver/ToolChains/Cuda.cpp Source File

12#include "clang/Config/config.h" 19#include "llvm/ADT/StringExtras.h" 20#include "llvm/Config/llvm-config.h" 21#include "llvm/Option/ArgList.h" 22#include "llvm/Support/FileSystem.h" 23#include "llvm/Support/FormatAdapters.h" 24#include "llvm/Support/FormatVariadic.h" 25#include "llvm/Support/Path.h" 26#include "llvm/Support/Process.h" 27#include "llvm/Support/Program.h" 28#include "llvm/Support/VirtualFileSystem.h" 29#include "llvm/TargetParser/Host.h" 30#include "llvm/TargetParser/TargetParser.h" 31#include <system_error> 36using namespace clang

;

42 if

(raw_version < 7050)

43 return

CudaVersion::CUDA_70;

44 if

(raw_version < 8000)

45 return

CudaVersion::CUDA_75;

46 if

(raw_version < 9000)

47 return

CudaVersion::CUDA_80;

48 if

(raw_version < 9010)

49 return

CudaVersion::CUDA_90;

50 if

(raw_version < 9020)

51 return

CudaVersion::CUDA_91;

52 if

(raw_version < 10000)

53 return

CudaVersion::CUDA_92;

54 if

(raw_version < 10010)

55 return

CudaVersion::CUDA_100;

56 if

(raw_version < 10020)

57 return

CudaVersion::CUDA_101;

58 if

(raw_version < 11000)

59 return

CudaVersion::CUDA_102;

60 if

(raw_version < 11010)

61 return

CudaVersion::CUDA_110;

62 if

(raw_version < 11020)

63 return

CudaVersion::CUDA_111;

64 if

(raw_version < 11030)

65 return

CudaVersion::CUDA_112;

66 if

(raw_version < 11040)

67 return

CudaVersion::CUDA_113;

68 if

(raw_version < 11050)

69 return

CudaVersion::CUDA_114;

70 if

(raw_version < 11060)

71 return

CudaVersion::CUDA_115;

72 if

(raw_version < 11070)

73 return

CudaVersion::CUDA_116;

74 if

(raw_version < 11080)

75 return

CudaVersion::CUDA_117;

76 if

(raw_version < 11090)

77 return

CudaVersion::CUDA_118;

78 if

(raw_version < 12010)

79 return

CudaVersion::CUDA_120;

80 if

(raw_version < 12020)

81 return

CudaVersion::CUDA_121;

82 if

(raw_version < 12030)

83 return

CudaVersion::CUDA_122;

84 if

(raw_version < 12040)

85 return

CudaVersion::CUDA_123;

86 if

(raw_version < 12050)

87 return

CudaVersion::CUDA_124;

88 if

(raw_version < 12060)

89 return

CudaVersion::CUDA_125;

90 if

(raw_version < 12070)

91 return

CudaVersion::CUDA_126;

92 if

(raw_version < 12090)

93 return

CudaVersion::CUDA_128;

94 return

CudaVersion::NEW;

100 auto

StartsWithWords =

101

[](llvm::StringRef Line,

103 for

(StringRef word : words) {

104 if

(!Line.consume_front(word))

111

Input = Input.ltrim();

112 while

(!Input.empty()) {

114

StartsWithWords(Input.ltrim(), {

"#"

"define"

"CUDA_VERSION"

})) {

116

Line->consumeInteger(10, RawVersion);

117 return

getCudaVersion(RawVersion);

120

Input = Input.drop_front(Input.find_first_of(

"\n\r"

)).ltrim();

122 return

CudaVersion::UNKNOWN;

129 if

(!VersionString.empty())

130

VersionString.insert(0,

" "

);

131

Diag

(diag::warn_drv_new_cuda_version)

136

Diag

(diag::warn_drv_partially_supported_cuda_version)

141 const Driver

const

llvm::Triple &HostTriple,

142 const

llvm::opt::ArgList &Args)

148

Candidate(std::string

Path

bool

StrictChecking =

false

)

149

Path

(

Path

), StrictChecking(StrictChecking) {}

154

std::initializer_list<const char *> Versions = {

"8.0"

"7.5"

"7.0"

};

155 auto

&FS =

.getVFS();

157 if

(Args.hasArg(clang::driver::options::OPT_cuda_path_EQ)) {

158

Candidates.emplace_back(

159

Args.getLastArgValue(clang::driver::options::OPT_cuda_path_EQ).str());

160

}

else if

(HostTriple.isOSWindows()) {

161 for

(

const char

*Ver : Versions)

162

Candidates.emplace_back(

163 D

.SysRoot +

"/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v"

166 if

(!Args.hasArg(clang::driver::options::OPT_cuda_path_ignore_env)) {

175 if

(llvm::ErrorOr<std::string> ptxas =

176

llvm::sys::findProgramByName(

"ptxas"

)) {

178

llvm::sys::fs::real_path(*ptxas, ptxasAbsolutePath);

180

StringRef ptxasDir = llvm::sys::path::parent_path(ptxasAbsolutePath);

181 if

(llvm::sys::path::filename(ptxasDir) ==

"bin"

)

182

Candidates.emplace_back(

183

std::string(llvm::sys::path::parent_path(ptxasDir)),

188

Candidates.emplace_back(

.SysRoot +

"/usr/local/cuda"

);

189 for

(

const char

*Ver : Versions)

190

Candidates.emplace_back(

.SysRoot +

"/usr/local/cuda-"

+ Ver);

192 Distro

Dist(FS, llvm::Triple(llvm::sys::getProcessTriple()));

196

Candidates.emplace_back(

.SysRoot +

"/usr/lib/cuda"

);

199 bool

NoCudaLib = Args.hasArg(options::OPT_nogpulib);

201 for

(

const auto

&Candidate : Candidates) {

202

InstallPath = Candidate.Path;

203 if

(InstallPath.empty() || !FS.exists(InstallPath))

206

BinPath = InstallPath +

"/bin"

;

207

IncludePath = InstallPath +

"/include"

;

208

LibDevicePath = InstallPath +

"/nvvm/libdevice"

;

210 if

(!(FS.exists(IncludePath) && FS.exists(BinPath)))

212 bool

CheckLibDevice = (!NoCudaLib || Candidate.StrictChecking);

213 if

(CheckLibDevice && !FS.exists(LibDevicePath))

217 if

(

auto

CudaHFile = FS.getBufferForFile(InstallPath +

"/include/cuda.h"

))

218

Version = parseCudaHFile((*CudaHFile)->getBuffer());

222

Version = FS.exists(LibDevicePath +

"/libdevice.10.bc"

)

229

std::string FilePath = LibDevicePath +

"/libdevice.10.bc"

;

230 if

(FS.exists(FilePath)) {

237

LibDeviceMap[OffloadArchName] = FilePath;

242 for

(llvm::vfs::directory_iterator LI = FS.dir_begin(LibDevicePath, EC),

244

!EC && LI != LE; LI = LI.increment(EC)) {

245

StringRef FilePath = LI->path();

246

StringRef

FileName

= llvm::sys::path::filename(FilePath);

249 const

StringRef LibDeviceName =

"libdevice."

;

250 if

(!(

FileName

.starts_with(LibDeviceName) &&

FileName

.ends_with(

".bc"

)))

252

StringRef GpuArch =

FileName

.slice(

253

LibDeviceName.size(),

FileName

.find(

'.'

, LibDeviceName.size()));

254

LibDeviceMap[GpuArch] = FilePath.str();

258 if

(GpuArch ==

"compute_20"

) {

259

LibDeviceMap[

"sm_20"

] = std::string(FilePath);

260

LibDeviceMap[

"sm_21"

] = std::string(FilePath);

261

LibDeviceMap[

"sm_32"

] = std::string(FilePath);

262

}

else if

(GpuArch ==

"compute_30"

) {

263

LibDeviceMap[

"sm_30"

] = std::string(FilePath);

265

LibDeviceMap[

"sm_50"

] = std::string(FilePath);

266

LibDeviceMap[

"sm_52"

] = std::string(FilePath);

267

LibDeviceMap[

"sm_53"

] = std::string(FilePath);

269

LibDeviceMap[

"sm_60"

] = std::string(FilePath);

270

LibDeviceMap[

"sm_61"

] = std::string(FilePath);

271

LibDeviceMap[

"sm_62"

] = std::string(FilePath);

272

}

else if

(GpuArch ==

"compute_35"

) {

273

LibDeviceMap[

"sm_35"

] = std::string(FilePath);

274

LibDeviceMap[

"sm_37"

] = std::string(FilePath);

275

}

else if

(GpuArch ==

"compute_50"

) {

277

LibDeviceMap[

"sm_50"

] = std::string(FilePath);

278

LibDeviceMap[

"sm_52"

] = std::string(FilePath);

279

LibDeviceMap[

"sm_53"

] = std::string(FilePath);

287 if

(LibDeviceMap.empty() && !NoCudaLib)

296 const

ArgList &DriverArgs, ArgStringList &CC1Args)

const

{

297 if

(!DriverArgs.hasArg(options::OPT_nobuiltininc)) {

301

llvm::sys::path::append(

"include"

);

302

llvm::sys::path::append(

"cuda_wrappers"

);

303

CC1Args.push_back(

"-internal-isystem"

);

304

CC1Args.push_back(DriverArgs.MakeArgString(

));

307 if

(DriverArgs.hasArg(options::OPT_nogpuinc))

311

Diag

(diag::err_drv_no_cuda_installation);

315

CC1Args.push_back(

"-include"

);

316

CC1Args.push_back(

"__clang_cuda_runtime_wrapper.h"

);

322

ArchsWithBadVersion[(

int

)Arch])

327 if

(Version < MinVersion || Version > MaxVersion) {

328

ArchsWithBadVersion[(

int

)Arch] =

true

;

329

Diag

(diag::err_drv_cuda_version_unsupported)

338

OS <<

"Found CUDA installation: "

<< InstallPath <<

", version " 348enum

DeviceDebugInfoLevel {

351

EmitSameDebugInfoAsHost,

365 const

Arg *A = Args.getLastArg(options::OPT_O_Group);

366 bool

IsDebugEnabled = !A || A->getOption().matches(options::OPT_O0) ||

367

Args.hasFlag(options::OPT_cuda_noopt_device_debug,

368

options::OPT_no_cuda_noopt_device_debug,

370 if

(

const

Arg *A = Args.getLastArg(options::OPT_g_Group)) {

371 const

Option &Opt = A->getOption();

372 if

(Opt.matches(options::OPT_gN_Group)) {

373 if

(Opt.matches(options::OPT_g0) || Opt.matches(options::OPT_ggdb0))

374 return

DisableDebugInfo;

375 if

(Opt.matches(options::OPT_gline_directives_only))

376 return

DebugDirectivesOnly;

378 return

IsDebugEnabled ? EmitSameDebugInfoAsHost : DebugDirectivesOnly;

380 return willEmitRemarks

(Args) ? DebugDirectivesOnly : DisableDebugInfo;

387 const char

*LinkingOutput)

const

{

390

assert(TC.getTriple().isNVPTX() &&

"Wrong platform"

);

392

StringRef GPUArchName;

400

GPUArchName = Args.getLastArgValue(options::OPT_march_EQ);

401 if

(GPUArchName.empty()) {

402 C

.getDriver().Diag(diag::err_drv_offload_missing_gpu_arch)

403

<< getToolChain().getArchName() << getShortName();

411 "Device action expected to have an architecture."

);

414 if

(!Args.hasArg(options::OPT_no_cuda_version_check)) {

415

TC.CudaInstallation.CheckCudaVersionSupportsArch(gpu_arch);

418

ArgStringList CmdArgs;

419

CmdArgs.push_back(TC.getTriple().isArch64Bit() ?

"-m64"

"-m32"

);

421 if

(DIKind == EmitSameDebugInfoAsHost) {

424

CmdArgs.push_back(

"-g"

);

425

CmdArgs.push_back(

"--dont-merge-basicblocks"

);

426

CmdArgs.push_back(

"--return-at-end"

);

427

}

else if

(Arg *A = Args.getLastArg(options::OPT_O_Group)) {

435

StringRef OOpt =

"3"

;

436 if

(A->getOption().matches(options::OPT_O4) ||

437

A->getOption().matches(options::OPT_Ofast))

439 else if

(A->getOption().matches(options::OPT_O0))

441 else if

(A->getOption().matches(options::OPT_O)) {

443

OOpt = llvm::StringSwitch<const char *>(A->getValue())

451

CmdArgs.push_back(Args.MakeArgString(llvm::Twine(

"-O"

) + OOpt));

455

CmdArgs.push_back(

"-O0"

);

457 if

(DIKind == DebugDirectivesOnly)

458

CmdArgs.push_back(

"-lineinfo"

);

461 if

(Args.hasArg(options::OPT_v))

462

CmdArgs.push_back(

"-v"

);

464

CmdArgs.push_back(

"--gpu-name"

);

466

CmdArgs.push_back(

"--output-file"

);

467

std::string OutputFileName = TC.getInputFilename(Output);

470 C

.addTempFile(Args.MakeArgString(OutputFileName));

472

CmdArgs.push_back(Args.MakeArgString(OutputFileName));

473 for

(

const auto

&II : Inputs)

474

CmdArgs.push_back(Args.MakeArgString(II.getFilename()));

476 for

(

const auto

&A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))

477

CmdArgs.push_back(Args.MakeArgString(A));

482

Relocatable = Args.hasFlag(options::OPT_fopenmp_relocatable_target,

483

options::OPT_fnoopenmp_relocatable_target,

487

Relocatable = Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc,

494

CmdArgs.push_back(

"-c"

);

497 if

(Arg *A = Args.getLastArg(options::OPT_ptxas_path_EQ))

498

Exec = A->getValue();

500

Exec = Args.MakeArgString(TC.GetProgramPath(

"ptxas"

));

501 C

.addCommand(std::make_unique<Command>(

505

Exec, CmdArgs, Inputs, Output));

510 bool

includePTX = !Args.hasFlag(options::OPT_offload_new_driver,

511

options::OPT_no_offload_new_driver,

true

);

512 for

(Arg *A : Args.filtered(options::OPT_cuda_include_ptx_EQ,

513

options::OPT_no_cuda_include_ptx_EQ)) {

515 const

StringRef ArchStr = A->getValue();

516 if

(A->getOption().matches(options::OPT_cuda_include_ptx_EQ) &&

517

(ArchStr ==

"all"

|| ArchStr == InputArch))

519 else if

(A->getOption().matches(options::OPT_no_cuda_include_ptx_EQ) &&

520

(ArchStr ==

"all"

|| ArchStr == InputArch))

533 const char

*LinkingOutput)

const

{

536

assert(TC.getTriple().isNVPTX() &&

"Wrong platform"

);

538

ArgStringList CmdArgs;

540

CmdArgs.push_back(

"--cuda"

);

541

CmdArgs.push_back(TC.getTriple().isArch64Bit() ?

"-64"

"-32"

);

542

CmdArgs.push_back(Args.MakeArgString(

"--create"

));

543

CmdArgs.push_back(Args.MakeArgString(Output.

getFilename

()));

545

CmdArgs.push_back(

"-g"

);

547 for

(

const auto

&II : Inputs) {

548 auto

*A = II.getAction();

549

assert(A->getInputs().size() == 1 &&

550 "Device offload action is expected to have a single input"

);

551 const char

*gpu_arch_str = A->getOffloadingArch();

552

assert(gpu_arch_str &&

553 "Device action expected to have associated a GPU architecture!"

);

556 if

(II.getType() == types::TY_PP_Asm &&

561 const char

*Arch = (II.getType() == types::TY_PP_Asm)

565

Args.MakeArgString(llvm::Twine(

"--image=profile="

) + Arch +

566 ",file="

+ getToolChain().getInputFilename(II)));

569 for

(

const auto

&A : Args.getAllArgValues(options::OPT_Xcuda_fatbinary))

570

CmdArgs.push_back(Args.MakeArgString(A));

572 const char

*Exec = Args.MakeArgString(TC.GetProgramPath(

"fatbinary"

));

573 C

.addCommand(std::make_unique<Command>(

577

Exec, CmdArgs, Inputs, Output));

584 const char

*LinkingOutput)

const

{

587

ArgStringList CmdArgs;

589

assert(TC.getTriple().isNVPTX() &&

"Wrong platform"

);

593

CmdArgs.push_back(

"-o"

);

598

CmdArgs.push_back(

"-g"

);

600 if

(Args.hasArg(options::OPT_v))

601

CmdArgs.push_back(

"-v"

);

603

StringRef GPUArch = Args.getLastArgValue(options::OPT_march_EQ);

604 if

(GPUArch.empty() && !

.getDriver().isUsingLTO()) {

605 C

.getDriver().Diag(diag::err_drv_offload_missing_gpu_arch)

606

<< getToolChain().getArchName() << getShortName();

610 if

(!GPUArch.empty()) {

611

CmdArgs.push_back(

"-arch"

);

612

CmdArgs.push_back(Args.MakeArgString(GPUArch));

615 if

(Args.hasArg(options::OPT_ptxas_path_EQ))

616

CmdArgs.push_back(Args.MakeArgString(

617 "--pxtas-path="

+ Args.getLastArgValue(options::OPT_ptxas_path_EQ)));

619 if

(Args.hasArg(options::OPT_cuda_path_EQ))

620

CmdArgs.push_back(Args.MakeArgString(

621 "--cuda-path="

+ Args.getLastArgValue(options::OPT_cuda_path_EQ)));

627

Args.AddAllArgs(CmdArgs, options::OPT_L);

628

getToolChain().AddFilePathLibArgs(Args, CmdArgs);

631 if

(

.getDriver().isUsingLTO())

632 addLTOOptions

(getToolChain(), Args, CmdArgs, Output, Inputs[0],

636

std::vector<StringRef> Features;

640

Args.MakeArgString(

"--plugin-opt=-mattr="

+ llvm::join(Features,

","

)));

643

CmdArgs.append({

"-mllvm"

"--nvptx-lower-global-ctor-dtor"

});

647

llvm::sys::path::parent_path(TC.getDriver().Dir);

648

llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);

649

CmdArgs.push_back(Args.MakeArgString(Twine(

"-L"

) + DefaultLibPath));

651 if

(Args.hasArg(options::OPT_stdlib))

652

CmdArgs.append({

"-lc"

"-lm"

});

653 if

(Args.hasArg(options::OPT_startfiles)) {

654

std::optional<std::string> IncludePath = getToolChain().getStdlibPath();

656

IncludePath =

"/lib"

;

658

llvm::sys::path::append(

"crt1.o"

);

659

CmdArgs.push_back(Args.MakeArgString(

));

662 C

.addCommand(std::make_unique<Command>(

666

Args.MakeArgString(getToolChain().GetProgramPath(

"clang-nvlink-wrapper"

)),

667

CmdArgs, Inputs, Output));

671 const

llvm::opt::ArgList &Args,

672

std::vector<StringRef> &Features) {

673 if

(Args.hasArg(options::OPT_cuda_feature_EQ)) {

674

StringRef PtxFeature =

675

Args.getLastArgValue(options::OPT_cuda_feature_EQ,

"+ptx42"

);

676

Features.push_back(Args.MakeArgString(PtxFeature));

684 const char

*PtxFeature =

nullptr

;

685 switch

(CudaInstallation.

version

()) {

686#define CASE_CUDA_VERSION(CUDA_VER, PTX_VER) \ 687 case CudaVersion::CUDA_##CUDA_VER: \ 688 PtxFeature = "+ptx"

#PTX_VER; \

713#undef CASE_CUDA_VERSION 716

PtxFeature =

"+ptx86"

;

719

PtxFeature =

"+ptx42"

;

721

Features.push_back(PtxFeature);

728 const

llvm::Triple &HostTriple,

729 const

ArgList &Args,

bool

Freestanding =

false

)

730

ToolChain

(

, Triple, Args), CudaInstallation(

, HostTriple, Args),

731

Freestanding(Freestanding) {

732 if

(CudaInstallation.isValid())

733

getProgramPaths().push_back(std::string(CudaInstallation.getBinPath()));

736

getProgramPaths().push_back(getDriver().Dir);

746

llvm::opt::DerivedArgList *

752

DAL =

new

DerivedArgList(Args.getBaseArgs());

754 const

OptTable &Opts = getDriver().getOpts();

757 if

(!llvm::is_contained(*DAL, A))

760 if

(!DAL->hasArg(options::OPT_march_EQ) && OffloadKind !=

Action::OFK_None

) {

761

DAL->AddJoinedArg(

nullptr

, Opts.getOption(options::OPT_march_EQ),

763

}

else if

(DAL->getLastArgValue(options::OPT_march_EQ) ==

"generic"

765

DAL->eraseArg(options::OPT_march_EQ);

766

}

else if

(DAL->getLastArgValue(options::OPT_march_EQ) ==

"native"

) {

767 auto

GPUsOrErr = getSystemGPUArchs(Args);

769

getDriver().Diag(diag::err_drv_undetermined_gpu_arch)

770

<< getArchName() << llvm::toString(GPUsOrErr.takeError()) <<

"-march"

;

772 if

(GPUsOrErr->size() > 1)

773

getDriver().Diag(diag::warn_drv_multi_gpu_arch)

774

<< getArchName() << llvm::join(*GPUsOrErr,

", "

) <<

"-march"

;

775

DAL->AddJoinedArg(

nullptr

, Opts.getOption(options::OPT_march_EQ),

776

Args.MakeArgString(GPUsOrErr->front()));

784 const

llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,

789 if

(Freestanding && !getDriver().isUsingLTO())

790

CC1Args.append({

"-mllvm"

"--nvptx-lower-global-ctor-dtor"

});

794 const

Option &O = A->getOption();

795 return

(O.matches(options::OPT_gN_Group) &&

796

!O.matches(options::OPT_gmodules)) ||

797

O.matches(options::OPT_g_Flag) ||

798

O.matches(options::OPT_ggdbN_Group) || O.matches(options::OPT_ggdb) ||

799

O.matches(options::OPT_gdwarf) || O.matches(options::OPT_gdwarf_2) ||

800

O.matches(options::OPT_gdwarf_3) || O.matches(options::OPT_gdwarf_4) ||

801

O.matches(options::OPT_gdwarf_5) ||

802

O.matches(options::OPT_gcolumn_info);

806

llvm::codegenoptions::DebugInfoKind &DebugInfoKind,

807 const

ArgList &Args)

const

{

809 case

DisableDebugInfo:

810

DebugInfoKind = llvm::codegenoptions::NoDebugInfo;

812 case

DebugDirectivesOnly:

813

DebugInfoKind = llvm::codegenoptions::DebugDirectivesOnly;

815 case

EmitSameDebugInfoAsHost:

825 if

(Arg *A = Args.getLastArg(options::OPT_nvptx_arch_tool_EQ))

826

Program = A->getValue();

828

Program = GetProgramPath(

"nvptx-arch"

);

830 auto

StdoutOrErr = executeToolChainProgram(Program);

832 return

StdoutOrErr.takeError();

835 for

(StringRef Arch : llvm::split((*StdoutOrErr)->getBuffer(),

"\n"

))

837

GPUArchs.push_back(Arch.str());

839 if

(GPUArchs.empty())

840 return

llvm::createStringError(std::error_code(),

841 "No NVIDIA GPU detected in the system"

);

843 return

std::move(GPUArchs);

851 const ToolChain

&HostTC,

const

ArgList &Args)

852

NVPTXToolChain

(

, Triple, HostTC.getTriple(), Args), HostTC(HostTC) {}

855 const

llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,

859

StringRef GpuArch = DriverArgs.getLastArgValue(options::OPT_march_EQ);

862 "Only OpenMP or CUDA offloading kinds are supported for NVIDIA GPUs."

);

864

CC1Args.append({

"-fcuda-is-device"

"-mllvm"

865 "-enable-memcpyopt-without-libcalls"

866 "-fno-threadsafe-statics"

});

873

CC1Args.push_back(

"-fcuda-allow-variadic-functions"

);

875 if

(DriverArgs.hasFlag(options::OPT_fcuda_short_ptr,

876

options::OPT_fno_cuda_short_ptr,

false

))

877

CC1Args.append({

"-mllvm"

"--nvptx-short-ptr"

});

879 if

(DriverArgs.hasArg(options::OPT_nogpulib))

883

DriverArgs.hasArg(options::OPT_S))

887 if

(LibDeviceFile.empty()) {

888 getDriver

().

Diag

(diag::err_drv_no_cuda_libdevice) << GpuArch;

892

CC1Args.push_back(

"-mlink-builtin-bitcode"

);

893

CC1Args.push_back(DriverArgs.MakeArgString(LibDeviceFile));

898 if

(DriverArgs.hasFlag(options::OPT_foffload_via_llvm,

899

options::OPT_fno_offload_via_llvm,

false

))

906

DriverArgs.MakeArgString(Twine(

"-target-sdk-version="

) +

912

diag::err_drv_omp_offload_target_cuda_version_not_support)

927 const

llvm::opt::ArgList &DriverArgs,

const JobAction

&JA,

928 const

llvm::fltSemantics *FPType)

const

{

930 if

(FPType && FPType == &llvm::APFloat::IEEEsingle() &&

931

DriverArgs.hasFlag(options::OPT_fgpu_flush_denormals_to_zero,

932

options::OPT_fno_gpu_flush_denormals_to_zero,

false

))

933 return

llvm::DenormalMode::getPreserveSign();

937 return

llvm::DenormalMode::getIEEE();

941

ArgStringList &CC1Args)

const

{

943 if

(!DriverArgs.hasArg(options::OPT_nogpuinc) &&

944

!DriverArgs.hasArg(options::OPT_no_cuda_version_check)) {

945

StringRef Arch = DriverArgs.getLastArgValue(options::OPT_march_EQ);

946

assert(!Arch.empty() &&

"Must have an explicit GPU arch."

);

955 if

(Input.

getType

() != types::TY_Object ||

getDriver

().offloadDeviceOnly())

961

llvm::opt::DerivedArgList *

965

DerivedArgList *DAL =

968

DAL =

new

DerivedArgList(Args.getBaseArgs());

972 for

(Arg *A : Args) {

974 if

(!llvm::is_contained(*DAL, A)) {

979 if

(!BoundArch.empty()) {

980

DAL->eraseArg(options::OPT_march_EQ);

981

DAL->AddJoinedArg(

nullptr

, Opts.getOption(options::OPT_march_EQ),

1013

ArgStringList &CC1Args)

const

{

1018

{

"-internal-isystem"

1023

ArgStringList &CC1Args)

const

{

1028

ArgStringList &CC1Args)

const

{

1046 const

ArgList &Args)

const

{

const char * getOffloadingArch() const

OffloadKind getOffloadingDeviceKind() const

bool isDeviceOffloading(OffloadKind OKind) const

bool isOffloading(OffloadKind OKind) const

Compilation - A set of tasks to perform for a single driver invocation.

A class to find a viable CUDA installation.

void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const

CudaInstallationDetector(const Driver &D, const llvm::Triple &HostTriple, const llvm::opt::ArgList &Args)

void WarnIfUnsupportedVersion()

CudaVersion version() const

Get the detected Cuda install's version.

std::string getLibDeviceFile(StringRef Gpu) const

Get libdevice file for given architecture.

void CheckCudaVersionSupportsArch(OffloadArch Arch) const

Emit an error if Version does not support the given Arch.

void print(raw_ostream &OS) const

Print information about the detected CUDA installation.

StringRef getIncludePath() const

Get the detected Cuda Include path.

bool isValid() const

Check whether we detected a valid Cuda install.

Distro - Helper class for detecting and classifying Linux distributions.

Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...

DiagnosticBuilder Diag(unsigned DiagID) const

const llvm::opt::OptTable & getOpts() const

std::string ResourceDir

The path to the compiler resource directory.

InputInfo - Wrapper for information about an input source.

const char * getFilename() const

types::ID getType() const

bool willEmitRemarks(const llvm::opt::ArgList &Args)

The JSON file list parser is used to communicate input to InstallAPI.

CudaVersion MaxVersionForOffloadArch(OffloadArch A)

Get the latest CudaVersion that supports the given OffloadArch.

static bool IsNVIDIAOffloadArch(OffloadArch A)

const char * CudaVersionToString(CudaVersion V)

const char * OffloadArchToVirtualArchString(OffloadArch A)

OffloadArch StringToOffloadArch(llvm::StringRef S)

const char * OffloadArchToString(OffloadArch A)

CudaVersion MinVersionForOffloadArch(OffloadArch A)

Get the earliest CudaVersion that supports the given OffloadArch.

Diagnostic wrappers for TextAPI types for error reporting.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4