Use abstraction instead of setting TREE_ADDRESSABLE
directly. */
- if (TREE_INLINE (fndecl) && extra_warnings && !flag_no_inline)
+ if (DECL_INLINE (fndecl) && extra_warnings && !flag_no_inline)
warning_with_decl (fndecl, "can't inline call to `%s' which was declared inline");
mark_addressable (fndecl);
}
return "nested function cannot be inline";
/* If its not even close, don't even look. */
- if (!TREE_INLINE (fndecl) && get_max_uid () > 3 * max_insns)
+ if (!DECL_INLINE (fndecl) && get_max_uid () > 3 * max_insns)
return "function too large to be inline";
#if 0
/* Large stacks are OK now that inlined functions can share them. */
/* Don't inline functions with large stack usage,
since they can make other recursive functions burn up stack. */
- if (!TREE_INLINE (fndecl) && get_frame_size () > 100)
+ if (!DECL_INLINE (fndecl) && get_frame_size () > 100)
return "function stack frame for inlining";
#endif
if (int_size_in_bytes (TREE_TYPE (parms)) < 0)
return "function with varying-size parameter cannot be inline";
- if (!TREE_INLINE (fndecl) && get_max_uid () > max_insns)
+ if (!DECL_INLINE (fndecl) && get_max_uid () > max_insns)
{
for (ninsns = 0, insn = get_first_nonparm_insn (); insn && ninsns < max_insns;
insn = NEXT_INSN (insn))
FIRST_PARM_INSN (head) = get_insns ();
DECL_SAVED_INSNS (fndecl) = head;
DECL_FRAME_SIZE (fndecl) = get_frame_size ();
- TREE_INLINE (fndecl) = 1;
+ DECL_INLINE (fndecl) = 1;
}
/* Make the insns and PARM_DECLs of the current function permanent
}
else if (DECL_RTL (t))
DECL_RTL (d) = copy_rtx (DECL_RTL (t));
- TREE_EXTERNAL (d) = TREE_EXTERNAL (t);
+ DECL_EXTERNAL (d) = DECL_EXTERNAL (t);
TREE_STATIC (d) = TREE_STATIC (t);
TREE_PUBLIC (d) = TREE_PUBLIC (t);
TREE_CONSTANT (d) = TREE_CONSTANT (t);
case 'd':
mode = DECL_MODE (node);
- if (TREE_EXTERNAL (node))
+ if (DECL_EXTERNAL (node))
fputs (" external", file);
- if (TREE_NONLOCAL (node))
+ if (DECL_NONLOCAL (node))
fputs (" nonlocal", file);
- if (TREE_REGDECL (node))
+ if (DECL_REGISTER (node))
fputs (" regdecl", file);
- if (TREE_INLINE (node))
+ if (DECL_INLINE (node))
fputs (" inline", file);
if (DECL_BIT_FIELD (node))
fputs (" bit-field", file);
indent_to (file, indent + 3);
if (TREE_CODE (node) != FUNCTION_DECL)
fprintf (file, " align %d", DECL_ALIGN (node));
- else if (TREE_INLINE (node))
+ else if (DECL_INLINE (node))
fprintf (file, " frame_size %d", DECL_FRAME_SIZE (node));
else if (DECL_BUILT_IN (node))
fprintf (file, " built-in code %d", DECL_FUNCTION_CODE (node));
context = decl_function_context (decl);
if (context == current_function_decl)
return;
- if (TREE_EXTERNAL (decl))
+ if (DECL_EXTERNAL (decl))
return;
if (GET_CODE (DECL_RTL (decl)) != MEM
|| GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
case VAR_DECL:
/* Don't mention a variable that is external.
Let the file that defines it describe it. */
- if (TREE_EXTERNAL (decl))
+ if (DECL_EXTERNAL (decl))
return;
/* Ignore __FUNCTION__, etc. */
&& DECL_INITIAL (decl) != 0
&& (TREE_ADDRESSABLE (decl)
|| TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl)))
- && ! TREE_EXTERNAL (decl))
+ && ! DECL_EXTERNAL (decl))
output_inline_function (decl);
/* Warn about any function
|| (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl))))
&& TREE_CODE (decl) == FUNCTION_DECL
&& DECL_INITIAL (decl) == 0
- && TREE_EXTERNAL (decl)
+ && DECL_EXTERNAL (decl)
&& ! TREE_PUBLIC (decl))
warning_with_decl (decl, "`%s' declared `static' but never defined");
/* Warn about static fns or vars defined but not used,
&& (TREE_CODE (decl) == FUNCTION_DECL
|| TREE_CODE (decl) == VAR_DECL)
&& ! DECL_IN_SYSTEM_HEADER (decl)
- && ! TREE_EXTERNAL (decl)
+ && ! DECL_EXTERNAL (decl)
&& ! TREE_PUBLIC (decl)
&& ! TREE_USED (decl)
- && ! TREE_INLINE (decl)
+ && ! DECL_INLINE (decl)
/* The TREE_USED bit for file-scope decls
is kept in the identifier, to handle multiple
external decls in different scopes. */
/* Forward declarations for nested functions are not "external",
but we need to treat them as if they were. */
- if (TREE_STATIC (decl) || TREE_EXTERNAL (decl)
+ if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
|| TREE_CODE (decl) == FUNCTION_DECL)
TIMEVAR (varconst_time,
{
|| DECL_IGNORED_P (decl))))
assemble_variable (decl, top_level, at_end);
});
- else if (TREE_REGDECL (decl) && asmspec != 0)
+ else if (DECL_REGISTER (decl) && asmspec != 0)
{
if (decode_reg_name (asmspec) >= 0)
{
if (DECL_SAVED_INSNS (decl) == 0)
{
- int specd = TREE_INLINE (decl);
+ int specd = DECL_INLINE (decl);
char *lose;
/* If requested, consider whether to make this function inline. */
{
if (warn_inline && specd)
warning_with_decl (decl, lose);
- TREE_INLINE (decl) = 0;
+ DECL_INLINE (decl) = 0;
}
else
- TREE_INLINE (decl) = 1;
+ DECL_INLINE (decl) = 1;
});
insns = get_insns ();
finish_compilation will call rest_of_compilation again
for those functions that need to be output. */
- if (TREE_INLINE (decl)
+ if (DECL_INLINE (decl)
&& ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
&& ! flag_keep_inline_functions)
- || TREE_EXTERNAL (decl)))
+ || DECL_EXTERNAL (decl)))
{
TIMEVAR (integration_time, save_for_inline_nocopy (decl));
goto exit_rest_of_compilation;
/* If we have to compile the function now, save its rtl and subdecls
so that its compilation will not affect what others get. */
- if (TREE_INLINE (decl))
+ if (DECL_INLINE (decl))
{
saved_block_tree = DECL_INITIAL (decl);
saved_arguments = DECL_ARGUMENTS (decl);