Update inline builtin handling to honor gnu inline attribute

[serge-sans-paille]

Summary

Per the GCC info page:

If the function is declared 'extern', then this definition of the
function is used only for inlining.  In no case is the function
compiled as a standalone function, not even if you take its address
explicitly.  Such an address becomes an external reference, as if
you had only declared the function, and had not defined it.

Respect that behavior for inline builtins: keep the original definition, and
generate a copy of the declaration suffixed by '.inline' that's only referenced
in direct call.

[nickdesaulniers]

hmm...this seems to cause a bunch of ICEs building the kernel:

Global is external, but doesn't have external or weak linkage!
i64 (i8*)* @strlen
fatal error: error in backend: Broken module found, compilation aborted!
Global is external, but doesn't have external or weak linkage!
i8* (i8*, i8*, i64)* @strncpy
Global is external, but doesn't have external or weak linkage!
i8* (i8*, i8*)* @strcpy
Global is external, but doesn't have external or weak linkage!
i64 (i8*)* @strlen
Global is external, but doesn't have external or weak linkage!
i64 (i8*, i8*, i64)* @strlcpy
Global is external, but doesn't have external or weak linkage!
i8* (i8*, i32, i64)* @memchr

clang/lib/CodeGen/CGExpr.cpp

4895

s/Replaceable builtin/Replaceable builtins/

4915

When building this patch (with Clang, via cmake vars -DCMAKE_C_COMPILER= and -DCMAKE_CXX_COMPILER=), I observe the following warning:

[99/110] Building CXX object tools/clang/lib/CodeGen/CMakeFiles/obj.clangCodeGen.dir/CGExpr.cpp.o
/android0/llvm-project/clang/lib/CodeGen/CGExpr.cpp:4898:30: warning: object backing the pointer will be destroyed at the end of the full-expression [-Wdangling-gsl]
    StringRef FDInlineName = (FD->getName() + ".inline").str();
                             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

This leads to crashes when using the resulting image built with assertions enabled.

diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp
index afed918c5c7f..cb6469d58b4c 100644
--- a/clang/lib/CodeGen/CGExpr.cpp
+++ b/clang/lib/CodeGen/CGExpr.cpp
@@ -4895,9 +4895,9 @@ static CGCallee EmitDirectCallee(CodeGenFunction &CGF, GlobalDecl GD) {
     // Replaceable builtin provide their own implementation of a builtin. If we
     // are in an inline builtin implementation, avoid trivial infinite
     // recursion.
-    StringRef FDInlineName = (FD->getName() + ".inline").str();
+    Twine FDInlineName = FD->getName() + ".inline";
     if (!FD->isInlineBuiltinDeclaration() ||
-        CGF.CurFn->getName() == FDInlineName) {
+        CGF.CurFn->getName() == FDInlineName.str()) {
       return CGCallee::forBuiltin(builtinID, FD);
     }
     // When directing calling an inline builtin, call it through it's mangled
@@ -4906,7 +4906,7 @@ static CGCallee EmitDirectCallee(CodeGenFunction &CGF, GlobalDecl GD) {
       llvm::Constant *CalleePtr = EmitFunctionDeclPointer(CGF.CGM, GD);
       llvm::Function *Fn = llvm::cast<llvm::Function>(CalleePtr);
       llvm::Module &M = CGF.CGM.getModule();
-      llvm::Function *Clone = M.getFunction(FDInlineName);
+      llvm::Function *Clone = M.getFunction(FDInlineName.str());
       if (!Clone) {
         Clone = llvm::Function::Create(Fn->getFunctionType(), Fn->getLinkage(),
                                        Fn->getAddressSpace(),

4916

I think if you flip the order of the branches by inverting the logic in the conditional, then you could avoid needing braces for the single statement branch. ie.

if (FD->isInlineBuiltinDeclaration() && CGF.CurFn->getName() != FDInlineName) {
  llvm::Constant *CalleePtr = EmitFunctionDeclPointer(CGF.CGM, GD);
  ...
} else
  return CGCallee::forBuiltin(builtinID, FD);

4923

If you have a handle to a Function, you can get a pointer to it's module via Function::getParent().

4928

Can we reuse FDInlineName here for the 4th param?

clang/lib/CodeGen/CodeGenFunction.cpp

1302

could use Fn->getParent() here, too.

1307

Fn->getName() + ".inline" appears twice. Want to save it in a local variable then reuse it, similar to what you do above in clang/lib/CodeGen/CGExpr.cpp?

[nickdesaulniers]

Note: kernel tests need to have CONFIG_FORTIFY_SOURCE=y enabled in the .config to use the fortified routines; this isn't enabled by default in an x86_64 defconfig build.

[nickdesaulniers]

clang/lib/CodeGen/CGExpr.cpp

4926

given the reported ICE, I wonder if we shouldn't be reusing the Fn's linkage, but explicitly setting extern? Same with below.

[nickdesaulniers]

Here's a reduced test case from the kernel. Let's add a unit test for it.

const void *con_unify_unimap_p1;
extern inline __attribute__((__always_inline__)) __attribute__((gnu_inline))
int memcmp(const void *p, const void *q, unsigned long size) {
  __builtin_memcmp(p, q, size);
}
void con_unify_unimap_q1(void) {
  memcmp(con_unify_unimap_p1, con_unify_unimap_q1, sizeof(int));
}

[serge-sans-paille]

+ extra test case
+ avoid Playing with Twines
+ fix storage of external declaration of inline builtins
+ minor nits

[nickdesaulniers]

With Diff 376790, I'm seeing a similar failure to https://github.com/ClangBuiltLinux/linux/issues/1466#issue-1011472964, but from different TUs.

ld.lld: error: duplicate symbol: memcpy.inline
>>> defined at file.c
>>>            fs/efivarfs/file.o:(memcpy.inline)
>>> defined at super.c
>>>            fs/efivarfs/super.o:(.text+0x800)

let me see if I can put together another reproducer.

[serge-sans-paille]

+ fix linkage of generated function

[nickdesaulniers]

With Diff 376790

inline __attribute__((__always_inline__)) __attribute__((gnu_inline)) void*
memcpy() {}

clang -O2 is producing undefined references to memcpy.inline. Please add that to the new unit tests added here.

diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
index a8ae5f5fc0de..132834516473 100644
--- a/clang/lib/CodeGen/CodeGenFunction.cpp
+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -1303,7 +1303,7 @@ void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
     llvm::Module *M = Fn->getParent();
     llvm::Function *Clone = M->getFunction(FDInlineName);
     if (!Clone) {
-      Clone = llvm::Function::Create(Fn->getFunctionType(), Fn->getLinkage(),
+      Clone = llvm::Function::Create(Fn->getFunctionType(), llvm::GlobalValue::AvailableExternallyLinkage,
                                      Fn->getAddressSpace(), FDInlineName, M);
       Clone->addFnAttr(llvm::Attribute::AlwaysInline);
     }

fixes that, but I don't think that's the right visibility.

00000000000002a0 T memcpy.inline

should be t not T I think? Because now the failure looks like

ld.lld: error: duplicate symbol: memcpy.inline
>>> defined at file.c
>>>            fs/efivarfs/file.o:(memcpy.inline)
>>> defined at super.c
>>>            fs/efivarfs/super.o:(.text+0x800)

Perhaps llvm::GlobalValue::InternalLinkage?

[nickdesaulniers]

Diff 376794 builds! Let's still add a test for

inline __attribute__((__always_inline__)) __attribute__((gnu_inline)) void*
memcpy() {}

though.

[serge-sans-paille]

+ extra test case
+ use internal linkage instead of available_externally linkage for generated clone

[nickdesaulniers]

clang/lib/CodeGen/CGExpr.cpp

4901

llvm::Module *M = Fn->getParent();

[manojgupta]

I am noticing a clang crash with ToT after this change.

• testcase --

long a;
char b, d;
extern inline __attribute__((always_inline))
__attribute__((gnu_inline)) unsigned long
strlen() {
  return a;
}
c(void) {
  strlen(&b);
  return 0;
}
unsigned long strlen() { return d; }

bin/clang -x c foo.c -Wno-error
foo.c:8:1: warning: type specifier missing, defaults to 'int' [-Wimplicit-int]
c(void) {
^
Global is external, but doesn't have external or weak linkage!
i64 (i8*)* @strlen.inline
fatal error: error in backend: Broken module found, compilation aborted!
clang version 14.0.0 (https://github.com/llvm/llvm-project.git 3129aa5caf1f9b5c48ab708f43cb3fc5173dd021)

[nickdesaulniers]

See also: https://github.com/ClangBuiltLinux/linux/issues/1477. Surprising that this didn't show up in newer kernels, just older (but still supported) kernel versions. Sorry I missed that in my tests.

[nickdesaulniers]

Also reported here: https://lore.kernel.org/llvm/1817774243.12566.1634255267713@localhost/

[serge-sans-paille]

https://reviews.llvm.org/D112059 should address the issue pointed by @manojgupta and @nickdesaulniers

clang/lib/AST/Decl.cpp

 }
 
 bool FunctionDecl::isInlineBuiltinDeclaration() const {
   if (!getBuiltinID())
     return false;
 
   const FunctionDecl *Definition;
   return hasBody(Definition) && Definition->isInlineSpecified() &&
-         Definition->hasAttr<AlwaysInlineAttr>();
+         Definition->hasAttr<AlwaysInlineAttr>() &&
+         Definition->hasAttr<GNUInlineAttr>();
 }
 
 bool FunctionDecl::isDestroyingOperatorDelete() const {
   // C++ P0722:
   //   Within a class C, a single object deallocation function with signature
   //     (T, std::destroying_delete_t, <more params>)
   //   is a destroying operator delete.
   if (!isa<CXXMethodDecl>(this) || getOverloadedOperator() != OO_Delete ||

clang/lib/CodeGen/CGExpr.cpp

RValue CodeGenFunction::EmitSimpleCallExpr(const CallExpr *E,
   CGCallee Callee = EmitCallee(E->getCallee());
   return EmitCall(E->getCallee()->getType(), Callee, E, ReturnValue);
 }
 
 static CGCallee EmitDirectCallee(CodeGenFunction &CGF, GlobalDecl GD) {
   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
 
   if (auto builtinID = FD->getBuiltinID()) {
-    // Replaceable builtin provide their own implementation of a builtin. Unless
-    // we are in the builtin implementation itself, don't call the actual
-    // builtin. If we are in the builtin implementation, avoid trivial infinite
+    std::string FDInlineName = (FD->getName() + ".inline").str();
+    // When directing calling an inline builtin, call it through it's mangled
+    // name to make it clear it's not the actual builtin.
+    if (FD->isInlineBuiltinDeclaration() &&
+        CGF.CurFn->getName() != FDInlineName) {
+      llvm::Constant *CalleePtr = EmitFunctionDeclPointer(CGF.CGM, GD);
+      llvm::Function *Fn = llvm::cast<llvm::Function>(CalleePtr);
+      llvm::Module *M = Fn->getParent();
+      llvm::Function *Clone = M->getFunction(FDInlineName);
+      if (!Clone) {
+        Clone = llvm::Function::Create(Fn->getFunctionType(),
+                                       llvm::GlobalValue::InternalLinkage,
+                                       Fn->getAddressSpace(), FDInlineName, M);
+        Clone->addFnAttr(llvm::Attribute::AlwaysInline);
+      }
+      return CGCallee::forDirect(Clone, GD);
+    }
+
+    // Replaceable builtins provide their own implementation of a builtin. If we
+    // are in an inline builtin implementation, avoid trivial infinite
     // recursion.
-    if (!FD->isInlineBuiltinDeclaration() ||
-        CGF.CurFn->getName() == FD->getName())
+    else
       return CGCallee::forBuiltin(builtinID, FD);
   }
 
   llvm::Constant *CalleePtr = EmitFunctionDeclPointer(CGF.CGM, GD);
   if (CGF.CGM.getLangOpts().CUDA && !CGF.CGM.getLangOpts().CUDAIsDevice &&
       FD->hasAttr<CUDAGlobalAttr>())
     CalleePtr = CGF.CGM.getCUDARuntime().getKernelStub(
         cast<llvm::GlobalValue>(CalleePtr->stripPointerCasts()));
+
   return CGCallee::forDirect(CalleePtr, GD);
 }
 
 CGCallee CodeGenFunction::EmitCallee(const Expr *E) {
   E = E->IgnoreParens();
 
   // Look through function-to-pointer decay.
   if (auto ICE = dyn_cast<ImplicitCastExpr>(E)) {
     if (ICE->getCastKind() == CK_FunctionToPointerDecay ||
         ICE->getCastKind() == CK_BuiltinFnToFnPtr) {
       return EmitCallee(ICE->getSubExpr());
     }

clang/lib/CodeGen/CodeGenFunction.cpp

 #include "llvm/IR/FPEnv.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Support/CRC.h"
 #include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
 #include "llvm/Transforms/Utils/PromoteMemToReg.h"
+
 using namespace clang;
 using namespace CodeGen;
 
 /// shouldEmitLifetimeMarkers - Decide whether we need emit the life-time
 /// markers.
 static bool shouldEmitLifetimeMarkers(const CodeGenOptions &CGOpts,
                                       const LangOptions &LangOpts) {
   if (CGOpts.DisableLifetimeMarkers)

 void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
                                    const CGFunctionInfo &FnInfo) {
   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
   CurGD = GD;
 
   FunctionArgList Args;
   QualType ResTy = BuildFunctionArgList(GD, Args);
 
-  // Give a different name to inline builtin to avoid conflict with actual
-  // builtins.
-  if (FD->isInlineBuiltinDeclaration() && Fn)
-    Fn->setName(Fn->getName() + ".inline");
+  // When generating code for a builtin with an inline declaration, use a
+  // mangled name to hold the actual body, while keeping an external definition
+  // in case the function pointer is referenced somewhere.
+  if (FD->isInlineBuiltinDeclaration() && Fn) {
+    std::string FDInlineName = (Fn->getName() + ".inline").str();
+    llvm::Module *M = Fn->getParent();
+    llvm::Function *Clone = M->getFunction(FDInlineName);
+    if (!Clone) {
+      Clone = llvm::Function::Create(Fn->getFunctionType(),
+                                     llvm::GlobalValue::InternalLinkage,
+                                     Fn->getAddressSpace(), FDInlineName, M);
+      Clone->addFnAttr(llvm::Attribute::AlwaysInline);
+    }
+    Fn->setLinkage(llvm::GlobalValue::ExternalLinkage);
+    Fn = Clone;
+  }
 
   // Check if we should generate debug info for this function.
   if (FD->hasAttr<NoDebugAttr>()) {
     // Clear non-distinct debug info that was possibly attached to the function
     // due to an earlier declaration without the nodebug attribute
     if (Fn)
       Fn->setSubprogram(nullptr);
     // Disable debug info indefinitely for this function

clang/test/CodeGen/memcmp-inline-builtin-to-asm.c

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+
+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -o - %s | opt -S -verify | FileCheck %s
+//
+// Verifies that clang detects memcmp inline version and uses it instead of the builtin.
+
+typedef unsigned long size_t;
+
+// Clang requires these attributes for a function to be redefined.
+#define AVAILABLE_EXTERNALLY extern inline __attribute__((always_inline)) __attribute__((gnu_inline))
+
+const void *con_unify_unimap_p1;
+
+AVAILABLE_EXTERNALLY
+int memcmp(const void *p, const void *q, unsigned long size) {
+  return __builtin_memcmp(p, q, size);
+}
+
+// CHECK-LABEL: @con_unify_unimap_q1(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[P_ADDR_I:%.*]] = alloca i8*, align 8
+// CHECK-NEXT:    [[Q_ADDR_I:%.*]] = alloca i8*, align 8
+// CHECK-NEXT:    [[SIZE_ADDR_I:%.*]] = alloca i64, align 8
+// CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** @con_unify_unimap_p1, align 8
+// CHECK-NEXT:    store i8* [[TMP0]], i8** [[P_ADDR_I]], align 8
+// CHECK-NEXT:    store i8* bitcast (i32 ()* @con_unify_unimap_q1 to i8*), i8** [[Q_ADDR_I]], align 8
+// CHECK-NEXT:    store i64 4, i64* [[SIZE_ADDR_I]], align 8
+// CHECK-NEXT:    [[TMP1:%.*]] = load i8*, i8** [[P_ADDR_I]], align 8
+// CHECK-NEXT:    [[TMP2:%.*]] = load i8*, i8** [[Q_ADDR_I]], align 8
+// CHECK-NEXT:    [[TMP3:%.*]] = load i64, i64* [[SIZE_ADDR_I]], align 8
+// CHECK-NEXT:    [[CALL_I:%.*]] = call i32 @memcmp(i8* [[TMP1]], i8* [[TMP2]], i64 [[TMP3]]) #[[ATTR3:[0-9]+]]
+// CHECK-NEXT:    ret i32 [[CALL_I]]
+//
+int con_unify_unimap_q1(void) {
+  return memcmp(con_unify_unimap_p1, con_unify_unimap_q1, sizeof(int));
+}

clang/test/CodeGen/memcpy-inline-builtin-no-extern.c

+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -disable-llvm-passes -o - %s | FileCheck %s
+//
+// Verifies that clang-generated *.inline are flagged as internal.
+
+typedef unsigned long size_t;
+
+#define AVAILABLE_EXTERNALLY extern inline __attribute__((always_inline)) __attribute__((gnu_inline))
+// Clang recognizes an inline builtin and renames it to memcmp.inline to prevent conflict with builtins.
+AVAILABLE_EXTERNALLY int memcmp(const void *a, const void *b, size_t c) {
+  return __builtin_memcmp(a, b, c);
+}
+
+// CHECK: internal{{.*}}memcmp.inline
+int bar(const void *a, const void *b, size_t c) {
+  return memcmp(a, b, c);
+}
+
+// Note that extern has been omitted here.
+#define TRIPLE_INLINE inline __attribute__((always_inline)) __attribute__((gnu_inline))
+
+// Clang recognizes an inline builtin and renames it to memcpy.inline to prevent conflict with builtins.
+TRIPLE_INLINE void *memcpy(void *a, const void *b, size_t c) {
+  return __builtin_memcpy(a, b, c);
+}
+
+// CHECK: internal{{.*}}memcpy.inline
+void *foo(void *a, const void *b, size_t c) {
+  return memcpy(a, b, c);
+}

clang/test/CodeGen/memcpy-inline-builtin.c

 // CHECK-NEXT:    store i8* [[B:%.*]], i8** [[B_ADDR]], align 8
 // CHECK-NEXT:    store i64 [[C:%.*]], i64* [[C_ADDR]], align 8
 // CHECK-NEXT:    [[TMP0:%.*]] = load i8*, i8** [[A_ADDR]], align 8
 // CHECK-NEXT:    [[TMP1:%.*]] = load i8*, i8** [[B_ADDR]], align 8
 // CHECK-NEXT:    [[TMP2:%.*]] = load i64, i64* [[C_ADDR]], align 8
 // CHECK-NEXT:    store i8* [[TMP0]], i8** [[A_ADDR_I]], align 8
 // CHECK-NEXT:    store i8* [[TMP1]], i8** [[B_ADDR_I]], align 8
 // CHECK-NEXT:    store i64 [[TMP2]], i64* [[C_ADDR_I]], align 8
-// CHECK-NEXT:    call void asm sideeffect "# memcpy.inline marker", "~{dirflag},~{fpsr},~{flags}"() #[[ATTR2:[0-9]+]], !srcloc !2
+// CHECK-NEXT:    call void asm sideeffect "# memcpy.inline marker", "~{dirflag},~{fpsr},~{flags}"() #[[ATTR4:[0-9]+]], !srcloc !2
 // CHECK-NEXT:    [[TMP3:%.*]] = load i8*, i8** [[A_ADDR_I]], align 8
 // CHECK-NEXT:    [[TMP4:%.*]] = load i8*, i8** [[B_ADDR_I]], align 8
 // CHECK-NEXT:    [[TMP5:%.*]] = load i64, i64* [[C_ADDR_I]], align 8
-// CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 [[TMP3]], i8* align 1 [[TMP4]], i64 [[TMP5]], i1 false) #[[ATTR2]]
+// CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 [[TMP3]], i8* align 1 [[TMP4]], i64 [[TMP5]], i1 false) #[[ATTR4]]
+// CHECK-NEXT:    ret i8* [[TMP3]]
+//
+void *foo(void *a, const void *b, size_t c) {
+  return memcpy(a, b, c);
+}
+
+// CHECK-LABEL: @bar(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[A_ADDR:%.*]] = alloca i8*, align 8
+// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca i8*, align 8
+// CHECK-NEXT:    [[C_ADDR:%.*]] = alloca i64, align 8
+// CHECK-NEXT:    [[CPY:%.*]] = alloca i8* (i8*, i8*, i64)*, align 8
+// CHECK-NEXT:    store i8* [[A:%.*]], i8** [[A_ADDR]], align 8
+// CHECK-NEXT:    store i8* [[B:%.*]], i8** [[B_ADDR]], align 8
+// CHECK-NEXT:    store i64 [[C:%.*]], i64* [[C_ADDR]], align 8
+// CHECK-NEXT:    [[TMP0:%.*]] = load i64, i64* [[C_ADDR]], align 8
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i64 [[TMP0]], 10
+// CHECK-NEXT:    [[TMP1:%.*]] = zext i1 [[CMP]] to i64
+// CHECK-NEXT:    [[COND:%.*]] = select i1 [[CMP]], i8* (i8*, i8*, i64)* @memcpy, i8* (i8*, i8*, i64)* @foo
+// CHECK-NEXT:    store i8* (i8*, i8*, i64)* [[COND]], i8* (i8*, i8*, i64)** [[CPY]], align 8
+// CHECK-NEXT:    [[TMP2:%.*]] = load i8* (i8*, i8*, i64)*, i8* (i8*, i8*, i64)** [[CPY]], align 8
+// CHECK-NEXT:    [[TMP3:%.*]] = load i8*, i8** [[A_ADDR]], align 8
+// CHECK-NEXT:    [[TMP4:%.*]] = load i8*, i8** [[B_ADDR]], align 8
+// CHECK-NEXT:    [[TMP5:%.*]] = load i64, i64* [[C_ADDR]], align 8
+// CHECK-NEXT:    [[CALL:%.*]] = call i8* [[TMP2]](i8* [[TMP3]], i8* [[TMP4]], i64 [[TMP5]])
 // CHECK-NEXT:    ret void
 //
-void foo(void *a, const void *b, size_t c) {
-  memcpy(a, b, c);
+void bar(void *a, const void *b, size_t c) {
+  void *(*cpy)(void *, const void *, size_t) = c > 10 ? memcpy : foo;
+  cpy(a, b, c);
 }

clang/test/CodeGen/memcpy-nobuiltin.c

 // RUN: %clang_cc1 -verify -S -emit-llvm -o- %s -isystem %S -DWITH_DECL | FileCheck --check-prefix=CHECK-WITH-DECL %s
 // RUN: %clang_cc1 -verify -S -emit-llvm -o- %s -isystem %S -UWITH_DECL | FileCheck --check-prefix=CHECK-NO-DECL %s
-// RUN: %clang_cc1 -verify -S -emit-llvm -o- %s -isystem %S -DWITH_SELF_REFERENCE_DECL | FileCheck --check-prefix=CHECK-SELF-REF-DECL %s
+// RUN: %clang_cc1 -verify -S -emit-llvm -o- %s -isystem %S -disable-llvm-passes -DWITH_SELF_REFERENCE_DECL | FileCheck --check-prefix=CHECK-SELF-REF-DECL %s
 //
 // CHECK-WITH-DECL-NOT: @llvm.memcpy
 // CHECK-NO-DECL: @llvm.memcpy
 // CHECK-SELF-REF-DECL-LABEL: define {{.*}}i8* @memcpy.inline
-// CHECK-SELF-REF-DECL:       @memcpy(
+// CHECK-SELF-REF-DECL:       @llvm.memcpy.{{.*}}(
 //
 #include <memcpy-nobuiltin.inc>
 void test(void *dest, void const *from, size_t n) {
   memcpy(dest, from, n);
 
   static char buffer[1];
   memcpy(buffer, from, 2); // expected-warning {{'memcpy' will always overflow; destination buffer has size 1, but size argument is 2}}
 }

clang/test/CodeGen/memcpy-nobuiltin.inc

 #include <stddef.h>
 extern void *memcpy(void *dest, void const *from, size_t n);
 
 #ifdef WITH_DECL
-inline __attribute__((always_inline)) void *memcpy(void *dest, void const *from, size_t n) {
+inline __attribute__((always_inline)) __attribute__((gnu_inline)) void *memcpy(void *dest, void const *from, size_t n) {
   char const *ifrom = from;
   char *idest = dest;
   while (n--)
     *idest++ = *ifrom++;
   return dest;
 }
 #endif
 #ifdef WITH_SELF_REFERENCE_DECL
-inline __attribute__((always_inline)) void *memcpy(void *dest, void const *from, size_t n) {
+inline __attribute__((always_inline)) __attribute__((gnu_inline)) void *memcpy(void *dest, void const *from, size_t n) {
   if (n != 0)
     memcpy(dest, from, n);
   return dest;
 }
 #endif

clang/test/CodeGen/pr9614.c

void f(void) {
   abs(0);
   strrchr_foo("", '.');
   prefetch();
   memchr("", '.', 0);
 }
 
 // CHECK-LABEL: define{{.*}} void @f()
 // CHECK: call void @foo()
-// CHECK: call i32 @abs(i32 %0)
+// CHECK: call i32 @abs(i32 0)
 // CHECK: call i8* @strrchr(
 // CHECK: call void @llvm.prefetch.p0i8(
 // CHECK: call i8* @memchr(
 // CHECK: ret void
 
 // CHECK: declare void @foo()
+// CHECK: declare i32 @abs(i32
 // CHECK: declare i8* @strrchr(i8*, i32)
 // CHECK: declare i8* @memchr(
-// CHECK: declare i32 @abs(i32
 // CHECK: declare void @llvm.prefetch.p0i8(