1 /* Some code common to C and ObjC front ends.
2 Copyright (C) 2001, 2002 Free Software Foundation, Inc.
4 This file is part of GCC.
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
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
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
23 #include "coretypes.h"
27 #include "insn-config.h"
28 #include "integrate.h"
34 #include "diagnostic.h"
35 #include "tree-inline.h"
38 #include "langhooks.h"
42 static bool c_tree_printer PARAMS ((output_buffer *, text_info *));
43 static tree inline_forbidden_p PARAMS ((tree *, int *, void *));
44 static void expand_deferred_fns PARAMS ((void));
45 static tree start_cdtor PARAMS ((int));
46 static void finish_cdtor PARAMS ((tree));
48 static GTY(()) varray_type deferred_fns;
51 c_missing_noreturn_ok_p (decl)
54 /* A missing noreturn is not ok for freestanding implementations and
55 ok for the `main' function in hosted implementations. */
56 return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
59 /* We want to inline `extern inline' functions even if this would
60 violate inlining limits. Some glibc and linux constructs depend on
61 such functions always being inlined when optimizing. */
64 c_disregard_inline_limits (fn)
67 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
70 return DECL_DECLARED_INLINE_P (fn) && DECL_EXTERNAL (fn);
74 inline_forbidden_p (nodep, walk_subtrees, fn)
76 int *walk_subtrees ATTRIBUTE_UNUSED;
82 switch (TREE_CODE (node))
85 t = get_callee_fndecl (node);
90 /* We cannot inline functions that call setjmp. */
91 if (setjmp_call_p (t))
94 switch (DECL_FUNCTION_CODE (t))
96 /* We cannot inline functions that take a variable number of
98 case BUILT_IN_VA_START:
99 case BUILT_IN_STDARG_START:
101 /* Functions that need information about the address of the
102 caller can't (shouldn't?) be inlined. */
103 case BUILT_IN_RETURN_ADDRESS:
114 /* We cannot inline functions that contain other functions. */
115 if (TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
116 && DECL_INITIAL (TREE_OPERAND (node, 0)))
122 t = TREE_OPERAND (node, 0);
124 /* We will not inline a function which uses computed goto. The
125 addresses of its local labels, which may be tucked into
126 global storage, are of course not constant across
127 instantiations, which causes unexpected behavior. */
128 if (TREE_CODE (t) != LABEL_DECL)
131 /* We cannot inline a nested function that jumps to a nonlocal
133 if (TREE_CODE (t) == LABEL_DECL
134 && DECL_CONTEXT (t) && DECL_CONTEXT (t) != fn)
141 /* We cannot inline a function of the form
143 void F (int i) { struct S { int ar[i]; } s; }
145 Attempting to do so produces a catch-22 in tree-inline.c.
146 If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/
147 UNION_TYPE nodes, then it goes into infinite recursion on a
148 structure containing a pointer to its own type. If it doesn't,
149 then the type node for S doesn't get adjusted properly when
150 F is inlined, and we abort in find_function_data. */
151 for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t))
152 if (variably_modified_type_p (TREE_TYPE (t)))
163 c_cannot_inline_tree_fn (fnp)
169 if (flag_really_no_inline
170 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL)
173 /* Don't auto-inline anything that might not be bound within
174 this unit of translation. */
175 if (!DECL_DECLARED_INLINE_P (fn) && !(*targetm.binds_local_p) (fn))
178 if (! function_attribute_inlinable_p (fn))
181 /* If a function has pending sizes, we must not defer its
182 compilation, and we can't inline it as a tree. */
183 if (fn == current_function_decl)
185 t = get_pending_sizes ();
186 put_pending_sizes (t);
192 if (DECL_CONTEXT (fn))
194 /* If a nested function has pending sizes, we may have already
196 if (DECL_LANG_SPECIFIC (fn)->pending_sizes)
201 /* We rely on the fact that this function is called upfront,
202 just before we start expanding a function. If FN is active
203 (i.e., it's the current_function_decl or a parent thereof),
204 we have to walk FN's saved tree. Otherwise, we can safely
205 assume we have done it before and, if we didn't mark it as
206 uninlinable (in which case we wouldn't have been called), it
207 is inlinable. Unfortunately, this strategy doesn't work for
208 nested functions, because they're only expanded as part of
209 their enclosing functions, so the inlinability test comes in
211 t = current_function_decl;
214 t = DECL_CONTEXT (t);
219 if (walk_tree (&DECL_SAVED_TREE (fn), inline_forbidden_p, fn, NULL))
225 DECL_UNINLINABLE (fn) = 1;
229 /* Called from check_global_declarations. */
232 c_warn_unused_global_decl (decl)
235 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
237 if (DECL_IN_SYSTEM_HEADER (decl))
243 /* Initialization common to C and Objective-C front ends. */
245 c_objc_common_init (filename)
246 const char *filename;
248 c_init_decl_processing ();
250 filename = c_common_init (filename);
251 if (filename == NULL)
254 lang_expand_decl_stmt = c_expand_decl_stmt;
256 /* These were not defined in the Objective-C front end, but I'm
257 putting them here anyway. The diagnostic format decoder might
258 want an enhanced ObjC implementation. */
259 diagnostic_format_decoder (global_dc) = &c_tree_printer;
260 lang_missing_noreturn_ok_p = &c_missing_noreturn_ok_p;
262 /* If still unspecified, make it match -std=c99
263 (allowing for -pedantic-errors). */
264 if (mesg_implicit_function_declaration < 0)
267 mesg_implicit_function_declaration = flag_pedantic_errors ? 2 : 1;
269 mesg_implicit_function_declaration = 0;
272 VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns");
277 /* Register a function tree, so that its optimization and conversion
278 to RTL is only done at the end of the compilation. */
284 VARRAY_PUSH_TREE (deferred_fns, fn);
289 /* Expand deferred functions for C and ObjC. */
292 expand_deferred_fns ()
296 for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_fns); i++)
298 tree decl = VARRAY_TREE (deferred_fns, i);
300 if (! TREE_ASM_WRITTEN (decl))
302 /* For static inline functions, delay the decision whether to
303 emit them or not until wrapup_global_declarations. */
304 if (! TREE_PUBLIC (decl))
305 DECL_DEFER_OUTPUT (decl) = 1;
306 c_expand_deferred_function (decl);
314 start_cdtor (method_type)
317 tree fnname = get_file_function_name (method_type);
318 tree void_list_node_1 = build_tree_list (NULL_TREE, void_type_node);
321 start_function (void_list_node_1,
322 build_nt (CALL_EXPR, fnname,
323 tree_cons (NULL_TREE, NULL_TREE, void_list_node_1),
328 current_function_cannot_inline
329 = "static constructors and destructors cannot be inlined";
331 body = c_begin_compound_stmt ();
335 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
347 scope = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0);
348 block = poplevel (0, 0, 0);
349 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope)) = block;
350 SCOPE_STMT_BLOCK (TREE_VALUE (scope)) = block;
352 RECHAIN_STMTS (body, COMPOUND_BODY (body));
354 finish_function (0, 0);
357 /* Called at end of parsing, but before end-of-file processing. */
360 c_objc_common_finish_file ()
363 c_common_write_pch ();
365 if (flag_unit_at_a_time)
367 cgraph_finalize_compilation_unit ();
371 expand_deferred_fns ();
375 tree body = start_cdtor ('I');
377 for (; static_ctors; static_ctors = TREE_CHAIN (static_ctors))
378 c_expand_expr_stmt (build_function_call (TREE_VALUE (static_ctors),
386 tree body = start_cdtor ('D');
388 for (; static_dtors; static_dtors = TREE_CHAIN (static_dtors))
389 c_expand_expr_stmt (build_function_call (TREE_VALUE (static_dtors),
397 FILE *stream = dump_begin (TDI_all, &flags);
401 dump_node (getdecls (), flags & ~TDF_SLIM, stream);
402 dump_end (TDI_all, stream);
407 /* Called during diagnostic message formatting process to print a
408 source-level entity onto BUFFER. The meaning of the format specifiers
411 %F: a function declaration,
414 These format specifiers form a subset of the format specifiers set used
415 by the C++ front-end.
416 Please notice when called, the `%' part was already skipped by the
417 diagnostic machinery. */
419 c_tree_printer (buffer, text)
420 output_buffer *buffer;
423 tree t = va_arg (*text->args_ptr, tree);
425 switch (*text->format_spec)
431 const char *n = DECL_NAME (t)
432 ? (*lang_hooks.decl_printable_name) (t, 2)
434 output_add_string (buffer, n);
443 #include "gt-c-objc-common.h"