On 5/14/19 5:07 PM, Martin Sebor wrote:
> On 5/14/19 8:55 AM, Martin Liška wrote:
>> On 5/13/19 3:07 PM, Jakub Jelinek wrote:
>>> On Mon, May 13, 2019 at 12:14:37PM +0200, Martin Liška wrote:
>>>> On 5/10/19 11:21 AM, Jakub Jelinek wrote:
>>>>> On Fri, May 10, 2019 at 11:04:12AM +0200, Martin Liška wrote:
>>>>>> --- a/gcc/config/i386/i386.h
>>>>>> +++ b/gcc/config/i386/i386.h
>>>>>> @@ -1906,6 +1906,9 @@ typedef struct ix86_args {
>>>>>> #define CLEAR_RATIO(speed) ((speed) ? MIN (6, ix86_cost->move_ratio)
>>>>>> : 2)
>>>>>> +/* C library provides fast implementation of mempcpy function. */
>>>>>> +#define TARGET_HAS_FAST_MEMPCPY_ROUTINE 1
>>>>>> +
>>>>>
>>>>> 1) we shouldn't be adding further target macros, but target hooks
>>>>
>>>> Done.
>>>>
>>>>> 2) I don't think this is a property of the x86 target, but of x86 glibc,
>>>>> so you should set it on x86 glibc only (i.e. i?86/x86_64 linux and
>>>>> hurd
>>>>> when using glibc, not newlib, nor bionic/android, nor uclibc, nor
>>>>> musl)
>>>>
>>>> I've implemented the in i386.c with DEFAULT_LIBC == LIBC_GLIBC. Hope it's
>>>> correct?
>>>
>>> No, that would be correct only in the rare SINGLE_LIBC configurations.
>>> Either you can do
>>> #ifdef OPTION_GLIBC
>>> return OPTION_GLIBC;
>>> #else
>>> return false;
>>> #endif
>>> or define something in config/linux.h (or .[ch]) that you can then use in
>>> i386.c.
>>>
>>> Jakub
>>>
>>
>> Hi.
>>
>> You always have nice ideas. I'm sending updated patch which addresses both
>> Jakub's
>> and Wilco's comments.
>>
>
> index 66cee075018..7bff5cbd313 100644
> --- a/gcc/target.def
> +++ b/gcc/target.def
> @@ -5797,6 +5797,12 @@ DEFHOOK
> const char *, (void),
> hook_constcharptr_void_null)
>
> +DEFHOOK
> +(has_fast_mempcpy_routine,
> + "Return true if a target has a fast mempcpy routine.",
> + bool, (void),
> + hook_bool_void_false)
> +
>
> Not to be too nit-picky about the name but target.def refers to
> functions rather than routines. It also defines a hook called
> libc_has_function with the obvious semantics so if there's
> a chance that it could be useful to query whether another libc
> function is "fast" I would suggest to consider defining the hook
> correspondingly, i.e.,
>
> bool libc_has_fast_function (enum function_class)
>
> and naming the macro similarly.
>
> Martin
Hi Martin.
That's a very good suggestion and I'm implementing that!
Patch can bootstrap on x86_64-linux-gnu and survives regression tests.
Thanks,
Martin
>From f865ba74008acc651e9ef2fbfc9f2d4bb9ce8fb8 Mon Sep 17 00:00:00 2001
From: marxin <mli...@suse.cz>
Date: Mon, 29 Apr 2019 13:46:25 +0200
Subject: [PATCH] Come up with hook libc_has_fast_function (PR
middle-end/90263).
gcc/ChangeLog:
2019-05-15 Martin Liska <mli...@suse.cz>
PR middle-end/90263
* builtins.c (expand_builtin_memory_copy_args): When having a
target with fast mempcpy implementation do now use memcpy.
* config/i386/i386.c (ix86_libc_has_fast_function): New.
(TARGET_LIBC_HAS_FAST_FUNCTION): Likewise.
* doc/tm.texi: Likewise.
* doc/tm.texi.in: Likewise.
* target.def:
* expr.c (emit_block_move_hints): Add 2 new arguments.
* expr.h (emit_block_move_hints): Bail out when libcall
to memcpy would be used.
gcc/testsuite/ChangeLog:
2019-05-15 Martin Liska <mli...@suse.cz>
PR middle-end/90263
* gcc.c-torture/compile/pr90263.c: New test.
* lib/target-supports.exp: Add check_effective_target_glibc.
---
gcc/builtins.c | 17 +++++++++++++++--
gcc/config/i386/i386.c | 15 +++++++++++++++
gcc/doc/tm.texi | 5 +++++
gcc/doc/tm.texi.in | 2 ++
gcc/expr.c | 13 ++++++++++++-
gcc/expr.h | 4 +++-
gcc/target.def | 7 +++++++
gcc/testsuite/gcc.c-torture/compile/pr90263.c | 10 ++++++++++
gcc/testsuite/lib/target-supports.exp | 11 +++++++++++
9 files changed, 80 insertions(+), 4 deletions(-)
create mode 100644 gcc/testsuite/gcc.c-torture/compile/pr90263.c
diff --git a/gcc/builtins.c b/gcc/builtins.c
index d37d73fc4a0..70d44927052 100644
--- a/gcc/builtins.c
+++ b/gcc/builtins.c
@@ -3839,6 +3839,8 @@ expand_builtin_memory_copy_args (tree dest, tree src, tree len,
unsigned HOST_WIDE_INT max_size;
unsigned HOST_WIDE_INT probable_max_size;
+ bool is_move_done;
+
/* If DEST is not a pointer type, call the normal function. */
if (dest_align == 0)
return NULL_RTX;
@@ -3888,11 +3890,22 @@ expand_builtin_memory_copy_args (tree dest, tree src, tree len,
if (CALL_EXPR_TAILCALL (exp)
&& (retmode == RETURN_BEGIN || target == const0_rtx))
method = BLOCK_OP_TAILCALL;
- if (retmode == RETURN_END && target != const0_rtx)
+ bool use_mempcpy_call = (targetm.libc_has_fast_function (BUILT_IN_MEMPCPY)
+ && retmode == RETURN_END
+ && target != const0_rtx);
+ if (use_mempcpy_call)
method = BLOCK_OP_NO_LIBCALL_RET;
dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx, method,
expected_align, expected_size,
- min_size, max_size, probable_max_size);
+ min_size, max_size, probable_max_size,
+ use_mempcpy_call, &is_move_done);
+
+ /* Bail out when a mempcpy call would be expanded as libcall and when
+ we have a target that provides a fast implementation
+ of mempcpy routine. */
+ if (!is_move_done)
+ return NULL_RTX;
+
if (dest_addr == pc_rtx)
return NULL_RTX;
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index cc0ae3fcfd3..6fbfe5f53e4 100644
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -23056,6 +23056,21 @@ ix86_run_selftests (void)
#define TARGET_GET_MULTILIB_ABI_NAME \
ix86_get_multilib_abi_name
+static bool ix86_libc_has_fast_function (int fcode)
+{
+#ifdef OPTION_GLIBC
+ if (OPTION_GLIBC)
+ return (built_in_function)fcode == BUILT_IN_MEMPCPY;
+ else
+ return false;
+#else
+ return false;
+#endif
+}
+
+#undef TARGET_LIBC_HAS_FAST_FUNCTION
+#define TARGET_LIBC_HAS_FAST_FUNCTION ix86_libc_has_fast_function
+
#if CHECKING_P
#undef TARGET_RUN_TARGET_SELFTESTS
#define TARGET_RUN_TARGET_SELFTESTS selftest::ix86_run_selftests
diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi
index 8c8978bb13a..0941039536b 100644
--- a/gcc/doc/tm.texi
+++ b/gcc/doc/tm.texi
@@ -5594,6 +5594,11 @@ This hook determines whether a function from a class of functions
@var{fn_class} is present at the runtime.
@end deftypefn
+@deftypefn {Target Hook} bool TARGET_LIBC_HAS_FAST_FUNCTION (int @var{fcode})
+This hook determines whether a function from a class of functions
+@var{fn_class} has a fast implementation.
+@end deftypefn
+
@defmac NEXT_OBJC_RUNTIME
Set this macro to 1 to use the "NeXT" Objective-C message sending conventions
by default. This calling convention involves passing the object, the selector
diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in
index fe1194ef91a..17560fce6b7 100644
--- a/gcc/doc/tm.texi.in
+++ b/gcc/doc/tm.texi.in
@@ -3991,6 +3991,8 @@ macro, a reasonable default is used.
@hook TARGET_LIBC_HAS_FUNCTION
+@hook TARGET_LIBC_HAS_FAST_FUNCTION
+
@defmac NEXT_OBJC_RUNTIME
Set this macro to 1 to use the "NeXT" Objective-C message sending conventions
by default. This calling convention involves passing the object, the selector
diff --git a/gcc/expr.c b/gcc/expr.c
index fa15b7eceae..c78bc74c0d9 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -1561,12 +1561,16 @@ emit_block_move_hints (rtx x, rtx y, rtx size, enum block_op_methods method,
unsigned int expected_align, HOST_WIDE_INT expected_size,
unsigned HOST_WIDE_INT min_size,
unsigned HOST_WIDE_INT max_size,
- unsigned HOST_WIDE_INT probable_max_size)
+ unsigned HOST_WIDE_INT probable_max_size,
+ bool bail_out_libcall, bool *is_move_done)
{
int may_use_call;
rtx retval = 0;
unsigned int align;
+ if (is_move_done)
+ *is_move_done = true;
+
gcc_assert (size);
if (CONST_INT_P (size) && INTVAL (size) == 0)
return 0;
@@ -1628,6 +1632,13 @@ emit_block_move_hints (rtx x, rtx y, rtx size, enum block_op_methods method,
&& ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (x))
&& ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (y)))
{
+ if (bail_out_libcall)
+ {
+ if (is_move_done)
+ *is_move_done = false;
+ return retval;
+ }
+
if (may_use_call < 0)
return pc_rtx;
diff --git a/gcc/expr.h b/gcc/expr.h
index 17c3962436a..6eb70bf12f1 100644
--- a/gcc/expr.h
+++ b/gcc/expr.h
@@ -114,7 +114,9 @@ extern rtx emit_block_move_hints (rtx, rtx, rtx, enum block_op_methods,
unsigned int, HOST_WIDE_INT,
unsigned HOST_WIDE_INT,
unsigned HOST_WIDE_INT,
- unsigned HOST_WIDE_INT);
+ unsigned HOST_WIDE_INT,
+ bool bail_out_libcall = false,
+ bool *is_move_done = NULL);
extern rtx emit_block_cmp_hints (rtx, rtx, rtx, tree, rtx, bool,
by_pieces_constfn, void *);
extern bool emit_storent_insn (rtx to, rtx from);
diff --git a/gcc/target.def b/gcc/target.def
index 66cee075018..23e260cb535 100644
--- a/gcc/target.def
+++ b/gcc/target.def
@@ -2547,6 +2547,13 @@ DEFHOOK
bool, (enum function_class fn_class),
default_libc_has_function)
+DEFHOOK
+(libc_has_fast_function,
+ "This hook determines whether a function from a class of functions\n\
+@var{fn_class} has a fast implementation.",
+ bool, (int fcode),
+ default_libc_has_fast_function)
+
/* True if new jumps cannot be created, to replace existing ones or
not, at the current point in the compilation. */
DEFHOOK
diff --git a/gcc/testsuite/gcc.c-torture/compile/pr90263.c b/gcc/testsuite/gcc.c-torture/compile/pr90263.c
new file mode 100644
index 00000000000..df3ab0fc1cd
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/pr90263.c
@@ -0,0 +1,10 @@
+/* PR middle-end/90263 */
+/* { dg-require-effective-target glibc } */
+
+int *f (int *p, int *q, long n)
+{
+ return __builtin_mempcpy (p, q, n);
+}
+
+/* { dg-final { scan-assembler "mempcpy" { target { i?86-*-* x86_64-*-* } } } } */
+/* { dg-final { scan-assembler "memcpy" { target { ! { i?86-*-* x86_64-*-* } } } } } */
diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp
index da132369a4b..2f6f990d285 100644
--- a/gcc/testsuite/lib/target-supports.exp
+++ b/gcc/testsuite/lib/target-supports.exp
@@ -9300,6 +9300,17 @@ proc check_effective_target_arm_v8_3a_complex_neon_hw { } {
} [add_options_for_arm_v8_3a_complex_neon ""]]
}
+# Returns 1 if the target is using glibc, 0 otherwise.
+
+proc check_effective_target_glibc { } {
+ return [check_no_compiler_messages glibc_object assembly {
+ #include <stdlib.h>
+ #if !defined(__GLIBC__)
+ #error undefined
+ #endif
+ }]
+}
+
# Return 1 if the target plus current options supports a vector
# complex addition with rotate of half and single float modes, 0 otherwise.
#
--
2.21.0
