[SimplifyLibCalls] Keep calling convention when simplifying to libcall

[john.brawn]

Summary

Currently when simplifying to a library function for which no declaration exists a new declaration is created which defaults to the C calling convention. This can cause problems if the definition is of a different calling convention, so use the calling convention of the library call that's being replaced.

Fixes PR45524.

[efriedma]

In general, if TargetLibraryInfo says a library function is available, that means it's available with the C calling convention. Copying the calling convention from some other call shouldn't be necessary. In general, there is no call to copy the calling convention from.

I'd recommend taking a closer look at why these markings exist in the first place. My first impression is that clang is doing something wrong: it shouldn't be marking up calls to C library functions with a non-C calling convention.

[john.brawn]

Clang treats C library calls the same as any other function calls when it comes to the calling convention, so they get a non-C calling convention in the same circumstances that other functions do.

Looking at the ARM target in specific, a function gets a non-C calling convention when CodeGenModule::getTargetCodeGenInfo sets a calling convention (based on target triple and CodeGenOpts.FloatABI) that's different to what ARMABIInfo::getLLVMDefaultCC (which is based solely on the target triple) returns. So if you're using -mtriple=arm-none-eabi -mfloat-abi=hard then functions get the arm_aapcs_vfpcc calling convention, and if you're using -mtriple=arm-none-eabihf -mfloat-abi=soft then functions get the arm_aapcscc calling convention.

Looking at the backend it's ARMTargetLowering::getEffectiveCallingConv that determines the effective calling convention for functions with the C calling convention, which it does based on getTargetMachine().Options.FloatABIType which by default is derived from the target triple.

So if we wanted clang to use the C calling convention always for C library calls we would need to either:

• Add special handling to make sure C library calls only get the C calling convention and add some mechanism to signal to the backend what the actual calling convention is.
• Remove the behaviour that the calling-convention is non-C when there's a mismatch between the triple and the float-abi and do something different to make sure we end up with the right calling convention in the end (maybe have -mfloat-abi implicitly modify the triple like -march and -mcpu do).

[efriedma]

Remove the behaviour that the calling-convention is non-C when there's a mismatch between the triple and the float-abi and do something different to make sure we end up with the right calling convention in the end (maybe have -mfloat-abi implicitly modify the triple like -march and -mcpu do).

I would lean towards doing this.

The alternative is that we add module metadata or something like that to specify the "C" calling convention in LLVM IR. And I don't really want to go there if we can avoid it. (I can't think of any reason it would be better than messing with the triple on ARM.)

Note that we do currently have TargetOptions::FloatABIType. But that doesn't really work with LTO.

Add special handling to make sure C library calls only get the C calling convention and add some mechanism to signal to the backend what the actual calling convention is.

Special-casing C library functions seems more complicated for no benefit.

[john.brawn]

D89573 is a fix for this by adjusting the triple. I'll abandon this if that gets accepted.

[john.brawn]

Abandoning as I've committed D89573.

llvm/include/llvm/Transforms/Utils/SimplifyLibCalls.h

private:
   Value *optimizeFFS(CallInst *CI, IRBuilderBase &B);
   Value *optimizeFls(CallInst *CI, IRBuilderBase &B);
   Value *optimizeAbs(CallInst *CI, IRBuilderBase &B);
   Value *optimizeIsDigit(CallInst *CI, IRBuilderBase &B);
   Value *optimizeIsAscii(CallInst *CI, IRBuilderBase &B);
   Value *optimizeToAscii(CallInst *CI, IRBuilderBase &B);
   Value *optimizeAtoi(CallInst *CI, IRBuilderBase &B);
   Value *optimizeStrtol(CallInst *CI, IRBuilderBase &B);
+  // Wrapper for all integer library call optimizations
+  Value *optimizeIntegerLibCall(CallInst *CI, LibFunc Func,
+                                IRBuilderBase &B);
 
   // Formatting and IO Library Call Optimizations
   Value *optimizeErrorReporting(CallInst *CI, IRBuilderBase &B,
                                 int StreamArg = -1);
   Value *optimizePrintF(CallInst *CI, IRBuilderBase &B);
   Value *optimizeSPrintF(CallInst *CI, IRBuilderBase &B);
   Value *optimizeSnPrintF(CallInst *CI, IRBuilderBase &B);
   Value *optimizeFPrintF(CallInst *CI, IRBuilderBase &B);
   Value *optimizeFWrite(CallInst *CI, IRBuilderBase &B);
   Value *optimizeFPuts(CallInst *CI, IRBuilderBase &B);
   Value *optimizePuts(CallInst *CI, IRBuilderBase &B);
+  // Wrapper for all formatting and IO library call optimizations
+  Value *optimizeIOLibCall(CallInst *CI, LibFunc Func,
+                           IRBuilderBase &B);
 
   // Helper methods
   Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len,
                           IRBuilderBase &B);
   void classifyArgUse(Value *Val, Function *F, bool IsFloat,
                       SmallVectorImpl<CallInst *> &SinCalls,
                       SmallVectorImpl<CallInst *> &CosCalls,
                       SmallVectorImpl<CallInst *> &SinCosCalls);

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

Value *LibCallSimplifier::optimizeFloatingPointLibCall(CallInst *CI,
   case LibFunc_cabsf:
   case LibFunc_cabsl:
     return optimizeCAbs(CI, Builder);
   default:
     return nullptr;
   }
 }
 
+Value *LibCallSimplifier::optimizeIntegerLibCall(CallInst *CI,
+                                                 LibFunc Func,
+                                                 IRBuilderBase &Builder) {
+  switch (Func) {
+  case LibFunc_ffs:
+  case LibFunc_ffsl:
+  case LibFunc_ffsll:
+    return optimizeFFS(CI, Builder);
+  case LibFunc_fls:
+  case LibFunc_flsl:
+  case LibFunc_flsll:
+    return optimizeFls(CI, Builder);
+  case LibFunc_abs:
+  case LibFunc_labs:
+  case LibFunc_llabs:
+    return optimizeAbs(CI, Builder);
+  case LibFunc_isdigit:
+    return optimizeIsDigit(CI, Builder);
+  case LibFunc_isascii:
+    return optimizeIsAscii(CI, Builder);
+  case LibFunc_toascii:
+    return optimizeToAscii(CI, Builder);
+  case LibFunc_atoi:
+  case LibFunc_atol:
+  case LibFunc_atoll:
+    return optimizeAtoi(CI, Builder);
+  case LibFunc_strtol:
+  case LibFunc_strtoll:
+    return optimizeStrtol(CI, Builder);
+  default:
+    return nullptr;
+  }
+}
+
+Value *LibCallSimplifier::optimizeIOLibCall(CallInst *CI,
+                                            LibFunc Func,
+                                            IRBuilderBase &Builder) {
+  switch (Func) {
+  case LibFunc_printf:
+    return optimizePrintF(CI, Builder);
+  case LibFunc_sprintf:
+    return optimizeSPrintF(CI, Builder);
+  case LibFunc_snprintf:
+    return optimizeSnPrintF(CI, Builder);
+  case LibFunc_fprintf:
+    return optimizeFPrintF(CI, Builder);
+  case LibFunc_fwrite:
+    return optimizeFWrite(CI, Builder);
+  case LibFunc_fputs:
+    return optimizeFPuts(CI, Builder);
+  case LibFunc_puts:
+    return optimizePuts(CI, Builder);
+  case LibFunc_perror:
+    return optimizeErrorReporting(CI, Builder);
+  case LibFunc_vfprintf:
+  case LibFunc_fiprintf:
+    return optimizeErrorReporting(CI, Builder, 0);
+  default:
+    return nullptr;
+  }
+}
+
+// Copy the calling convention from CI to NewVal if it's a function call.
+// Used when replacing one function call with another.
+static void copyCallingConv(Value *NewVal, CallInst *CI) {
+  if (!NewVal)
+    return;
+  if (CallInst *NewCI = dyn_cast<CallInst>(NewVal)) {
+    if (Function *F = NewCI->getCalledFunction()) {
+      F->setCallingConv(CI->getCallingConv());
+      NewCI->setCallingConv(CI->getCallingConv());
+    }
+  }
+}
+
 Value *LibCallSimplifier::optimizeCall(CallInst *CI, IRBuilderBase &Builder) {
   // TODO: Split out the code below that operates on FP calls so that
   //       we can all non-FP calls with the StrictFP attribute to be
   //       optimized.
   if (CI->isNoBuiltin())
     return nullptr;
 
   LibFunc Func;
else if (isa<FPMathOperator>(CI) && CI->isFast())
     UnsafeFPShrink = true;
 
   // First, check for intrinsics.
   if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI)) {
     if (!isCallingConvC)
       return nullptr;
     // The FP intrinsics have corresponding constrained versions so we don't
     // need to check for the StrictFP attribute here.
+    Value *NewVal = nullptr;
     switch (II->getIntrinsicID()) {
     case Intrinsic::pow:
-      return optimizePow(CI, Builder);
+      NewVal = optimizePow(CI, Builder);
+      break;
     case Intrinsic::exp2:
-      return optimizeExp2(CI, Builder);
+      NewVal = optimizeExp2(CI, Builder);
+      break;
     case Intrinsic::log:
     case Intrinsic::log2:
     case Intrinsic::log10:
-      return optimizeLog(CI, Builder);
+      NewVal = optimizeLog(CI, Builder);
+      break;
     case Intrinsic::sqrt:
-      return optimizeSqrt(CI, Builder);
+      NewVal = optimizeSqrt(CI, Builder);
+      break;
     // TODO: Use foldMallocMemset() with memset intrinsic.
     case Intrinsic::memset:
-      return optimizeMemSet(CI, Builder);
+      NewVal = optimizeMemSet(CI, Builder);
+      break;
     case Intrinsic::memcpy:
-      return optimizeMemCpy(CI, Builder);
+      NewVal = optimizeMemCpy(CI, Builder);
+      break;
     case Intrinsic::memmove:
-      return optimizeMemMove(CI, Builder);
+      NewVal = optimizeMemMove(CI, Builder);
+      break;
     default:
       return nullptr;
     }
+    copyCallingConv(NewVal, CI);
+    return NewVal;
   }
 
   // Also try to simplify calls to fortified library functions.
   if (Value *SimplifiedFortifiedCI =
           FortifiedSimplifier.optimizeCall(CI, Builder)) {
     // Try to further simplify the result.
     CallInst *SimplifiedCI = dyn_cast<CallInst>(SimplifiedFortifiedCI);
     if (SimplifiedCI && SimplifiedCI->getCalledFunction()) {
       // Ensure that SimplifiedCI's uses are complete, since some calls have
       // their uses analyzed.
       replaceAllUsesWith(CI, SimplifiedCI);
 
       // Set insertion point to SimplifiedCI to guarantee we reach all uses
       // we might replace later on.
       IRBuilderBase::InsertPointGuard Guard(Builder);
       Builder.SetInsertPoint(SimplifiedCI);
       if (Value *V = optimizeStringMemoryLibCall(SimplifiedCI, Builder)) {
         // If we were able to further simplify, remove the now redundant call.
+        copyCallingConv(V, SimplifiedCI);
         substituteInParent(SimplifiedCI, V);
         return V;
       }
     }
     return SimplifiedFortifiedCI;
   }
 
   // Then check for known library functions.
   if (TLI->getLibFunc(*Callee, Func) && TLI->has(Func)) {
     // We never change the calling convention.
     if (!ignoreCallingConv(Func) && !isCallingConvC)
       return nullptr;
-    if (Value *V = optimizeStringMemoryLibCall(CI, Builder))
-      return V;
-    if (Value *V = optimizeFloatingPointLibCall(CI, Func, Builder))
-      return V;
-    switch (Func) {
-    case LibFunc_ffs:
-    case LibFunc_ffsl:
-    case LibFunc_ffsll:
-      return optimizeFFS(CI, Builder);
-    case LibFunc_fls:
-    case LibFunc_flsl:
-    case LibFunc_flsll:
-      return optimizeFls(CI, Builder);
-    case LibFunc_abs:
-    case LibFunc_labs:
-    case LibFunc_llabs:
-      return optimizeAbs(CI, Builder);
-    case LibFunc_isdigit:
-      return optimizeIsDigit(CI, Builder);
-    case LibFunc_isascii:
-      return optimizeIsAscii(CI, Builder);
-    case LibFunc_toascii:
-      return optimizeToAscii(CI, Builder);
-    case LibFunc_atoi:
-    case LibFunc_atol:
-    case LibFunc_atoll:
-      return optimizeAtoi(CI, Builder);
-    case LibFunc_strtol:
-    case LibFunc_strtoll:
-      return optimizeStrtol(CI, Builder);
-    case LibFunc_printf:
-      return optimizePrintF(CI, Builder);
-    case LibFunc_sprintf:
-      return optimizeSPrintF(CI, Builder);
-    case LibFunc_snprintf:
-      return optimizeSnPrintF(CI, Builder);
-    case LibFunc_fprintf:
-      return optimizeFPrintF(CI, Builder);
-    case LibFunc_fwrite:
-      return optimizeFWrite(CI, Builder);
-    case LibFunc_fputs:
-      return optimizeFPuts(CI, Builder);
-    case LibFunc_puts:
-      return optimizePuts(CI, Builder);
-    case LibFunc_perror:
-      return optimizeErrorReporting(CI, Builder);
-    case LibFunc_vfprintf:
-    case LibFunc_fiprintf:
-      return optimizeErrorReporting(CI, Builder, 0);
-    default:
-      return nullptr;
+    Value *NewVal = nullptr;
+    if ((NewVal = optimizeStringMemoryLibCall(CI, Builder)) ||
+        (NewVal = optimizeFloatingPointLibCall(CI, Func, Builder)) ||
+        (NewVal = optimizeIntegerLibCall(CI, Func, Builder)) ||
+        (NewVal = optimizeIOLibCall(CI, Func, Builder))) {
+      copyCallingConv(NewVal, CI);
+      return NewVal;
     }
   }
   return nullptr;
 }
 
 LibCallSimplifier::LibCallSimplifier(
     const DataLayout &DL, const TargetLibraryInfo *TLI,
     OptimizationRemarkEmitter &ORE,
Value *FortifiedLibCallSimplifier::optimizeCall(CallInst *CI,
   // is correct.
   if (!TLI->getLibFunc(*Callee, Func))
     return nullptr;
 
   // We never change the calling convention.
   if (!ignoreCallingConv(Func) && !isCallingConvC)
     return nullptr;
 
+  Value *NewVal = nullptr;
   switch (Func) {
   case LibFunc_memcpy_chk:
-    return optimizeMemCpyChk(CI, Builder);
+    NewVal = optimizeMemCpyChk(CI, Builder);
+    break;
   case LibFunc_mempcpy_chk:
-    return optimizeMemPCpyChk(CI, Builder);
+    NewVal = optimizeMemPCpyChk(CI, Builder);
+    break;
   case LibFunc_memmove_chk:
-    return optimizeMemMoveChk(CI, Builder);
+    NewVal = optimizeMemMoveChk(CI, Builder);
+    break;
   case LibFunc_memset_chk:
-    return optimizeMemSetChk(CI, Builder);
+    NewVal = optimizeMemSetChk(CI, Builder);
+    break;
   case LibFunc_stpcpy_chk:
   case LibFunc_strcpy_chk:
-    return optimizeStrpCpyChk(CI, Builder, Func);
+    NewVal = optimizeStrpCpyChk(CI, Builder, Func);
+    break;
   case LibFunc_strlen_chk:
-    return optimizeStrLenChk(CI, Builder);
+    NewVal = optimizeStrLenChk(CI, Builder);
+    break;
   case LibFunc_stpncpy_chk:
   case LibFunc_strncpy_chk:
-    return optimizeStrpNCpyChk(CI, Builder, Func);
+    NewVal = optimizeStrpNCpyChk(CI, Builder, Func);
+    break;
   case LibFunc_memccpy_chk:
-    return optimizeMemCCpyChk(CI, Builder);
+    NewVal = optimizeMemCCpyChk(CI, Builder);
+    break;
   case LibFunc_snprintf_chk:
-    return optimizeSNPrintfChk(CI, Builder);
+    NewVal = optimizeSNPrintfChk(CI, Builder);
+    break;
   case LibFunc_sprintf_chk:
-    return optimizeSPrintfChk(CI, Builder);
+    NewVal = optimizeSPrintfChk(CI, Builder);
+    break;
   case LibFunc_strcat_chk:
-    return optimizeStrCatChk(CI, Builder);
+    NewVal = optimizeStrCatChk(CI, Builder);
+    break;
   case LibFunc_strlcat_chk:
-    return optimizeStrLCat(CI, Builder);
+    NewVal = optimizeStrLCat(CI, Builder);
+    break;
   case LibFunc_strncat_chk:
-    return optimizeStrNCatChk(CI, Builder);
+    NewVal = optimizeStrNCatChk(CI, Builder);
+    break;
   case LibFunc_strlcpy_chk:
-    return optimizeStrLCpyChk(CI, Builder);
+    NewVal = optimizeStrLCpyChk(CI, Builder);
+    break;
   case LibFunc_vsnprintf_chk:
-    return optimizeVSNPrintfChk(CI, Builder);
+    NewVal = optimizeVSNPrintfChk(CI, Builder);
+    break;
   case LibFunc_vsprintf_chk:
-    return optimizeVSPrintfChk(CI, Builder);
+    NewVal = optimizeVSPrintfChk(CI, Builder);
+    break;
   default:
     break;
   }
-  return nullptr;
+  copyCallingConv(NewVal, CI);
+  return NewVal;
 }
 
 FortifiedLibCallSimplifier::FortifiedLibCallSimplifier(
     const TargetLibraryInfo *TLI, bool OnlyLowerUnknownSize)
     : TLI(TLI), OnlyLowerUnknownSize(OnlyLowerUnknownSize) {}

llvm/test/Transforms/InstCombine/ARM/strcmp.ll

;
   ret i32 %temp1
 }
 
 ; strcmp(x, y)   -> memcmp(x, y, <known length>)
 ; (This transform is rather difficult to trigger in a useful manner)
 define arm_aapcscc i32 @test5(i1 %b) {
 ; CHECK-LABEL: @test5(
 ; CHECK-NEXT:    [[STR2:%.*]] = select i1 [[B:%.*]], i8* getelementptr inbounds ([5 x i8], [5 x i8]* @hell, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @bell, i32 0, i32 0)
-; CHECK-NEXT:    [[MEMCMP:%.*]] = call i32 @memcmp(i8* nonnull dereferenceable(5) getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i8* nonnull dereferenceable(5) [[STR2]], i32 5)
+; CHECK-NEXT:    [[MEMCMP:%.*]] = call arm_aapcscc i32 @memcmp(i8* nonnull dereferenceable(5) getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i8* nonnull dereferenceable(5) [[STR2]], i32 5)
 ; CHECK-NEXT:    ret i32 [[MEMCMP]]
 ;
 
   %str1 = getelementptr inbounds [6 x i8], [6 x i8]* @hello, i32 0, i32 0
   %temp1 = getelementptr inbounds [5 x i8], [5 x i8]* @hell, i32 0, i32 0
   %temp2 = getelementptr inbounds [5 x i8], [5 x i8]* @bell, i32 0, i32 0
   %str2 = select i1 %b, i8* %temp1, i8* %temp2
   %temp3 = call arm_aapcscc i32 @strcmp(i8* %str1, i8* %str2)
;
   ret i32 %temp1
 }
 
 ; strcmp(x, y)   -> memcmp(x, y, <known length>)
 ; (This transform is rather difficult to trigger in a useful manner)
 define arm_aapcs_vfpcc i32 @test5_vfp(i1 %b) {
 ; CHECK-LABEL: @test5_vfp(
 ; CHECK-NEXT:    [[STR2:%.*]] = select i1 [[B:%.*]], i8* getelementptr inbounds ([5 x i8], [5 x i8]* @hell, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @bell, i32 0, i32 0)
-; CHECK-NEXT:    [[MEMCMP:%.*]] = call i32 @memcmp(i8* nonnull dereferenceable(5) getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i8* nonnull dereferenceable(5) [[STR2]], i32 5)
+; CHECK-NEXT:    [[MEMCMP:%.*]] = call arm_aapcs_vfpcc i32 @memcmp(i8* nonnull dereferenceable(5) getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i8* nonnull dereferenceable(5) [[STR2]], i32 5)
 ; CHECK-NEXT:    ret i32 [[MEMCMP]]
 ;
 
   %str1 = getelementptr inbounds [6 x i8], [6 x i8]* @hello, i32 0, i32 0
   %temp1 = getelementptr inbounds [5 x i8], [5 x i8]* @hell, i32 0, i32 0
   %temp2 = getelementptr inbounds [5 x i8], [5 x i8]* @bell, i32 0, i32 0
   %str2 = select i1 %b, i8* %temp1, i8* %temp2
   %temp3 = call arm_aapcs_vfpcc i32 @strcmp(i8* %str1, i8* %str2)

llvm/test/Transforms/InstCombine/call-callconv.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 ; Verify that the non-default calling conv doesn't prevent the libcall simplification
 
+target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
+
 @.str = private unnamed_addr constant [4 x i8] c"abc\00", align 1
 
 define arm_aapcscc i32 @_abs(i32 %i) nounwind readnone {
 ; CHECK-LABEL: @_abs(
 ; CHECK-NEXT:    [[TMP1:%.*]] = icmp slt i32 [[I:%.*]], 0
 ; CHECK-NEXT:    [[NEG:%.*]] = sub nsw i32 0, [[I]]
 ; CHECK-NEXT:    [[TMP2:%.*]] = select i1 [[TMP1]], i32 [[NEG]], i32 [[I]]
 ; CHECK-NEXT:    ret i32 [[TMP2]]

 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i8 [[STRLENFIRST]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %call = tail call arm_aapcscc i32 @strlen(i8* %str)
   %cmp = icmp ne i32 %call, 0
   ret i1 %cmp
 }
 
+%struct.FILE = type opaque
+declare arm_aapcscc i32 @fprintf(%struct.FILE*, i8*, ...)
+
+define arm_aapcscc void @_fprintf(%struct.FILE* %file) {
+; CHECK-LABEL: @_fprintf(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = call arm_aapcscc i32 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 3, i32 1, %struct.FILE* [[FILE:%.*]])
+; CHECK-NEXT:    ret void
+;
+entry:
+  %call = tail call arm_aapcscc i32 (%struct.FILE*, i8*, ...) @fprintf(%struct.FILE* %file, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0))
+  ret void
+}
+
+declare arm_aapcscc i32 @printf(i8*, ...)
+@.str2 = private unnamed_addr constant [2 x i8] c"a\00", align 1
+
+define arm_aapcscc void @_printf(%struct.FILE* %file) {
+; CHECK-LABEL: @_printf(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[PUTCHAR:%.*]] = call arm_aapcscc i32 @putchar(i32 97)
+; CHECK-NEXT:    ret void
+;
+entry:
+  %call = tail call arm_aapcscc i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str2, i32 0, i32 0))
+  ret void
+}
+
+@a = common global [60 x i8] zeroinitializer, align 1
+@b = common global [60 x i8] zeroinitializer, align 1
+declare arm_aapcscc i8* @__strcpy_chk(i8*, i8*, i32)
+
+define arm_aapcscc i8* @_strcpy_chk() {
+; CHECK-LABEL: @_strcpy_chk(
+; CHECK-NEXT:    [[STRCPY:%.*]] = call arm_aapcscc i8* @strcpy(i8* nonnull dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* nonnull dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @b, i32 0, i32 0))
+; CHECK-NEXT:    ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0)
+;
+  %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
+  %src = getelementptr inbounds [60 x i8], [60 x i8]* @b, i32 0, i32 0
+
+  %ret = call arm_aapcscc i8* @__strcpy_chk(i8* %dst, i8* %src, i32 -1)
+  ret i8* %ret
+}