CbC/CbC_gcc: gcc/stmt.c comparison

comparison gcc/stmt.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 "insn-config.h"
 #include "expr.h"
 #include "libfuncs.h"
 #include "recog.h"
 #include "machmode.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
 #include "output.h"
 #include "ggc.h"
 #include "langhooks.h"
 #include "predict.h"
 #include "optabs.h"
 nclobbers = 0;
 CLEAR_HARD_REG_SET (clobbered_regs);
 for (tail = clobbers; tail; tail = TREE_CHAIN (tail))
 {
 const char *regname;
+int nregs;
 if (TREE_VALUE (tail) == error_mark_node)
 	return;
 regname = TREE_STRING_POINTER (TREE_VALUE (tail));
-i = decode_reg_name (regname);
+i = decode_reg_name_and_count (regname, &nregs);
-if (i >= 0 || i == -4)
+if (i == -4)
 	++nclobbers;
 else if (i == -2)
 	error ("unknown register name %qs in %<asm%>", regname);
 /* Mark clobbered registers.  */
 if (i >= 0)
 {
-	  /* Clobbering the PIC register is an error.  */
+	  int reg;
-	  if (i == (int) PIC_OFFSET_TABLE_REGNUM)
+	  for (reg = i; reg < i + nregs; reg++)
 	    {
-	      error ("PIC register %qs clobbered in %<asm%>", regname);
+	      ++nclobbers;
-	      return;
+	      /* Clobbering the PIC register is an error.  */
+	      if (reg == (int) PIC_OFFSET_TABLE_REGNUM)
+		{
+		  error ("PIC register clobbered by %qs in %<asm%>", regname);
+		  return;
+		}
+	      SET_HARD_REG_BIT (clobbered_regs, reg);
 	    }
-	  SET_HARD_REG_BIT (clobbered_regs, i);
 	}
 }
 /* First pass over inputs and outputs checks validity and sets
 mark_addressable if needed.  */
 if (! allows_reg && allows_mem)
 	mark_addressable (TREE_VALUE (tail));
 }
 /* Second pass evaluates arguments.  */
+/* Make sure stack is consistent for asm goto.  */
+if (nlabels > 0)
+do_pending_stack_adjust ();
 ninout = 0;
 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
 {
 tree val = TREE_VALUE (tail);
 /* Store (clobber REG) for each clobbered register specified.  */
 for (tail = clobbers; tail; tail = TREE_CHAIN (tail))
 	{
 	  const char *regname = TREE_STRING_POINTER (TREE_VALUE (tail));
-	  int j = decode_reg_name (regname);
+	  int reg, nregs;
+	  int j = decode_reg_name_and_count (regname, &nregs);
 	  rtx clobbered_reg;
 	  if (j < 0)
 	    {
 	      if (j == -3)	/* `cc', which is not a register */
 	      /* Ignore unknown register, error already signaled.  */
 	      continue;
 	    }
-	  /* Use QImode since that's guaranteed to clobber just one reg.  */
+	  for (reg = j; reg < j + nregs; reg++)
-	  clobbered_reg = gen_rtx_REG (QImode, j);
-	  /* Do sanity check for overlap between clobbers and respectively
-	     input and outputs that hasn't been handled.  Such overlap
-	     should have been detected and reported above.  */
-	  if (!clobber_conflict_found)
 	    {
-	      int opno;
+	      /* Use QImode since that's guaranteed to clobber just
+	       * one reg.  */
-	      /* We test the old body (obody) contents to avoid tripping
+	      clobbered_reg = gen_rtx_REG (QImode, reg);
-		 over the under-construction body.  */
-	      for (opno = 0; opno < noutputs; opno++)
+	      /* Do sanity check for overlap between clobbers and
-		if (reg_overlap_mentioned_p (clobbered_reg, output_rtx[opno]))
+		 respectively input and outputs that hasn't been
-		  internal_error ("asm clobber conflict with output operand");
+		 handled.  Such overlap should have been detected and
+		 reported above.  */
-	      for (opno = 0; opno < ninputs - ninout; opno++)
+	      if (!clobber_conflict_found)
-		if (reg_overlap_mentioned_p (clobbered_reg,
+		{
-					     ASM_OPERANDS_INPUT (obody, opno)))
+		  int opno;
-		  internal_error ("asm clobber conflict with input operand");
+		  /* We test the old body (obody) contents to avoid
+		     tripping over the under-construction body.  */
+		  for (opno = 0; opno < noutputs; opno++)
+		    if (reg_overlap_mentioned_p (clobbered_reg,
+						 output_rtx[opno]))
+		      internal_error
+			("asm clobber conflict with output operand");
+		  for (opno = 0; opno < ninputs - ninout; opno++)
+		    if (reg_overlap_mentioned_p (clobbered_reg,
+						 ASM_OPERANDS_INPUT (obody,
+								     opno)))
+		      internal_error
+			("asm clobber conflict with input operand");
+		}
+	      XVECEXP (body, 0, i++)
+		= gen_rtx_CLOBBER (VOIDmode, clobbered_reg);
 	    }
-	  XVECEXP (body, 0, i++)
-	    = gen_rtx_CLOBBER (VOIDmode, clobbered_reg);
 	}
 if (nlabels > 0)
 	emit_jump_insn (body);
 else
 	break;
 else if (ISALPHA (c[1]) && c[2] == '[')
 	break;
 else
 	{
-	  c += 1;
+	  c += 1 + (c[1] == '%');
 	  continue;
 	}
 }
 if (c)
 	    p += 1;
 	  else if (ISALPHA (p[1]) && p[2] == '[')
 	    p += 2;
 	  else
 	    {
-	      p += 1;
+	      p += 1 + (p[1] == '%');
 	      continue;
 	    }
 	  p = resolve_operand_name_1 (p, outputs, inputs, labels);
 	}
 {
 tree funtype = TREE_TYPE (current_function_decl);
 tree type = TREE_TYPE (decl);
 int unsignedp = TYPE_UNSIGNED (type);
 enum machine_mode old_mode = DECL_MODE (decl);
-enum machine_mode mode = promote_function_mode (type, old_mode,
+enum machine_mode mode;
-						      &unsignedp, funtype, 1);
+if (DECL_BY_REFERENCE (decl))
+mode = promote_function_mode (type, old_mode, &unsignedp, funtype, 2);
+else
+mode = promote_function_mode (type, old_mode, &unsignedp, funtype, 1);
 if (mode != old_mode)
 	val = convert_modes (mode, old_mode, val, unsignedp);
 if (GET_CODE (return_reg) == PARALLEL)
 	  /* Use bitpos for the source extraction (left justified) and
 	     xbitpos for the destination store (right justified).  */
 	  store_bit_field (dst, bitsize, xbitpos % BITS_PER_WORD, word_mode,
 			   extract_bit_field (src, bitsize,
-					      bitpos % BITS_PER_WORD, 1,
+					      bitpos % BITS_PER_WORD, 1, false,
 					      NULL_RTX, word_mode, word_mode));
 	}
 tmpmode = GET_MODE (result_rtl);
 if (tmpmode == BLKmode)
 the original assignment true.
 So the following insn will actually be
 decrementing fp by STARTING_FRAME_OFFSET.  */
 emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
-#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
+#if !HARD_FRAME_POINTER_IS_ARG_POINTER
 if (fixed_regs[ARG_POINTER_REGNUM])
 {
 #ifdef ELIMINABLE_REGS
 /* If the argument pointer can be eliminated in favor of the
 	 frame pointer, we don't need to restore it.  We assume here
 expand_stack_save (void)
 {
 rtx ret = NULL_RTX;
 do_pending_stack_adjust ();
-emit_stack_save (SAVE_BLOCK, &ret, NULL_RTX);
+emit_stack_save (SAVE_BLOCK, &ret);
 return ret;
 }
 /* Emit code to restore the current value of stack.  */
 void
 expand_stack_restore (tree var)
 {
 rtx sa = expand_normal (var);
 sa = convert_memory_address (Pmode, sa);
-emit_stack_restore (SAVE_BLOCK, sa, NULL_RTX);
+emit_stack_restore (SAVE_BLOCK, sa);
 }
 /* Do the insertion of a case label into case_list.  The labels are
 fed to us in descending order from the sorted vector of case labels used
 in the tree part of the middle end.  So the list we construct is
 /* Maximum number of case bit tests.  */
 #define MAX_CASE_BIT_TESTS  3
 /* By default, enable case bit tests on targets with ashlsi3.  */
 #ifndef CASE_USE_BIT_TESTS
-#define CASE_USE_BIT_TESTS  (optab_handler (ashl_optab, word_mode)->insn_code \
+#define CASE_USE_BIT_TESTS  (optab_handler (ashl_optab, word_mode) \
 			     != CODE_FOR_nothing)
 #endif
 /* A case_bit_test represents a set of case nodes that may be
 /* Determine whether "1 << x" is relatively cheap in word_mode.  */
 static
 bool lshift_cheap_p (void)
 {
-static bool init = false;
+static bool init[2] = {false, false};
-static bool cheap = true;
+static bool cheap[2] = {true, true};
-if (!init)
+bool speed_p = optimize_insn_for_speed_p ();
+if (!init[speed_p])
 {
 rtx reg = gen_rtx_REG (word_mode, 10000);
 int cost = rtx_cost (gen_rtx_ASHIFT (word_mode, const1_rtx, reg), SET,
-			   optimize_insn_for_speed_p ());
+			   speed_p);
-cheap = cost < COSTS_N_INSNS (3);
+cheap[speed_p] = cost < COSTS_N_INSNS (3);
-init = true;
+init[speed_p] = true;
 }
-return cheap;
+return cheap[speed_p];
 }
 /* Comparison function for qsort to order bit tests by decreasing
 number of case nodes, i.e. the node with the most cases gets
 tested first.  */
 #endif
 #ifndef HAVE_tablejump
 #define HAVE_tablejump 0
 #endif
+/* Return true if a switch should be expanded as a bit test.
+INDEX_EXPR is the index expression, RANGE is the difference between
+highest and lowest case, UNIQ is number of unique case node targets
+not counting the default case and COUNT is the number of comparisons
+needed, not counting the default case.  */
+bool
+expand_switch_using_bit_tests_p (tree index_expr, tree range,
+				 unsigned int uniq, unsigned int count)
+{
+return (CASE_USE_BIT_TESTS
+	  && ! TREE_CONSTANT (index_expr)
+	  && compare_tree_int (range, GET_MODE_BITSIZE (word_mode)) < 0
+	  && compare_tree_int (range, 0) > 0
+	  && lshift_cheap_p ()
+	  && ((uniq == 1 && count >= 3)
+	      || (uniq == 2 && count >= 5)
+	      || (uniq == 3 && count >= 6)));
+}
 /* Terminate a case (Pascal/Ada) or switch (C) statement
 in which ORIG_INDEX is the expression to be tested.
 If ORIG_TYPE is not NULL, it is the original ORIG_INDEX
 type as given in the source before any compiler conversions.
 	    count++;
 	  /* If we have not seen this label yet, then increase the
 	     number of unique case node targets seen.  */
 	  lab = label_rtx (n->code_label);
-	  if (!bitmap_bit_p (label_bitmap, CODE_LABEL_NUMBER (lab)))
+	  if (bitmap_set_bit (label_bitmap, CODE_LABEL_NUMBER (lab)))
-	    {
+	    uniq++;
-	      bitmap_set_bit (label_bitmap, CODE_LABEL_NUMBER (lab));
-	      uniq++;
-	    }
 	}
 BITMAP_FREE (label_bitmap);
 /* cleanup_tree_cfg removes all SWITCH_EXPR with a single
 range = fold_build2 (MINUS_EXPR, index_type, maxval, minval);
 /* Try implementing this switch statement by a short sequence of
 	 bit-wise comparisons.  However, we let the binary-tree case
 	 below handle constant index expressions.  */
-if (CASE_USE_BIT_TESTS
+if (expand_switch_using_bit_tests_p (index_expr, range, uniq, count))
-	  && ! TREE_CONSTANT (index_expr)
-	  && compare_tree_int (range, GET_MODE_BITSIZE (word_mode)) < 0
-	  && compare_tree_int (range, 0) > 0
-	  && lshift_cheap_p ()
-	  && ((uniq == 1 && count >= 3)
-	      || (uniq == 2 && count >= 5)
-	      || (uniq == 3 && count >= 6)))
 	{
 	  /* Optimize the case where all the case values fit in a
 	     word without having to subtract MINVAL.  In this case,
 	     we can optimize away the subtraction.  */
 	  if (compare_tree_int (minval, 0) > 0

Mercurial > hg > CbC > CbC_gcc

comparison gcc/stmt.c @ 67:f6334be47118