1 /* Language-specific hook definitions for C front end.
2 Copyright (C) 1991, 1995, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GCC.
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
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
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
26 #include "tree-inline.h"
30 #include "diagnostic.h"
39 #include "insn-config.h"
40 #include "integrate.h"
41 #include "langhooks.h"
42 #include "langhooks-def.h"
44 static int c_tree_printer PARAMS ((output_buffer *));
45 static int c_missing_noreturn_ok_p PARAMS ((tree));
46 static void c_init PARAMS ((void));
47 static void c_init_options PARAMS ((void));
48 static void c_post_options PARAMS ((void));
49 static int c_disregard_inline_limits PARAMS ((tree));
50 static int c_cannot_inline_tree_fn PARAMS ((tree *));
52 #undef LANG_HOOKS_NAME
53 #define LANG_HOOKS_NAME "GNU C"
54 #undef LANG_HOOKS_INIT
55 #define LANG_HOOKS_INIT c_init
56 #undef LANG_HOOKS_INIT_OPTIONS
57 #define LANG_HOOKS_INIT_OPTIONS c_init_options
58 #undef LANG_HOOKS_DECODE_OPTION
59 #define LANG_HOOKS_DECODE_OPTION c_decode_option
60 #undef LANG_HOOKS_POST_OPTIONS
61 #define LANG_HOOKS_POST_OPTIONS c_post_options
62 #undef LANG_HOOKS_GET_ALIAS_SET
63 #define LANG_HOOKS_GET_ALIAS_SET c_common_get_alias_set
64 #undef LANG_HOOKS_PRINT_IDENTIFIER
65 #define LANG_HOOKS_PRINT_IDENTIFIER c_print_identifier
66 #undef LANG_HOOKS_SET_YYDEBUG
67 #define LANG_HOOKS_SET_YYDEBUG c_set_yydebug
69 #undef LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN
70 #define LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN \
71 c_cannot_inline_tree_fn
72 #undef LANG_HOOKS_TREE_INLINING_DISREGARD_INLINE_LIMITS
73 #define LANG_HOOKS_TREE_INLINING_DISREGARD_INLINE_LIMITS \
74 c_disregard_inline_limits
75 #undef LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P
76 #define LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P \
79 /* Each front end provides its own. */
80 const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
82 /* Post-switch processing. */
86 cpp_post_options (parse_in);
88 /* Use tree inlining if possible. Function instrumentation is only
89 done in the RTL level, so we disable tree inlining. */
90 if (! flag_instrument_function_entry_exit)
94 flag_inline_trees = 1;
97 if (flag_inline_functions)
99 flag_inline_trees = 2;
100 flag_inline_functions = 0;
108 parse_in = cpp_create_reader (ident_hash, CLK_GNUC89);
110 /* Mark as "unspecified". */
111 flag_bounds_check = -1;
117 c_common_lang_init ();
119 /* If still unspecified, make it match -std=c99
120 (allowing for -pedantic-errors). */
121 if (mesg_implicit_function_declaration < 0)
124 mesg_implicit_function_declaration = flag_pedantic_errors ? 2 : 1;
126 mesg_implicit_function_declaration = 0;
129 save_lang_status = &push_c_function_context;
130 restore_lang_status = &pop_c_function_context;
131 mark_lang_status = &mark_c_function_context;
132 lang_expand_expr = &c_expand_expr;
133 lang_safe_from_p = &c_safe_from_p;
134 diagnostic_format_decoder (global_dc) = &c_tree_printer;
135 lang_expand_decl_stmt = &c_expand_decl_stmt;
136 lang_missing_noreturn_ok_p = &c_missing_noreturn_ok_p;
141 /* Used by c-lex.c, but only for objc. */
144 lookup_interface (arg)
145 tree arg ATTRIBUTE_UNUSED;
152 tree arg ATTRIBUTE_UNUSED;
158 maybe_objc_check_decl (decl)
159 tree decl ATTRIBUTE_UNUSED;
164 maybe_objc_comptypes (lhs, rhs, reflexive)
165 tree lhs ATTRIBUTE_UNUSED;
166 tree rhs ATTRIBUTE_UNUSED;
167 int reflexive ATTRIBUTE_UNUSED;
173 maybe_building_objc_message_expr ()
179 recognize_objc_keyword ()
184 /* Used by c-typeck.c (build_external_ref), but only for objc. */
187 lookup_objc_ivar (id)
188 tree id ATTRIBUTE_UNUSED;
193 #if !defined(ASM_OUTPUT_CONSTRUCTOR) || !defined(ASM_OUTPUT_DESTRUCTOR)
194 extern tree static_ctors;
195 extern tree static_dtors;
197 static tree start_cdtor PARAMS ((int));
198 static void finish_cdtor PARAMS ((tree));
201 start_cdtor (method_type)
204 tree fnname = get_file_function_name (method_type);
205 tree void_list_node_1 = build_tree_list (NULL_TREE, void_type_node);
208 start_function (void_list_node_1,
209 build_nt (CALL_EXPR, fnname,
210 tree_cons (NULL_TREE, NULL_TREE, void_list_node_1),
215 current_function_cannot_inline
216 = "static constructors and destructors cannot be inlined";
218 body = c_begin_compound_stmt ();
222 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
234 scope = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0);
235 block = poplevel (0, 0, 0);
236 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope)) = block;
237 SCOPE_STMT_BLOCK (TREE_VALUE (scope)) = block;
239 RECHAIN_STMTS (body, COMPOUND_BODY (body));
245 /* Called at end of parsing, but before end-of-file processing. */
250 #ifndef ASM_OUTPUT_CONSTRUCTOR
253 tree body = start_cdtor ('I');
255 for (; static_ctors; static_ctors = TREE_CHAIN (static_ctors))
256 c_expand_expr_stmt (build_function_call (TREE_VALUE (static_ctors),
262 #ifndef ASM_OUTPUT_DESTRUCTOR
265 tree body = start_cdtor ('D');
267 for (; static_dtors; static_dtors = TREE_CHAIN (static_dtors))
268 c_expand_expr_stmt (build_function_call (TREE_VALUE (static_dtors),
276 (*back_end_hook) (getdecls ());
280 FILE *stream = dump_begin (TDI_all, &flags);
284 dump_node (getdecls (), flags & ~TDF_SLIM, stream);
285 dump_end (TDI_all, stream);
290 /* Called during diagnostic message formatting process to print a
291 source-level entity onto BUFFER. The meaning of the format specifiers
294 %F: a function declaration,
297 These format specifiers form a subset of the format specifiers set used
298 by the C++ front-end.
299 Please notice when called, the `%' part was already skipped by the
300 diagnostic machinery. */
302 c_tree_printer (buffer)
303 output_buffer *buffer;
305 tree t = va_arg (output_buffer_format_args (buffer), tree);
307 switch (*output_buffer_text_cursor (buffer))
313 const char *n = DECL_NAME (t)
314 ? (*decl_printable_name) (t, 2)
316 output_add_string (buffer, n);
326 c_missing_noreturn_ok_p (decl)
329 /* A missing noreturn is not ok for freestanding implementations and
330 ok for the `main' function in hosted implementations. */
331 return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
334 /* We want to inline `extern inline' functions even if this would
335 violate inlining limits. Some glibc and linux constructs depend on
336 such functions always being inlined when optimizing. */
339 c_disregard_inline_limits (fn)
342 return DECL_DECLARED_INLINE_P (fn) && DECL_EXTERNAL (fn);
345 static tree inline_forbidden_p PARAMS ((tree *, int *, void *));
348 inline_forbidden_p (nodep, walk_subtrees, fn)
350 int *walk_subtrees ATTRIBUTE_UNUSED;
356 switch (TREE_CODE (node))
359 t = get_callee_fndecl (node);
364 /* We cannot inline functions that call setjmp. */
365 if (setjmp_call_p (t))
368 switch (DECL_FUNCTION_CODE (t))
370 /* We cannot inline functions that take a variable number of
372 case BUILT_IN_VARARGS_START:
373 case BUILT_IN_STDARG_START:
375 /* Functions that need information about the address of the
376 caller can't (shouldn't?) be inlined. */
377 case BUILT_IN_RETURN_ADDRESS:
388 /* We cannot inline functions that contain other functions. */
389 if (TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
390 && DECL_INITIAL (TREE_OPERAND (node, 0)))
396 t = TREE_OPERAND (node, 0);
398 /* We will not inline a function which uses computed goto. The
399 addresses of its local labels, which may be tucked into
400 global storage, are of course not constant across
401 instantiations, which causes unexpected behaviour. */
402 if (TREE_CODE (t) != LABEL_DECL)
405 /* We cannot inline a nested function that jumps to a nonlocal
407 if (TREE_CODE (t) == LABEL_DECL
408 && DECL_CONTEXT (t) && DECL_CONTEXT (t) != fn)
421 c_cannot_inline_tree_fn (fnp)
427 if (! function_attribute_inlinable_p (fn))
429 DECL_UNINLINABLE (fn) = 1;
433 /* If a function has pending sizes, we must not defer its
434 compilation, and we can't inline it as a tree. */
435 if (fn == current_function_decl)
437 t = get_pending_sizes ();
438 put_pending_sizes (t);
442 DECL_UNINLINABLE (fn) = 1;
447 if (DECL_CONTEXT (fn))
449 /* If a nested function has pending sizes, we may have already
451 if (DECL_LANG_SPECIFIC (fn)->pending_sizes)
453 DECL_UNINLINABLE (fn) = 1;
459 /* We rely on the fact that this function is called upfront,
460 just before we start expanding a function. If FN is active
461 (i.e., it's the current_function_decl or a parent thereof),
462 we have to walk FN's saved tree. Otherwise, we can safely
463 assume we have done it before and, if we didn't mark it as
464 uninlinable (in which case we wouldn't have been called), it
465 is inlinable. Unfortunately, this strategy doesn't work for
466 nested functions, because they're only expanded as part of
467 their enclosing functions, so the inlinability test comes in
469 t = current_function_decl;
472 t = DECL_CONTEXT (t);
477 if (walk_tree (&DECL_SAVED_TREE (fn), inline_forbidden_p, fn, NULL))
479 DECL_UNINLINABLE (fn) = 1;