gcc/c-objc-common.c

   1 /* Some code common to C and ObjC front ends.
   2    Copyright (C) 2001 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 2, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING.  If not, write to the Free
  18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  19 02111-1307, USA.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "tree.h"
  24 #include "rtl.h"
  25 #include "insn-config.h"
  26 #include "integrate.h"
  27 #include "expr.h"
  28 #include "c-tree.h"
  29 #include "function.h"
  30 #include "flags.h"
  31 #include "toplev.h"
  32 #include "diagnostic.h"
  33 #include "tree-inline.h"
  34 #include "varray.h"
  35 #include "ggc.h"
  36 #include "langhooks.h"
  37 #include "target.h"
  38
  39 static bool c_tree_printer PARAMS ((output_buffer *, text_info *));
  40 static tree inline_forbidden_p PARAMS ((tree *, int *, void *));
  41 static void expand_deferred_fns PARAMS ((void));
  42 static tree start_cdtor PARAMS ((int));
  43 static void finish_cdtor PARAMS ((tree));
  44
  45 static GTY(()) varray_type deferred_fns;
  46
  47 int
  48 c_missing_noreturn_ok_p (decl)
  49      tree decl;
  50 {
  51   /* A missing noreturn is not ok for freestanding implementations and
  52      ok for the `main' function in hosted implementations.  */
  53   return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
  54 }
  55
  56 /* We want to inline `extern inline' functions even if this would
  57    violate inlining limits.  Some glibc and linux constructs depend on
  58    such functions always being inlined when optimizing.  */
  59
  60 int
  61 c_disregard_inline_limits (fn)
  62      tree fn;
  63 {
  64   if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
  65     return 1;
  66
  67   return DECL_DECLARED_INLINE_P (fn) && DECL_EXTERNAL (fn);
  68 }
  69
  70 static tree
  71 inline_forbidden_p (nodep, walk_subtrees, fn)
  72      tree *nodep;
  73      int *walk_subtrees ATTRIBUTE_UNUSED;
  74      void *fn;
  75 {
  76   tree node = *nodep;
  77   tree t;
  78
  79   switch (TREE_CODE (node))
  80     {
  81     case CALL_EXPR:
  82       t = get_callee_fndecl (node);
  83
  84       if (! t)
  85         break;
  86
  87       /* We cannot inline functions that call setjmp.  */
  88       if (setjmp_call_p (t))
  89         return node;
  90
  91       switch (DECL_FUNCTION_CODE (t))
  92         {
  93           /* We cannot inline functions that take a variable number of
  94              arguments.  */
  95         case BUILT_IN_VA_START:
  96         case BUILT_IN_STDARG_START:
  97 #if 0
  98           /* Functions that need information about the address of the
  99              caller can't (shouldn't?) be inlined.  */
 100         case BUILT_IN_RETURN_ADDRESS:
 101 #endif
 102           return node;
 103
 104         default:
 105           break;
 106         }
 107
 108       break;
 109
 110     case DECL_STMT:
 111       /* We cannot inline functions that contain other functions.  */
 112       if (TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
 113           && DECL_INITIAL (TREE_OPERAND (node, 0)))
 114         return node;
 115       break;
 116
 117     case GOTO_STMT:
 118     case GOTO_EXPR:
 119       t = TREE_OPERAND (node, 0);
 120
 121       /* We will not inline a function which uses computed goto.  The
 122          addresses of its local labels, which may be tucked into
 123          global storage, are of course not constant across
 124          instantiations, which causes unexpected behavior.  */
 125       if (TREE_CODE (t) != LABEL_DECL)
 126         return node;
 127
 128       /* We cannot inline a nested function that jumps to a nonlocal
 129          label.  */
 130       if (TREE_CODE (t) == LABEL_DECL
 131           && DECL_CONTEXT (t) && DECL_CONTEXT (t) != fn)
 132         return node;
 133
 134       break;
 135
 136     default:
 137       break;
 138     }
 139
 140   return NULL_TREE;
 141 }
 142
 143 int
 144 c_cannot_inline_tree_fn (fnp)
 145      tree *fnp;
 146 {
 147   tree fn = *fnp;
 148   tree t;
 149
 150   if (flag_really_no_inline
 151       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL)
 152     return 1;
 153
 154   /* Don't auto-inline anything that might not be bound within
 155      this unit of translation.  */
 156   if (!DECL_DECLARED_INLINE_P (fn) && !(*targetm.binds_local_p) (fn))
 157     goto cannot_inline;
 158
 159   if (! function_attribute_inlinable_p (fn))
 160     goto cannot_inline;
 161
 162   /* If a function has pending sizes, we must not defer its
 163      compilation, and we can't inline it as a tree.  */
 164   if (fn == current_function_decl)
 165     {
 166       t = get_pending_sizes ();
 167       put_pending_sizes (t);
 168
 169       if (t)
 170         goto cannot_inline;
 171     }
 172
 173   if (DECL_CONTEXT (fn))
 174     {
 175       /* If a nested function has pending sizes, we may have already
 176          saved them.  */
 177       if (DECL_LANG_SPECIFIC (fn)->pending_sizes)
 178         goto cannot_inline;
 179     }
 180   else
 181     {
 182       /* We rely on the fact that this function is called upfront,
 183          just before we start expanding a function.  If FN is active
 184          (i.e., it's the current_function_decl or a parent thereof),
 185          we have to walk FN's saved tree.  Otherwise, we can safely
 186          assume we have done it before and, if we didn't mark it as
 187          uninlinable (in which case we wouldn't have been called), it
 188          is inlinable.  Unfortunately, this strategy doesn't work for
 189          nested functions, because they're only expanded as part of
 190          their enclosing functions, so the inlinability test comes in
 191          late.  */
 192       t = current_function_decl;
 193
 194       while (t && t != fn)
 195         t = DECL_CONTEXT (t);
 196       if (! t)
 197         return 0;
 198     }
 199
 200   if (walk_tree (&DECL_SAVED_TREE (fn), inline_forbidden_p, fn, NULL))
 201     goto cannot_inline;
 202
 203   return 0;
 204
 205  cannot_inline:
 206   DECL_UNINLINABLE (fn) = 1;
 207   return 1;
 208 }
 209
 210 /* Called from check_global_declarations.  */
 211
 212 bool
 213 c_warn_unused_global_decl (decl)
 214      tree decl;
 215 {
 216   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
 217     return false;
 218   if (DECL_IN_SYSTEM_HEADER (decl))
 219     return false;
 220
 221   return true;
 222 }
 223
 224 /* Initialization common to C and Objective-C front ends.  */
 225 const char *
 226 c_objc_common_init (filename)
 227      const char *filename;
 228 {
 229   c_init_decl_processing ();
 230
 231   filename = c_common_init (filename);
 232   if (filename == NULL)
 233     return NULL;
 234
 235   lang_expand_decl_stmt = c_expand_decl_stmt;
 236
 237   /* These were not defined in the Objective-C front end, but I'm
 238      putting them here anyway.  The diagnostic format decoder might
 239      want an enhanced ObjC implementation.  */
 240   diagnostic_format_decoder (global_dc) = &c_tree_printer;
 241   lang_missing_noreturn_ok_p = &c_missing_noreturn_ok_p;
 242
 243   /* If still unspecified, make it match -std=c99
 244      (allowing for -pedantic-errors).  */
 245   if (mesg_implicit_function_declaration < 0)
 246     {
 247       if (flag_isoc99)
 248         mesg_implicit_function_declaration = flag_pedantic_errors ? 2 : 1;
 249       else
 250         mesg_implicit_function_declaration = 0;
 251     }
 252
 253   VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns");
 254
 255   return filename;
 256 }
 257
 258 /* Register a function tree, so that its optimization and conversion
 259    to RTL is only done at the end of the compilation.  */
 260
 261 int
 262 defer_fn (fn)
 263      tree fn;
 264 {
 265   VARRAY_PUSH_TREE (deferred_fns, fn);
 266
 267   return 1;
 268 }
 269
 270 /* Expand deferred functions for C and ObjC.  */
 271
 272 static void
 273 expand_deferred_fns ()
 274 {
 275   unsigned int i;
 276
 277   for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_fns); i++)
 278     {
 279       tree decl = VARRAY_TREE (deferred_fns, i);
 280
 281       if (! TREE_ASM_WRITTEN (decl))
 282         {
 283           /* For static inline functions, delay the decision whether to
 284              emit them or not until wrapup_global_declarations.  */
 285           if (! TREE_PUBLIC (decl))
 286             DECL_DEFER_OUTPUT (decl) = 1;
 287           c_expand_deferred_function (decl);
 288         }
 289     }
 290
 291   deferred_fns = 0;
 292 }
 293
 294 static tree
 295 start_cdtor (method_type)
 296      int method_type;
 297 {
 298   tree fnname = get_file_function_name (method_type);
 299   tree void_list_node_1 = build_tree_list (NULL_TREE, void_type_node);
 300   tree body;
 301
 302   start_function (void_list_node_1,
 303                   build_nt (CALL_EXPR, fnname,
 304                             tree_cons (NULL_TREE, NULL_TREE, void_list_node_1),
 305                             NULL_TREE),
 306                   NULL_TREE);
 307   store_parm_decls ();
 308
 309   current_function_cannot_inline
 310     = "static constructors and destructors cannot be inlined";
 311
 312   body = c_begin_compound_stmt ();
 313
 314   pushlevel (0);
 315   clear_last_expr ();
 316   add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
 317
 318   return body;
 319 }
 320
 321 static void
 322 finish_cdtor (body)
 323      tree body;
 324 {
 325   tree scope;
 326   tree block;
 327
 328   scope = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0);
 329   block = poplevel (0, 0, 0);
 330   SCOPE_STMT_BLOCK (TREE_PURPOSE (scope)) = block;
 331   SCOPE_STMT_BLOCK (TREE_VALUE (scope)) = block;
 332
 333   RECHAIN_STMTS (body, COMPOUND_BODY (body));
 334
 335   finish_function (0, 0);
 336 }
 337
 338 /* Called at end of parsing, but before end-of-file processing.  */
 339
 340 void
 341 c_objc_common_finish_file ()
 342 {
 343   expand_deferred_fns ();
 344
 345   if (static_ctors)
 346     {
 347       tree body = start_cdtor ('I');
 348
 349       for (; static_ctors; static_ctors = TREE_CHAIN (static_ctors))
 350         c_expand_expr_stmt (build_function_call (TREE_VALUE (static_ctors),
 351                                                  NULL_TREE));
 352
 353       finish_cdtor (body);
 354     }
 355
 356   if (static_dtors)
 357     {
 358       tree body = start_cdtor ('D');
 359
 360       for (; static_dtors; static_dtors = TREE_CHAIN (static_dtors))
 361         c_expand_expr_stmt (build_function_call (TREE_VALUE (static_dtors),
 362                                                  NULL_TREE));
 363
 364       finish_cdtor (body);
 365     }
 366
 367   {
 368     int flags;
 369     FILE *stream = dump_begin (TDI_all, &flags);
 370
 371     if (stream)
 372       {
 373         dump_node (getdecls (), flags & ~TDF_SLIM, stream);
 374         dump_end (TDI_all, stream);
 375       }
 376   }
 377 }
 378
 379 /* Called during diagnostic message formatting process to print a
 380    source-level entity onto BUFFER.  The meaning of the format specifiers
 381    is as follows:
 382    %D: a general decl,
 383    %F: a function declaration,
 384    %T: a type.
 385
 386    These format specifiers form a subset of the format specifiers set used
 387    by the C++ front-end.
 388    Please notice when called, the `%' part was already skipped by the
 389    diagnostic machinery.  */
 390 static bool
 391 c_tree_printer (buffer, text)
 392      output_buffer *buffer;
 393      text_info *text;
 394 {
 395   tree t = va_arg (*text->args_ptr, tree);
 396
 397   switch (*text->format_spec)
 398     {
 399     case 'D':
 400     case 'F':
 401     case 'T':
 402       {
 403         const char *n = DECL_NAME (t)
 404           ? (*lang_hooks.decl_printable_name) (t, 2)
 405           : "({anonymous})";
 406         output_add_string (buffer, n);
 407       }
 408       return true;
 409
 410     default:
 411       return false;
 412     }
 413 }
 414
 415 #include "gt-c-objc-common.h"