void
c_common_write_pch (void)
{
timevar_push (TV_PCH_SAVE);
targetm.prepare_pch_save ();
(*debug_hooks->handle_pch) (1);
cpp_write_pch_deps (parse_in, pch_outfile);
gt_pch_save (pch_outfile);
timevar_push (TV_PCH_CPP_SAVE);
cpp_write_pch_state (parse_in, pch_outfile);
timevar_pop (TV_PCH_CPP_SAVE);
if (fseek (pch_outfile, 0, SEEK_SET) != 0
|| fwrite (get_ident (), IDENT_LENGTH, 1, pch_outfile) != 1)
fatal_error ("can%'t write %s: %m", pch_file);
fclose (pch_outfile);
timevar_pop (TV_PCH_SAVE);
}
/* Output all variables enqueued to be assembled. */
bool
varpool_assemble_pending_decls (void)
{
bool changed = false;
if (seen_error ())
return false;
timevar_push (TV_VAROUT);
/* EH might mark decls as needed during expansion. This should be safe since
we don't create references to new function, but it should not be used
elsewhere. */
varpool_analyze_pending_decls ();
while (varpool_nodes_queue)
{
struct varpool_node *node = varpool_nodes_queue;
varpool_nodes_queue = varpool_nodes_queue->next_needed;
if (varpool_assemble_decl (node))
changed = true;
else
{
node->prev_needed = NULL;
node->next_needed = NULL;
}
}
/* varpool_nodes_queue is now empty, clear the pointer to the last element
in the queue. */
varpool_last_needed_node = NULL;
timevar_pop (TV_VAROUT);
return changed;
}
void
build_type_inheritance_graph (void)
{
struct cgraph_node *n;
FILE *inheritance_dump_file;
int flags;
if (odr_hash.is_created ())
return;
timevar_push (TV_IPA_INHERITANCE);
inheritance_dump_file = dump_begin (TDI_inheritance, &flags);
odr_hash.create (23);
/* We reconstruct the graph starting of types of all methods seen in the
the unit. */
FOR_EACH_FUNCTION (n)
if (DECL_VIRTUAL_P (n->decl)
&& symtab_real_symbol_p (n))
get_odr_type (method_class_type (TREE_TYPE (n->decl)), true);
if (inheritance_dump_file)
{
dump_type_inheritance_graph (inheritance_dump_file);
dump_end (TDI_inheritance, inheritance_dump_file);
}
timevar_pop (TV_IPA_INHERITANCE);
}
/* Walk the decls we marked as necessary and see if they reference new
variables or functions and add them into the worklists. */
bool
varpool_analyze_pending_decls (void)
{
bool changed = false;
timevar_push (TV_CGRAPH);
while (varpool_first_unanalyzed_node)
{
tree decl = varpool_first_unanalyzed_node->decl;
bool analyzed = varpool_first_unanalyzed_node->analyzed;
varpool_first_unanalyzed_node->analyzed = true;
varpool_first_unanalyzed_node = varpool_first_unanalyzed_node->next_needed;
/* When reading back varpool at LTO time, we re-construct the queue in order
to have "needed" list right by inserting all needed nodes into varpool.
We however don't want to re-analyze already analyzed nodes. */
if (!analyzed)
{
gcc_assert (!in_lto_p);
/* Compute the alignment early so function body expanders are
already informed about increased alignment. */
align_variable (decl, 0);
}
if (DECL_INITIAL (decl))
record_references_in_initializer (decl, analyzed);
changed = true;
}
timevar_pop (TV_CGRAPH);
return changed;
}
unsigned int
inline_transform (struct cgraph_node *node)
{
unsigned int todo = 0;
struct cgraph_edge *e;
/* FIXME: Currently the pass manager is adding inline transform more than
once to some clones. This needs revisiting after WPA cleanups. */
if (cfun->after_inlining)
return 0;
/* We might need the body of this function so that we can expand
it inline somewhere else. */
if (preserve_function_body_p (node))
save_inline_function_body (node);
for (e = node->callees; e; e = e->next_callee)
cgraph_redirect_edge_call_stmt_to_callee (e);
timevar_push (TV_INTEGRATION);
if (node->callees)
todo = optimize_inline_calls (current_function_decl);
timevar_pop (TV_INTEGRATION);
cfun->always_inline_functions_inlined = true;
cfun->after_inlining = true;
todo |= execute_fixup_cfg ();
if (!(todo & TODO_update_ssa_any))
/* Redirecting edges might lead to a need for vops to be recomputed. */
todo |= TODO_update_ssa_only_virtuals;
return todo;
}
void
lto_end_compression (struct lto_compression_stream *stream)
{
unsigned char *cursor = (unsigned char *) stream->buffer;
size_t remaining = stream->bytes;
const size_t outbuf_length = Z_BUFFER_LENGTH;
unsigned char *outbuf = (unsigned char *) xmalloc (outbuf_length);
z_stream out_stream;
size_t compressed_bytes = 0;
int status;
gcc_assert (stream->is_compression);
timevar_push (TV_IPA_LTO_COMPRESS);
out_stream.next_out = outbuf;
out_stream.avail_out = outbuf_length;
out_stream.next_in = cursor;
out_stream.avail_in = remaining;
out_stream.zalloc = lto_zalloc;
out_stream.zfree = lto_zfree;
out_stream.opaque = Z_NULL;
status = deflateInit (&out_stream, lto_normalized_zlib_level ());
if (status != Z_OK)
internal_error ("compressed stream: %s", zError (status));
do
{
size_t in_bytes, out_bytes;
status = deflate (&out_stream, Z_FINISH);
if (status != Z_OK && status != Z_STREAM_END)
internal_error ("compressed stream: %s", zError (status));
in_bytes = remaining - out_stream.avail_in;
out_bytes = outbuf_length - out_stream.avail_out;
stream->callback ((const char *) outbuf, out_bytes, stream->opaque);
lto_stats.num_compressed_il_bytes += out_bytes;
compressed_bytes += out_bytes;
cursor += in_bytes;
remaining -= in_bytes;
out_stream.next_out = outbuf;
out_stream.avail_out = outbuf_length;
out_stream.next_in = cursor;
out_stream.avail_in = remaining;
}
while (status != Z_STREAM_END);
status = deflateEnd (&out_stream);
if (status != Z_OK)
internal_error ("compressed stream: %s", zError (status));
lto_destroy_compression_stream (stream);
free (outbuf);
timevar_pop (TV_IPA_LTO_COMPRESS);
}
/* Walk the decls we marked as necessary and see if they reference new
variables or functions and add them into the worklists. */
bool
varpool_analyze_pending_decls (void)
{
bool changed = false;
timevar_push (TV_CGRAPH);
while (varpool_first_unanalyzed_node)
{
tree decl = varpool_first_unanalyzed_node->decl;
varpool_first_unanalyzed_node->analyzed = true;
varpool_first_unanalyzed_node = varpool_first_unanalyzed_node->next_needed;
/* Compute the alignment early so function body expanders are
already informed about increased alignment. */
align_variable (decl, 0);
if (DECL_INITIAL (decl))
record_references_in_initializer (decl);
changed = true;
}
timevar_pop (TV_CGRAPH);
return changed;
}
// llvm_asm_file_start - Start the .s file.
void llvm_asm_file_start(void) {
timevar_push(TV_LLVM_INIT);
AsmOutStream = new oFILEstream(asm_out_file);
AsmOutFile = new OStream(*AsmOutStream);
flag_llvm_pch_read = 0;
createOptimizationPasses();
timevar_pop(TV_LLVM_INIT);
}
void
loop_optimizer_init (unsigned flags)
{
timevar_push (TV_LOOP_INIT);
if (!current_loops)
{
gcc_assert (!(cfun->curr_properties & PROP_loops));
/* Find the loops. */
current_loops = flow_loops_find (NULL);
}
else
{
bool recorded_exits = loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS);
bool needs_fixup = loops_state_satisfies_p (LOOPS_NEED_FIXUP);
gcc_assert (cfun->curr_properties & PROP_loops);
/* Ensure that the dominators are computed, like flow_loops_find does. */
calculate_dominance_info (CDI_DOMINATORS);
#ifdef ENABLE_CHECKING
if (!needs_fixup)
verify_loop_structure ();
#endif
/* Clear all flags. */
if (recorded_exits)
release_recorded_exits ();
loops_state_clear (~0U);
if (needs_fixup)
{
/* Apply LOOPS_MAY_HAVE_MULTIPLE_LATCHES early as fix_loop_structure
re-applies flags. */
loops_state_set (flags & LOOPS_MAY_HAVE_MULTIPLE_LATCHES);
fix_loop_structure (NULL);
}
}
/* Apply flags to loops. */
apply_loop_flags (flags);
/* Dump loops. */
flow_loops_dump (dump_file, NULL, 1);
#ifdef ENABLE_CHECKING
verify_loop_structure ();
#endif
timevar_pop (TV_LOOP_INIT);
}
void
rest_of_type_compilation (tree type, int toplev)
{
/* Avoid confusing the debug information machinery when there are
errors. */
if (errorcount != 0 || sorrycount != 0)
return;
timevar_push (TV_SYMOUT);
debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
timevar_pop (TV_SYMOUT);
}
void
reorder_basic_blocks (void)
{
int n_traces;
int i;
struct trace *traces;
if (n_basic_blocks <= 1)
return;
if ((* targetm.cannot_modify_jumps_p) ())
return;
timevar_push (TV_REORDER_BLOCKS);
cfg_layout_initialize ();
set_edge_can_fallthru_flag ();
mark_dfs_back_edges ();
/* We are estimating the length of uncond jump insn only once since the code
for getting the insn length always returns the minimal length now. */
if (uncond_jump_length == 0)
uncond_jump_length = get_uncond_jump_length ();
/* We need to know some information for each basic block. */
array_size = GET_ARRAY_SIZE (last_basic_block);
bbd = xmalloc (array_size * sizeof (bbro_basic_block_data));
for (i = 0; i < array_size; i++)
{
bbd[i].start_of_trace = -1;
bbd[i].end_of_trace = -1;
bbd[i].heap = NULL;
bbd[i].node = NULL;
}
traces = xmalloc (n_basic_blocks * sizeof (struct trace));
n_traces = 0;
find_traces (&n_traces, traces);
connect_traces (n_traces, traces);
FREE (traces);
FREE (bbd);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
cfg_layout_finalize ();
timevar_pop (TV_REORDER_BLOCKS);
}
// llvm_emit_code_for_current_function - Top level interface for emitting a
// function to the .s file.
void llvm_emit_code_for_current_function(tree fndecl) {
if (cfun->nonlocal_goto_save_area)
sorry("%Jnon-local gotos not supported by LLVM", fndecl);
if (errorcount || sorrycount) {
TREE_ASM_WRITTEN(fndecl) = 1;
return; // Do not process broken code.
}
timevar_push(TV_LLVM_FUNCS);
// Convert the AST to raw/ugly LLVM code.
Function *Fn;
{
TreeToLLVM Emitter(fndecl);
// Set up parameters and prepare for return, for the function.
Emitter.StartFunctionBody();
// Emit the body of the function.
Emitter.Emit(DECL_SAVED_TREE(fndecl), 0);
// Wrap things up.
Fn = Emitter.FinishFunctionBody();
}
#if 0
if (dump_file) {
fprintf (dump_file,
"\n\n;;\n;; Full LLVM generated for this function:\n;;\n");
Fn->dump();
}
#endif
if (PerFunctionPasses)
PerFunctionPasses->run(*Fn);
// TODO: Nuke the .ll code for the function at -O[01] if we don't want to
// inline it or something else.
// There's no need to defer outputting this function any more; we
// know we want to output it.
DECL_DEFER_OUTPUT(fndecl) = 0;
// Finally, we have written out this function!
TREE_ASM_WRITTEN(fndecl) = 1;
timevar_pop(TV_LLVM_FUNCS);
}
DEBUG_FUNCTION void
verify_symtab_node (symtab_node node)
{
if (seen_error ())
return;
timevar_push (TV_CGRAPH_VERIFY);
if (symtab_function_p (node))
verify_cgraph_node (cgraph (node));
else
if (verify_symtab_base (node))
{
dump_symtab_node (stderr, node);
internal_error ("verify_symtab_node failed");
}
timevar_pop (TV_CGRAPH_VERIFY);
}
DEBUG_FUNCTION void
symtab_node::verify (void)
{
if (seen_error ())
return;
timevar_push (TV_CGRAPH_VERIFY);
if (cgraph_node *node = dyn_cast <cgraph_node *> (this))
node->verify_node ();
else
if (verify_base ())
{
debug ();
internal_error ("symtab_node::verify failed");
}
timevar_pop (TV_CGRAPH_VERIFY);
}
void
finish_optimization_passes (void)
{
/* LLVM LOCAL begin Dead code strip cc1. */
#ifdef ENABLE_LLVM
return;
#else
enum tree_dump_index i;
struct dump_file_info *dfi;
char *name;
timevar_push (TV_DUMP);
if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
{
dump_file = dump_begin (pass_profile.static_pass_number, NULL);
end_branch_prob ();
if (dump_file)
dump_end (pass_profile.static_pass_number, dump_file);
}
if (optimize > 0)
{
dump_file = dump_begin (pass_combine.static_pass_number, NULL);
if (dump_file)
{
dump_combine_total_stats (dump_file);
dump_end (pass_combine.static_pass_number, dump_file);
}
}
/* Do whatever is necessary to finish printing the graphs. */
if (graph_dump_format != no_graph)
for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i)
if (dump_initialized_p (i)
&& (dfi->flags & TDF_GRAPH) != 0
&& (name = get_dump_file_name (i)) != NULL)
{
finish_graph_dump_file (name);
free (name);
}
timevar_pop (TV_DUMP);
#endif
/* LLVM LOCAL end Dead code strip cc1. */
}
void
loop_optimizer_finalize (void)
{
struct loop *loop;
basic_block bb;
timevar_push (TV_LOOP_FINI);
if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
release_recorded_exits ();
free_numbers_of_iterations_estimates ();
/* If we should preserve loop structure, do not free it but clear
flags that advanced properties are there as we are not preserving
that in full. */
if (cfun->curr_properties & PROP_loops)
{
loops_state_clear (LOOP_CLOSED_SSA
| LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS
| LOOPS_HAVE_PREHEADERS
| LOOPS_HAVE_SIMPLE_LATCHES
| LOOPS_HAVE_FALLTHRU_PREHEADERS);
loops_state_set (LOOPS_MAY_HAVE_MULTIPLE_LATCHES);
goto loop_fini_done;
}
gcc_assert (current_loops != NULL);
FOR_EACH_LOOP (loop, 0)
free_simple_loop_desc (loop);
/* Clean up. */
flow_loops_free (current_loops);
ggc_free (current_loops);
current_loops = NULL;
FOR_ALL_BB_FN (bb, cfun)
{
bb->loop_father = NULL;
}
loop_fini_done:
timevar_pop (TV_LOOP_FINI);
}
/* This function rebuilds the JUMP_LABEL field and REG_LABEL_TARGET
notes in jumping insns and REG_LABEL_OPERAND notes in non-jumping
instructions and jumping insns that have labels as operands
(e.g. cbranchsi4). */
void
rebuild_jump_labels (rtx f)
{
rtx insn;
timevar_push (TV_REBUILD_JUMP);
init_label_info (f);
mark_all_labels (f);
/* Keep track of labels used from static data; we don't track them
closely enough to delete them here, so make sure their reference
count doesn't drop to zero. */
for (insn = forced_labels; insn; insn = XEXP (insn, 1))
if (LABEL_P (XEXP (insn, 0)))
LABEL_NUSES (XEXP (insn, 0))++;
timevar_pop (TV_REBUILD_JUMP);
}
void
rest_of_type_compilation (tree type, int toplev)
{
/* Avoid confusing the debug information machinery when there are
errors. */
if (errorcount != 0 || sorrycount != 0)
return;
/* LLVM LOCAL begin */
#ifndef ENABLE_LLVM
timevar_push (TV_SYMOUT);
debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
timevar_pop (TV_SYMOUT);
#else
llvm_emit_typedef (TYPE_STUB_DECL (type));
toplev = toplev; /* avoid unused var warning */
#endif
/* LLVM LOCAL end */
}
// Initialize PCH writing.
void llvm_pch_write_init(void) {
timevar_push(TV_LLVM_INIT);
AsmOutStream = new oFILEstream(asm_out_file);
AsmOutFile = new OStream(*AsmOutStream);
PerModulePasses = new PassManager();
PerModulePasses->add(new TargetData(*TheTarget->getTargetData()));
// Emit an LLVM .bc file to the output. This is used when passed
// -emit-llvm -c to the GCC driver.
PerModulePasses->add(CreateBitcodeWriterPass(*AsmOutStream));
// Disable emission of .ident into the output file... which is completely
// wrong for llvm/.bc emission cases.
flag_no_ident = 1;
flag_llvm_pch_read = 0;
timevar_pop(TV_LLVM_INIT);
}
/* Walk the decls we marked as necessary and see if they reference new
variables or functions and add them into the worklists. */
bool
varpool_analyze_pending_decls (void)
{
bool changed = false;
timevar_push (TV_VARPOOL);
while (varpool_first_unanalyzed_node)
{
struct varpool_node *node = varpool_first_unanalyzed_node, *next;
tree decl = node->decl;
bool analyzed = node->analyzed;
varpool_first_unanalyzed_node->analyzed = true;
varpool_first_unanalyzed_node = varpool_first_unanalyzed_node->next_needed;
/* When reading back varpool at LTO time, we re-construct the queue in order
to have "needed" list right by inserting all needed nodes into varpool.
We however don't want to re-analyze already analyzed nodes. */
if (!analyzed)
{
gcc_assert (!in_lto_p || cgraph_function_flags_ready);
/* Compute the alignment early so function body expanders are
already informed about increased alignment. */
align_variable (decl, 0);
}
if (DECL_INITIAL (decl))
record_references_in_initializer (decl, analyzed);
if (node->same_comdat_group)
{
for (next = node->same_comdat_group;
next != node;
next = next->same_comdat_group)
varpool_mark_needed_node (next);
}
changed = true;
}
timevar_pop (TV_VARPOOL);
return changed;
}
/* Output all variables enqueued to be assembled. */
bool
varpool_output_variables (void)
{
bool changed = false;
varpool_node *node;
if (seen_error ())
return false;
varpool_remove_unreferenced_decls ();
timevar_push (TV_VAROUT);
FOR_EACH_DEFINED_VARIABLE (node)
varpool_finalize_named_section_flags (node);
FOR_EACH_DEFINED_VARIABLE (node)
if (varpool_assemble_decl (node))
changed = true;
timevar_pop (TV_VAROUT);
return changed;
}
void
update_stmt_operands (gimple stmt)
{
/* If update_stmt_operands is called before SSA is initialized, do
nothing. */
if (!ssa_operands_active ())
return;
timevar_push (TV_TREE_OPS);
/* If the stmt is a noreturn call queue it to be processed by
split_bbs_on_noreturn_calls during cfg cleanup. */
if (is_gimple_call (stmt)
&& gimple_call_noreturn_p (stmt))
VEC_safe_push (gimple, gc, MODIFIED_NORETURN_CALLS (cfun), stmt);
gcc_assert (gimple_modified_p (stmt));
build_ssa_operands (stmt);
gimple_set_modified (stmt, false);
timevar_pop (TV_TREE_OPS);
}
void
tracer (void)
{
if (n_basic_blocks <= 1)
return;
timevar_push (TV_TRACER);
cfg_layout_initialize ();
mark_dfs_back_edges ();
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
tail_duplicate ();
layout_superblocks ();
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
cfg_layout_finalize ();
/* Merge basic blocks in duplicated traces. */
cleanup_cfg (CLEANUP_EXPENSIVE);
timevar_pop (TV_TRACER);
}
void
rest_of_decl_compilation (tree decl,
int top_level,
int at_end)
{
/* We deferred calling assemble_alias so that we could collect
other attributes such as visibility. Emit the alias now. */
{
tree alias;
alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
if (alias)
{
alias = TREE_VALUE (TREE_VALUE (alias));
alias = get_identifier (TREE_STRING_POINTER (alias));
assemble_alias (decl, alias);
}
}
/* Emit tm_* attributes for declarations now */
{
tree tm_attribute;
tm_attribute = lookup_attribute ("tm_wrapper", DECL_ATTRIBUTES (decl));
if (tm_attribute == NULL)
tm_attribute = lookup_attribute ("transaction_wrap", DECL_ATTRIBUTES (decl));
if (tm_attribute) {
tm_attribute = TREE_VALUE (TREE_VALUE (tm_attribute));
tm_attribute = get_identifier (TREE_STRING_POINTER (tm_attribute));
assemble_tm_wrapper (decl, tm_attribute);
}
if (has_tm_pure_attribute(decl)) {
assemble_tm_pure (decl);
}
if (has_tm_callable_attribute(decl)) {
assemble_tm_callable (decl);
}
}
/* Can't defer this, because it needs to happen before any
later function definitions are processed. */
if (DECL_ASSEMBLER_NAME_SET_P (decl) && DECL_REGISTER (decl))
/* LLVM LOCAL begin */
#ifndef ENABLE_LLVM
make_decl_rtl (decl);
#else
make_decl_llvm (decl);
#endif
/* LLVM LOCAL end */
/* Forward declarations for nested functions are not "external",
but we need to treat them as if they were. */
if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
|| TREE_CODE (decl) == FUNCTION_DECL)
{
timevar_push (TV_VARCONST);
/* Don't output anything when a tentative file-scope definition
is seen. But at end of compilation, do output code for them.
We do output all variables when unit-at-a-time is active and rely on
callgraph code to defer them except for forward declarations
(see gcc.c-torture/compile/920624-1.c) */
if ((at_end
|| !DECL_DEFER_OUTPUT (decl)
|| DECL_INITIAL (decl))
&& !DECL_EXTERNAL (decl))
{
if (TREE_CODE (decl) != FUNCTION_DECL)
cgraph_varpool_finalize_decl (decl);
else
assemble_variable (decl, top_level, at_end, 0);
}
#ifdef ASM_FINISH_DECLARE_OBJECT
if (decl == last_assemble_variable_decl)
{
ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
top_level, at_end);
}
#endif
timevar_pop (TV_VARCONST);
}
else if (TREE_CODE (decl) == TYPE_DECL
/* Like in rest_of_type_compilation, avoid confusing the debug
information machinery when there are errors. */
&& !(sorrycount || errorcount))
{
/* LLVM LOCAL begin */
#ifndef ENABLE_LLVM
timevar_push (TV_SYMOUT);
debug_hooks->type_decl (decl, !top_level);
timevar_pop (TV_SYMOUT);
#else
llvm_emit_typedef (decl);
#endif
/* LLVM LOCAL end */
}
/* Let cgraph know about the existence of variables. */
if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
cgraph_varpool_node (decl);
}
enum cpp_ttype
c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags)
{
static bool no_more_pch;
const cpp_token *tok;
enum cpp_ttype type;
timevar_push (TV_CPP);
retry:
tok = cpp_get_token (parse_in);
type = tok->type;
retry_after_at:
#ifdef USE_MAPPED_LOCATION
*loc = tok->src_loc;
#else
*loc = input_location;
#endif
switch (type)
{
case CPP_PADDING:
goto retry;
case CPP_NAME:
*value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
break;
case CPP_NUMBER:
{
unsigned int flags = cpp_classify_number (parse_in, tok);
switch (flags & CPP_N_CATEGORY)
{
case CPP_N_INVALID:
/* cpplib has issued an error. */
*value = error_mark_node;
errorcount++;
break;
case CPP_N_INTEGER:
*value = interpret_integer (tok, flags);
break;
case CPP_N_FLOATING:
*value = interpret_float (tok, flags);
break;
default:
gcc_unreachable ();
}
}
break;
case CPP_ATSIGN:
/* An @ may give the next token special significance in Objective-C. */
if (c_dialect_objc ())
{
location_t atloc = input_location;
retry_at:
tok = cpp_get_token (parse_in);
type = tok->type;
switch (type)
{
case CPP_PADDING:
goto retry_at;
case CPP_STRING:
case CPP_WSTRING:
type = lex_string (tok, value, true);
break;
case CPP_NAME:
*value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
if (objc_is_reserved_word (*value))
{
type = CPP_AT_NAME;
break;
}
/* FALLTHROUGH */
default:
/* ... or not. */
error ("%Hstray %<@%> in program", &atloc);
goto retry_after_at;
}
break;
}
/* FALLTHROUGH */
case CPP_HASH:
case CPP_PASTE:
{
unsigned char name[4];
*cpp_spell_token (parse_in, tok, name, true) = 0;
error ("stray %qs in program", name);
}
goto retry;
case CPP_OTHER:
{
cppchar_t c = tok->val.str.text[0];
if (c == '"' || c == '\'')
error ("missing terminating %c character", (int) c);
else if (ISGRAPH (c))
error ("stray %qc in program", (int) c);
else
error ("stray %<\\%o%> in program", (int) c);
}
goto retry;
case CPP_CHAR:
case CPP_WCHAR:
*value = lex_charconst (tok);
break;
case CPP_STRING:
case CPP_WSTRING:
if (!c_lex_return_raw_strings)
{
type = lex_string (tok, value, false);
break;
}
/* FALLTHROUGH */
case CPP_PRAGMA:
*value = build_string (tok->val.str.len, (char *) tok->val.str.text);
break;
/* These tokens should not be visible outside cpplib. */
case CPP_HEADER_NAME:
case CPP_COMMENT:
case CPP_MACRO_ARG:
gcc_unreachable ();
default:
*value = NULL_TREE;
break;
}
if (cpp_flags)
*cpp_flags = tok->flags;
if (!no_more_pch)
{
no_more_pch = true;
c_common_no_more_pch ();
}
timevar_pop (TV_CPP);
return type;
}
int
main (int argc, char *argv[])
{
set_program_name (argv[0]);
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
bindtextdomain ("bison-runtime", LOCALEDIR);
textdomain (PACKAGE);
{
char const *cp = getenv ("LC_CTYPE");
if (cp && STREQ (cp, "C"))
set_custom_quoting ("e_quoting_options, "'", "'");
else
set_quoting_style ("e_quoting_options, locale_quoting_style);
}
atexit (close_stdout);
uniqstrs_new ();
muscle_init ();
complain_init ();
getargs (argc, argv);
timevar_report = trace_flag & trace_time;
init_timevar ();
timevar_start (TV_TOTAL);
if (trace_flag & trace_bitsets)
bitset_stats_enable ();
/* Read the input. Copy some parts of it to FGUARD, FACTION, FTABLE
and FATTRS. In file reader.c. The other parts are recorded in
the grammar; see gram.h. */
timevar_push (TV_READER);
reader ();
timevar_pop (TV_READER);
if (complaint_status == status_complaint)
goto finish;
/* Find useless nonterminals and productions and reduce the grammar. */
timevar_push (TV_REDUCE);
reduce_grammar ();
timevar_pop (TV_REDUCE);
/* Record other info about the grammar. In files derives and
nullable. */
timevar_push (TV_SETS);
derives_compute ();
nullable_compute ();
timevar_pop (TV_SETS);
/* Compute LR(0) parser states. See state.h for more info. */
timevar_push (TV_LR0);
generate_states ();
timevar_pop (TV_LR0);
/* Add lookahead sets to parser states. Except when LALR(1) is
requested, split states to eliminate LR(1)-relative
inadequacies. */
ielr ();
/* Find and record any conflicts: places where one token of
lookahead is not enough to disambiguate the parsing. In file
conflicts. Also resolve s/r conflicts based on precedence
declarations. */
timevar_push (TV_CONFLICTS);
conflicts_solve ();
if (!muscle_percent_define_flag_if ("lr.keep-unreachable-state"))
{
state_number *old_to_new = xnmalloc (nstates, sizeof *old_to_new);
state_number nstates_old = nstates;
state_remove_unreachable_states (old_to_new);
lalr_update_state_numbers (old_to_new, nstates_old);
conflicts_update_state_numbers (old_to_new, nstates_old);
free (old_to_new);
}
conflicts_print ();
timevar_pop (TV_CONFLICTS);
/* Compute the parser tables. */
timevar_push (TV_ACTIONS);
tables_generate ();
timevar_pop (TV_ACTIONS);
grammar_rules_useless_report (_("rule useless in parser due to conflicts"));
print_precedence_warnings ();
/* Output file names. */
compute_output_file_names ();
/* Output the detailed report on the grammar. */
if (report_flag)
{
timevar_push (TV_REPORT);
print_results ();
timevar_pop (TV_REPORT);
}
/* Output the graph. */
if (graph_flag)
{
timevar_push (TV_GRAPH);
print_graph ();
timevar_pop (TV_GRAPH);
}
/* Output xml. */
if (xml_flag)
{
timevar_push (TV_XML);
print_xml ();
timevar_pop (TV_XML);
}
/* Stop if there were errors, to avoid trashing previous output
files. */
if (complaint_status == status_complaint)
goto finish;
/* Lookahead tokens are no longer needed. */
timevar_push (TV_FREE);
lalr_free ();
timevar_pop (TV_FREE);
/* Output the tables and the parser to ftable. In file output. */
timevar_push (TV_PARSER);
output ();
timevar_pop (TV_PARSER);
timevar_push (TV_FREE);
nullable_free ();
derives_free ();
tables_free ();
states_free ();
reduce_free ();
conflicts_free ();
grammar_free ();
output_file_names_free ();
/* The scanner memory cannot be released right after parsing, as it
contains things such as user actions, prologue, epilogue etc. */
gram_scanner_free ();
muscle_free ();
uniqstrs_free ();
code_scanner_free ();
skel_scanner_free ();
quotearg_free ();
timevar_pop (TV_FREE);
if (trace_flag & trace_bitsets)
bitset_stats_dump (stderr);
finish:
/* Stop timing and print the times. */
timevar_stop (TV_TOTAL);
timevar_print (stderr);
cleanup_caret ();
return complaint_status ? EXIT_FAILURE : EXIT_SUCCESS;
}
enum cpp_ttype
/* APPLE LOCAL CW asm blocks C++ comments 6338079 */
c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags, int defer)
{
static bool no_more_pch;
const cpp_token *tok;
enum cpp_ttype type;
unsigned char add_flags = 0;
/* APPLE LOCAL CW asm blocks C++ */
const cpp_token *lasttok;
/* APPLE LOCAL begin CW asm blocks */
/* Make a local copy of the flag for efficiency, since the compiler can't
figure that it won't change during a compilation. */
int flag_iasm_blocks_local = flag_iasm_blocks;
if (flag_iasm_blocks_local)
++c_lex_depth;
/* APPLE LOCAL end CW asm blocks */
timevar_push (TV_CPP);
retry:
/* APPLE LOCAL begin CW asm blocks */
/* If there's a token we saved while returning the special BOL
token, return it now. */
if (iasm_saved_token)
{
tok = iasm_saved_token;
type = tok->type;
iasm_saved_token = NULL;
goto bypass;
}
/* APPLE LOCAL end CW asm blocks */
tok = cpp_get_token (parse_in);
type = tok->type;
/* APPLE LOCAL begin CW asm blocks */
/* This test should be as efficient as possible, because it affects
all lexing with or without CW asm enabled. */
if (flag_iasm_blocks_local && iasm_state != iasm_none && c_lex_depth == 1
&& type != CPP_PADDING)
{
/* "}" switches us out of our special mode. */
if (tok->type == CPP_CLOSE_BRACE && iasm_state >= iasm_decls)
iasm_state = iasm_none;
/* This is tricky. We're only ready to start parsing assembly
instructions if we're in the asm block, we're not in the
middle of parsing a C decl, and the next token is plausibly
the beginning of an asm line. This works because if we have
a "typedef int nop", a nop at the beginning of a line should
be taken as an instruction rather than a declaration of type
nop. (Doesn't have to go this way, but it's how CW works.)
We're not quite as good as CW yet, because CW knows about the
complete list of valid opcodes, and will try to take anything
as a decl that is not in the opcode list. */
if (iasm_state == iasm_decls
&& !iasm_in_decl)
{
if (tok->type == CPP_ATSIGN
|| tok->type == CPP_DOT
|| (tok->type == CPP_SEMICOLON)
|| (tok->type == CPP_NAME
&& (*value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node)))
&& !iasm_typename_or_reserved (*value)))
{
iasm_state = iasm_asm;
inside_iasm_block = true;
}
else
{
iasm_in_decl = true;
}
}
}
bypass:
/* APPLE LOCAL end CW asm blocks */
retry_after_at:
#ifdef USE_MAPPED_LOCATION
*loc = tok->src_loc;
#else
*loc = input_location;
#endif
switch (type)
{
case CPP_PADDING:
goto retry;
case CPP_NAME:
*value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
/* APPLE LOCAL begin CW asm blocks */
if (iasm_state >= iasm_decls
&& flag_ms_asms
&& strcasecmp (IDENTIFIER_POINTER (HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node))),
"offset") == 0)
{
type = CPP_AND;
*value = NULL_TREE;
break;
}
/* APPLE LOCAL end CW asm blocks */
break;
case CPP_NUMBER:
{
/* APPLE LOCAL CW asm blocks C++ comments 6338079 */
unsigned int flags = cpp_classify_number (parse_in, tok, defer);
switch (flags & CPP_N_CATEGORY)
{
case CPP_N_INVALID:
/* APPLE LOCAL begin CW asm blocks C++ comments 6338079 */
if (flags & CPP_N_DEFER)
{
add_flags = ERROR_DEFERRED;
*value = error_mark_node;
break;
}
/* APPLE LOCAL end CW asm blocks C++ comments 6338079 */
/* cpplib has issued an error. */
*value = error_mark_node;
errorcount++;
break;
case CPP_N_INTEGER:
/* C++ uses '0' to mark virtual functions as pure.
Set PURE_ZERO to pass this information to the C++ parser. */
if (tok->val.str.len == 1 && *tok->val.str.text == '0')
add_flags = PURE_ZERO;
*value = interpret_integer (tok, flags);
break;
case CPP_N_FLOATING:
*value = interpret_float (tok, flags);
break;
default:
gcc_unreachable ();
}
}
break;
case CPP_ATSIGN:
/* APPLE LOCAL begin CW asm blocks */
if (iasm_state >= iasm_decls)
{
/* Return the @-sign verbatim. */
*value = NULL_TREE;
break;
}
lasttok = tok;
/* APPLE LOCAL end CW asm blocks */
/* An @ may give the next token special significance in Objective-C. */
if (c_dialect_objc ())
{
location_t atloc = input_location;
/* APPLE LOCAL CW asm blocks */
++parse_in->keep_tokens;
retry_at:
tok = cpp_get_token (parse_in);
type = tok->type;
switch (type)
{
case CPP_PADDING:
goto retry_at;
case CPP_STRING:
case CPP_WSTRING:
type = lex_string (tok, value, true);
break;
case CPP_NAME:
*value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
if (objc_is_reserved_word (*value))
{
type = CPP_AT_NAME;
break;
}
/* FALLTHROUGH */
default:
/* APPLE LOCAL begin CW asm blocks C++ */
if (flag_iasm_blocks_local)
{
/* This is necessary for C++, as we don't have the tight
integration between the lexer and the parser... */
_cpp_backup_tokens (parse_in, 1);
/* Return the @-sign verbatim. */
*value = NULL;
tok = lasttok;
type = tok->type;
break;
}
/* APPLE LOCAL end CW asm blocks C++ */
/* ... or not. */
error ("%Hstray %<@%> in program", &atloc);
goto retry_after_at;
}
/* APPLE LOCAL CW asm blocks */
--parse_in->keep_tokens;
break;
}
/* APPLE LOCAL begin CW asm blocks C++ */
if (flag_iasm_blocks_local)
{
/* This is necessary for C++, as we don't have the tight
integration between the lexer and the parser... */
/* Return the @-sign verbatim. */
*value = NULL;
break;
}
/* APPLE LOCAL end CW asm blocks C++ */
/* FALLTHROUGH */
case CPP_HASH:
case CPP_PASTE:
/* APPLE LOCAL begin CW asm blocks C++ comments 4248139 */
/* Because we don't recognize inline asm commments during
lexing, we have to pass this back to the parser to error out
with or eat as a comment as appropriate. */
if (flag_iasm_blocks_local)
{
*value = NULL;
break;
}
/* APPLE LOCAL end CW asm blocks C++ comments 4248139 */
{
unsigned char name[4];
*cpp_spell_token (parse_in, tok, name, true) = 0;
error ("stray %qs in program", name);
}
goto retry;
case CPP_OTHER:
{
cppchar_t c = tok->val.str.text[0];
/* APPLE LOCAL begin CW asm blocks C++ comments 4248139 */
/* Because we don't recognize inline asm commments during
lexing, we have to pass this back to the parser to error
out with or eat as a comment as appropriate. */
if (defer && flag_iasm_blocks_local)
{
*value = build_int_cst_wide (char_type_node, c, 0);
break;
}
/* APPLE LOCAL end CW asm blocks C++ comments 4248139 */
if (c == '"' || c == '\'')
error ("missing terminating %c character", (int) c);
else if (ISGRAPH (c))
error ("stray %qc in program", (int) c);
else
error ("stray %<\\%o%> in program", (int) c);
}
goto retry;
case CPP_CHAR:
case CPP_WCHAR:
*value = lex_charconst (tok);
break;
case CPP_STRING:
case CPP_WSTRING:
if (!c_lex_return_raw_strings)
{
type = lex_string (tok, value, false);
break;
}
*value = build_string (tok->val.str.len, (char *) tok->val.str.text);
break;
case CPP_PRAGMA:
*value = build_int_cst (NULL, tok->val.pragma);
break;
/* APPLE LOCAL begin CW asm blocks */
case CPP_MULT:
if (inside_iasm_block)
{
/* Check and replace use of '*' with '.' if '*' is followed by '-'
or '+'. This is to allow "b *+8" which is disallwed by darwin's
assembler but nevertheless is needed to be compatible with CW tools. */
lasttok = tok;
++parse_in->keep_tokens;
do
tok = cpp_get_token (parse_in);
while (tok->type == CPP_PADDING);
_cpp_backup_tokens (parse_in, 1);
--parse_in->keep_tokens;
if (tok->type == CPP_PLUS || tok->type == CPP_MINUS)
type = CPP_DOT;
tok = lasttok;
}
*value = NULL_TREE;
break;
/* APPLE LOCAL end CW asm blocks */
/* APPLE LOCAL begin 4137741 */
/* For CPP_BINCL and CPP_EINCL tokens, we shall need to propagate
line number information; the location field shall already include
the desired file name. */
case CPP_BINCL:
case CPP_EINCL:
*value = build_int_cst (integer_type_node, (HOST_WIDE_INT) tok->src_loc);
break;
/* APPLE LOCAL end 4137741 */
/* These tokens should not be visible outside cpplib. */
case CPP_HEADER_NAME:
case CPP_COMMENT:
case CPP_MACRO_ARG:
gcc_unreachable ();
default:
*value = NULL_TREE;
break;
}
if (cpp_flags)
*cpp_flags = tok->flags | add_flags;
/* APPLE LOCAL begin CW asm blocks */
if (flag_iasm_blocks_local)
--c_lex_depth;
/* APPLE LOCAL end CW asm blocks */
/* APPLE LOCAL begin 4137741 */
if (!no_more_pch
&& type != CPP_BINCL
&& type != CPP_EINCL)
/* APPLE LOCAL end 4137741 */
{
no_more_pch = true;
c_common_no_more_pch ();
}
timevar_pop (TV_CPP);
return type;
}
static void
output_skeleton (void)
{
FILE *in;
FILE *out;
int filter_fd[2];
char const *argv[6];
pid_t pid;
/* Compute the names of the package data dir and skeleton file.
Test whether m4sugar.m4 is readable, to check for proper
installation. A faulty installation can cause deadlock, so a
cheap sanity check is worthwhile. */
char const m4sugar[] = "m4sugar/m4sugar.m4";
char *full_m4sugar;
char *full_skeleton;
char const *p;
char const *m4 = (p = getenv ("M4")) ? p : M4;
char const *pkgdatadir = (p = getenv ("BISON_PKGDATADIR")) ? p : PKGDATADIR;
size_t skeleton_size = strlen (skeleton) + 1;
size_t pkgdatadirlen = strlen (pkgdatadir);
while (pkgdatadirlen && pkgdatadir[pkgdatadirlen - 1] == '/')
pkgdatadirlen--;
full_skeleton = xmalloc (pkgdatadirlen + 1
+ (skeleton_size < sizeof m4sugar
? sizeof m4sugar : skeleton_size));
strcpy (full_skeleton, pkgdatadir);
full_skeleton[pkgdatadirlen] = '/';
strcpy (full_skeleton + pkgdatadirlen + 1, m4sugar);
full_m4sugar = xstrdup (full_skeleton);
strcpy (full_skeleton + pkgdatadirlen + 1, skeleton);
xfclose (xfopen (full_m4sugar, "r"));
/* Create an m4 subprocess connected to us via two pipes. */
if (trace_flag & trace_tools)
fprintf (stderr, "running: %s %s - %s\n",
m4, full_m4sugar, full_skeleton);
argv[0] = m4;
argv[1] = full_m4sugar;
argv[2] = "-";
argv[3] = full_skeleton;
argv[4] = trace_flag & trace_m4 ? "-dV" : NULL;
argv[5] = NULL;
init_subpipe ();
pid = create_subpipe (argv, filter_fd);
free (full_m4sugar);
free (full_skeleton);
out = fdopen (filter_fd[0], "w");
if (! out)
error (EXIT_FAILURE, get_errno (),
"fdopen");
/* Output the definitions of all the muscles. */
fputs ("m4_init()\n", out);
user_actions_output (out);
merger_output (out);
token_definitions_output (out);
symbol_destructors_output (out);
symbol_printers_output (out);
muscles_m4_output (out);
fputs ("m4_wrap([m4_divert_pop(0)])\n", out);
fputs ("m4_divert_push(0)dnl\n", out);
xfclose (out);
/* Read and process m4's output. */
timevar_push (TV_M4);
end_of_output_subpipe (pid, filter_fd);
in = fdopen (filter_fd[1], "r");
if (! in)
error (EXIT_FAILURE, get_errno (),
"fdopen");
scan_skel (in);
xfclose (in);
reap_subpipe (pid, m4);
timevar_pop (TV_M4);
}
/* Walk the decls we marked as necessary and see if they reference new
variables or functions and add them into the worklists. */
bool
varpool_analyze_pending_decls (void)
{
bool changed = false;
timevar_push (TV_VARPOOL);
while (varpool_first_unanalyzed_node)
{
struct varpool_node *node = varpool_first_unanalyzed_node, *next;
tree decl = node->decl;
bool analyzed = node->analyzed;
varpool_first_unanalyzed_node->analyzed = true;
varpool_first_unanalyzed_node = varpool_first_unanalyzed_node->next_needed;
/* When reading back varpool at LTO time, we re-construct the queue in order
to have "needed" list right by inserting all needed nodes into varpool.
We however don't want to re-analyze already analyzed nodes. */
if (!analyzed)
{
gcc_assert (!in_lto_p || cgraph_function_flags_ready);
/* Compute the alignment early so function body expanders are
already informed about increased alignment. */
align_variable (decl, 0);
}
if (node->alias && node->alias_of)
{
struct varpool_node *tgt = varpool_node (node->alias_of);
struct varpool_node *n;
for (n = tgt; n && n->alias;
n = n->analyzed ? varpool_alias_aliased_node (n) : NULL)
if (n == node)
{
error ("variable %q+D part of alias cycle", node->decl);
node->alias = false;
continue;
}
if (!VEC_length (ipa_ref_t, node->ref_list.references))
ipa_record_reference (NULL, node, NULL, tgt, IPA_REF_ALIAS, NULL);
/* C++ FE sometimes change linkage flags after producing same body aliases. */
if (node->extra_name_alias)
{
DECL_WEAK (node->decl) = DECL_WEAK (node->alias_of);
TREE_PUBLIC (node->decl) = TREE_PUBLIC (node->alias_of);
DECL_EXTERNAL (node->decl) = DECL_EXTERNAL (node->alias_of);
DECL_VISIBILITY (node->decl) = DECL_VISIBILITY (node->alias_of);
if (TREE_PUBLIC (node->decl))
{
DECL_COMDAT (node->decl) = DECL_COMDAT (node->alias_of);
DECL_COMDAT_GROUP (node->decl) = DECL_COMDAT_GROUP (node->alias_of);
if (DECL_ONE_ONLY (node->alias_of) && !node->same_comdat_group)
{
node->same_comdat_group = tgt;
if (!tgt->same_comdat_group)
tgt->same_comdat_group = node;
else
{
struct varpool_node *n;
for (n = tgt->same_comdat_group;
n->same_comdat_group != tgt;
n = n->same_comdat_group)
;
n->same_comdat_group = node;
}
}
}
}
}
else if (DECL_INITIAL (decl))
record_references_in_initializer (decl, analyzed);
if (node->same_comdat_group)
{
for (next = node->same_comdat_group;
next != node;
next = next->same_comdat_group)
varpool_mark_needed_node (next);
}
changed = true;
}
timevar_pop (TV_VARPOOL);
return changed;
}
void
tree_rest_of_compilation (tree fndecl)
{
location_t saved_loc;
timevar_push (TV_EXPAND);
gcc_assert (cgraph_global_info_ready);
/* Initialize the default bitmap obstack. */
bitmap_obstack_initialize (NULL);
/* Initialize the RTL code for the function. */
current_function_decl = fndecl;
saved_loc = input_location;
input_location = DECL_SOURCE_LOCATION (fndecl);
init_function_start (fndecl);
/* Even though we're inside a function body, we still don't want to
call expand_expr to calculate the size of a variable-sized array.
We haven't necessarily assigned RTL to all variables yet, so it's
not safe to try to expand expressions involving them. */
cfun->dont_save_pending_sizes_p = 1;
gimple_register_cfg_hooks ();
bitmap_obstack_initialize (®_obstack); /* FIXME, only at RTL generation*/
execute_all_ipa_transforms ();
/* Perform all tree transforms and optimizations. */
/* Signal the start of passes. */
invoke_plugin_callbacks (PLUGIN_ALL_PASSES_START, NULL);
execute_pass_list (all_passes);
/* Signal the end of passes. */
invoke_plugin_callbacks (PLUGIN_ALL_PASSES_END, NULL);
bitmap_obstack_release (®_obstack);
/* Release the default bitmap obstack. */
bitmap_obstack_release (NULL);
set_cfun (NULL);
/* If requested, warn about function definitions where the function will
return a value (usually of some struct or union type) which itself will
take up a lot of stack space. */
if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
{
tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
if (ret_type && TYPE_SIZE_UNIT (ret_type)
&& TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
&& 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
larger_than_size))
{
unsigned int size_as_int
= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
warning (OPT_Wlarger_than_eq, "size of return value of %q+D is %u bytes",
fndecl, size_as_int);
else
warning (OPT_Wlarger_than_eq, "size of return value of %q+D is larger than %wd bytes",
fndecl, larger_than_size);
}
}
gimple_set_body (fndecl, NULL);
if (DECL_STRUCT_FUNCTION (fndecl) == 0
&& !cgraph_node (fndecl)->origin)
{
/* Stop pointing to the local nodes about to be freed.
But DECL_INITIAL must remain nonzero so we know this
was an actual function definition.
For a nested function, this is done in c_pop_function_context.
If rest_of_compilation set this to 0, leave it 0. */
if (DECL_INITIAL (fndecl) != 0)
DECL_INITIAL (fndecl) = error_mark_node;
}
input_location = saved_loc;
ggc_collect ();
timevar_pop (TV_EXPAND);
}
