[ARM64EC 14/?] Set comdat for thunks and enable wowthk section to help reduce thunk numbers

[bcl5980]

Summary

Part of initial Arm64EC patchset.

Canonicalize type to generate thunks, then we can reuse the same name thunks generated before.
Emit thunks to .wowthk section with comdat to make the linker remove the same thunks in different obj files.

[bcl5980]

Set the thunks to external linkage.

[bcl5980]

early return if mangled name is the thunk

[bcl5980]

If struct type only have one element canonicalize it to the element type

[efriedma]

llvm/lib/Target/AArch64/AArch64Arm64ECCallLowering.cpp

245

What does "canonicalizing" like this accomplish?

llvm/lib/Target/AArch64/AArch64TargetObjectFile.cpp

89 ↗

(On Diff #458127)

You shouldn't need to hack at the backend like this. Just set the section name explicitly in IR, and make the linkage linkonce_odr. That should put it in the right section with the right attributes.

[bcl5980]

llvm/lib/Target/AArch64/AArch64Arm64ECCallLowering.cpp

245

For example int f(int) share the same thunk to char f(char).
If we want to eliminate duplicate thunks we need to map all original pow2 interger types less than 64bit to 64bit.
The goal for this function is following msvc's arm64ec thunk naming rule. Generate the thunk type from original function type.

[efriedma]

llvm/lib/Target/AArch64/AArch64Arm64ECCallLowering.cpp

245

Oh, okay, that makes sense.

[bcl5980]

Address comments.

llvm/lib/Target/AArch64/AArch64Arm64ECCallLowering.cpp

 private:
   int cfguard_module_flag = 0;
   FunctionType *GuardFnType = nullptr;
   PointerType *GuardFnPtrType = nullptr;
   Constant *GuardFnCFGlobal = nullptr;
   Constant *GuardFnGlobal = nullptr;
   Module *M = nullptr;
 
+  Type *CanonicalizeThunkType(Type *T);
   void mangleArm64ECThunk(FunctionType *FT, AttributeList AttrList, bool entry,
                           raw_ostream &Out);
   void mangleArm64ECThunkRetType(FunctionType *FT, AttributeList AttrList,
                                  bool EntryThunk, raw_ostream &Out);
   void mangleArm64ECThunkArgs(FunctionType *FT, AttributeList AttrList,
                               bool EntryThunk, raw_ostream &Out);
   void mangleArm64ECThunkType(Type *T, Align Alignment, bool EntryThunk,
                               bool Ret, uint64_t ArgSizeBytes,
void AArch64Arm64ECCallLowering::mangleArm64ECThunkArgs(FunctionType *FT,
 
   unsigned I = 0;
   if (AttrList.getParamAttr(I, Attribute::StructRet).isValid())
     I++;
 
   for (unsigned E = FT->getNumParams(); I != E; ++I) {
     Align ParamAlign = AttrList.getParamAlignment(I).valueOrOne();
     uint64_t ArgSizeBytes = AttrList.getParamArm64ECArgSizeBytes(I);
-    mangleArm64ECThunkType(FT->getParamType(I), ParamAlign, EntryThunk,
+    Type *ParamType = CanonicalizeThunkType(FT->getParamType(I));
+    mangleArm64ECThunkType(ParamType, ParamAlign, EntryThunk,
                            /*Ret*/ false, ArgSizeBytes, Out);
   }
 }
 
 void AArch64Arm64ECCallLowering::mangleArm64ECThunkRetType(
     FunctionType *FT, AttributeList AttrList, bool EntryThunk,
     raw_ostream &Out) {
-  Type *T = FT->getReturnType();
+  Type *T = CanonicalizeThunkType(FT->getReturnType());
   uint64_t ArgSizeBytes = AttrList.getRetArm64ECArgSizeBytes();
   if (T->isVoidTy()) {
     if (FT->getNumParams()) {
       auto Attr = AttrList.getParamAttr(0, Attribute::StructRet);
       if (Attr.isValid()) {
         Type *SRetType = Attr.getValueAsType();
         Align SRetAlign = AttrList.getParamAlignment(0).valueOrOne();
         mangleArm64ECThunkType(SRetType, SRetAlign, EntryThunk, /*Ret*/ true,
if (!Ret && !EntryThunk && ArgSizeBytes > 16) {
       if (Alignment.value() >= 8 && !T->isPointerTy())
         Out << "a" << Alignment.value();
     }
   } else {
     Out << "i8";
   }
 }
 
+Type *AArch64Arm64ECCallLowering::CanonicalizeThunkType(Type *T) {
+  if (T->isVoidTy())
+    return T;
+
+  auto &DL = M->getDataLayout();
+  uint64_t Size = DL.getTypeSizeInBits(T);
+  if ((T->isIntegerTy() && Size < 64) || T->isPointerTy())
+    return Type::getInt64Ty(M->getContext());
+
+  if (auto *StructTy = dyn_cast<StructType>(T)) {
+    if (StructTy->getNumElements() == 1)
+      return StructTy->getElementType(0);
+  }
+
+  return T;
+}
+
 Function *AArch64Arm64ECCallLowering::buildExitThunk(CallBase *CB) {
   FunctionType *FT = CB->getFunctionType();
-  Type *RetTy = FT->getReturnType();
+  SmallString<256> ExitThunkName;
+  llvm::raw_svector_ostream Out(ExitThunkName);
+  mangleArm64ECThunk(FT, CB->getAttributes(), /*EntryThunk*/ false, Out);
+  Function *F = M->getFunction(ExitThunkName);
+  if (F)
+    return F;
+
   bool IsVarArg = FT->isVarArg();
   Type *PtrTy = Type::getInt8PtrTy(M->getContext());
   Type *I64Ty = Type::getInt64Ty(M->getContext());
 
   SmallVector<Type *> DefArgTypes;
   // The first argument to a thunk is the called function, stored in x9.
   // (Normally, we won't explicitly refer to this in the assembly; it just
   // gets passed on by the call.)
if (IsVarArg) {
     DefArgTypes.push_back(PtrTy);
     for (int i = 0; i < 3; i++)
       DefArgTypes.push_back(I64Ty);
 
     DefArgTypes.push_back(PtrTy);
     DefArgTypes.push_back(I64Ty);
   } else {
     for (unsigned i = 0; i < CB->arg_size(); ++i) {
-      DefArgTypes.push_back(CB->getArgOperand(i)->getType());
+      Type *ArgType = CB->getArgOperand(i)->getType();
+      if (!CB->getParamAttr(i, Attribute::StructRet).isValid())
+        ArgType = CanonicalizeThunkType(ArgType);
+      DefArgTypes.push_back(ArgType);
     }
   }
 
-  SmallString<256> ExitThunkName;
-  llvm::raw_svector_ostream Out(ExitThunkName);
-  mangleArm64ECThunk(FT, CB->getAttributes(), /*EntryThunk*/ false, Out);
-
+  Type *RetTy = CanonicalizeThunkType(FT->getReturnType());
   FunctionType *Ty = FunctionType::get(RetTy, DefArgTypes, false);
-  Function *F =
-      Function::Create(Ty, GlobalValue::InternalLinkage, 0, ExitThunkName, M);
+
+  F = Function::Create(Ty, GlobalValue::ExternalLinkage, 0, ExitThunkName, M);
   F->setCallingConv(CallingConv::ARM64EC_Thunk_Native);
   // Copy MSVC, and always set up a frame pointer. (Maybe this isn't necessary.)
   F->addFnAttr("frame-pointer", "all");
+  F->setSection(".wowthk$aa");
+  F->setLinkage(GlobalValue::LinkOnceODRLinkage);
+  F->setComdat(M->getOrInsertComdat(ExitThunkName));
   // Only copy sret from the first argument. For C++ instance methods, clang can
   // stick an sret marking on a later argument, but it doesn't actually affect
   // the ABI, so we can omit it. This avoids triggering a verifier assertion.
   if (CB->arg_size() > 0) {
     auto Attr = CB->getParamAttr(0, Attribute::StructRet);
     if (Attr.isValid())
       F->addParamAttr(1, Attr);
   }

llvm/test/CodeGen/AArch64/arm64ec-cfg.ll

 ; CHECK:       .seh_proc fvar3
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    sub sp, sp, #32
 ; CHECK-NEXT:    .seh_stackalloc 32
 ; CHECK-NEXT:    str x30, [sp, #16] // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$varargs.1)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$varargs.1)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$varargs)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$varargs)
 ; CHECK-NEXT:    mov x11, x0
 ; CHECK-NEXT:    ldr x8, [x8, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    mov x4, sp
 ; CHECK-NEXT:    mov w8, #9
 ; CHECK-NEXT:    mov w9, #7
 ; CHECK-NEXT:    mov w0, #4
 ; CHECK-NEXT:    mov w1, #5

 ; CHECK-NEXT:    sub sp, sp, #64
 ; CHECK-NEXT:    .seh_stackalloc 64
 ; CHECK-NEXT:    stp x29, x30, [sp, #48] // 16-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_fplr 48
 ; CHECK-NEXT:    add x29, sp, #48
 ; CHECK-NEXT:    .seh_add_fp 48
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, __os_arm64x_dispatch_call_no_redirect
-; CHECK-NEXT:    str w4, [sp, #32]
+; CHECK-NEXT:    str x4, [sp, #32]
 ; CHECK-NEXT:    ldr x8, [x8, :lo12:__os_arm64x_dispatch_call_no_redirect]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldp x29, x30, [sp, #48] // 16-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_fplr 48
 ; CHECK-NEXT:    add sp, sp, #64
 ; CHECK-NEXT:    .seh_stackalloc 64
 ; CHECK-NEXT:    .seh_endepilogue

 ; CHECK-NEXT:    mov x2, x20
 ; CHECK-NEXT:    mov x3, x19
 ; CHECK-NEXT:    mov x9, x25
 ; CHECK-NEXT:    fmov d0, x0
 ; CHECK-NEXT:    fmov d1, x1
 ; CHECK-NEXT:    fmov d2, x2
 ; CHECK-NEXT:    fmov d3, x3
 ; CHECK-NEXT:    blr x26
-; CHECK-NEXT:    mov w0, w8
+; CHECK-NEXT:    mov x0, x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    sub sp, x29, #48
 ; CHECK-NEXT:    .seh_add_fp 48
 ; CHECK-NEXT:    ldp x29, x30, [sp, #48] // 16-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_fplr 48
 ; CHECK-NEXT:    ldp x25, x26, [sp, #32] // 16-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_regp x25, 32
 ; CHECK-NEXT:    ldp x21, x22, [sp, #16] // 16-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_regp x21, 16
 ; CHECK-NEXT:    ldp x19, x20, [sp], #64 // 16-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_regp_x x19, 64
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:    .seh_endfunclet
 ; CHECK-NEXT:    .seh_endproc
 ;
-; CHECK-LABEL: $iexit_thunk$cdecl$i8$varargs.1:
-; CHECK:       .seh_proc $iexit_thunk$cdecl$i8$varargs.1
-; CHECK-NEXT:  // %bb.0:
-; CHECK-NEXT:    stp x19, x20, [sp, #-64]! // 16-byte Folded Spill
-; CHECK-NEXT:    .seh_save_regp_x x19, 64
-; CHECK-NEXT:    stp x21, x22, [sp, #16] // 16-byte Folded Spill
-; CHECK-NEXT:    .seh_save_regp x21, 16
-; CHECK-NEXT:    str x25, [sp, #32] // 8-byte Folded Spill
-; CHECK-NEXT:    .seh_save_reg x25, 32
-; CHECK-NEXT:    stp x29, x30, [sp, #40] // 16-byte Folded Spill
-; CHECK-NEXT:    .seh_save_fplr 40
-; CHECK-NEXT:    add x29, sp, #40
-; CHECK-NEXT:    .seh_add_fp 40
-; CHECK-NEXT:    sub sp, sp, #16
-; CHECK-NEXT:    .seh_stackalloc 16
-; CHECK-NEXT:    .seh_endprologue
-; CHECK-NEXT:    adrp x8, __os_arm64x_dispatch_call_no_redirect
-; CHECK-NEXT:    mov x19, x2
-; CHECK-NEXT:    mov x20, x1
-; CHECK-NEXT:    mov x21, x0
-; CHECK-NEXT:    mov x22, x9
-; CHECK-NEXT:    ldr x25, [x8, :lo12:__os_arm64x_dispatch_call_no_redirect]
-; CHECK-NEXT:    add x8, x5, #55
-; CHECK-NEXT:    lsr x15, x8, #4
-; CHECK-NEXT:    bl __chkstk_arm64ec
-; CHECK-NEXT:    sub x8, sp, x15, lsl #4
-; CHECK-NEXT:    mov sp, x8
-; CHECK-NEXT:    add x0, x8, #40
-; CHECK-NEXT:    mov x1, x4
-; CHECK-NEXT:    mov x2, x5
-; CHECK-NEXT:    str x3, [x8, #32]
-; CHECK-NEXT:    bl "#memcpy"
-; CHECK-NEXT:    sub x0, x29, #56
-; CHECK-NEXT:    mov x1, x21
-; CHECK-NEXT:    mov x2, x20
-; CHECK-NEXT:    mov x3, x19
-; CHECK-NEXT:    mov x9, x22
-; CHECK-NEXT:    fmov d0, x0
-; CHECK-NEXT:    fmov d1, x1
-; CHECK-NEXT:    fmov d2, x2
-; CHECK-NEXT:    fmov d3, x3
-; CHECK-NEXT:    blr x25
-; CHECK-NEXT:    ldp x0, x1, [x29, #-56]
-; CHECK-NEXT:    .seh_startepilogue
-; CHECK-NEXT:    sub sp, x29, #40
-; CHECK-NEXT:    .seh_add_fp 40
-; CHECK-NEXT:    ldp x29, x30, [sp, #40] // 16-byte Folded Reload
-; CHECK-NEXT:    .seh_save_fplr 40
-; CHECK-NEXT:    ldr x25, [sp, #32] // 8-byte Folded Reload
-; CHECK-NEXT:    .seh_save_reg x25, 32
-; CHECK-NEXT:    ldp x21, x22, [sp, #16] // 16-byte Folded Reload
-; CHECK-NEXT:    .seh_save_regp x21, 16
-; CHECK-NEXT:    ldp x19, x20, [sp], #64 // 16-byte Folded Reload
-; CHECK-NEXT:    .seh_save_regp_x x19, 64
-; CHECK-NEXT:    .seh_endepilogue
-; CHECK-NEXT:    ret
-; CHECK-NEXT:    .seh_endfunclet
-; CHECK-NEXT:    .seh_endproc
-;
 ; CHECK-LABEL: $iexit_thunk$cdecl$m17$varargs:
 ; CHECK:       .seh_proc $iexit_thunk$cdecl$m17$varargs
 ; CHECK-NEXT:  // %bb.0:
 ; CHECK-NEXT:    stp x19, x20, [sp, #-64]! // 16-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_regp_x x19, 64
 ; CHECK-NEXT:    stp x21, x22, [sp, #16] // 16-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_regp x21, 16
 ; CHECK-NEXT:    stp x25, x26, [sp, #32] // 16-byte Folded Spill

llvm/test/CodeGen/AArch64/arm64ec-mangle-align.ll

 ; CHECK-LABEL: callstruct6:
 ; CHECK:       .seh_proc callstruct6
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnstruct6
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m8$m8.1)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m8$m8.1)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m8$m8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m8$m8)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnstruct6]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-LABEL: callstruct7:
 ; CHECK:       .seh_proc callstruct7
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnstruct7
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m8$m8.2)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m8$m8.2)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m8$m8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m8$m8)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnstruct7]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-NEXT:    adrp x9, pfnstruct12
 ; CHECK-NEXT:    adrp x10, __os_arm64x_check_icall
 ; CHECK-NEXT:    ldp q0, q1, [x0]
 ; CHECK-NEXT:    ldp q2, q3, [x0, #32]
 ; CHECK-NEXT:    stp q0, q1, [sp]
 ; CHECK-NEXT:    ldr x11, [x9, :lo12:pfnstruct12]
 ; CHECK-NEXT:    stp q2, q3, [sp, #32]
 ; CHECK-NEXT:    ldr x9, [x10, :lo12:__os_arm64x_check_icall]
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m64a64$i8.3)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m64a64$i8.3)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m64a64$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m64a64$i8)
 ; CHECK-NEXT:    blr x9
 ; CHECK-NEXT:    mov x0, sp
 ; CHECK-NEXT:    blr x11
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    mov sp, x29
 ; CHECK-NEXT:    .seh_set_fp
 ; CHECK-NEXT:    ldp x29, x30, [sp], #16 // 16-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_fplr_x 16

 ; CHECK-LABEL: callstruct14:
 ; CHECK:       .seh_proc callstruct14
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnstruct14
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m16$m16.4)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m16$m16.4)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m16$m16)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m16$m16)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnstruct14]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-LABEL: callstruct15:
 ; CHECK:       .seh_proc callstruct15
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnstruct15
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m16a16$m16a16.5)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m16a16$m16a16.5)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m16a16$m16a16)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m16a16$m16a16)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnstruct15]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-NEXT:    .seh_stackalloc 48
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x9, pfnstruct16
 ; CHECK-NEXT:    adrp x10, __os_arm64x_check_icall
 ; CHECK-NEXT:    ldp q0, q1, [x0]
 ; CHECK-NEXT:    ldr x11, [x9, :lo12:pfnstruct16]
 ; CHECK-NEXT:    stp q0, q1, [sp]
 ; CHECK-NEXT:    ldr x9, [x10, :lo12:__os_arm64x_check_icall]
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m32a32$i8.6)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m32a32$i8.6)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m32a32$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m32a32$i8)
 ; CHECK-NEXT:    blr x9
 ; CHECK-NEXT:    mov x0, sp
 ; CHECK-NEXT:    blr x11
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    mov sp, x29
 ; CHECK-NEXT:    .seh_set_fp
 ; CHECK-NEXT:    ldp x29, x30, [sp], #16 // 16-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_fplr_x 16

 ; CHECK-NEXT:    adrp x9, pfnstruct17
 ; CHECK-NEXT:    adrp x10, __os_arm64x_check_icall
 ; CHECK-NEXT:    ldp q0, q1, [x0]
 ; CHECK-NEXT:    ldp q2, q3, [x0, #32]
 ; CHECK-NEXT:    stp q0, q1, [sp]
 ; CHECK-NEXT:    ldr x11, [x9, :lo12:pfnstruct17]
 ; CHECK-NEXT:    stp q2, q3, [sp, #32]
 ; CHECK-NEXT:    ldr x9, [x10, :lo12:__os_arm64x_check_icall]
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m64a64$i8.7)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m64a64$i8.7)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m64a64$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m64a64$i8)
 ; CHECK-NEXT:    blr x9
 ; CHECK-NEXT:    mov x0, sp
 ; CHECK-NEXT:    blr x11
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    mov sp, x29
 ; CHECK-NEXT:    .seh_set_fp
 ; CHECK-NEXT:    ldp x29, x30, [sp], #16 // 16-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_fplr_x 16

 ; CHECK-LABEL: callstructf2:
 ; CHECK:       .seh_proc callstructf2
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnstructf2
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m8$F8)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m8$F8)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$F8$F8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$F8$F8)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnstructf2]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-NEXT:    adrp x9, pfnstructf3
 ; CHECK-NEXT:    adrp x10, __os_arm64x_check_icall
 ; CHECK-NEXT:    ldp q0, q1, [x0]
 ; CHECK-NEXT:    ldp q2, q3, [x0, #32]
 ; CHECK-NEXT:    stp q0, q1, [sp]
 ; CHECK-NEXT:    ldr x11, [x9, :lo12:pfnstructf3]
 ; CHECK-NEXT:    stp q2, q3, [sp, #32]
 ; CHECK-NEXT:    ldr x9, [x10, :lo12:__os_arm64x_check_icall]
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m64a64$i8.8)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m64a64$i8.8)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m64a64$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m64a64$i8)
 ; CHECK-NEXT:    blr x9
 ; CHECK-NEXT:    mov x0, sp
 ; CHECK-NEXT:    blr x11
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    mov sp, x29
 ; CHECK-NEXT:    .seh_set_fp
 ; CHECK-NEXT:    ldp x29, x30, [sp], #16 // 16-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_fplr_x 16

 ; CHECK-NEXT:    .seh_stackalloc 48
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x9, pfnstructf4
 ; CHECK-NEXT:    adrp x10, __os_arm64x_check_icall
 ; CHECK-NEXT:    ldp q0, q1, [x0]
 ; CHECK-NEXT:    ldr x11, [x9, :lo12:pfnstructf4]
 ; CHECK-NEXT:    stp q0, q1, [sp]
 ; CHECK-NEXT:    ldr x9, [x10, :lo12:__os_arm64x_check_icall]
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m32a32$i8.9)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m32a32$i8.9)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m32a32$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m32a32$i8)
 ; CHECK-NEXT:    blr x9
 ; CHECK-NEXT:    mov x0, sp
 ; CHECK-NEXT:    blr x11
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    mov sp, x29
 ; CHECK-NEXT:    .seh_set_fp
 ; CHECK-NEXT:    ldp x29, x30, [sp], #16 // 16-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_fplr_x 16

 ; CHECK-NEXT:    .seh_stackalloc 48
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x9, pfnstructf5
 ; CHECK-NEXT:    adrp x10, __os_arm64x_check_icall
 ; CHECK-NEXT:    ldp q0, q1, [x0]
 ; CHECK-NEXT:    ldr x11, [x9, :lo12:pfnstructf5]
 ; CHECK-NEXT:    stp q0, q1, [sp]
 ; CHECK-NEXT:    ldr x9, [x10, :lo12:__os_arm64x_check_icall]
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m32a32$i8.10)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m32a32$i8.10)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m32a32$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m32a32$i8)
 ; CHECK-NEXT:    blr x9
 ; CHECK-NEXT:    mov x0, sp
 ; CHECK-NEXT:    blr x11
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    mov sp, x29
 ; CHECK-NEXT:    .seh_set_fp
 ; CHECK-NEXT:    ldp x29, x30, [sp], #16 // 16-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_fplr_x 16

 ; CHECK-NEXT:    adrp x9, pfnstructd2
 ; CHECK-NEXT:    adrp x10, __os_arm64x_check_icall
 ; CHECK-NEXT:    ldp q0, q1, [x0]
 ; CHECK-NEXT:    ldp q2, q3, [x0, #32]
 ; CHECK-NEXT:    stp q0, q1, [sp]
 ; CHECK-NEXT:    ldr x11, [x9, :lo12:pfnstructd2]
 ; CHECK-NEXT:    stp q2, q3, [sp, #32]
 ; CHECK-NEXT:    ldr x9, [x10, :lo12:__os_arm64x_check_icall]
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m64a64$i8.11)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m64a64$i8.11)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m64a64$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m64a64$i8)
 ; CHECK-NEXT:    blr x9
 ; CHECK-NEXT:    mov x0, sp
 ; CHECK-NEXT:    blr x11
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    mov sp, x29
 ; CHECK-NEXT:    .seh_set_fp
 ; CHECK-NEXT:    ldp x29, x30, [sp], #16 // 16-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_fplr_x 16

 ; CHECK-NEXT:    adrp x9, pfnstructd3
 ; CHECK-NEXT:    adrp x10, __os_arm64x_check_icall
 ; CHECK-NEXT:    ldp q0, q1, [x0]
 ; CHECK-NEXT:    ldp q2, q3, [x0, #32]
 ; CHECK-NEXT:    stp q0, q1, [sp]
 ; CHECK-NEXT:    ldr x11, [x9, :lo12:pfnstructd3]
 ; CHECK-NEXT:    stp q2, q3, [sp, #32]
 ; CHECK-NEXT:    ldr x9, [x10, :lo12:__os_arm64x_check_icall]
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m64a64$i8.12)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m64a64$i8.12)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m64a64$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m64a64$i8)
 ; CHECK-NEXT:    blr x9
 ; CHECK-NEXT:    mov x0, sp
 ; CHECK-NEXT:    blr x11
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    mov sp, x29
 ; CHECK-NEXT:    .seh_set_fp
 ; CHECK-NEXT:    ldp x29, x30, [sp], #16 // 16-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_fplr_x 16

llvm/test/CodeGen/AArch64/arm64ec-mangle-basic.ll

 ; CHECK-LABEL: callchar:
 ; CHECK:       .seh_proc callchar
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnchar
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$i8.1)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$i8.1)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$i8)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnchar]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-LABEL: callshort:
 ; CHECK:       .seh_proc callshort
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnshort
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$i8.2)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$i8.2)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$i8)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnshort]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-LABEL: callwchar_t:
 ; CHECK:       .seh_proc callwchar_t
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnwchar_t
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$i8.3)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$i8.3)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$i8)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnwchar_t]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-LABEL: callint:
 ; CHECK:       .seh_proc callint
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnint
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$i8.4)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$i8.4)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$i8)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnint]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-LABEL: calli64:
 ; CHECK:       .seh_proc calli64
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfni64
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$i8.5)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$i8.5)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$i8)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfni64]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-LABEL: calllongdouble:
 ; CHECK:       .seh_proc calllongdouble
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnlongdouble
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$d$d.6)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$d$d.6)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$d$d)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$d$d)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnlongdouble]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-LABEL: callVOIDP:
 ; CHECK:       .seh_proc callVOIDP
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnVOIDP
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$i8.7)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$i8.7)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$i8$i8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$i8$i8)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnVOIDP]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11
 ; CHECK-NEXT:    .seh_endfunclet
 ; CHECK-NEXT:    .seh_endproc
 entry:
   %0 = load ptr, ptr @pfnVOIDP, align 8
   %call = tail call ptr %0(ptr %x)
   ret ptr %call
 }

llvm/test/CodeGen/AArch64/arm64ec-mangle-struct.ll

 ; CHECK-LABEL: callstructf2:
 ; CHECK:       .seh_proc callstructf2
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnstructf2
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m8$F8)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m8$F8)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$F8$F8)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$F8$F8)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnstructf2]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-LABEL: callstructf3:
 ; CHECK:       .seh_proc callstructf3
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnstructf3
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m12$F12)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m12$F12)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$F12$F12)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$F12$F12)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnstructf3]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-LABEL: callstructf4:
 ; CHECK:       .seh_proc callstructf4
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnstructf4
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m16$F16)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m16$F16)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$F16$F16)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$F16$F16)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnstructf4]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-LABEL: callstructd2:
 ; CHECK:       .seh_proc callstructd2
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnstructd2
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m16$D16)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m16$D16)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$D16$D16)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$D16$D16)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnstructd2]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-LABEL: callstructd3:
 ; CHECK:       .seh_proc callstructd3
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnstructd3
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m24$D24)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m24$D24)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$D24$D24)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$D24$D24)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnstructd3]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11

 ; CHECK-LABEL: callstructd4:
 ; CHECK:       .seh_proc callstructd4
 ; CHECK-NEXT:  // %bb.0: // %entry
 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endprologue
 ; CHECK-NEXT:    adrp x8, pfnstructd4
 ; CHECK-NEXT:    adrp x9, __os_arm64x_check_icall
-; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$m32$D32)
-; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$m32$D32)
+; CHECK-NEXT:    adrp x10, ($iexit_thunk$cdecl$D32$D32)
+; CHECK-NEXT:    add x10, x10, :lo12:($iexit_thunk$cdecl$D32$D32)
 ; CHECK-NEXT:    ldr x11, [x8, :lo12:pfnstructd4]
 ; CHECK-NEXT:    ldr x8, [x9, :lo12:__os_arm64x_check_icall]
 ; CHECK-NEXT:    blr x8
 ; CHECK-NEXT:    .seh_startepilogue
 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
 ; CHECK-NEXT:    .seh_save_reg_x x30, 16
 ; CHECK-NEXT:    .seh_endepilogue
 ; CHECK-NEXT:    br x11