Re: RFA: Remove useless code in builtins.c

[Richard Guenther <richard dot guenther at gmail dot com>]

On Wed, Nov 25, 2009 at 4:45 PM, Michael Matz <matz@suse.de> wrote:
> Hi,
>
> some more trivial things from my expand-calls work. ?The three *printf
> expanders in builtins.c are useless, because they do exactly the same as
> the corresponding three builtin folders, which run just a few passes
> before. ?Hence they in fact don't do anything.
>
> Regstrapped on x86_64-linux, all langs+Ada. ?Okay for trunk?

Ack.

Thanks,
Richard.

>
> Ciao,
> Michael.
> --
> ? ? ? ?* builtins.c (expand_builtin_printf, expand_builtin_fprintf,
> ? ? ? ?expand_builtin_sprintf): Remove.
> ? ? ? ?(expand_builtin): Don't call them.
>
> Index: builtins.c
> ===================================================================
> --- builtins.c ?(revision 154502)
> +++ builtins.c ?(working copy)
> @@ -132,9 +132,6 @@ static rtx expand_builtin_strlen (tree,
> ?static rtx expand_builtin_alloca (tree, rtx);
> ?static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
> ?static rtx expand_builtin_frame_address (tree, tree);
> -static rtx expand_builtin_printf (tree, rtx, enum machine_mode, bool);
> -static rtx expand_builtin_fprintf (tree, rtx, enum machine_mode, bool);
> -static rtx expand_builtin_sprintf (tree, rtx, enum machine_mode);
> ?static tree stabilize_va_list_loc (location_t, tree, int);
> ?static rtx expand_builtin_expect (tree, rtx);
> ?static tree fold_builtin_constant_p (tree);
> @@ -4983,286 +4980,6 @@ build_string_literal (int len, const cha
> ? return t;
> ?}
>
> -/* Expand EXP, a call to printf or printf_unlocked.
> - ? Return NULL_RTX if a normal call should be emitted rather than transforming
> - ? the function inline. ?If convenient, the result should be placed in
> - ? TARGET with mode MODE. ?UNLOCKED indicates this is a printf_unlocked
> - ? call. ?*/
> -static rtx
> -expand_builtin_printf (tree exp, rtx target, enum machine_mode mode,
> - ? ? ? ? ? ? ? ? ? ? ?bool unlocked)
> -{
> - ?/* If we're using an unlocked function, assume the other unlocked
> - ? ? functions exist explicitly. ?*/
> - ?tree const fn_putchar = unlocked ? built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED]
> - ? ?: implicit_built_in_decls[BUILT_IN_PUTCHAR];
> - ?tree const fn_puts = unlocked ? built_in_decls[BUILT_IN_PUTS_UNLOCKED]
> - ? ?: implicit_built_in_decls[BUILT_IN_PUTS];
> - ?const char *fmt_str;
> - ?tree fn = 0;
> - ?tree fmt, arg;
> - ?int nargs = call_expr_nargs (exp);
> -
> - ?/* If the return value is used, don't do the transformation. ?*/
> - ?if (target != const0_rtx)
> - ? ?return NULL_RTX;
> -
> - ?/* Verify the required arguments in the original call. ?*/
> - ?if (nargs == 0)
> - ? ?return NULL_RTX;
> - ?fmt = CALL_EXPR_ARG (exp, 0);
> - ?if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
> - ? ?return NULL_RTX;
> -
> - ?/* Check whether the format is a literal string constant. ?*/
> - ?fmt_str = c_getstr (fmt);
> - ?if (fmt_str == NULL)
> - ? ?return NULL_RTX;
> -
> - ?if (!init_target_chars ())
> - ? ?return NULL_RTX;
> -
> - ?/* If the format specifier was "%s\n", call __builtin_puts(arg). ?*/
> - ?if (strcmp (fmt_str, target_percent_s_newline) == 0)
> - ? ?{
> - ? ? ?if ((nargs != 2)
> - ? ? ? ? || ! POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_ARG (exp, 1))))
> - ? ? ? return NULL_RTX;
> - ? ? ?if (fn_puts)
> - ? ? ? fn = build_call_nofold (fn_puts, 1, CALL_EXPR_ARG (exp, 1));
> - ? ?}
> - ?/* If the format specifier was "%c", call __builtin_putchar(arg). ?*/
> - ?else if (strcmp (fmt_str, target_percent_c) == 0)
> - ? ?{
> - ? ? ?if ((nargs != 2)
> - ? ? ? ? || TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1))) != INTEGER_TYPE)
> - ? ? ? return NULL_RTX;
> - ? ? ?if (fn_putchar)
> - ? ? ? fn = build_call_nofold (fn_putchar, 1, CALL_EXPR_ARG (exp, 1));
> - ? ?}
> - ?else
> - ? ?{
> - ? ? ?/* We can't handle anything else with % args or %% ... yet. ?*/
> - ? ? ?if (strchr (fmt_str, target_percent))
> - ? ? ? return NULL_RTX;
> -
> - ? ? ?if (nargs > 1)
> - ? ? ? return NULL_RTX;
> -
> - ? ? ?/* If the format specifier was "", printf does nothing. ?*/
> - ? ? ?if (fmt_str[0] == '\0')
> - ? ? ? return const0_rtx;
> - ? ? ?/* If the format specifier has length of 1, call putchar. ?*/
> - ? ? ?if (fmt_str[1] == '\0')
> - ? ? ? {
> - ? ? ? ? /* Given printf("c"), (where c is any one character,)
> - ? ? ? ? ? ?convert "c"[0] to an int and pass that to the replacement
> - ? ? ? ? ? ?function. ?*/
> - ? ? ? ? arg = build_int_cst (NULL_TREE, fmt_str[0]);
> - ? ? ? ? if (fn_putchar)
> - ? ? ? ? ? fn = build_call_nofold (fn_putchar, 1, arg);
> - ? ? ? }
> - ? ? ?else
> - ? ? ? {
> - ? ? ? ? /* If the format specifier was "string\n", call puts("string"). ?*/
> - ? ? ? ? size_t len = strlen (fmt_str);
> - ? ? ? ? if ((unsigned char)fmt_str[len - 1] == target_newline)
> - ? ? ? ? ? {
> - ? ? ? ? ? ? /* Create a NUL-terminated string that's one char shorter
> - ? ? ? ? ? ? ? ?than the original, stripping off the trailing '\n'. ?*/
> - ? ? ? ? ? ? char *newstr = XALLOCAVEC (char, len);
> - ? ? ? ? ? ? memcpy (newstr, fmt_str, len - 1);
> - ? ? ? ? ? ? newstr[len - 1] = 0;
> - ? ? ? ? ? ? arg = build_string_literal (len, newstr);
> - ? ? ? ? ? ? if (fn_puts)
> - ? ? ? ? ? ? ? fn = build_call_nofold (fn_puts, 1, arg);
> - ? ? ? ? ? }
> - ? ? ? ? else
> - ? ? ? ? ? /* We'd like to arrange to call fputs(string,stdout) here,
> - ? ? ? ? ? ? ?but we need stdout and don't have a way to get it yet. ?*/
> - ? ? ? ? ? return NULL_RTX;
> - ? ? ? }
> - ? ?}
> -
> - ?if (!fn)
> - ? ?return NULL_RTX;
> - ?gcc_assert (TREE_CODE (fn) == CALL_EXPR);
> - ?CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
> - ?return expand_expr (fn, target, mode, EXPAND_NORMAL);
> -}
> -
> -/* Expand EXP, a call to fprintf or fprintf_unlocked.
> - ? Return NULL_RTX if a normal call should be emitted rather than transforming
> - ? the function inline. ?If convenient, the result should be placed in
> - ? TARGET with mode MODE. ?UNLOCKED indicates this is a fprintf_unlocked
> - ? call. ?*/
> -static rtx
> -expand_builtin_fprintf (tree exp, rtx target, enum machine_mode mode,
> - ? ? ? ? ? ? ? ? ? ? ? bool unlocked)
> -{
> - ?/* If we're using an unlocked function, assume the other unlocked
> - ? ? functions exist explicitly. ?*/
> - ?tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
> - ? ?: implicit_built_in_decls[BUILT_IN_FPUTC];
> - ?tree const fn_fputs = unlocked ? built_in_decls[BUILT_IN_FPUTS_UNLOCKED]
> - ? ?: implicit_built_in_decls[BUILT_IN_FPUTS];
> - ?const char *fmt_str;
> - ?tree fn = 0;
> - ?tree fmt, fp, arg;
> - ?int nargs = call_expr_nargs (exp);
> -
> - ?/* If the return value is used, don't do the transformation. ?*/
> - ?if (target != const0_rtx)
> - ? ?return NULL_RTX;
> -
> - ?/* Verify the required arguments in the original call. ?*/
> - ?if (nargs < 2)
> - ? ?return NULL_RTX;
> - ?fp = CALL_EXPR_ARG (exp, 0);
> - ?if (! POINTER_TYPE_P (TREE_TYPE (fp)))
> - ? ?return NULL_RTX;
> - ?fmt = CALL_EXPR_ARG (exp, 1);
> - ?if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
> - ? ?return NULL_RTX;
> -
> - ?/* Check whether the format is a literal string constant. ?*/
> - ?fmt_str = c_getstr (fmt);
> - ?if (fmt_str == NULL)
> - ? ?return NULL_RTX;
> -
> - ?if (!init_target_chars ())
> - ? ?return NULL_RTX;
> -
> - ?/* If the format specifier was "%s", call __builtin_fputs(arg,fp). ?*/
> - ?if (strcmp (fmt_str, target_percent_s) == 0)
> - ? ?{
> - ? ? ?if ((nargs != 3)
> - ? ? ? ? || ! POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_ARG (exp, 2))))
> - ? ? ? return NULL_RTX;
> - ? ? ?arg = CALL_EXPR_ARG (exp, 2);
> - ? ? ?if (fn_fputs)
> - ? ? ? fn = build_call_nofold (fn_fputs, 2, arg, fp);
> - ? ?}
> - ?/* If the format specifier was "%c", call __builtin_fputc(arg,fp). ?*/
> - ?else if (strcmp (fmt_str, target_percent_c) == 0)
> - ? ?{
> - ? ? ?if ((nargs != 3)
> - ? ? ? ? || TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2))) != INTEGER_TYPE)
> - ? ? ? return NULL_RTX;
> - ? ? ?arg = CALL_EXPR_ARG (exp, 2);
> - ? ? ?if (fn_fputc)
> - ? ? ? fn = build_call_nofold (fn_fputc, 2, arg, fp);
> - ? ?}
> - ?else
> - ? ?{
> - ? ? ?/* We can't handle anything else with % args or %% ... yet. ?*/
> - ? ? ?if (strchr (fmt_str, target_percent))
> - ? ? ? return NULL_RTX;
> -
> - ? ? ?if (nargs > 2)
> - ? ? ? return NULL_RTX;
> -
> - ? ? ?/* If the format specifier was "", fprintf does nothing. ?*/
> - ? ? ?if (fmt_str[0] == '\0')
> - ? ? ? {
> - ? ? ? ? /* Evaluate and ignore FILE* argument for side-effects. ?*/
> - ? ? ? ? expand_expr (fp, const0_rtx, VOIDmode, EXPAND_NORMAL);
> - ? ? ? ? return const0_rtx;
> - ? ? ? }
> -
> - ? ? ?/* When "string" doesn't contain %, replace all cases of
> - ? ? ? ?fprintf(stream,string) with fputs(string,stream). ?The fputs
> - ? ? ? ?builtin will take care of special cases like length == 1. ?*/
> - ? ? ?if (fn_fputs)
> - ? ? ? fn = build_call_nofold (fn_fputs, 2, fmt, fp);
> - ? ?}
> -
> - ?if (!fn)
> - ? ?return NULL_RTX;
> - ?gcc_assert (TREE_CODE (fn) == CALL_EXPR);
> - ?CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
> - ?return expand_expr (fn, target, mode, EXPAND_NORMAL);
> -}
> -
> -/* Expand a call EXP to sprintf. ?Return NULL_RTX if
> - ? a normal call should be emitted rather than expanding the function
> - ? inline. ?If convenient, the result should be placed in TARGET with
> - ? mode MODE. ?*/
> -
> -static rtx
> -expand_builtin_sprintf (tree exp, rtx target, enum machine_mode mode)
> -{
> - ?tree dest, fmt;
> - ?const char *fmt_str;
> - ?int nargs = call_expr_nargs (exp);
> -
> - ?/* Verify the required arguments in the original call. ?*/
> - ?if (nargs < 2)
> - ? ?return NULL_RTX;
> - ?dest = CALL_EXPR_ARG (exp, 0);
> - ?if (! POINTER_TYPE_P (TREE_TYPE (dest)))
> - ? ?return NULL_RTX;
> - ?fmt = CALL_EXPR_ARG (exp, 0);
> - ?if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
> - ? ?return NULL_RTX;
> -
> - ?/* Check whether the format is a literal string constant. ?*/
> - ?fmt_str = c_getstr (fmt);
> - ?if (fmt_str == NULL)
> - ? ?return NULL_RTX;
> -
> - ?if (!init_target_chars ())
> - ? ?return NULL_RTX;
> -
> - ?/* If the format doesn't contain % args or %%, use strcpy. ?*/
> - ?if (strchr (fmt_str, target_percent) == 0)
> - ? ?{
> - ? ? ?tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
> - ? ? ?tree exp;
> -
> - ? ? ?if ((nargs > 2) || ! fn)
> - ? ? ? return NULL_RTX;
> - ? ? ?expand_expr (build_call_nofold (fn, 2, dest, fmt),
> - ? ? ? ? ? ? ? ? ?const0_rtx, VOIDmode, EXPAND_NORMAL);
> - ? ? ?if (target == const0_rtx)
> - ? ? ? return const0_rtx;
> - ? ? ?exp = build_int_cst (NULL_TREE, strlen (fmt_str));
> - ? ? ?return expand_expr (exp, target, mode, EXPAND_NORMAL);
> - ? ?}
> - ?/* If the format is "%s", use strcpy if the result isn't used. ?*/
> - ?else if (strcmp (fmt_str, target_percent_s) == 0)
> - ? ?{
> - ? ? ?tree fn, arg, len;
> - ? ? ?fn = implicit_built_in_decls[BUILT_IN_STRCPY];
> -
> - ? ? ?if (! fn)
> - ? ? ? return NULL_RTX;
> - ? ? ?if (nargs != 3)
> - ? ? ? return NULL_RTX;
> - ? ? ?arg = CALL_EXPR_ARG (exp, 2);
> - ? ? ?if (! POINTER_TYPE_P (TREE_TYPE (arg)))
> - ? ? ? return NULL_RTX;
> -
> - ? ? ?if (target != const0_rtx)
> - ? ? ? {
> - ? ? ? ? len = c_strlen (arg, 1);
> - ? ? ? ? if (! len || TREE_CODE (len) != INTEGER_CST)
> - ? ? ? ? ? return NULL_RTX;
> - ? ? ? }
> - ? ? ?else
> - ? ? ? len = NULL_TREE;
> -
> - ? ? ?expand_expr (build_call_nofold (fn, 2, dest, arg),
> - ? ? ? ? ? ? ? ? ?const0_rtx, VOIDmode, EXPAND_NORMAL);
> -
> - ? ? ?if (target == const0_rtx)
> - ? ? ? return const0_rtx;
> - ? ? ?return expand_expr (len, target, mode, EXPAND_NORMAL);
> - ? ?}
> -
> - ?return NULL_RTX;
> -}
> -
> ?/* Expand a call to either the entry or exit function profiler. ?*/
>
> ?static rtx
> @@ -6365,36 +6082,6 @@ expand_builtin (tree exp, rtx target, rt
> ? ? ? expand_builtin_unreachable ();
> ? ? ? return const0_rtx;
>
> - ? ?case BUILT_IN_PRINTF:
> - ? ? ?target = expand_builtin_printf (exp, target, mode, false);
> - ? ? ?if (target)
> - ? ? ? return target;
> - ? ? ?break;
> -
> - ? ?case BUILT_IN_PRINTF_UNLOCKED:
> - ? ? ?target = expand_builtin_printf (exp, target, mode, true);
> - ? ? ?if (target)
> - ? ? ? return target;
> - ? ? ?break;
> -
> - ? ?case BUILT_IN_FPRINTF:
> - ? ? ?target = expand_builtin_fprintf (exp, target, mode, false);
> - ? ? ?if (target)
> - ? ? ? return target;
> - ? ? ?break;
> -
> - ? ?case BUILT_IN_FPRINTF_UNLOCKED:
> - ? ? ?target = expand_builtin_fprintf (exp, target, mode, true);
> - ? ? ?if (target)
> - ? ? ? return target;
> - ? ? ?break;
> -
> - ? ?case BUILT_IN_SPRINTF:
> - ? ? ?target = expand_builtin_sprintf (exp, target, mode);
> - ? ? ?if (target)
> - ? ? ? return target;
> - ? ? ?break;
> -
> ? ? CASE_FLT_FN (BUILT_IN_SIGNBIT):
> ? ? case BUILT_IN_SIGNBITD32:
> ? ? case BUILT_IN_SIGNBITD64:
>