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

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

clang: lib/CodeGen/CGCUDANV.cpp Source File

;

CodeGen;

CudaFatMagic = 0x466243b1;

HIPFatMagic = 0x48495046;

StringRef SectionPrefix;

llvm::IntegerType *IntTy, *SizeTy;

llvm::PointerType *PtrTy;

llvm::LLVMContext &Context;

llvm::Module &TheModule;

llvm::DenseMap<StringRef, llvm::GlobalValue *> KernelHandles;

llvm::DenseMap<llvm::GlobalValue *, llvm::Function *> KernelStubs;

llvm::GlobalVariable *Var;

llvm::GlobalVariable *GpuBinaryHandle =

;

RelocatableDeviceCode;

std::unique_ptr<MangleContext> DeviceMC;

llvm::FunctionCallee getSetupArgumentFn()

;

llvm::FunctionCallee getLaunchFn()

;

llvm::FunctionType *getRegisterGlobalsFnTy()

;

llvm::FunctionType *getCallbackFnTy()

;

llvm::FunctionType *getRegisterLinkedBinaryFnTy()

;

std::string addPrefixToName(StringRef FuncName)

;

std::string addUnderscoredPrefixToName(StringRef FuncName)

;

llvm::Function *makeRegisterGlobalsFn();

llvm::Constant *makeConstantString(

std::string &Str,

std::string &Name =

) {

CGM.GetAddrOfConstantCString(Str, Name.c_str()).getPointer();

llvm::Constant *makeConstantArray(StringRef Str,

StringRef Name =

,

StringRef SectionName =

,

Alignment = 0,

AddNull =

) {

llvm::Constant *

=

llvm::ConstantDataArray::getString(Context, Str, AddNull);

*GV =

llvm::GlobalVariable(

llvm::GlobalValue::PrivateLinkage,

, Name);

(!SectionName.empty()) {

GV->setSection(SectionName);

GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::None);

GV->setAlignment(llvm::Align(Alignment));

llvm::Function *makeDummyFunction(llvm::FunctionType *FnTy) {

assert(FnTy->getReturnType()->isVoidTy() &&

);

llvm::Function *DummyFunc = llvm::Function::Create(

FnTy, llvm::GlobalValue::InternalLinkage,

, &TheModule);

llvm::BasicBlock *DummyBlock =

llvm::BasicBlock::Create(Context,

, DummyFunc);

FuncBuilder.SetInsertPoint(DummyBlock);

FuncBuilder.CreateRetVoid();

registerDeviceVar(

*VD, llvm::GlobalVariable &Var,

Extern,

Constant) {

DeviceVars.push_back({&Var,

VD->hasAttr<HIPManagedAttr>(),

registerDeviceSurf(

*VD, llvm::GlobalVariable &Var,

Extern,

) {

DeviceVars.push_back({&Var,

registerDeviceTex(

*VD, llvm::GlobalVariable &Var,

Extern,

,

Normalized) {

DeviceVars.push_back({&Var,

, Normalized,

}});

llvm::Function *makeModuleCtorFunction();

llvm::Function *makeModuleDtorFunction();

transformManagedVars();

createOffloadingEntries();

llvm::Function *

(llvm::GlobalValue *Handle)

{

= KernelStubs.find(Handle);

assert(

!= KernelStubs.end());

llvm::GlobalVariable &Var)

;

llvm::GlobalValue::LinkageTypes &

)

;

std::string CGNVCUDARuntime::addPrefixToName(StringRef FuncName)

{

(Prefix + FuncName).str();

CGNVCUDARuntime::addUnderscoredPrefixToName(StringRef FuncName)

{

(

+ Prefix + FuncName).str();

std::unique_ptr<MangleContext>(

TheModule(CGM.getModule()),

RelocatableDeviceCode(CGM.getLangOpts().GPURelocatableDeviceCode),

SectionPrefix =

;

SectionPrefix = Prefix =

;

SectionPrefix = Prefix =

;

llvm::FunctionCallee CGNVCUDARuntime::getSetupArgumentFn()

{

llvm::Type *Params[] = {PtrTy, SizeTy, SizeTy};

llvm::FunctionType::get(IntTy, Params,

),

addPrefixToName(

));

llvm::FunctionCallee CGNVCUDARuntime::getLaunchFn()

{

llvm::FunctionType::get(IntTy, PtrTy,

),

);

llvm::FunctionType *CGNVCUDARuntime::getRegisterGlobalsFnTy()

{

llvm::FunctionType::get(VoidTy, PtrTy,

);

llvm::FunctionType *CGNVCUDARuntime::getCallbackFnTy()

{

llvm::FunctionType::get(VoidTy, PtrTy,

);

llvm::FunctionType *CGNVCUDARuntime::getRegisterLinkedBinaryFnTy()

{

llvm::Type *Params[] = {llvm::PointerType::getUnqual(Context), PtrTy, PtrTy,

llvm::PointerType::getUnqual(Context)};

llvm::FunctionType::get(VoidTy, Params,

);

std::string CGNVCUDARuntime::getDeviceSideName(

*ND) {

(

*FD = dyn_cast<FunctionDecl>(ND))

GD =

(FD, KernelReferenceKind::Kernel);

std::string DeviceSideName;

llvm::raw_svector_ostream Out(Buffer);

DeviceSideName = std::string(Out.str());

llvm::raw_svector_ostream Out(Buffer);

Out << DeviceSideName;

DeviceSideName = std::string(Out.str());

DeviceSideName;

dyn_cast<llvm::GlobalVariable>(KernelHandles[CGF.

->getName()])) {

GV->setLinkage(CGF.

->getLinkage());

GV->setInitializer(CGF.

);

CudaFeature::CUDA_USES_NEW_LAUNCH) ||

emitDeviceStubBodyNew(CGF, Args);

emitDeviceStubBodyLegacy(CGF, Args);

(

&Arg : Args)

llvm::StructType *KernelArgsTy = llvm::StructType::create(ArgTypes);

*Int64Ty = CGF.

.getInt64Ty();

KernelLaunchParamsTypes.push_back(Int64Ty);

KernelLaunchParamsTypes.push_back(PtrTy);

KernelLaunchParamsTypes.push_back(PtrTy);

llvm::StructType *KernelLaunchParamsTy =

llvm::StructType::create(KernelLaunchParamsTypes);

);

KernelArgsSize = CGM.

().getTypeAllocSize(KernelArgsTy);

(

i = 0; i < Args.size(); ++i) {

KernelLaunchParams;

llvm::ConstantInt::get(SizeTy, std::max<size_t>(1, Args.size())));

(

i = 0; i < Args.size(); ++i) {

llvm::Value *VoidVarPtr = CGF.

.CreatePointerCast(VarPtr, PtrTy);

VoidVarPtr, CGF.

.CreateConstGEP1_32(

? prepareKernelArgsLLVMOffload(CGF, Args)

: prepareKernelArgs(CGF, Args);

std::string KernelLaunchAPI =

;

LangOptions::GPUDefaultStreamKind::PerThread) {

KernelLaunchAPI = KernelLaunchAPI +

;

KernelLaunchAPI = KernelLaunchAPI +

;

LaunchKernelName = addPrefixToName(KernelLaunchAPI);

(

*Result : DC->

(&cudaLaunchKernelII)) {

cudaLaunchKernelFD = FD;

(cudaLaunchKernelFD ==

) {

+ LaunchKernelName);

llvm::FunctionType::get(IntTy,

addUnderscoredPrefixToName(

));

CGF.

.CreatePointerCast(KernelHandles[CGF.

->getName()], PtrTy);

llvm::FunctionType *FTy = cast<llvm::FunctionType>(Ty);

llvm::FunctionCallee cudaLaunchKernelFn =

llvm::Function *KernelFunction = llvm::cast<llvm::Function>(

);

std::string GlobalVarName = (KernelFunction->getName() +

).str();

llvm::GlobalVariable *HandleVar =

CGM.

().getNamedGlobal(GlobalVarName);

HandleVar =

llvm::GlobalVariable(

, KernelFunction->getLinkage(),

llvm::ConstantInt::get(CGM.

, 0), GlobalVarName);

HandleVar->setDSOLocal(KernelFunction->isDSOLocal());

HandleVar->setVisibility(KernelFunction->getVisibility());

(KernelFunction->hasComdat())

HandleVar->setComdat(CGM.

().getOrInsertComdat(GlobalVarName));

llvm::FunctionCallee cudaSetupArgFn = getSetupArgumentFn();

(

*A : Args) {

Offset = Offset.alignTo(TInfo.Align);

llvm::Value *Args[] = {

CGF.

.CreatePointerCast(

llvm::ConstantInt::get(SizeTy, TInfo.Width.getQuantity()),

llvm::ConstantInt::get(SizeTy, Offset.getQuantity()),

llvm::Constant *

= llvm::ConstantInt::get(IntTy, 0);

llvm::Value *CBZero = CGF.

.CreateICmpEQ(CB, Zero);

CGF.

.CreateCondBr(CBZero, NextBlock, EndBlock);

Offset += TInfo.Width;

llvm::FunctionCallee cudaLaunchFn = getLaunchFn();

CGF.

.CreatePointerCast(KernelHandles[CGF.

->getName()], PtrTy);

llvm::GlobalVariable *ManagedVar) {

(

&&VarUse : Var->uses()) {

WorkList.push_back({VarUse.getUser()});

(!WorkList.empty()) {

&&WorkItem = WorkList.pop_back_val();

*

= WorkItem.back();

(isa<llvm::ConstantExpr>(

)) {

(

&&UU :

->uses()) {

WorkItem.push_back(UU.getUser());

WorkList.push_back(WorkItem);

(

*I = dyn_cast<llvm::Instruction>(

)) {

llvm::Value *OldV = Var;

llvm::Instruction *NewV =

llvm::LoadInst(

Var->getType(), ManagedVar,

,

,

llvm::Align(Var->getAlignment()), I->getIterator());

(

&&Op : WorkItem) {

*CE = cast<llvm::ConstantExpr>(Op);

*NewInst = CE->getAsInstruction();

NewInst->insertBefore(*I->getParent(), I->getIterator());

NewInst->replaceUsesOfWith(OldV, NewV);

I->replaceUsesOfWith(OldV, NewV);

llvm_unreachable(

);

llvm::Function *CGNVCUDARuntime::makeRegisterGlobalsFn() {

(EmittedKernels.empty() && DeviceVars.empty())

llvm::Function *RegisterKernelsFunc = llvm::Function::Create(

getRegisterGlobalsFnTy(), llvm::GlobalValue::InternalLinkage,

addUnderscoredPrefixToName(

), &TheModule);

llvm::BasicBlock *EntryBB =

llvm::BasicBlock::Create(Context,

, RegisterKernelsFunc);

Builder.SetInsertPoint(EntryBB);

llvm::Type *RegisterFuncParams[] = {

PtrTy, PtrTy, PtrTy, PtrTy, IntTy,

PtrTy, PtrTy, PtrTy, PtrTy, llvm::PointerType::getUnqual(Context)};

llvm::FunctionType::get(IntTy, RegisterFuncParams,

),

addUnderscoredPrefixToName(

));

llvm::Argument &GpuBinaryHandlePtr = *RegisterKernelsFunc->arg_begin();

(

&&I : EmittedKernels) {

llvm::Constant *KernelName =

makeConstantString(getDeviceSideName(cast<NamedDecl>(I.D)));

llvm::Constant *NullPtr = llvm::ConstantPointerNull::get(PtrTy);

llvm::Value *Args[] = {

KernelHandles[I.Kernel->getName()],

llvm::ConstantInt::get(IntTy, -1),

llvm::ConstantPointerNull::get(llvm::PointerType::getUnqual(Context))};

Builder.CreateCall(RegisterFunc, Args);

llvm::Type *VarSizeTy = IntTy;

llvm::Type *RegisterVarParams[] = {PtrTy, PtrTy, PtrTy, PtrTy,

IntTy, VarSizeTy, IntTy, IntTy};

llvm::FunctionType::get(VoidTy, RegisterVarParams,

),

addUnderscoredPrefixToName(

));

llvm::Type *RegisterManagedVarParams[] = {PtrTy, PtrTy, PtrTy,

PtrTy, VarSizeTy, IntTy};

llvm::FunctionType::get(VoidTy, RegisterManagedVarParams,

),

addUnderscoredPrefixToName(

));

llvm::FunctionType::get(

VoidTy, {PtrTy, PtrTy, PtrTy, PtrTy, IntTy, IntTy},

),

addUnderscoredPrefixToName(

));

llvm::FunctionType::get(

VoidTy, {PtrTy, PtrTy, PtrTy, PtrTy, IntTy, IntTy, IntTy},

),

addUnderscoredPrefixToName(

));

(

&&Info : DeviceVars) {

llvm::GlobalVariable *Var = Info.Var;

assert((!Var->isDeclaration() || Info.Flags.isManaged()) &&

llvm::Constant *VarName = makeConstantString(getDeviceSideName(Info.D));

(Info.Flags.getKind()) {

DeviceVarFlags::Variable: {

(Info.Flags.isManaged()) {

assert(Var->getName().ends_with(

) &&

);

*ManagedVar = CGM.

().getNamedGlobal(

Var->getName().drop_back(StringRef(

).size()));

llvm::Value *Args[] = {

llvm::ConstantInt::get(VarSizeTy, VarSize),

llvm::ConstantInt::get(IntTy, Var->getAlignment())};

(!Var->isDeclaration())

Builder.CreateCall(RegisterManagedVar, Args);

llvm::Value *Args[] = {

llvm::ConstantInt::get(IntTy, Info.Flags.isExtern()),

llvm::ConstantInt::get(VarSizeTy, VarSize),

llvm::ConstantInt::get(IntTy, Info.Flags.isConstant()),

llvm::ConstantInt::get(IntTy, 0)};

Builder.CreateCall(RegisterVar, Args);

DeviceVarFlags::Surface:

{&GpuBinaryHandlePtr, Var, VarName, VarName,

llvm::ConstantInt::get(IntTy, Info.Flags.getSurfTexType()),

llvm::ConstantInt::get(IntTy, Info.Flags.isExtern())});

DeviceVarFlags::Texture:

{&GpuBinaryHandlePtr, Var, VarName, VarName,

llvm::ConstantInt::get(IntTy, Info.Flags.getSurfTexType()),

llvm::ConstantInt::get(IntTy, Info.Flags.isNormalized()),

llvm::ConstantInt::get(IntTy, Info.Flags.isExtern())});

Builder.CreateRetVoid();

RegisterKernelsFunc;

llvm::Function *CGNVCUDARuntime::makeModuleCtorFunction() {

(CudaGpuBinaryFileName.empty() && !IsHIP)

((IsHIP || (IsCUDA && !RelocatableDeviceCode)) && EmittedKernels.empty() &&

llvm::Function *RegisterGlobalsFunc = makeRegisterGlobalsFn();

(RelocatableDeviceCode && !RegisterGlobalsFunc)

RegisterGlobalsFunc = makeDummyFunction(getRegisterGlobalsFnTy());

llvm::FunctionType::get(PtrTy, PtrTy,

),

addUnderscoredPrefixToName(

));

llvm::StructType *FatbinWrapperTy =

llvm::StructType::get(IntTy, IntTy, PtrTy, PtrTy);

std::unique_ptr<llvm::MemoryBuffer> CudaGpuBinary =

;

(!CudaGpuBinaryFileName.empty()) {

CudaGpuBinaryOrErr =

->getBufferForFile(CudaGpuBinaryFileName, -1,

);

(std::error_code EC = CudaGpuBinaryOrErr.getError()) {

<< CudaGpuBinaryFileName << EC.message();

CudaGpuBinary = std::move(CudaGpuBinaryOrErr.get());

llvm::Function *ModuleCtorFunc = llvm::Function::Create(

llvm::FunctionType::get(VoidTy,

),

llvm::GlobalValue::InternalLinkage,

addUnderscoredPrefixToName(

), &TheModule);

llvm::BasicBlock *CtorEntryBB =

llvm::BasicBlock::Create(Context,

, ModuleCtorFunc);

CtorBuilder.SetInsertPoint(CtorEntryBB);

*FatbinConstantName;

*FatbinSectionName;

*ModuleIDSectionName;

StringRef ModuleIDPrefix;

llvm::Constant *FatBinStr;

FatbinConstantName =

;

FatbinSectionName =

;

ModuleIDSectionName =

;

ModuleIDPrefix =

;

HIPCodeObjectAlign = 4096;

FatBinStr = makeConstantArray(std::string(CudaGpuBinary->getBuffer()),

,

FatbinConstantName, HIPCodeObjectAlign);

FatBinStr =

llvm::GlobalVariable(

, llvm::GlobalValue::ExternalLinkage,

,

, llvm::GlobalVariable::NotThreadLocal);

cast<llvm::GlobalVariable>(FatBinStr)->setSection(FatbinConstantName);

FatMagic = HIPFatMagic;

(RelocatableDeviceCode)

FatbinConstantName = CGM.

().isMacOSX()

?

CGM.

().isMacOSX() ?

:

;

CGM.

().isMacOSX() ?

:

;

ModuleIDSectionName = CGM.

().isMacOSX()

?

ModuleIDPrefix =

;

FatBinStr = makeConstantArray(std::string(CudaGpuBinary->getBuffer()),

,

FatbinConstantName, 8);

FatMagic = CudaFatMagic;

Values = Builder.beginStruct(FatbinWrapperTy);

Values.addInt(IntTy, FatMagic);

Values.addInt(IntTy, 1);

Values.add(FatBinStr);

Values.add(llvm::ConstantPointerNull::get(PtrTy));

llvm::GlobalVariable *FatbinWrapper = Values.finishAndCreateGlobal(

addUnderscoredPrefixToName(

), CGM.

(),

FatbinWrapper->setSection(FatbinSectionName);

= RelocatableDeviceCode ? llvm::GlobalValue::ExternalLinkage

: llvm::GlobalValue::InternalLinkage;

llvm::BasicBlock *IfBlock =

llvm::BasicBlock::Create(Context,

, ModuleCtorFunc);

llvm::BasicBlock *ExitBlock =

llvm::BasicBlock::Create(Context,

, ModuleCtorFunc);

GpuBinaryHandle =

llvm::GlobalVariable(

TheModule, PtrTy,

,

,

!RelocatableDeviceCode ? llvm::ConstantPointerNull::get(PtrTy)

(

!= llvm::GlobalValue::InternalLinkage)

GpuBinaryHandle->setVisibility(llvm::GlobalValue::HiddenVisibility);

GpuBinaryHandle, PtrTy,

*HandleValue = CtorBuilder.CreateLoad(GpuBinaryAddr);

llvm::Constant *

=

llvm::Constant::getNullValue(HandleValue->getType());

llvm::Value *EQZero = CtorBuilder.CreateICmpEQ(HandleValue, Zero);

CtorBuilder.CreateCondBr(EQZero, IfBlock, ExitBlock);

CtorBuilder.SetInsertPoint(IfBlock);

llvm::CallInst *RegisterFatbinCall =

CtorBuilder.CreateCall(RegisterFatbinFunc, FatbinWrapper);

CtorBuilder.CreateStore(RegisterFatbinCall, GpuBinaryAddr);

CtorBuilder.CreateBr(ExitBlock);

CtorBuilder.SetInsertPoint(ExitBlock);

(RegisterGlobalsFunc) {

*HandleValue = CtorBuilder.CreateLoad(GpuBinaryAddr);

CtorBuilder.CreateCall(RegisterGlobalsFunc, HandleValue);

}

(!RelocatableDeviceCode) {

llvm::CallInst *RegisterFatbinCall =

CtorBuilder.CreateCall(RegisterFatbinFunc, FatbinWrapper);

GpuBinaryHandle =

llvm::GlobalVariable(

TheModule, PtrTy,

, llvm::GlobalValue::InternalLinkage,

llvm::ConstantPointerNull::get(PtrTy),

);

CtorBuilder.CreateAlignedStore(RegisterFatbinCall, GpuBinaryHandle,

(RegisterGlobalsFunc)

CtorBuilder.CreateCall(RegisterGlobalsFunc, RegisterFatbinCall);

CudaFeature::CUDA_USES_FATBIN_REGISTER_END)) {

llvm::FunctionType::get(VoidTy, PtrTy,

),

);

CtorBuilder.CreateCall(RegisterFatbinEndFunc, RegisterFatbinCall);

llvm::raw_svector_ostream OS(ModuleID);

OS << ModuleIDPrefix << llvm::format(

PRIx64, FatbinWrapper->getGUID());

llvm::Constant *ModuleIDConstant = makeConstantArray(

std::string(ModuleID),

, ModuleIDSectionName, 32,

);

llvm::GlobalAlias::create(llvm::GlobalValue::ExternalLinkage,

Twine(

) + ModuleID, FatbinWrapper);

RegisterLinkedBinaryName += ModuleID;

getRegisterLinkedBinaryFnTy(), RegisterLinkedBinaryName);

assert(RegisterGlobalsFunc &&

);

llvm::Value *Args[] = {RegisterGlobalsFunc, FatbinWrapper, ModuleIDConstant,

makeDummyFunction(getCallbackFnTy())};

CtorBuilder.CreateCall(RegisterLinkedBinaryFunc, Args);

(llvm::Function *CleanupFn = makeModuleDtorFunction()) {

llvm::FunctionType *AtExitTy =

llvm::FunctionType::get(IntTy, CleanupFn->getType(),

);

llvm::FunctionCallee AtExitFunc =

CtorBuilder.CreateCall(AtExitFunc, CleanupFn);

CtorBuilder.CreateRetVoid();

ModuleCtorFunc;

llvm::Function *CGNVCUDARuntime::makeModuleDtorFunction() {

(!GpuBinaryHandle)

llvm::FunctionType::get(VoidTy, PtrTy,

),

addUnderscoredPrefixToName(

));

llvm::Function *ModuleDtorFunc = llvm::Function::Create(

llvm::FunctionType::get(VoidTy,

),

llvm::GlobalValue::InternalLinkage,

addUnderscoredPrefixToName(

), &TheModule);

llvm::BasicBlock *DtorEntryBB =

llvm::BasicBlock::Create(Context,

, ModuleDtorFunc);

DtorBuilder.SetInsertPoint(DtorEntryBB);

GpuBinaryHandle, GpuBinaryHandle->getValueType(),

*HandleValue = DtorBuilder.CreateLoad(GpuBinaryAddr);

llvm::BasicBlock *IfBlock =

llvm::BasicBlock::Create(Context,

, ModuleDtorFunc);

llvm::BasicBlock *ExitBlock =

llvm::BasicBlock::Create(Context,

, ModuleDtorFunc);

llvm::Constant *

= llvm::Constant::getNullValue(HandleValue->getType());

llvm::Value *NEZero = DtorBuilder.CreateICmpNE(HandleValue, Zero);

DtorBuilder.CreateCondBr(NEZero, IfBlock, ExitBlock);

DtorBuilder.SetInsertPoint(IfBlock);

DtorBuilder.CreateCall(UnregisterFatbinFunc, HandleValue);

DtorBuilder.CreateStore(Zero, GpuBinaryAddr);

DtorBuilder.CreateBr(ExitBlock);

DtorBuilder.SetInsertPoint(ExitBlock);

DtorBuilder.CreateCall(UnregisterFatbinFunc, HandleValue);

DtorBuilder.CreateRetVoid();

ModuleDtorFunc;

CGNVCUDARuntime(CGM);

CGNVCUDARuntime::internalizeDeviceSideVar(

(

->

<CUDADeviceAttr>() ||

->

<CUDAConstantAttr>() ||

->getType()->isCUDADeviceBuiltinSurfaceType() ||

->getType()->isCUDADeviceBuiltinTextureType()) {

= llvm::GlobalValue::InternalLinkage;

CGNVCUDARuntime::handleVarRegistration(

*

,

llvm::GlobalVariable &GV) {

(

->

<CUDADeviceAttr>() ||

->

<CUDAConstantAttr>()) {

((!

->hasExternalStorage() && !

->isInline()) ||

registerDeviceVar(

, GV, !

->hasDefinition(),

->

<CUDAConstantAttr>());

}

(

->getType()->isCUDADeviceBuiltinSurfaceType() ||

->getType()->isCUDADeviceBuiltinTextureType()) {

*TD = cast<ClassTemplateSpecializationDecl>(

(TD->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>()) {

assert(Args.

() == 2 &&

);

SurfType = Args[1].getAsIntegral();

(!

->hasExternalStorage())

registerDeviceSurf(

, GV, !

->hasDefinition(), SurfType.getSExtValue());

assert(Args.

() == 3 &&

);

TexType = Args[1].getAsIntegral();

Normalized = Args[2].getAsIntegral();

(!

->hasExternalStorage())

registerDeviceTex(

, GV, !

->hasDefinition(), TexType.getSExtValue(),

Normalized.getZExtValue());

CGNVCUDARuntime::transformManagedVars() {

(

&&Info : DeviceVars) {

llvm::GlobalVariable *Var = Info.Var;

(Info.Flags.getKind() == DeviceVarFlags::Variable &&

Info.Flags.isManaged()) {

*ManagedVar =

llvm::GlobalVariable(

, Var->getLinkage(),

Var->isDeclaration()

: llvm::ConstantPointerNull::get(Var->getType()),

llvm::GlobalVariable::NotThreadLocal,

? LangAS::cuda_device

: LangAS::Default));

ManagedVar->setDSOLocal(Var->isDSOLocal());

ManagedVar->setVisibility(Var->getVisibility());

ManagedVar->setExternallyInitialized(

);

ManagedVar->takeName(Var);

Var->setName(Twine(ManagedVar->getName()) +

);

(CGM.

().CUDAIsDevice && !Var->isDeclaration()) {

assert(!ManagedVar->isDeclaration());

CGNVCUDARuntime::createOffloadingEntries() {

StringRef Section = (SectionPrefix +

).toStringRef(Out);

? llvm::object::OffloadKind::OFK_HIP

: llvm::object::OffloadKind::OFK_Cuda;

(KernelInfo &I : EmittedKernels)

llvm::offloading::emitOffloadingEntry(

M, Kind, KernelHandles[I.Kernel->getName()],

getDeviceSideName(cast<NamedDecl>(I.D)),

0,

0,

llvm::offloading::OffloadGlobalEntry, Section);

(VarInfo &I : DeviceVars) {

CGM.

().getTypeAllocSize(I.Var->getValueType());

?

(llvm::offloading::OffloadGlobalExtern)

(I.Flags.isConstant()

?

(llvm::offloading::OffloadGlobalConstant)

(I.Flags.isNormalized()

?

(llvm::offloading::OffloadGlobalNormalized)

(I.Flags.getKind() == DeviceVarFlags::Variable) {

(I.Flags.isManaged()) {

assert(I.Var->getName().ends_with(

) &&

);

*ManagedVar = M.getNamedGlobal(

I.Var->getName().drop_back(StringRef(

).size()));

llvm::offloading::emitOffloadingEntry(

M, Kind, I.Var, getDeviceSideName(I.D), VarSize,

llvm::offloading::OffloadGlobalManagedEntry | Flags,

I.Var->getAlignment(), Section, ManagedVar);

llvm::offloading::emitOffloadingEntry(

M, Kind, I.Var, getDeviceSideName(I.D), VarSize,

llvm::offloading::OffloadGlobalEntry | Flags,

}

(I.Flags.getKind() == DeviceVarFlags::Surface) {

llvm::offloading::emitOffloadingEntry(

M, Kind, I.Var, getDeviceSideName(I.D), VarSize,

llvm::offloading::OffloadGlobalSurfaceEntry | Flags,

I.Flags.getSurfTexType(), Section);

}

(I.Flags.getKind() == DeviceVarFlags::Texture) {

llvm::offloading::emitOffloadingEntry(

M, Kind, I.Var, getDeviceSideName(I.D), VarSize,

llvm::offloading::OffloadGlobalTextureEntry | Flags,

I.Flags.getSurfTexType(), Section);

llvm::Function *CGNVCUDARuntime::finalizeModule() {

transformManagedVars();

(

&&Info : DeviceVars) {

= Info.Flags.getKind();

(!Info.Var->isDeclaration() &&

!llvm::GlobalValue::isLocalLinkage(Info.Var->getLinkage()) &&

(Kind == DeviceVarFlags::Variable ||

Kind == DeviceVarFlags::Surface ||

Kind == DeviceVarFlags::Texture) &&

Info.D->isUsed() && !Info.D->hasAttr<UsedAttr>()) {

(CGM.

().OffloadingNewDriver && RelocatableDeviceCode))

createOffloadingEntries();

makeModuleCtorFunction();

llvm::GlobalValue *CGNVCUDARuntime::getKernelHandle(llvm::Function *F,

= KernelHandles.find(F->getName());

(

!= KernelHandles.end()) {

OldHandle =

->second;

(KernelStubs[OldHandle] == F)

KernelStubs[OldHandle] = F;

KernelStubs.erase(OldHandle);

KernelHandles[F->getName()] = F;

*Var =

llvm::GlobalVariable(

TheModule, F->getType(),

, F->getLinkage(),

Var->setDSOLocal(F->isDSOLocal());

Var->setVisibility(F->getVisibility());

*FD = cast<FunctionDecl>(GD.

());

*FT = FD->getPrimaryTemplate();

(!FT || FT->isThisDeclarationADefinition())

KernelHandles[F->getName()] = Var;

KernelStubs[Var] = F;

static std::unique_ptr< MangleContext > InitDeviceMC(CodeGenModule &CGM)

static void replaceManagedVar(llvm::GlobalVariable *Var, llvm::GlobalVariable *ManagedVar)

TranslationUnitDecl * getTranslationUnitDecl() const

MangleContext * createMangleContext(const TargetInfo *T=nullptr)

If T is null pointer, assume the target in ASTContext.

bool shouldExternalize(const Decl *D) const

Whether a C++ static variable or CUDA/HIP kernel should be externalized.

StringRef getCUIDHash() const

const TargetInfo * getAuxTargetInfo() const

llvm::DenseSet< const VarDecl * > CUDADeviceVarODRUsedByHost

Keep track of CUDA/HIP device-side variables ODR-used by host code.

MangleContext * createDeviceMangleContext(const TargetInfo &T)

Creates a device mangle context to correctly mangle lambdas in a mixed architecture compile by settin...

TypeInfoChars getTypeInfoInChars(const Type *T) const

const TargetInfo & getTargetInfo() const

unsigned getTargetAddressSpace(LangAS AS) const

CharUnits - This is an opaque type for sizes expressed in character units.

llvm::Align getAsAlign() const

getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...

static CharUnits One()

One - Construct a CharUnits quantity of one.

static CharUnits fromQuantity(QuantityType Quantity)

fromQuantity - Construct a CharUnits quantity from a raw integer type.

static CharUnits Zero()

Zero - Construct a CharUnits quantity of zero.

std::string CudaGpuBinaryFileName

Name of file passed with -fcuda-include-gpubinary option to forward to CUDA runtime back-end for inco...

Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...

llvm::Value * emitRawPointer(CodeGenFunction &CGF) const

Return the pointer contained in this class after authenticating it and adding offset to it if necessa...

llvm::PointerType * getType() const

Return the type of the pointer value.

llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)

llvm::StoreInst * CreateAlignedStore(llvm::Value *Val, llvm::Value *Addr, CharUnits Align, bool IsVolatile=false)

llvm::StoreInst * CreateDefaultAlignedStore(llvm::Value *Val, llvm::Value *Addr, bool IsVolatile=false)

Address CreateStructGEP(Address Addr, unsigned Index, const llvm::Twine &Name="")

llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")

virtual std::string getDeviceSideName(const NamedDecl *ND)=0

Returns function or variable name on device side even if the current compilation is for host.

virtual void emitDeviceStub(CodeGenFunction &CGF, FunctionArgList &Args)=0

Emits a kernel launch stub.

virtual llvm::Function * getKernelStub(llvm::GlobalValue *Handle)=0

Get kernel stub by kernel handle.

virtual void handleVarRegistration(const VarDecl *VD, llvm::GlobalVariable &Var)=0

Check whether a variable is a device variable and register it if true.

virtual llvm::Function * finalizeModule()=0

Finalize generated LLVM module.

virtual llvm::GlobalValue * getKernelHandle(llvm::Function *Stub, GlobalDecl GD)=0

Get kernel handle by stub function.

virtual void internalizeDeviceSideVar(const VarDecl *D, llvm::GlobalValue::LinkageTypes &Linkage)=0

Adjust linkage of shadow variables in host compilation.

MangleContext & getMangleContext()

Gets the mangle context.

static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())

CGFunctionInfo - Class to encapsulate the information about a function definition.

CallArgList - Type for representing both the value and type of arguments in a call.

void add(RValue rvalue, QualType type)

CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...

RawAddress CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)

llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)

createBasicBlock - Create an LLVM basic block.

const LangOptions & getLangOpts() const

void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)

EmitBlock - Emit the given block.

llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)

CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...

llvm::Type * ConvertTypeForMem(QualType T)

RawAddress CreateMemTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)

CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...

void EmitBranch(llvm::BasicBlock *Block)

EmitBranch - Emit a branch to the specified basic block from the current insert block,...

RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **CallOrInvoke, bool IsMustTail, SourceLocation Loc, bool IsVirtualFunctionPointerThunk=false)

EmitCall - Generate a call of the given function, expecting the given result type,...

const Decl * CurFuncDecl

CurFuncDecl - Holds the Decl for the current outermost non-closure context.

llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")

Address GetAddrOfLocalVar(const VarDecl *VD)

GetAddrOfLocalVar - Return the address of a local variable.

This class organizes the cross-function state that is used while generating LLVM code.

llvm::Module & getModule() const

llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)

Create or return a runtime function declaration with the specified type and name.

void addCompilerUsedGlobal(llvm::GlobalValue *GV)

Add a global to a list to be added to the llvm.compiler.used metadata.

const IntrusiveRefCntPtr< llvm::vfs::FileSystem > & getFileSystem() const

DiagnosticsEngine & getDiags() const

const LangOptions & getLangOpts() const

CodeGenTypes & getTypes()

const TargetInfo & getTarget() const

const llvm::DataLayout & getDataLayout() const

void Error(SourceLocation loc, StringRef error)

Emit a general error that something can't be done.

CGCXXABI & getCXXABI() const

const llvm::Triple & getTriple() const

ASTContext & getContext() const

const CodeGenOptions & getCodeGenOpts() const

StringRef getMangledName(GlobalDecl GD)

void maybeSetTrivialComdat(const Decl &D, llvm::GlobalObject &GO)

void printPostfixForExternalizedDecl(llvm::raw_ostream &OS, const Decl *D) const

Print the postfix for externalized static variable or kernels for single source offloading languages ...

llvm::Type * ConvertType(QualType T)

ConvertType - Convert type T into a llvm::Type.

const CGFunctionInfo & arrangeFunctionDeclaration(const FunctionDecl *FD)

Free functions are functions that are compatible with an ordinary C function pointer type.

The standard implementation of ConstantInitBuilder used in Clang.

FunctionArgList - Type for representing both the decl and type of parameters to a function.

static RValue get(llvm::Value *V)

static RValue getAggregate(Address addr, bool isVolatile=false)

Convert an Address to an RValue.

ReturnValueSlot - Contains the address where the return value of a function can be stored,...

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

lookup_result lookup(DeclarationName Name) const

lookup - Find the declarations (if any) with the given Name in this context.

Decl - This represents one declaration (or definition), e.g.

SourceLocation getLocation() const

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

Represents a function declaration or definition.

const ParmVarDecl * getParamDecl(unsigned i) const

GlobalDecl - represents a global declaration.

GlobalDecl getWithKernelReferenceKind(KernelReferenceKind Kind)

const Decl * getDecl() const

One of these records is kept for each identifier that is lexed.

StringRef getName() const

Return the actual identifier string.

IdentifierInfo & get(StringRef Name)

Return the identifier token info for the specified named identifier.

std::string CUID

The user provided compilation unit ID, if non-empty.

GPUDefaultStreamKind GPUDefaultStream

The default stream kind used for HIP kernel launching.

MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...

bool shouldMangleDeclName(const NamedDecl *D)

void mangleName(GlobalDecl GD, raw_ostream &)

This represents a decl that may have a name.

IdentifierInfo * getIdentifier() const

Get the identifier that names this declaration, if there is one.

Represents a parameter to a function.

A (possibly-)qualified type.

QualType getCanonicalType() const

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...

RecordDecl * getDecl() const

bool isMicrosoft() const

Is this ABI an MSVC-compatible ABI?

bool isItaniumFamily() const

Does this ABI generally fall into the Itanium family of ABIs?

TargetCXXABI getCXXABI() const

Get the C++ ABI currently in use.

const llvm::VersionTuple & getSDKVersion() const

A template argument list.

unsigned size() const

Retrieve the number of template arguments in this template argument list.

The top declaration context.

static DeclContext * castToDeclContext(const TranslationUnitDecl *D)

The base class of the type hierarchy.

Represents a variable declaration or definition.

CGCUDARuntime * CreateNVCUDARuntime(CodeGenModule &CGM)

Creates an instance of a CUDA runtime class.

bool Zero(InterpState &S, CodePtr OpPC)

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

CudaVersion ToCudaVersion(llvm::VersionTuple)

bool CudaFeatureEnabled(llvm::VersionTuple, CudaFeature)

Linkage

Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.

llvm::IntegerType * Int8Ty

i8, i16, i32, and i64

llvm::IntegerType * SizeTy

llvm::IntegerType * IntTy

int

CharUnits getSizeAlign() const

llvm::PointerType * UnqualPtrTy

CharUnits getPointerAlign() const

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