[gcc最適化]printfがputs呼び出しに置き換えられる場合がある

#include<stdio.h>
 
int main()
{
    printf( "test0\n" );                // puts
 
    printf( "test1" );                  // printf
 
    printf( "test2:%s\n", "test2" );    // printf
 
    printf( "%s", "test3\n" );          // puts
 
    printf( "%s\n", "test4" );          // puts
 
    printf( "test5%s\n", "test5" );     // puts
 
    printf( "A" );                      // putchar
 
    printf( "%c", '6' );                // putchar
 
    printf( "%c\n", '7' );              // printf
 
    printf( "%%" );                     // printf
}

$ gcc -S opt.c
 
 
$ cat opt.s
    .file   "opt.c"
    .section    .rodata
.LC0:
    .string "test0"
.LC1:
    .string "test1"
.LC2:
    .string "test2:%s\n"
.LC3:
    .string "test2"
.LC4:
    .string "test3"
.LC5:
    .string "test4"
.LC6:
    .string "test5%s\n"
.LC7:
    .string "test5"
.LC8:
    .string "%c\n"
.LC9:
    .string "%%"
    .text
    .globl  main
    .type   main, @function
main:
.LFB0:
    .cfi_startproc
    pushl   %ebp
    .cfi_def_cfa_offset 8
    .cfi_offset 5, -8
    movl    %esp, %ebp
    .cfi_def_cfa_register 5
    andl    $-16, %esp
    subl    $16, %esp
    movl    $.LC0, (%esp)
    call    puts
    movl    $.LC1, %eax
    movl    %eax, (%esp)
    call    printf
    movl    $.LC2, %eax
    movl    $.LC3, 4(%esp)
    movl    %eax, (%esp)
    call    printf
    movl    $.LC4, (%esp)
    call    puts
    movl    $.LC5, (%esp)
    call    puts
    movl    $.LC6, %eax
    movl    $.LC7, 4(%esp)
    movl    %eax, (%esp)
    call    printf
    movl    $65, (%esp)
    call    putchar
    movl    $54, (%esp)
    call    putchar
    movl    $.LC8, %eax
    movl    $55, 4(%esp)
    movl    %eax, (%esp)
    call    printf
    movl    $.LC9, %eax
    movl    %eax, (%esp)
    call    printf
    leave
    .cfi_restore 5
    .cfi_def_cfa 4, 4
    ret
    .cfi_endproc
.LFE0:
    .size   main, .-main
    .ident  "GCC: (Ubuntu/Linaro 4.6.1-9ubuntu3) 4.6.1"
    .section    .note.GNU-stack,"",@progbits

    printf( "test0\n" );                // puts
    printf( "%s", "test3\n" );          // puts
    printf( "%s\n", "test4" );          // puts
    printf( "test5%s\n", "test5" );     // puts (-O0だとprintfになる)

    printf( "test1" );

    printf( "A" );                      // putchar
    printf( "%c", '6' );                // putchar

    printf( "%%\n" );                   // printf

static rtx
c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
     tree arglist;
     rtx target;
     enum machine_mode tmode;
     enum expand_modifier modifier;
     int ignore;
     int unlocked;
{
  tree fn_putchar = unlocked ?
    built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
  tree fn_puts = unlocked ?
    built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
  tree fn, format_arg, stripped_string;
 
  /* If the return value is used, or the replacement _DECL isn't
     initialized, don't do the transformation.  */
  if (!ignore || !fn_putchar || !fn_puts)
    return 0;
 
  /* Verify the required arguments in the original call.  */
  if (arglist == 0
      || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
    return 0;
 
  /* Check the specifier vs. the parameters.  */
  if (!is_valid_printf_arglist (arglist))
    return 0;
 
  format_arg = TREE_VALUE (arglist);
  stripped_string = format_arg;
  STRIP_NOPS (stripped_string);
  if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
    stripped_string = TREE_OPERAND (stripped_string, 0);
 
  /* If the format specifier isn't a STRING_CST, punt.  */
  if (TREE_CODE (stripped_string) != STRING_CST)
    return 0;
 
  /* OK!  We can attempt optimization.  */
 
  /* If the format specifier was "%s\n", call __builtin_puts(arg2).  */
  if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
    {
      arglist = TREE_CHAIN (arglist);
      fn = fn_puts;
    }
  /* If the format specifier was "%c", call __builtin_putchar (arg2).  */
  else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
    {
      arglist = TREE_CHAIN (arglist);
      fn = fn_putchar;
    }
  else
    {
      /* We can't handle anything else with % args or %% ... yet.  */
      if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
  return 0;
 
      /* If the resulting constant string has a length of 1, call
         putchar.  Note, TREE_STRING_LENGTH includes the terminating
         NULL in its count.  */
      if (TREE_STRING_LENGTH (stripped_string) == 2)
        {
    /* Given printf("c"), (where c is any one character,)
             convert "c"[0] to an int and pass that to the replacement
             function.  */
    arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
    arglist = build_tree_list (NULL_TREE, arglist);
 
    fn = fn_putchar;
        }
      /* If the resulting constant was "string\n", call
         __builtin_puts("string").  Ensure "string" has at least one
         character besides the trailing \n.  Note, TREE_STRING_LENGTH
         includes the terminating NULL in its count.  */
      else if (TREE_STRING_LENGTH (stripped_string) > 2
         && TREE_STRING_POINTER (stripped_string)
         [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
        {
    /* Create a NULL-terminated string that's one char shorter
       than the original, stripping off the trailing '\n'.  */
    const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
    char *newstr = (char *) alloca (newlen);
    memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
    newstr[newlen - 1] = 0;
 
    arglist = fix_string_type (build_string (newlen, newstr));
    arglist = build_tree_list (NULL_TREE, arglist);
    fn = fn_puts;
  }
      else
  /* We'd like to arrange to call fputs(string) here, but we
           need stdout and don't have a way to get it ... yet.  */
  return 0;
    }
 
  return expand_expr (build_function_call (fn, arglist),
          (ignore ? const0_rtx : target),
          tmode, modifier);
}