llvm-project/clang/test/CodeGen/redefine_extname.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

39 lines
1.3 KiB
C
Raw Normal View History

// RUN: %clang_cc1 -triple=i386-pc-solaris2.11 -w -emit-llvm %s -o - | FileCheck %s
#pragma redefine_extname fake real
#pragma redefine_extname name alias
extern int fake(void);
int name;
// __PRAGMA_REDEFINE_EXTNAME should be defined. This will fail if it isn't...
int fish() { return fake() + __PRAGMA_REDEFINE_EXTNAME + name; }
// Check that the call to fake() is emitted as a call to real()
// CHECK: call i32 @real()
// Check that this also works with variables names
// CHECK: load i32, i32* @alias
// This is a case when redefenition is deferred *and* we have a local of the
// same name. PR23923.
#pragma redefine_extname foo bar
int f() {
int foo = 0;
return foo;
}
extern int foo() { return 1; }
// CHECK: define{{.*}} i32 @bar()
// Check that pragma redefine_extname applies to external declarations only.
#pragma redefine_extname foo_static bar_static
static int foo_static() { return 1; }
int baz() { return foo_static(); }
// CHECK-NOT: call i32 @bar_static()
[CGBuiltin] Respect asm labels and redefine_extname for builtins with specialized emitting rL131311 added `asm()` support for builtin functions, but `asm()` for builtins with specialized emitting (e.g. memcpy, various math functions) still do not work. This patch makes these functions work for `asm()` and `#pragma redefine_extname`. glibc uses `asm()` to redirect internal libc function calls to hidden aliases. Limitation: such a function is a builtin in clang, but will not be recognized as a libcall in optimization passes because Clang does not annotate the renamed function as a libcall. In GCC -O1 or above, `abs` can be optimized out but we can't. Additionally, we cannot redirect `__builtin_sin` to `real_sin` in the following example: double sin(double x) asm("real_sin"); double f(double d) { return __builtin_sin(d); } --- According to @rsmith, the following three statements cannot be simultaneously true: (1) The frontend function foo has known, builtin semantics X. (2) The symbol foo has known, builtin semantics X. (3) It's not correct to lower a call to the frontend function foo to the symbol foo. People do want (1) (if it is profitable to expand a memcpy, do it). This also means that people do not want to add -fno-builtin-memcpy. People do want (3): that is why they use asm("__GI_memcpy") in the first place. So unfortunately we make a compromise by not refuting (2) (see the limitation above). For most libcalls, there is a small loss because compilers don't synthesize them. For the few glibc cares about, it uses `asm("memcpy = __GI_memcpy");` to make the assembly level redirection. (Changing function names (e.g. `__memcpy`) is a hit to ergonomics which is not acceptable). Reviewed By: rsmith Differential Revision: https://reviews.llvm.org/D88712
2020-10-16 06:11:45 +08:00
// Check that pragma redefine_extname applies to builtin functions.
typedef unsigned long size_t;
extern void *memcpy(void *, const void *, size_t);
#pragma redefine_extname memcpy __GI_memcpy
void *test_memcpy(void *dst, const void *src, size_t n) { return memcpy(dst, src, n); }
// CHECK: call i8* @__GI_memcpy(