CbC/CbC_gcc: gcc/final.c comparison

comparison gcc/final.c @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 #include "flags.h"
 #include "hard-reg-set.h"
 #include "output.h"
 #include "except.h"
 #include "function.h"
-#include "toplev.h"
+#include "rtl-error.h"
+#include "toplev.h" /* exact_log2, floor_log2 */
 #include "reload.h"
 #include "intl.h"
 #include "basic-block.h"
 #include "target.h"
+#include "targhooks.h"
 #include "debug.h"
 #include "expr.h"
 #include "cfglayout.h"
 #include "tree-pass.h"
 #include "tree-flow.h"
 #ifdef XCOFF_DEBUGGING_INFO
 #include "xcoffout.h"		/* Needed for external data
 				   declarations for e.g. AIX 4.x.  */
 #endif
-#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
 #include "dwarf2out.h"
-#endif
 #ifdef DBX_DEBUGGING_INFO
 #include "dbxout.h"
 #endif
 #ifdef SDB_DEBUGGING_INFO
 #include "sdbout.h"
 #endif
-/* If we aren't using cc0, CC_STATUS_INIT shouldn't exist.  So define a
+/* Most ports that aren't using cc0 don't need to define CC_STATUS_INIT.
-null default for it to save conditionalization later.  */
+So define a null default for it to save conditionalization later.  */
 #ifndef CC_STATUS_INIT
 #define CC_STATUS_INIT
 #endif
 /* How to start an assembler comment.  */
 static rtx walk_alter_subreg (rtx *, bool *);
 static void output_asm_name (void);
 static void output_alternate_entry_point (FILE *, rtx);
 static tree get_mem_expr_from_op (rtx, int *);
 static void output_asm_operand_names (rtx *, int *, int);
-static void output_operand (rtx, int);
 #ifdef LEAF_REGISTERS
 static void leaf_renumber_regs (rtx);
 #endif
 #ifdef HAVE_cc0
 static int alter_cond (rtx);
 If not overridden for epilogue code, then the function body itself
 contains return instructions wherever needed.  */
 void
 default_function_pro_epilogue (FILE *file ATTRIBUTE_UNUSED,
 			       HOST_WIDE_INT size ATTRIBUTE_UNUSED)
+{
+}
+void
+default_function_switched_text_sections (FILE *file ATTRIBUTE_UNUSED,
+					 tree decl ATTRIBUTE_UNUSED,
+					 bool new_is_cold ATTRIBUTE_UNUSED)
 {
 }
 /* Default target hook that outputs nothing to a stream.  */
 void
 #ifndef LABEL_ALIGN
 #define LABEL_ALIGN(LABEL) align_labels_log
 #endif
-#ifndef LABEL_ALIGN_MAX_SKIP
-#define LABEL_ALIGN_MAX_SKIP align_labels_max_skip
-#endif
 #ifndef LOOP_ALIGN
 #define LOOP_ALIGN(LABEL) align_loops_log
 #endif
-#ifndef LOOP_ALIGN_MAX_SKIP
-#define LOOP_ALIGN_MAX_SKIP align_loops_max_skip
-#endif
 #ifndef LABEL_ALIGN_AFTER_BARRIER
 #define LABEL_ALIGN_AFTER_BARRIER(LABEL) 0
 #endif
-#ifndef LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP
-#define LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP 0
-#endif
 #ifndef JUMP_ALIGN
 #define JUMP_ALIGN(LABEL) align_jumps_log
 #endif
-#ifndef JUMP_ALIGN_MAX_SKIP
+int
-#define JUMP_ALIGN_MAX_SKIP align_jumps_max_skip
+default_label_align_after_barrier_max_skip (rtx insn ATTRIBUTE_UNUSED)
-#endif
+{
+return 0;
+}
+int
+default_loop_align_max_skip (rtx insn ATTRIBUTE_UNUSED)
+{
+return align_loops_max_skip;
+}
+int
+default_label_align_max_skip (rtx insn ATTRIBUTE_UNUSED)
+{
+return align_labels_max_skip;
+}
+int
+default_jump_align_max_skip (rtx insn ATTRIBUTE_UNUSED)
+{
+return align_jumps_max_skip;
+}
 #ifndef ADDR_VEC_ALIGN
 static int
 final_addr_vec_align (rtx addr_vec)
 {
 if (dump_file)
 {
 dump_flow_info (dump_file, TDF_DETAILS);
 flow_loops_dump (dump_file, NULL, 1);
-loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
+}
-}
+loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
 FOR_EACH_BB (bb)
 if (bb->frequency > freq_max)
 freq_max = bb->frequency;
 freq_threshold = freq_max / PARAM_VALUE (PARAM_ALIGN_THRESHOLD);
 	    fprintf(dump_file, "BB %4i freq %4i loop %2i loop_depth %2i skipped.\n",
 		    bb->index, bb->frequency, bb->loop_father->num, bb->loop_depth);
 	  continue;
 	}
 max_log = LABEL_ALIGN (label);
-max_skip = LABEL_ALIGN_MAX_SKIP;
+max_skip = targetm.asm_out.label_align_max_skip (label);
 FOR_EACH_EDGE (e, ei, bb->preds)
 	{
 	  if (e->flags & EDGE_FALLTHRU)
 	    has_fallthru = 1, fallthru_frequency += EDGE_FREQUENCY (e);
 	  if (dump_file)
 	    fprintf(dump_file, "  jump alignment added.\n");
 	  if (max_log < log)
 	    {
 	      max_log = log;
-	      max_skip = JUMP_ALIGN_MAX_SKIP;
+	      max_skip = targetm.asm_out.jump_align_max_skip (label);
 	    }
 	}
 /* In case block is frequent and reached mostly by non-fallthru edge,
 	 align it.  It is most likely a first block of loop.  */
 if (has_fallthru
 	  if (dump_file)
 	    fprintf(dump_file, "  internal loop alignment added.\n");
 	  if (max_log < log)
 	    {
 	      max_log = log;
-	      max_skip = LOOP_ALIGN_MAX_SKIP;
+	      max_skip = targetm.asm_out.loop_align_max_skip (label);
 	    }
 	}
 LABEL_TO_ALIGNMENT (label) = max_log;
 LABEL_TO_MAX_SKIP (label) = max_skip;
 }
-if (dump_file)
+loop_optimizer_finalize ();
-{
+free_dominance_info (CDI_DOMINATORS);
-loop_optimizer_finalize ();
-free_dominance_info (CDI_DOMINATORS);
-}
 return 0;
 }
 struct rtl_opt_pass pass_compute_alignments =
 {
 	    {
 	      log = LABEL_ALIGN (insn);
 	      if (max_log < log)
 		{
 		  max_log = log;
-		  max_skip = LABEL_ALIGN_MAX_SKIP;
+		  max_skip = targetm.asm_out.label_align_max_skip (insn);
 		}
 	    }
 	  /* ADDR_VECs only take room if read-only data goes into the text
 	     section.  */
 	  if ((JUMP_TABLES_IN_TEXT_SECTION
 	    {
 	      log = ADDR_VEC_ALIGN (next);
 	      if (max_log < log)
 		{
 		  max_log = log;
-		  max_skip = LABEL_ALIGN_MAX_SKIP;
+		  max_skip = targetm.asm_out.label_align_max_skip (insn);
 		}
 	    }
 	  LABEL_TO_ALIGNMENT (insn) = max_log;
 	  LABEL_TO_MAX_SKIP (insn) = max_skip;
 	  max_log = 0;
 	      {
 		log = LABEL_ALIGN_AFTER_BARRIER (insn);
 		if (max_log < log)
 		  {
 		    max_log = log;
-		    max_skip = LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP;
+		    max_skip = targetm.asm_out.label_align_after_barrier_max_skip (label);
 		  }
 		break;
 	      }
 	}
 }
 char *s;
 const char *name;
 size_t name_len;
 for (map = debug_prefix_maps; map; map = map->next)
-if (strncmp (filename, map->old_prefix, map->old_len) == 0)
+if (filename_ncmp (filename, map->old_prefix, map->old_len) == 0)
 break;
 if (!map)
 return filename;
 name = filename + map->old_len;
 name_len = strlen (name) + 1;
 for the new function.  The label for the function and associated
 assembler pseudo-ops have already been output in `assemble_start_function'.
 FIRST is the first insn of the rtl for the function being compiled.
 FILE is the file to write assembler code to.
-OPTIMIZE is nonzero if we should eliminate redundant
+OPTIMIZE_P is nonzero if we should eliminate redundant
 test and compare insns.  */
 void
 final_start_function (rtx first ATTRIBUTE_UNUSED, FILE *file,
-		      int optimize ATTRIBUTE_UNUSED)
+		      int optimize_p ATTRIBUTE_UNUSED)
 {
 block_depth = 0;
 this_is_asm_operands = 0;
 high_block_linenum = high_function_linenum = last_linenum;
 if (!DECL_IGNORED_P (current_function_decl))
 debug_hooks->begin_prologue (last_linenum, last_filename);
-#if defined (DWARF2_UNWIND_INFO) || defined (TARGET_UNWIND_INFO)
 if (!dwarf2_debug_info_emitted_p (current_function_decl))
 dwarf2out_begin_prologue (0, NULL);
-#endif
 #ifdef LEAF_REG_REMAP
 if (current_function_uses_only_leaf_regs)
 leaf_renumber_regs (first);
 #endif
 /* The Sun386i and perhaps other machines don't work right
 if the profiling code comes after the prologue.  */
-#ifdef PROFILE_BEFORE_PROLOGUE
+if (targetm.profile_before_prologue () && crtl->profile)
-if (crtl->profile)
 profile_function (file);
-#endif /* PROFILE_BEFORE_PROLOGUE */
+#if defined (HAVE_prologue)
-#if defined (DWARF2_UNWIND_INFO) && defined (HAVE_prologue)
 if (dwarf2out_do_frame ())
 dwarf2out_frame_debug (NULL_RTX, false);
 #endif
 /* If debugging, assign block numbers to all of the blocks in this
 }
 static void
 profile_after_prologue (FILE *file ATTRIBUTE_UNUSED)
 {
-#ifndef PROFILE_BEFORE_PROLOGUE
+if (!targetm.profile_before_prologue () && crtl->profile)
-if (crtl->profile)
 profile_function (file);
-#endif /* not PROFILE_BEFORE_PROLOGUE */
 }
 static void
 profile_function (FILE *file ATTRIBUTE_UNUSED)
 {
 /* And debug output.  */
 if (!DECL_IGNORED_P (current_function_decl))
 debug_hooks->end_epilogue (last_linenum, last_filename);
-#if defined (DWARF2_UNWIND_INFO)
 if (!dwarf2_debug_info_emitted_p (current_function_decl)
 && dwarf2out_do_frame ())
 dwarf2out_end_epilogue (last_linenum, last_filename);
-#endif
 }
 /* Output assembler code for some insns: all or part of a function.
 For description of args, see `final_start_function', above.  */
 void
-final (rtx first, FILE *file, int optimize)
+final (rtx first, FILE *file, int optimize_p)
 {
 rtx insn;
 int max_uid = 0;
 int seen = 0;
 if (INSN_UID (insn) > max_uid)       /* Find largest UID.  */
 	max_uid = INSN_UID (insn);
 #ifdef HAVE_cc0
 /* If CC tracking across branches is enabled, record the insn which
 	 jumps to each branch only reached from one place.  */
-if (optimize && JUMP_P (insn))
+if (optimize_p && JUMP_P (insn))
 	{
 	  rtx lab = JUMP_LABEL (insn);
 	  if (lab && LABEL_NUSES (lab) == 1)
 	    {
 	      LABEL_REFS (lab) = insn;
 	}
 else
 	insn_current_address = INSN_ADDRESSES (INSN_UID (insn));
 #endif /* HAVE_ATTR_length */
-insn = final_scan_insn (insn, file, optimize, 0, &seen);
+insn = final_scan_insn (insn, file, optimize_p, 0, &seen);
 }
 }
 const char *
 get_insn_template (int code, rtx insn)
 both NOTE_INSN_PROLOGUE_END and NOTE_INSN_FUNCTION_BEG, or
 at the beginning of the second basic block, whichever comes
 first.  */
 rtx
-final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED,
+final_scan_insn (rtx insn, FILE *file, int optimize_p ATTRIBUTE_UNUSED,
 		 int nopeepholes ATTRIBUTE_UNUSED, int *seen)
 {
 #ifdef HAVE_cc0
 rtx set;
 #endif
 	case NOTE_INSN_DELETED:
 	  break;
 	case NOTE_INSN_SWITCH_TEXT_SECTIONS:
 	  in_cold_section_p = !in_cold_section_p;
-#ifdef DWARF2_UNWIND_INFO
 	  if (dwarf2out_do_frame ())
 	    dwarf2out_switch_text_section ();
-	  else
+	  else if (!DECL_IGNORED_P (current_function_decl))
-#endif
-	  if (!DECL_IGNORED_P (current_function_decl))
 	    debug_hooks->switch_text_section ();
 	  switch_to_section (current_function_section ());
+	  targetm.asm_out.function_switched_text_sections (asm_out_file,
+							   current_function_decl,
+							   in_cold_section_p);
 	  break;
 	case NOTE_INSN_BASIC_BLOCK:
-#ifdef TARGET_UNWIND_INFO
+	  if (targetm.asm_out.unwind_emit)
-	  targetm.asm_out.unwind_emit (asm_out_file, insn);
+	    targetm.asm_out.unwind_emit (asm_out_file, insn);
-#endif
 	  if (flag_debug_asm)
 	    fprintf (asm_out_file, "\t%s basic block %d\n",
 		     ASM_COMMENT_START, NOTE_BASIC_BLOCK (insn)->index);
 	    *seen |= SEEN_NOTE;
 	  break;
 	case NOTE_INSN_EPILOGUE_BEG:
-#if defined (DWARF2_UNWIND_INFO) && defined (HAVE_epilogue)
+#if defined (HAVE_epilogue)
 	  if (dwarf2out_do_frame ())
-	    dwarf2out_begin_epilogue (insn);
+	    dwarf2out_cfi_begin_epilogue (insn);
 #endif
+	  (*debug_hooks->begin_epilogue) (last_linenum, last_filename);
 	  targetm.asm_out.function_begin_epilogue (file);
 	  break;
 	case NOTE_INSN_CFA_RESTORE_STATE:
-#if defined (DWARF2_UNWIND_INFO)
 	  dwarf2out_frame_debug_restore_state ();
-#endif
 	  break;
 	case NOTE_INSN_FUNCTION_BEG:
 	  app_disable ();
 	  if (!DECL_IGNORED_P (current_function_decl))
 	  break;
 	}
 break;
 case BARRIER:
-#if defined (DWARF2_UNWIND_INFO)
 if (dwarf2out_do_frame ())
 	dwarf2out_frame_debug (insn, false);
-#endif
 break;
 case CODE_LABEL:
 /* The target port might emit labels in the output function for
 	 some insn, e.g. sh.c output_branchy_insn.  */
 	      ASM_OUTPUT_ALIGN (file, align);
 #endif
 #endif
 	    }
 	}
-#ifdef HAVE_cc0
 CC_STATUS_INIT;
-#endif
 if (!DECL_IGNORED_P (current_function_decl) && LABEL_NAME (insn))
 	debug_hooks->label (insn);
 app_disable ();
 	    final_sequence = body;
 	    /* Record the delay slots' frame information before the branch.
 	       This is needed for delayed calls: see execute_cfa_program().  */
-#if defined (DWARF2_UNWIND_INFO)
 	    if (dwarf2out_do_frame ())
 	      for (i = 1; i < XVECLEN (body, 0); i++)
 		dwarf2out_frame_debug (XVECEXP (body, 0, i), false);
-#endif
 	    /* The first insn in this SEQUENCE might be a JUMP_INSN that will
 	       force the restoration of a comparison that was previously
 	       thought unnecessary.  If that happens, cancel this sequence
 	       and cause that insn to be restored.  */
 	   it should be possible for the user to alter a variable
 	   with the debugger in between statements
 	   and the next statement should reexamine the variable
 	   to compute the condition codes.  */
-	if (optimize)
+	if (optimize_p)
 	  {
 	    if (set
 		&& GET_CODE (SET_DEST (set)) == CC0
 		&& insn != last_ignored_compare)
 	      {
 #endif
 #ifdef HAVE_peephole
 	/* Do machine-specific peephole optimizations if desired.  */
-	if (optimize && !flag_no_peephole && !nopeepholes)
+	if (optimize_p && !flag_no_peephole && !nopeepholes)
 	  {
 	    rtx next = peephole (insn);
 	    /* When peepholing, if there were notes within the peephole,
 	       emit them before the peephole.  */
 	    if (next != 0 && next != NEXT_INSN (insn))
 	      {
 		rtx note, prev = PREV_INSN (insn);
 		for (note = NEXT_INSN (insn); note != next;
 		     note = NEXT_INSN (note))
-		  final_scan_insn (note, file, optimize, nopeepholes, seen);
+		  final_scan_insn (note, file, optimize_p, nopeepholes, seen);
 		/* Put the notes in the proper position for a later
 		   rescan.  For example, the SH target can do this
 		   when generating a far jump in a delayed branch
 		   sequence.  */
 	NOTICE_UPDATE_CC (body, insn);
 #endif
 	current_output_insn = debug_insn = insn;
-#if defined (DWARF2_UNWIND_INFO)
 	if (CALL_P (insn) && dwarf2out_do_frame ())
 	  dwarf2out_frame_debug (insn, false);
-#endif
 	/* Find the proper template for this insn.  */
 	templ = get_insn_template (insn_code_number, insn);
 	/* If the C code returns 0, it means that it is a jump insn
 #endif
 	    return new_rtx;
 	  }
-#ifdef TARGET_UNWIND_INFO
 	/* ??? This will put the directives in the wrong place if
 	   get_insn_template outputs assembly directly.  However calling it
 	   before get_insn_template breaks if the insns is split.  */
-	targetm.asm_out.unwind_emit (asm_out_file, insn);
+	if (targetm.asm_out.unwind_emit_before_insn
-#endif
+	    && targetm.asm_out.unwind_emit)
+	  targetm.asm_out.unwind_emit (asm_out_file, insn);
 	if (CALL_P (insn))
 	  {
 	    rtx x = call_from_call_insn (insn);
 	    x = XEXP (x, 0);
 					       recog_data.n_operands);
 	/* If necessary, report the effect that the instruction has on
 	   the unwind info.   We've already done this for delay slots
 	   and call instructions.  */
-#if defined (DWARF2_UNWIND_INFO)
 	if (final_sequence == 0
 #if !defined (HAVE_prologue)
 	    && !ACCUMULATE_OUTGOING_ARGS
 #endif
 	    && dwarf2out_do_frame ())
 	  dwarf2out_frame_debug (insn, true);
-#endif
+	if (!targetm.asm_out.unwind_emit_before_insn
+	    && targetm.asm_out.unwind_emit)
+	  targetm.asm_out.unwind_emit (asm_out_file, insn);
 	current_output_insn = debug_insn = 0;
 }
 }
 return NEXT_INSN (insn);
 	  }
 	/* % followed by a letter and some digits
 	   outputs an operand in a special way depending on the letter.
 	   Letters `acln' are implemented directly.
 	   Other letters are passed to `output_operand' so that
-	   the PRINT_OPERAND macro can define them.  */
+	   the TARGET_PRINT_OPERAND hook can define them.  */
 	else if (ISALPHA (*p))
 	  {
 	    int letter = *p++;
 	    unsigned long opnum;
 	    char *endptr;
 	    p = endptr;
 	    c = *p;
 	  }
 	/* % followed by punctuation: output something for that
-	   punctuation character alone, with no operand.
+	   punctuation character alone, with no operand.  The
-	   The PRINT_OPERAND macro decides what is actually done.  */
+	   TARGET_PRINT_OPERAND hook decides what is actually done.  */
-#ifdef PRINT_OPERAND_PUNCT_VALID_P
+	else if (targetm.asm_out.print_operand_punct_valid_p ((unsigned char) *p))
-	else if (PRINT_OPERAND_PUNCT_VALID_P ((unsigned char) *p))
 	  output_operand (NULL_RTX, *p++);
-#endif
 	else
 	  output_operand_lossage ("invalid %%-code");
 	break;
 default:
 {
 for_each_rtx (&x, mark_symbol_ref_as_used, NULL);
 }
 /* Print operand X using machine-dependent assembler syntax.
-The macro PRINT_OPERAND is defined just to control this function.
 CODE is a non-digit that preceded the operand-number in the % spec,
 such as 'z' if the spec was `%z3'.  CODE is 0 if there was no char
 between the % and the digits.
 When CODE is a non-letter, X is 0.
 The meanings of the letters are machine-dependent and controlled
-by PRINT_OPERAND.  */
+by TARGET_PRINT_OPERAND.  */
-static void
+void
 output_operand (rtx x, int code ATTRIBUTE_UNUSED)
 {
 if (x && GET_CODE (x) == SUBREG)
 x = alter_subreg (&x);
 /* X must not be a pseudo reg.  */
 gcc_assert (!x || !REG_P (x) || REGNO (x) < FIRST_PSEUDO_REGISTER);
-PRINT_OPERAND (asm_out_file, x, code);
+targetm.asm_out.print_operand (asm_out_file, x, code);
 if (x == NULL_RTX)
 return;
 for_each_rtx (&x, mark_symbol_ref_as_used, NULL);
 }
-/* Print a memory reference operand for address X
+/* Print a memory reference operand for address X using
-using machine-dependent assembler syntax.
+machine-dependent assembler syntax.  */
-The macro PRINT_OPERAND_ADDRESS exists just to control this function.  */
 void
 output_address (rtx x)
 {
 bool changed = false;
 walk_alter_subreg (&x, &changed);
-PRINT_OPERAND_ADDRESS (asm_out_file, x);
+targetm.asm_out.print_operand_address (asm_out_file, x);
 }
 /* Print an integer constant expression in assembler syntax.
 Addition and subtraction are the only arithmetic
 that may appear in these expressions.  */
 case TRUNCATE:
 output_addr_const (file, XEXP (x, 0));
 break;
 default:
-#ifdef OUTPUT_ADDR_CONST_EXTRA
+if (targetm.asm_out.output_addr_const_extra (file, x))
-OUTPUT_ADDR_CONST_EXTRA (file, x, fail);
+	break;
-break;
-fail:
-#endif
 output_operand_lossage ("invalid expression as operand");
 }
+}
+/* Output a quoted string.  */
+void
+output_quoted_string (FILE *asm_file, const char *string)
+{
+#ifdef OUTPUT_QUOTED_STRING
+OUTPUT_QUOTED_STRING (asm_file, string);
+#else
+char c;
+putc ('\"', asm_file);
+while ((c = *string++) != 0)
+{
+if (ISPRINT (c))
+	{
+	  if (c == '\"' || c == '\\')
+	    putc ('\\', asm_file);
+	  putc (c, asm_file);
+	}
+else
+	fprintf (asm_file, "\\%03o", (unsigned char) c);
+}
+putc ('\"', asm_file);
+#endif
 }
 /* A poor man's fprintf, with the added features of %I, %R, %L, and %U.
 %R prints the value of REGISTER_PREFIX.
 %L prints the value of LOCAL_LABEL_PREFIX.
 	  /* In this case the CONST_INT holds both target words.
 	     Extract the bits from it into two word-sized pieces.
 	     Sign extend each half to HOST_WIDE_INT.  */
 	  unsigned HOST_WIDE_INT low, high;
 	  unsigned HOST_WIDE_INT mask, sign_bit, sign_extend;
+	  unsigned bits_per_word = BITS_PER_WORD;
 	  /* Set sign_bit to the most significant bit of a word.  */
 	  sign_bit = 1;
-	  sign_bit <<= BITS_PER_WORD - 1;
+	  sign_bit <<= bits_per_word - 1;
 	  /* Set mask so that all bits of the word are set.  We could
 	     have used 1 << BITS_PER_WORD instead of basing the
 	     calculation on sign_bit.  However, on machines where
 	     HOST_BITS_PER_WIDE_INT == BITS_PER_WORD, it could cause a
 	    low |= sign_extend;
 	  /* Pick the higher word, shifted to the least significant
 	     bits, and sign-extend it.  */
 	  high = INTVAL (value);
-	  high >>= BITS_PER_WORD - 1;
+	  high >>= bits_per_word - 1;
 	  high >>= 1;
 	  high &= mask;
 	  if (high & sign_bit)
 	    high |= sign_extend;
 assemble_start_function (current_function_decl, fnname);
 final_start_function (get_insns (), asm_out_file, optimize);
 final (get_insns (), asm_out_file, optimize);
 final_end_function ();
-#ifdef TARGET_UNWIND_INFO
+/* The IA-64 ".handlerdata" directive must be issued before the ".endp"
-/* ??? The IA-64 ".handlerdata" directive must be issued before
+directive that closes the procedure descriptor.  Similarly, for x64 SEH.
-the ".endp" directive that closes the procedure descriptor.  */
+Otherwise it's not strictly necessary, but it doesn't hurt either.  */
 output_function_exception_table (fnname);
-#endif
 assemble_end_function (current_function_decl, fnname);
-#ifndef TARGET_UNWIND_INFO
-/* Otherwise, it feels unclean to switch sections in the middle.  */
-output_function_exception_table (fnname);
-#endif
 user_defined_section_attribute = false;
 /* Free up reg info memory.  */
 free_reg_info ();
 if (flag_dump_final_insns)
 {
 final_output = fopen (flag_dump_final_insns, "a");
 if (!final_output)
 	{
-	  error ("could not open final insn dump file %qs: %s",
+	  error ("could not open final insn dump file %qs: %m",
-		 flag_dump_final_insns, strerror (errno));
+		 flag_dump_final_insns);
 	  flag_dump_final_insns = NULL;
 	}
 else
 	{
 	  const char *aname;
 	  for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
 	    if (LABEL_P (insn))
 	      INSN_UID (insn) = CODE_LABEL_NUMBER (insn);
 	    else
-	      INSN_UID (insn) = 0;
+	      {
+		if (NOTE_P (insn))
+		  set_block_for_insn (insn, NULL);
+		INSN_UID (insn) = 0;
+	      }
 	}
 }
 /* It is very important to decompose the RTL instruction chain here:
 debug information keeps pointing into CODE_LABEL insns inside the function
 	      (NOTE_KIND (insn) != NOTE_INSN_VAR_LOCATION
 	       && NOTE_KIND (insn) != NOTE_INSN_BLOCK_BEG
 	       && NOTE_KIND (insn) != NOTE_INSN_BLOCK_END
 	       && NOTE_KIND (insn) != NOTE_INSN_CFA_RESTORE_STATE)))
 	print_rtl_single (final_output, insn);
 }
 if (final_output)
 {
 flag_dump_noaddr = save_noaddr;
 flag_dump_unnumbered = save_unnumbered;
 final_insns_dump_p = false;
 if (fclose (final_output))
 	{
-	  error ("could not close final insn dump file %qs: %s",
+	  error ("could not close final insn dump file %qs: %m",
-		 flag_dump_final_insns, strerror (errno));
+		 flag_dump_final_insns);
 	  flag_dump_final_insns = NULL;
 	}
 }
 /* In case the function was not output,
 free_bb_for_insn ();
 delete_tree_ssa ();
-if (targetm.binds_local_p (current_function_decl))
+/* We can reduce stack alignment on call site only when we are sure that
+the function body just produced will be actually used in the final
+executable.  */
+if (decl_binds_to_current_def_p (current_function_decl))
 {
 unsigned int pref = crtl->preferred_stack_boundary;
 if (crtl->stack_alignment_needed > crtl->preferred_stack_boundary)
 pref = crtl->stack_alignment_needed;
 cgraph_rtl_info (current_function_decl)->preferred_incoming_stack_boundary

Mercurial > hg > CbC > CbC_gcc

comparison gcc/final.c @ 67:f6334be47118