gcc/c-lang.c

   1 /* Language-specific hook definitions for C front end.
   2    Copyright (C) 1991, 1995, 1997, 1998,
   3    1999, 2000, 2001 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "tree.h"
  26 #include "tree-inline.h"
  27 #include "function.h"
  28 #include "input.h"
  29 #include "toplev.h"
  30 #include "diagnostic.h"
  31 #include "output.h"
  32 #include "flags.h"
  33 #include "ggc.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "c-tree.h"
  37 #include "c-lex.h"
  38 #include "cpplib.h"
  39 #include "insn-config.h"
  40 #include "integrate.h"
  41 #include "varray.h"
  42 #include "langhooks.h"
  43 #include "langhooks-def.h"
  44
  45 static int c_tree_printer PARAMS ((output_buffer *));
  46 static int c_missing_noreturn_ok_p PARAMS ((tree));
  47 static const char *c_init PARAMS ((const char *));
  48 static void c_init_options PARAMS ((void));
  49 static void c_post_options PARAMS ((void));
  50 static int c_disregard_inline_limits PARAMS ((tree));
  51 static int c_cannot_inline_tree_fn PARAMS ((tree *));
  52
  53 #undef LANG_HOOKS_NAME
  54 #define LANG_HOOKS_NAME "GNU C"
  55 #undef LANG_HOOKS_INIT
  56 #define LANG_HOOKS_INIT c_init
  57 #undef LANG_HOOKS_FINISH
  58 #define LANG_HOOKS_FINISH c_common_finish
  59 #undef LANG_HOOKS_INIT_OPTIONS
  60 #define LANG_HOOKS_INIT_OPTIONS c_init_options
  61 #undef LANG_HOOKS_DECODE_OPTION
  62 #define LANG_HOOKS_DECODE_OPTION c_decode_option
  63 #undef LANG_HOOKS_POST_OPTIONS
  64 #define LANG_HOOKS_POST_OPTIONS c_post_options
  65 #undef LANG_HOOKS_GET_ALIAS_SET
  66 #define LANG_HOOKS_GET_ALIAS_SET c_common_get_alias_set
  67 #undef LANG_HOOKS_PRINT_IDENTIFIER
  68 #define LANG_HOOKS_PRINT_IDENTIFIER c_print_identifier
  69 #undef LANG_HOOKS_SET_YYDEBUG
  70 #define LANG_HOOKS_SET_YYDEBUG c_set_yydebug
  71
  72 #undef LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN
  73 #define LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN \
  74   c_cannot_inline_tree_fn
  75 #undef LANG_HOOKS_TREE_INLINING_DISREGARD_INLINE_LIMITS
  76 #define LANG_HOOKS_TREE_INLINING_DISREGARD_INLINE_LIMITS \
  77   c_disregard_inline_limits
  78 #undef LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P
  79 #define LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P \
  80   anon_aggr_type_p
  81
  82 /* Each front end provides its own.  */
  83 const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
  84
  85 static varray_type deferred_fns;
  86
  87 /* Post-switch processing.  */
  88 static void
  89 c_post_options ()
  90 {
  91   cpp_post_options (parse_in);
  92
  93   /* Use tree inlining if possible.  Function instrumentation is only
  94      done in the RTL level, so we disable tree inlining.  */
  95   if (! flag_instrument_function_entry_exit)
  96     {
  97       if (!flag_no_inline)
  98         {
  99           flag_inline_trees = 1;
 100           flag_no_inline = 1;
 101         }
 102       if (flag_inline_functions)
 103         {
 104           flag_inline_trees = 2;
 105           flag_inline_functions = 0;
 106         }
 107     }
 108 }
 109
 110 static void
 111 c_init_options ()
 112 {
 113   parse_in = cpp_create_reader (CLK_GNUC89);
 114
 115   /* Mark as "unspecified".  */
 116   flag_bounds_check = -1;
 117 }
 118
 119 static const char *
 120 c_init (filename)
 121      const char *filename;
 122 {
 123   c_init_decl_processing ();
 124
 125   filename = c_common_lang_init (filename);
 126
 127   add_c_tree_codes ();
 128
 129   /* If still unspecified, make it match -std=c99
 130      (allowing for -pedantic-errors).  */
 131   if (mesg_implicit_function_declaration < 0)
 132     {
 133       if (flag_isoc99)
 134         mesg_implicit_function_declaration = flag_pedantic_errors ? 2 : 1;
 135       else
 136         mesg_implicit_function_declaration = 0;
 137     }
 138
 139   save_lang_status = &push_c_function_context;
 140   restore_lang_status = &pop_c_function_context;
 141   mark_lang_status = &mark_c_function_context;
 142   lang_expand_expr = &c_expand_expr;
 143   lang_safe_from_p = &c_safe_from_p;
 144   diagnostic_format_decoder (global_dc) = &c_tree_printer;
 145   lang_expand_decl_stmt = &c_expand_decl_stmt;
 146   lang_missing_noreturn_ok_p = &c_missing_noreturn_ok_p;
 147
 148   VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns");
 149   ggc_add_tree_varray_root (&deferred_fns, 1);
 150
 151   return filename;
 152 }
 153
 154 /* Used by c-lex.c, but only for objc.  */
 155
 156 tree
 157 lookup_interface (arg)
 158      tree arg ATTRIBUTE_UNUSED;
 159 {
 160   return 0;
 161 }
 162
 163 tree
 164 is_class_name (arg)
 165     tree arg ATTRIBUTE_UNUSED;
 166 {
 167   return 0;
 168 }
 169
 170 void
 171 maybe_objc_check_decl (decl)
 172      tree decl ATTRIBUTE_UNUSED;
 173 {
 174 }
 175
 176 int
 177 maybe_objc_comptypes (lhs, rhs, reflexive)
 178      tree lhs ATTRIBUTE_UNUSED;
 179      tree rhs ATTRIBUTE_UNUSED;
 180      int reflexive ATTRIBUTE_UNUSED;
 181 {
 182   return -1;
 183 }
 184
 185 tree
 186 maybe_building_objc_message_expr ()
 187 {
 188   return 0;
 189 }
 190
 191 int
 192 recognize_objc_keyword ()
 193 {
 194   return 0;
 195 }
 196
 197 /* Used by c-typeck.c (build_external_ref), but only for objc.  */
 198
 199 tree
 200 lookup_objc_ivar (id)
 201      tree id ATTRIBUTE_UNUSED;
 202 {
 203   return 0;
 204 }
 205
 206 extern tree static_ctors;
 207 extern tree static_dtors;
 208
 209 static tree start_cdtor         PARAMS ((int));
 210 static void finish_cdtor        PARAMS ((tree));
 211
 212 static tree
 213 start_cdtor (method_type)
 214      int method_type;
 215 {
 216   tree fnname = get_file_function_name (method_type);
 217   tree void_list_node_1 = build_tree_list (NULL_TREE, void_type_node);
 218   tree body;
 219
 220   start_function (void_list_node_1,
 221                   build_nt (CALL_EXPR, fnname,
 222                             tree_cons (NULL_TREE, NULL_TREE, void_list_node_1),
 223                             NULL_TREE),
 224                   NULL_TREE);
 225   store_parm_decls ();
 226
 227   current_function_cannot_inline
 228     = "static constructors and destructors cannot be inlined";
 229
 230   body = c_begin_compound_stmt ();
 231
 232   pushlevel (0);
 233   clear_last_expr ();
 234   add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
 235
 236   return body;
 237 }
 238
 239 static void
 240 finish_cdtor (body)
 241      tree body;
 242 {
 243   tree scope;
 244   tree block;
 245
 246   scope = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0);
 247   block = poplevel (0, 0, 0);
 248   SCOPE_STMT_BLOCK (TREE_PURPOSE (scope)) = block;
 249   SCOPE_STMT_BLOCK (TREE_VALUE (scope)) = block;
 250
 251   RECHAIN_STMTS (body, COMPOUND_BODY (body));
 252
 253   finish_function (0);
 254 }
 255
 256 /* Register a function tree, so that its optimization and conversion
 257    to RTL is only done at the end of the compilation.  */
 258
 259 int
 260 defer_fn (fn)
 261      tree fn;
 262 {
 263   VARRAY_PUSH_TREE (deferred_fns, fn);
 264
 265   return 1;
 266 }
 267
 268 /* Called at end of parsing, but before end-of-file processing.  */
 269
 270 void
 271 finish_file ()
 272 {
 273   unsigned int i;
 274
 275   for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_fns); i++)
 276     {
 277       tree decl = VARRAY_TREE (deferred_fns, i);
 278
 279       if (! TREE_ASM_WRITTEN (decl))
 280         {
 281           /* For static inline functions, delay the decision whether to
 282              emit them or not until wrapup_global_declarations.  */
 283           if (! TREE_PUBLIC (decl))
 284             DECL_DEFER_OUTPUT (decl) = 1;
 285           c_expand_deferred_function (decl);
 286         }
 287     }
 288   VARRAY_FREE (deferred_fns);
 289
 290   if (static_ctors)
 291     {
 292       tree body = start_cdtor ('I');
 293
 294       for (; static_ctors; static_ctors = TREE_CHAIN (static_ctors))
 295         c_expand_expr_stmt (build_function_call (TREE_VALUE (static_ctors),
 296                                                  NULL_TREE));
 297
 298       finish_cdtor (body);
 299     }
 300   if (static_dtors)
 301     {
 302       tree body = start_cdtor ('D');
 303
 304       for (; static_dtors; static_dtors = TREE_CHAIN (static_dtors))
 305         c_expand_expr_stmt (build_function_call (TREE_VALUE (static_dtors),
 306                                                  NULL_TREE));
 307
 308       finish_cdtor (body);
 309     }
 310
 311   if (back_end_hook)
 312     (*back_end_hook) (getdecls ());
 313
 314   {
 315     int flags;
 316     FILE *stream = dump_begin (TDI_all, &flags);
 317
 318     if (stream)
 319       {
 320         dump_node (getdecls (), flags & ~TDF_SLIM, stream);
 321         dump_end (TDI_all, stream);
 322       }
 323   }
 324 }
 325
 326 /* Called during diagnostic message formatting process to print a
 327    source-level entity onto BUFFER.  The meaning of the format specifiers
 328    is as follows:
 329    %D: a general decl,
 330    %F: a function declaration,
 331    %T: a type.
 332
 333    These format specifiers form a subset of the format specifiers set used
 334    by the C++ front-end.
 335    Please notice when called, the `%' part was already skipped by the
 336    diagnostic machinery.  */
 337 static int
 338 c_tree_printer (buffer)
 339      output_buffer *buffer;
 340 {
 341   tree t = va_arg (output_buffer_format_args (buffer), tree);
 342
 343   switch (*output_buffer_text_cursor (buffer))
 344     {
 345     case 'D':
 346     case 'F':
 347     case 'T':
 348       {
 349         const char *n = DECL_NAME (t)
 350           ? (*decl_printable_name) (t, 2)
 351           : "({anonymous})";
 352         output_add_string (buffer, n);
 353       }
 354       return 1;
 355
 356     default:
 357       return 0;
 358     }
 359 }
 360
 361 static int
 362 c_missing_noreturn_ok_p (decl)
 363      tree decl;
 364 {
 365   /* A missing noreturn is not ok for freestanding implementations and
 366      ok for the `main' function in hosted implementations.  */
 367   return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
 368 }
 369
 370 /* We want to inline `extern inline' functions even if this would
 371    violate inlining limits.  Some glibc and linux constructs depend on
 372    such functions always being inlined when optimizing.  */
 373
 374 static int
 375 c_disregard_inline_limits (fn)
 376      tree fn;
 377 {
 378   return DECL_DECLARED_INLINE_P (fn) && DECL_EXTERNAL (fn);
 379 }
 380
 381 static tree inline_forbidden_p PARAMS ((tree *, int *, void *));
 382
 383 static tree
 384 inline_forbidden_p (nodep, walk_subtrees, fn)
 385      tree *nodep;
 386      int *walk_subtrees ATTRIBUTE_UNUSED;
 387      void *fn;
 388 {
 389   tree node = *nodep;
 390   tree t;
 391
 392   switch (TREE_CODE (node))
 393     {
 394     case CALL_EXPR:
 395       t = get_callee_fndecl (node);
 396
 397       if (! t)
 398         break;
 399
 400       /* We cannot inline functions that call setjmp.  */
 401       if (setjmp_call_p (t))
 402         return node;
 403
 404       switch (DECL_FUNCTION_CODE (t))
 405         {
 406           /* We cannot inline functions that take a variable number of
 407              arguments.  */
 408         case BUILT_IN_VARARGS_START:
 409         case BUILT_IN_STDARG_START:
 410 #if 0
 411           /* Functions that need information about the address of the
 412              caller can't (shouldn't?) be inlined.  */
 413         case BUILT_IN_RETURN_ADDRESS:
 414 #endif
 415           return node;
 416
 417         default:
 418           break;
 419         }
 420
 421       break;
 422
 423     case DECL_STMT:
 424       /* We cannot inline functions that contain other functions.  */
 425       if (TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
 426           && DECL_INITIAL (TREE_OPERAND (node, 0)))
 427         return node;
 428       break;
 429
 430     case GOTO_STMT:
 431     case GOTO_EXPR:
 432       t = TREE_OPERAND (node, 0);
 433
 434       /* We will not inline a function which uses computed goto.  The
 435          addresses of its local labels, which may be tucked into
 436          global storage, are of course not constant across
 437          instantiations, which causes unexpected behaviour.  */
 438       if (TREE_CODE (t) != LABEL_DECL)
 439         return node;
 440
 441       /* We cannot inline a nested function that jumps to a nonlocal
 442          label.  */
 443       if (TREE_CODE (t) == LABEL_DECL
 444           && DECL_CONTEXT (t) && DECL_CONTEXT (t) != fn)
 445         return node;
 446
 447       break;
 448
 449     default:
 450       break;
 451     }
 452
 453   return NULL_TREE;
 454 }
 455
 456 static int
 457 c_cannot_inline_tree_fn (fnp)
 458      tree *fnp;
 459 {
 460   tree fn = *fnp;
 461   tree t;
 462
 463   if (! function_attribute_inlinable_p (fn))
 464     {
 465       DECL_UNINLINABLE (fn) = 1;
 466       return 1;
 467     }
 468
 469   /* If a function has pending sizes, we must not defer its
 470      compilation, and we can't inline it as a tree.  */
 471   if (fn == current_function_decl)
 472     {
 473       t = get_pending_sizes ();
 474       put_pending_sizes (t);
 475
 476       if (t)
 477         {
 478           DECL_UNINLINABLE (fn) = 1;
 479           return 1;
 480         }
 481     }
 482
 483   if (DECL_CONTEXT (fn))
 484     {
 485       /* If a nested function has pending sizes, we may have already
 486          saved them.  */
 487       if (DECL_LANG_SPECIFIC (fn)->pending_sizes)
 488         {
 489           DECL_UNINLINABLE (fn) = 1;
 490           return 1;
 491         }
 492     }
 493   else
 494     {
 495       /* We rely on the fact that this function is called upfront,
 496          just before we start expanding a function.  If FN is active
 497          (i.e., it's the current_function_decl or a parent thereof),
 498          we have to walk FN's saved tree.  Otherwise, we can safely
 499          assume we have done it before and, if we didn't mark it as
 500          uninlinable (in which case we wouldn't have been called), it
 501          is inlinable.  Unfortunately, this strategy doesn't work for
 502          nested functions, because they're only expanded as part of
 503          their enclosing functions, so the inlinability test comes in
 504          late.  */
 505       t = current_function_decl;
 506
 507       while (t && t != fn)
 508         t = DECL_CONTEXT (t);
 509       if (! t)
 510         return 0;
 511     }
 512
 513   if (walk_tree (&DECL_SAVED_TREE (fn), inline_forbidden_p, fn, NULL))
 514     {
 515       DECL_UNINLINABLE (fn) = 1;
 516       return 1;
 517     }
 518
 519   return 0;
 520 }