[CUDA][HIP] Allow comdat for kernels

[yaxunl]

Summary

Two identical instantiations of a template function can be emitted by two TU's
with linkonce_odr linkage without causing duplicate symbols in linker. MSVC
also requires these symbols be in comdat sections. Linux does not require
the symbols in comdat sections to be merged by linker but by default
clang puts them in comdat sections.

If a template kernel is instantiated identically in two TU's. MSVC requires
that them to be in comdat sections, otherwise MSVC linker will diagnose them as
duplicate symbols. However, currently clang does not put instantiated template
kernels in comdat sections, which causes link error for MSVC.

This patch allows putting instantiated template kernels into comdat sections.

[yaxunl]

ping

[tra]

As phrased, the summary would likely be rather confusing for anyone other than you and me.

Currently Visual Studio 2019 has a linker issue which causes linking error
when a template kernel is instantiated in different compilation units.

It's not clear what exactly is the issue and what causes it.

On the other hand, it is unnecessary to prefix kernel stub for MSVC
target since the host and device compilation uses different mangling
ABI.

This could use more details on why different mangling matters here. IIRC, on Linux where both host and device use the same mangling and HIP needed a way to tell apart the GPU-side kernels and their host-side stub. Different mangling makes it a non-issue.

This patch let clang not emit kernel handle for MSVC target to work around the linker issue.

Again, without the back-story the jump from linking error to mangling differences to "let's not emit a handle" does not make much sense.

I'd restructure it along the line of:

• we emit host-side handles to match GPU-side kernels
• the handles cause linking issues on windows because of X/Y/Z.
• handles are not necessary on Windows, because of the different host/device mangling
• not generating the handles avoids the linking issue on Windows.

This prompts the question -- should/could handle generation be improved instead? Having identical behavior on all platforms would arguably be better than a platform-specific workaround.

[yaxunl]

In D112492#3101090, @tra wrote:

As phrased, the summary would likely be rather confusing for anyone other than you and me.

Currently Visual Studio 2019 has a linker issue which causes linking error
when a template kernel is instantiated in different compilation units.

It's not clear what exactly is the issue and what causes it.

Currently, the identical instantiation of a template kernel in different TU causes linking error about duplicate symbols on Windows.

In the beginning, I thought it was due to a bug in MSVC linker. However, further investigation shows that it is not a MSVC linker bug, but a bug of clang.

Basically, it is not sufficient to set linkonce_odr linkage to let MSVC linker merge symbols. The symbol needs to be in comdat sections. This is not required on Linux. However, it would be more consistent to always put kernel stubs and kernel handles with linkonce_odr linkage into comdat if the target supports it.

I will update this patch to fix the comdat for kernel stub and kernel handle.

On the other hand, it is unnecessary to prefix kernel stub for MSVC
target since the host and device compilation uses different mangling
ABI.

This could use more details on why different mangling matters here. IIRC, on Linux where both host and device use the same mangling and HIP needed a way to tell apart the GPU-side kernels and their host-side stub. Different mangling makes it a non-issue.

This patch let clang not emit kernel handle for MSVC target to work around the linker issue.

Again, without the back-story the jump from linking error to mangling differences to "let's not emit a handle" does not make much sense.

I'd restructure it along the line of:

• we emit host-side handles to match GPU-side kernels
• the handles cause linking issues on windows because of X/Y/Z.
• handles are not necessary on Windows, because of the different host/device mangling
• not generating the handles avoids the linking issue on Windows.

This prompts the question -- should/could handle generation be improved instead? Having identical behavior on all platforms would arguably be better than a platform-specific workaround.

With the fix of comdat issue, we should be able to use a consistent kernel launching mechanism for Linux and Windows. Since the debugger requests kernel stub to have a different name than the kernel, we have to let the kernel stub and kernel handle have different names. That mechanism will stay unchanged.

I also found that MSVC name mangling currently does not add device_stub prefix to the mangled name of kernel stubs. I will update this patch to fix that.

With these changes, we should have consistent name mangling for kernel stubs and kernel launching mechanism on Linux and Windows.

[tra]

With these changes, we should have consistent name mangling for kernel stubs and kernel launching mechanism on Linux and Windows.

Nice! Thank you for figuring out the root causes.

[yaxunl]

fix comdat instead

[tra]

clang/lib/CodeGen/CodeGenModule.cpp

4290–4293 ↗

(On Diff #385812)

This was added in D63277 specifically to deal with comdat-related issue on windows.

We do need to have unique addresses for each kernel stub. Placing stubs into comdat may allow them to be merged into one and that would be a problem.
https://docs.microsoft.com/en-us/cpp/build/reference/opt-optimizations?view=vs-2019

@rnk,@kpyzhov -- how do we make sure that identical functions are placed in comdat (needed for templates) but do not get comdat-folded with /OPT:ICF?

[rnk]

clang/lib/CodeGen/CodeGenModule.cpp

4290–4293 ↗

(On Diff #385812)

These are readonly global variables. I believe MSVC's ICF implementation changed behavior here a few times over the years. I think the current state is that they don't merge such globals. If you are using LLD, you can use safe ICF to avoid merging such globals.

@zequanwu reviewed the state of ICF in LLD in the last year, so he may know more about the current status, and he may be more helpful if you have more questions.

Finally, you could mark these globals as mutable if you really want to block ICF. That will work reliably with any linker.

[rnk]

clang/lib/CodeGen/CodeGenModule.cpp

4290–4293 ↗

(On Diff #385812)

Broadly, I think this change is correct. If I had reviewed D63277, I probably would have objected to it and not approved it.

[yaxunl]

I think probably it is necessary to merge linkonce_odr symbols for them to work properly.

Consider the following testcase:

// a.cu
template<typename T>
__global__ void foo(T x) {}

void test1() {
    foo<<<1,1>>>(1);
}

// b.cu
template<typename T>
__global__ void foo(T x) {}

void test2() {
    foo<<<1,1>>>(1);
}

// c.cu
template<typename T>
__global__ void foo(T x);

int main() {
    foo<<<1,1>>>(1);
}

Assume a.cu, b.cu, and c.cu are compiled with default -fno-gpu-rdc option and linked together.

Both a.obj and b.obj contain a global symbol foo<int> as the kernel stub function. c.obj contains reference to foo<int>, so it has to resolve to foo<int> in a.obj or b.obj. It only makes sense for linker to merge foo<int> in a.obj and b.obj and let c.obj resolve to the merged symbol. This also requires that the fat binary embedded in a.obj and b.obj must contain the identical definition of kernel foo<int>. That is, if ODR is followed, even though there are two fat binaries containing kernel foo<int>, only one of them will be used (it is fine since they are identical), which corresponds to the merged symbol for the kernel stub foo<int>.

The implication is that, we have to ask users to follow ODR even with the default -fno-gpu-rdc option. And users cannot have different definitions for the same template instantiation (e.g. foo<int>) in different TU's, otherwise there will be UB.

Considering ODR is a fundamental assumption for C++, I think it is justifiable to request users to follow that no matter whether -fgpu-rdc or -fno-gpu-rdc.

[tra]

Yes, we do need to merge identical functions with identical names for templates.

The comdat-folding issue is different. IIUIC, it allows merging two functions with identical code and different names, into one function with two names. That will break CUDA as we do need to have each stub to have a unique address as we use it to find the matching GPU-side kernel.

[rnk]

In D112492#3119892, @tra wrote:

Yes, we do need to merge identical functions with identical names for templates.

The comdat-folding issue is different. IIUIC, it allows merging two functions with identical code and different names, into one function with two names. That will break CUDA as we do need to have each stub to have a unique address as we use it to find the matching GPU-side kernel.

Well, yes, ICF breaks function pointer identity. There's no way around that, and it is documented:
https://docs.microsoft.com/en-us/cpp/build/reference/opt-optimizations?view=msvc-170
CUDA users will have to remove /OPT:ICF from their linker flags.

Maybe you could make this work by embedding an ICF-breaking device into all the stubs. Something like a volatile asm blob that takes the current function as an argument and puts it in a register.

[yaxunl]

clang/lib/CodeGen/CodeGenModule.cpp

4290–4293 ↗

(On Diff #385812)

These symbols are for kernel stub functions. How do I mark them as mutable?

[yaxunl]

I did an experiment regarding the ICF issue and it seems not to affect kernel stub.

#include "hip/hip_runtime.h"

template<typename T>
void bar(T x) { }

template<typename T>
__global__ void foo(T x) {}

int main() {
  foo<<<1,1>>>(1);
  printf("%p\n", foo<int>);
  printf("%p\n", foo<float>);
  printf("%p\n", bar<int>);
  printf("%p\n", bar<float>);
}

If I pass -Wl,/opt:noicf, I got

00007FF622A01100
00007FF622A01170
00007FF622A01360
00007FF622A01370

By default, I got

00007FF693521100
00007FF693521170
00007FF693521360
00007FF693521360

This indicates bar<int> and bar<float> are folded but kernel stubs are not folded.

I also tried -Wl,/opt:icf=10, and kernel stubs are still not folded.

For HIP, since the kernel stub passes a unique kernel symbol to the internal kernel launching API, you may think the kernel stubs are not folded because they are not identical.

To imitate the CUDA case, where the address of kernel stub function itself is passed to the internal kernel launching API, I used the original patch of this review, where the kernel stub function passes the address of itself to the internal kernel launching API, therefore in a sense, the kernel stubs are all the same. Still, the kernel stubs are not folded.

Looking at the assembly of the kernel stub function:

; foo<int>
.seh_proc "??$foo@H@@YAXH@Z"
# %bb.0:
        pushq   %rsi
        .seh_pushreg %rsi
        pushq   %rdi
        .seh_pushreg %rdi
        subq    $120, %rsp
        .seh_stackalloc 120
        .seh_endprologue
        movl    %ecx, 60(%rsp)
        leaq    60(%rsp), %rax
        movq    %rax, 64(%rsp)
        leaq    104(%rsp), %rsi
        leaq    88(%rsp), %rdi
        leaq    80(%rsp), %r8
        leaq    72(%rsp), %r9
        movq    %rsi, %rcx
        movq    %rdi, %rdx
        callq   __hipPopCallConfiguration
        movq    80(%rsp), %rax
        movq    72(%rsp), %rcx
        movq    %rcx, 40(%rsp)
        movq    %rax, 32(%rsp)
        leaq    "??$foo@H@@YAXH@Z"(%rip), %rcx
        leaq    64(%rsp), %r9
        movq    %rsi, %rdx
        movq    %rdi, %r8
        callq   hipLaunchKernel
        nop
        addq    $120, %rsp
        popq    %rdi
        popq    %rsi
        retq
        .seh_endproc

; foo<float>
.seh_proc "??$foo@M@@YAXM@Z"
# %bb.0:
        pushq   %rsi
        .seh_pushreg %rsi
        pushq   %rdi
        .seh_pushreg %rdi
        subq    $120, %rsp
        .seh_stackalloc 120
        .seh_endprologue
        movss   %xmm0, 60(%rsp)
        leaq    60(%rsp), %rax
        movq    %rax, 64(%rsp)
        leaq    104(%rsp), %rsi
        leaq    88(%rsp), %rdi
        leaq    80(%rsp), %r8
        leaq    72(%rsp), %r9
        movq    %rsi, %rcx
        movq    %rdi, %rdx
        callq   __hipPopCallConfiguration
        movq    80(%rsp), %rax
        movq    72(%rsp), %rcx
        movq    %rcx, 40(%rsp)
        movq    %rax, 32(%rsp)
        leaq    "??$foo@M@@YAXM@Z"(%rip), %rcx
        leaq    64(%rsp), %r9
        movq    %rsi, %rdx
        movq    %rdi, %r8
        callq   hipLaunchKernel
        nop
        addq    $120, %rsp
        popq    %rdi
        popq    %rsi
        retq
        .seh_endproc

I think they are not folded because link.exe is smart enough to treat them as not identical comdat functions. I think we may stop worrying about the ICF foading kernel stubs.

[rnk]

I think the key is the self-reference in the LEA instruction:

; foo<int>
.seh_proc "??$foo@H@@YAXH@Z"
...
        leaq    "??$foo@H@@YAXH@Z"(%rip), %rcx
...
; foo<float>
.seh_proc "??$foo@M@@YAXM@Z"
...
        leaq    "??$foo@M@@YAXM@Z"(%rip), %rcx

I think they are not folded because link.exe is smart enough to treat them as not identical comdat functions. I think we may stop worrying about the ICF foading kernel stubs.

It sounds like the behavior may have changed since D63277 was landed, and maybe we don't need it anymore.

clang/include/clang/AST/GlobalDecl.h

 #define LLVM_CLANG_AST_GLOBALDECL_H
 
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclOpenMP.h"
 #include "clang/Basic/ABI.h"
 #include "clang/Basic/LLVM.h"
+#include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/type_traits.h"
 #include <cassert>
 
 namespace clang {
 
public:
 
   static GlobalDecl getFromOpaquePtr(void *P) {
     GlobalDecl GD;
     GD.Value.setFromOpaqueValue(P);
     return GD;
   }
 
   static KernelReferenceKind getDefaultKernelReference(const FunctionDecl *D) {
-    return D->getLangOpts().CUDAIsDevice ? KernelReferenceKind::Kernel
-                                         : KernelReferenceKind::Stub;
+    // When Target ABI is MSVC, do not mangle kernel stub differently.
+    return D->getLangOpts().CUDAIsDevice ||
+                   D->getASTContext().getTargetInfo().getCXXABI().isMicrosoft()
+               ? KernelReferenceKind::Kernel
   }
 
   GlobalDecl getWithDecl(const Decl *D) {
     GlobalDecl Result(*this);
     Result.Value.setPointer(D);
     return Result;
   }
 

clang/lib/CodeGen/CGCUDANV.cpp

 }
 
 llvm::GlobalValue *CGNVCUDARuntime::getKernelHandle(llvm::Function *F,
                                                     GlobalDecl GD) {
   auto Loc = KernelHandles.find(F);
   if (Loc != KernelHandles.end())
     return Loc->second;
 
-  if (!CGM.getLangOpts().HIP) {
+  // When HIP host target is MSVC, do not use kernel handle.
+  if (!CGM.getLangOpts().HIP ||
+      CGM.getContext().getTargetInfo().getCXXABI().isMicrosoft()) {
     KernelHandles[F] = F;
     KernelStubs[F] = F;
     return F;
   }
 
   auto *Var = new llvm::GlobalVariable(
       TheModule, F->getType(), /*isConstant=*/true, F->getLinkage(),
       /*Initializer=*/nullptr,

clang/lib/CodeGen/CGExpr.cpp

if (isa<FunctionNoProtoType>(FnType) || Chain) {
     CalleeTy = CalleeTy->getPointerTo(AS);
 
     llvm::Value *CalleePtr = Callee.getFunctionPointer();
     CalleePtr = Builder.CreateBitCast(CalleePtr, CalleeTy, "callee.knr.cast");
     Callee.setFunctionPointer(CalleePtr);
   }
 
   // HIP function pointer contains kernel handle when it is used in triple
-  // chevron. The kernel stub needs to be loaded from kernel handle and used
-  // as callee.
+  // chevron for non-MSVC target. The kernel stub needs to be loaded from
+  // kernel handle and used as callee.
   if (CGM.getLangOpts().HIP && !CGM.getLangOpts().CUDAIsDevice &&
       isa<CUDAKernelCallExpr>(E) &&
+      !CGM.getContext().getTargetInfo().getCXXABI().isMicrosoft() &&
       (!TargetDecl || !isa<FunctionDecl>(TargetDecl))) {
     llvm::Value *Handle = Callee.getFunctionPointer();
     auto *Cast =
         Builder.CreateBitCast(Handle, Handle->getType()->getPointerTo());
     auto *Stub = Builder.CreateLoad(Address(Cast, CGM.getPointerAlign()));
     Callee.setFunctionPointer(Stub);
   }
   llvm::CallBase *CallOrInvoke = nullptr;

clang/test/CodeGenCUDA/kernel-stub-name.cu

 // RUN: echo "GPU binary would be here" > %t
 
 // RUN: %clang_cc1 -triple x86_64-linux-gnu -emit-llvm %s \
 // RUN:     -fcuda-include-gpubinary %t -o - -x hip\
-// RUN:   | FileCheck %s
+// RUN:   | FileCheck -check-prefixes=CHECK,GNU %s
+
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -emit-llvm %s \
+// RUN:     -fcuda-include-gpubinary %t -o - -x hip\
+// RUN:   | FileCheck -check-prefix=GNUNEG %s
+
+// RUN: %clang_cc1 -triple x86_64-pc-windows-msvc -emit-llvm %s \
+// RUN:     -aux-triple amdgcn-amd-amdhsa -fcuda-include-gpubinary \
+// RUN:     %t -o - -x hip\
+// RUN:   | FileCheck -check-prefixes=CHECK,MSVC %s
+
+// RUN: %clang_cc1 -triple x86_64-pc-windows-msvc -emit-llvm %s \
+// RUN:     -aux-triple amdgcn-amd-amdhsa -fcuda-include-gpubinary \
+// RUN:     %t -o - -x hip\
+// RUN:   | FileCheck -check-prefix=MSVCNEG %s
 
 #include "Inputs/cuda.h"
 
-// Kernel handles
+// Check kernel handles are emitted for non-MSVC target but not for MSVC target.
 
-// CHECK: @[[HCKERN:ckernel]] = constant void ()* @__device_stub__ckernel, align 8
-// CHECK: @[[HNSKERN:_ZN2ns8nskernelEv]] = constant void ()* @_ZN2ns23__device_stub__nskernelEv, align 8
-// CHECK: @[[HTKERN:_Z10kernelfuncIiEvv]] = linkonce_odr constant void ()* @_Z25__device_stub__kernelfuncIiEvv, align 8
-// CHECK: @[[HDKERN:_Z11kernel_declv]] = external constant void ()*, align 8
+// GNU: @[[HCKERN:ckernel]] = constant void ()* @[[CSTUB:__device_stub__ckernel]], align 8
+// GNU: @[[HNSKERN:_ZN2ns8nskernelEv]] = constant void ()* @[[NSSTUB:_ZN2ns23__device_stub__nskernelEv]], align 8
+// GNU: @[[HTKERN:_Z10kernelfuncIiEvv]] = linkonce_odr constant void ()* @[[TSTUB:_Z25__device_stub__kernelfuncIiEvv]], align 8
+// GNU: @[[HDKERN:_Z11kernel_declv]] = external constant void ()*, align 8
+
+// MSVCNEG-NOT: @ckernel =
+// MSVCNEG-NOT: @{{"\?nskernel@ns@@YAXXZ.*"}} =
+// MSVCNEG-NOT: @{{"\?\?\$kernelfunc@H@@YAXXZ.*"}} =
+// MSVCNEG-NOT: @{{"\?kernel_decl@@YAXXZ.*"}} =
 
 extern "C" __global__ void ckernel() {}
 
 namespace ns {
 __global__ void nskernel() {}
 } // namespace ns
 
 template<class T>
 __global__ void kernelfunc() {}
 
 __global__ void kernel_decl();
 
-void (*kernel_ptr)();
-void *void_ptr;
+extern "C" void (*kernel_ptr)();
+extern "C" void *void_ptr;
 
-void launch(void *kern);
+extern "C" void launch(void *kern);
 
 // Device side kernel names
 
 // CHECK: @[[CKERN:[0-9]*]] = {{.*}} c"ckernel\00"
 // CHECK: @[[NSKERN:[0-9]*]] = {{.*}} c"_ZN2ns8nskernelEv\00"
 // CHECK: @[[TKERN:[0-9]*]] = {{.*}} c"_Z10kernelfuncIiEvv\00"
 
 // Non-template kernel stub functions
 
-// CHECK: define{{.*}}@[[CSTUB:__device_stub__ckernel]]
-// CHECK: call{{.*}}@hipLaunchByPtr{{.*}}@[[HCKERN]]
-// CHECK: define{{.*}}@[[NSSTUB:_ZN2ns23__device_stub__nskernelEv]]
-// CHECK: call{{.*}}@hipLaunchByPtr{{.*}}@[[HNSKERN]]
+// GNU: define{{.*}}@[[CSTUB]]
+// GNU: call{{.*}}@hipLaunchByPtr{{.*}}@[[HCKERN]]
+// MSVC: define{{.*}}@[[CSTUB:ckernel]]
+// MSVC: call{{.*}}@hipLaunchByPtr{{.*}}@[[CSTUB]]
+
+// GNU: define{{.*}}@[[NSSTUB]]
+// GNU: call{{.*}}@hipLaunchByPtr{{.*}}@[[HNSKERN]]
+// MSVC: define{{.*}}@[[NSSTUB:"\?nskernel@ns@@YAXXZ"]]
+// MSVC: call{{.*}}@hipLaunchByPtr{{.*}}@[[NSSTUB]]
 
+// Check kernel stub is called for triple chevron.
 
-// Check kernel stub is used for triple chevron
-
-// CHECK-LABEL: define{{.*}}@_Z4fun1v()
+// CHECK-LABEL: define{{.*}}@fun1()
 // CHECK: call void @[[CSTUB]]()
 // CHECK: call void @[[NSSTUB]]()
-// CHECK: call void @[[TSTUB:_Z25__device_stub__kernelfuncIiEvv]]()
-// CHECK: call void @[[DSTUB:_Z26__device_stub__kernel_declv]]()
+// GNU: call void @[[TSTUB]]()
+// GNU: call void @[[DSTUB:_Z26__device_stub__kernel_declv]]()
+// MSVC: call void @[[TSTUB:"\?\?\$kernelfunc@H@@YAXXZ"]]()
+// MSVC: call void @[[DSTUB:"\?kernel_decl@@YAXXZ"]]()
 
-void fun1(void) {
+extern "C" void fun1(void) {
   ckernel<<<1, 1>>>();
   ns::nskernel<<<1, 1>>>();
   kernelfunc<int><<<1, 1>>>();
   kernel_decl<<<1, 1>>>();
 }
 
 // Template kernel stub functions
 
 // CHECK: define{{.*}}@[[TSTUB]]
-// CHECK: call{{.*}}@hipLaunchByPtr{{.*}}@[[HTKERN]]
+// GNU: call{{.*}}@hipLaunchByPtr{{.*}}@[[HTKERN]]
+// MSVC: call{{.*}}@hipLaunchByPtr{{.*}}@[[TSTUB]]
 
 // Check declaration of stub function for external kernel.
 
 // CHECK: declare{{.*}}@[[DSTUB]]
 
 // Check kernel handle is used for passing the kernel as a function pointer
+// for non-MSVC target but kernel stub is used for MSVC target.
 
-// CHECK-LABEL: define{{.*}}@_Z4fun2v()
-// CHECK: call void @_Z6launchPv({{.*}}[[HCKERN]]
-// CHECK: call void @_Z6launchPv({{.*}}[[HNSKERN]]
-// CHECK: call void @_Z6launchPv({{.*}}[[HTKERN]]
-// CHECK: call void @_Z6launchPv({{.*}}[[HDKERN]]
-void fun2() {
+// CHECK-LABEL: define{{.*}}@fun2()
+// GNU: call void @launch({{.*}}[[HCKERN]]
+// GNU: call void @launch({{.*}}[[HNSKERN]]
+// GNU: call void @launch({{.*}}[[HTKERN]]
+// GNU: call void @launch({{.*}}[[HDKERN]]
+// MSVC: call void @launch({{.*}}[[CSTUB]]
+// MSVC: call void @launch({{.*}}[[NSSTUB]]
+// MSVC: call void @launch({{.*}}[[TSTUB]]
+// MSVC: call void @launch({{.*}}[[DSTUB]]
+extern "C" void fun2() {
   launch((void *)ckernel);
   launch((void *)ns::nskernel);
   launch((void *)kernelfunc<int>);
   launch((void *)kernel_decl);
 }
 
-// Check kernel handle is used for assigning a kernel to a function pointer
+// Check kernel handle is used for assigning a kernel to a function pointer for
+// non-MSVC target but kernel stub is used for MSVC target.
 
-// CHECK-LABEL: define{{.*}}@_Z4fun3v()
-// CHECK:  store void ()* bitcast (void ()** @[[HCKERN]] to void ()*), void ()** @kernel_ptr, align 8
-// CHECK:  store void ()* bitcast (void ()** @[[HCKERN]] to void ()*), void ()** @kernel_ptr, align 8
-// CHECK:  store i8* bitcast (void ()** @[[HCKERN]] to i8*), i8** @void_ptr, align 8
-// CHECK:  store i8* bitcast (void ()** @[[HCKERN]] to i8*), i8** @void_ptr, align 8
-void fun3() {
+// CHECK-LABEL: define{{.*}}@fun3()
+// GNU:  store void ()* bitcast (void ()** @[[HCKERN]] to void ()*), void ()** @kernel_ptr, align 8
+// GNU:  store void ()* bitcast (void ()** @[[HCKERN]] to void ()*), void ()** @kernel_ptr, align 8
+// GNU:  store i8* bitcast (void ()** @[[HCKERN]] to i8*), i8** @void_ptr, align 8
+// GNU:  store i8* bitcast (void ()** @[[HCKERN]] to i8*), i8** @void_ptr, align 8
+// MSVC:  store void ()* @[[CSTUB]], void ()** @kernel_ptr, align 8
+// MSVC:  store void ()* @[[CSTUB]], void ()** @kernel_ptr, align 8
+// MSVC:  store i8* bitcast (void ()* @[[CSTUB]] to i8*), i8** @void_ptr, align 8
+// MSVC:  store i8* bitcast (void ()* @[[CSTUB]] to i8*), i8** @void_ptr, align 8
+extern "C" void fun3() {
   kernel_ptr = ckernel;
   kernel_ptr = &ckernel;
   void_ptr = (void *)ckernel;
   void_ptr = (void *)&ckernel;
 }
 
 // Check kernel stub is loaded from kernel handle when function pointer is
-// used with triple chevron
+// used with triple chevron for non-MSVC target but kernel stub is directly
+// used without extra indirection for MSVC target.
 
-// CHECK-LABEL: define{{.*}}@_Z4fun4v()
-// CHECK:  store void ()* bitcast (void ()** @[[HCKERN]] to void ()*), void ()** @kernel_ptr
-// CHECK:  call i32 @_Z16hipConfigureCall4dim3S_mP9hipStream
-// CHECK:  %[[HANDLE:.*]] = load void ()*, void ()** @kernel_ptr, align 8
-// CHECK:  %[[CAST:.*]] = bitcast void ()* %[[HANDLE]] to void ()**
-// CHECK:  %[[STUB:.*]] = load void ()*, void ()** %[[CAST]], align 8
-// CHECK:  call void %[[STUB]]()
-void fun4() {
+// CHECK-LABEL: define{{.*}}@fun4()
+// GNU:  store void ()* bitcast (void ()** @[[HCKERN]] to void ()*), void ()** @kernel_ptr
+// GNU:  call i32 @{{.*hipConfigureCall}}
+// GNU:  %[[HANDLE:.*]] = load void ()*, void ()** @kernel_ptr, align 8
+// GNU:  %[[CAST:.*]] = bitcast void ()* %[[HANDLE]] to void ()**
+// GNU:  %[[STUB:.*]] = load void ()*, void ()** %[[CAST]], align 8
+// GNU:  call void %[[STUB]]()
+// MSVC:  store void ()* @[[CSTUB]], void ()** @kernel_ptr
+// MSVC:  call i32 @{{.*hipConfigureCall}}
+// MSVC:  %[[STUB:.*]] = load void ()*, void ()** @kernel_ptr, align 8
+// MSVC:  call void %[[STUB]]()
+extern "C" void fun4() {
   kernel_ptr = ckernel;
   kernel_ptr<<<1,1>>>();
 }
 
-// Check kernel handle is passed to a function
+// Check kernel handle is passed to a function for non-MSVC target but
+// kernel stub is passed for MSVC target.
 
-// CHECK-LABEL: define{{.*}}@_Z4fun5v()
-// CHECK:  store void ()* bitcast (void ()** @[[HCKERN]] to void ()*), void ()** @kernel_ptr
+// CHECK-LABEL: define{{.*}}@fun5()
+// GNU:  store void ()* bitcast (void ()** @[[HCKERN]] to void ()*), void ()** @kernel_ptr
+// MSVC:  store void ()* @[[CSTUB]], void ()** @kernel_ptr
 // CHECK:  %[[HANDLE:.*]] = load void ()*, void ()** @kernel_ptr, align 8
 // CHECK:  %[[CAST:.*]] = bitcast void ()* %[[HANDLE]] to i8*
-// CHECK:  call void @_Z6launchPv(i8* %[[CAST]])
-void fun5() {
+// CHECK:  call void @launch(i8* %[[CAST]])
+extern "C" void fun5() {
   kernel_ptr = ckernel;
   launch((void *)kernel_ptr);
 }
 
+// Check kernel handle is registered for non-MSVC target but kernel stub
+// is registered for MSVC target.
+
 // CHECK-LABEL: define{{.*}}@__hip_register_globals
-// CHECK: call{{.*}}@__hipRegisterFunction{{.*}}@[[HCKERN]]{{.*}}@[[CKERN]]
-// CHECK: call{{.*}}@__hipRegisterFunction{{.*}}@[[HNSKERN]]{{.*}}@[[NSKERN]]
-// CHECK: call{{.*}}@__hipRegisterFunction{{.*}}@[[HTKERN]]{{.*}}@[[TKERN]]
-// CHECK-NOT: call{{.*}}@__hipRegisterFunction{{.*}}@[[HDKERN]]{{.*}}@{{[0-9]*}}
+// GNU: call{{.*}}@__hipRegisterFunction{{.*}}@[[HCKERN]]{{.*}}@[[CKERN]]
+// GNU: call{{.*}}@__hipRegisterFunction{{.*}}@[[HNSKERN]]{{.*}}@[[NSKERN]]
+// GNU: call{{.*}}@__hipRegisterFunction{{.*}}@[[HTKERN]]{{.*}}@[[TKERN]]
+// GNUNEG-NOT: call{{.*}}@__hipRegisterFunction{{.*}}@__device_stub__ckernel{{.*}}@{{[0-9]*}}
+// GNUNEG-NOT: call{{.*}}@__hipRegisterFunction{{.*}}@_ZN2ns23__device_stub__nskernelEv{{.*}}@{{[0-9]*}}
+// GNUNEG-NOT: call{{.*}}@__hipRegisterFunction{{.*}}@_Z25__device_stub__kernelfuncIiEvv{{.*}}@{{[0-9]*}}
+// GNUNEG-NOT: call{{.*}}@__hipRegisterFunction{{.*}}@_Z26__device_stub__kernel_declv{{.*}}@{{[0-9]*}}
+// MSVC: call{{.*}}@__hipRegisterFunction{{.*}}@[[CSTUB]]{{.*}}@[[CKERN]]
+// MSVC: call{{.*}}@__hipRegisterFunction{{.*}}@[[NSSTUB]]{{.*}}@[[NSKERN]]
+// MSVC: call{{.*}}@__hipRegisterFunction{{.*}}@[[TSTUB]]{{.*}}@[[TKERN]]
+// MSVCNEG-NOT: call{{.*}}@__hipRegisterFunction{{.*}}@"\?kernel_decl@@YAXXZ"{{.*}}@{{[0-9]*}}