CbC/CbC_gcc: gcc/recog.c comparison

comparison gcc/recog.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	a06113de4d67
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 return true;
 }
 else
 return false;
 }
 /* This subroutine of apply_change_group verifies whether the changes to INSN
 were valid; i.e. whether INSN can still be recognized.  */
 int
 if (object == 0 || object == last_validated)
 	continue;
 if (MEM_P (object))
 	{
-	  if (! memory_address_p (GET_MODE (object), XEXP (object, 0)))
+	  if (! memory_address_addr_space_p (GET_MODE (object),
+					     XEXP (object, 0),
+					     MEM_ADDR_SPACE (object)))
 	    break;
 	}
 else if (REG_P (changes[i].old)
 	       && asm_noperands (PATTERN (object)) > 0
 	       && REG_EXPR (changes[i].old) != NULL_TREE
 	{
 	  /* Don't allow changes of hard register operands to inline
 	     assemblies if they have been defined as register asm ("x").  */
 	  break;
 	}
+else if (DEBUG_INSN_P (object))
+	continue;
 else if (insn_invalid_p (object))
 	{
 	  rtx pat = PATTERN (object);
 	  /* Perhaps we couldn't recognize the insn because there were
 		 but this shouldn't occur.  */
 	      validate_change (object, &PATTERN (object), newpat, 1);
 	      continue;
 	    }
-	  else if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER)
+	  else if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER
+		   || GET_CODE (pat) == VAR_LOCATION)
 	    /* If this insn is a CLOBBER or USE, it is always valid, but is
 	       never recognized.  */
 	    continue;
 	  else
 	    break;
 /* A subroutine of validate_replace_rtx_1 that tries to simplify the resulting
 rtx.  */
 static void
 simplify_while_replacing (rtx *loc, rtx to, rtx object,
 enum machine_mode op0_mode)
 {
 rtx x = *loc;
 enum rtx_code code = GET_CODE (x);
 rtx new_rtx;
 case PLUS:
 /* If we have a PLUS whose second operand is now a CONST_INT, use
 simplify_gen_binary to try to simplify it.
 ??? We may want later to remove this, once simplification is
 separated from this function.  */
-if (GET_CODE (XEXP (x, 1)) == CONST_INT && XEXP (x, 1) == to)
+if (CONST_INT_P (XEXP (x, 1)) && XEXP (x, 1) == to)
 	validate_change (object, loc,
 			 simplify_gen_binary
 			 (PLUS, GET_MODE (x), XEXP (x, 0), XEXP (x, 1)), 1);
 break;
 case MINUS:
-if (GET_CODE (XEXP (x, 1)) == CONST_INT
+if (CONST_INT_P (XEXP (x, 1))
 	  || GET_CODE (XEXP (x, 1)) == CONST_DOUBLE)
 	validate_change (object, loc,
 			 simplify_gen_binary
 			 (PLUS, GET_MODE (x), XEXP (x, 0),
 			  simplify_gen_unary (NEG,
 to be the mode required for memory in extract operations (this isn't
 likely to be an insertion operation; if it was, nothing bad will
 happen, we might just fail in some cases).  */
 if (MEM_P (XEXP (x, 0))
-	  && GET_CODE (XEXP (x, 1)) == CONST_INT
+	  && CONST_INT_P (XEXP (x, 1))
-	  && GET_CODE (XEXP (x, 2)) == CONST_INT
+	  && CONST_INT_P (XEXP (x, 2))
 	  && !mode_dependent_address_p (XEXP (XEXP (x, 0), 0))
 	  && !MEM_VOLATILE_P (XEXP (x, 0)))
 	{
 	  enum machine_mode wanted_mode = VOIDmode;
 	  enum machine_mode is_mode = GET_MODE (XEXP (x, 0));
 /* Replace every occurrence of FROM in X with TO.  Mark each change with
 validate_change passing OBJECT.  */
 static void
 validate_replace_rtx_1 (rtx *loc, rtx from, rtx to, rtx object,
 bool simplify)
 {
 int i, j;
 const char *fmt;
 rtx x = *loc;
 							      (x, 0, j))));
 	      validate_replace_rtx_1 (&SET_DEST (XVECEXP (x, 0, j)),
 				      from, to, object, simplify);
 	    }
 	  else
 	    validate_replace_rtx_1 (&XVECEXP (x, 0, j), from, to, object,
 simplify);
 	}
 }
 else
 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 {
 	if (fmt[i] == 'e')
 	  validate_replace_rtx_1 (&XEXP (x, i), from, to, object, simplify);
 	else if (fmt[i] == 'E')
 	  for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 	    validate_replace_rtx_1 (&XVECEXP (x, i, j), from, to, object,
 simplify);
 }
 /* If we didn't substitute, there is nothing more to do.  */
 if (num_changes == prev_changes)
 simplifications, as it is not our job.  */
 if (simplify)
 simplify_while_replacing (loc, to, object, op0_mode);
 }
+/* Try replacing every occurrence of FROM in subexpression LOC of INSN
+with TO.  After all changes have been made, validate by seeing
+if INSN is still valid.  */
+int
+validate_replace_rtx_subexp (rtx from, rtx to, rtx insn, rtx *loc)
+{
+validate_replace_rtx_1 (loc, from, to, insn, true);
+return apply_change_group ();
+}
 /* Try replacing every occurrence of FROM in INSN with TO.  After all
 changes have been made, validate by seeing if INSN is still valid.  */
 int
 validate_replace_rtx (rtx from, rtx to, rtx insn)
 validate_replace_rtx_1 (&PATTERN (insn), from, to, insn, true);
 return apply_change_group ();
 }
 /* Try replacing every occurrence of FROM in WHERE with TO.  Assume that WHERE
 is a part of INSN.  After all changes have been made, validate by seeing if
 INSN is still valid.
 validate_replace_rtx (from, to, insn) is equivalent to
 validate_replace_rtx_part (from, to, &PATTERN (insn), insn).  */
 int
 validate_replace_rtx_part (rtx from, rtx to, rtx *where, rtx insn)
 {
 validate_replace_rtx_1 (where, from, to, insn, true);
 return apply_change_group ();
 }
 /* Same as above, but do not simplify rtx afterwards.  */
 int
 validate_replace_rtx_part_nosimplify (rtx from, rtx to, rtx *where,
 rtx insn)
 {
 validate_replace_rtx_1 (where, from, to, insn, false);
 return apply_change_group ();
 if (GET_MODE (op) == VOIDmode && mode != VOIDmode
 && GET_MODE_CLASS (mode) != MODE_INT
 && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
 return 0;
-if (GET_CODE (op) == CONST_INT
+if (CONST_INT_P (op)
 && mode != VOIDmode
 && trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
 return 0;
 if (CONSTANT_P (op))
 if (! volatile_ok && MEM_VOLATILE_P (op))
 	return 0;
 /* Use the mem's mode, since it will be reloaded thus.  */
-if (memory_address_p (GET_MODE (op), y))
+if (memory_address_addr_space_p (GET_MODE (op), y, MEM_ADDR_SPACE (op)))
 	return 1;
 }
 return 0;
 }
 if (GET_MODE (op) == VOIDmode && mode != VOIDmode
 && GET_MODE_CLASS (mode) != MODE_INT
 && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
 return 0;
-if (GET_CODE (op) == CONST_INT
+if (CONST_INT_P (op)
 && mode != VOIDmode
 && trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
 return 0;
 return (CONSTANT_P (op)
 /* Returns 1 if OP is an operand that is a CONST_INT.  */
 int
 const_int_operand (rtx op, enum machine_mode mode)
 {
-if (GET_CODE (op) != CONST_INT)
+if (!CONST_INT_P (op))
 return 0;
 if (mode != VOIDmode
 && trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
 return 0;
 if (GET_MODE (op) == VOIDmode && mode != VOIDmode
 && GET_MODE_CLASS (mode) != MODE_INT
 && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
 return 0;
-return ((GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT)
+return ((GET_CODE (op) == CONST_DOUBLE || CONST_INT_P (op))
 	  && (mode == VOIDmode || GET_MODE (op) == mode
 	      || GET_MODE (op) == VOIDmode));
 }
 /* Return 1 if OP is a general operand that is not an immediate operand.  */
 if (GET_MODE (op) == VOIDmode && mode != VOIDmode
 	  && GET_MODE_CLASS (mode) != MODE_INT
 	  && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
 	return 0;
-if (GET_CODE (op) == CONST_INT
+if (CONST_INT_P (op)
 	  && mode != VOIDmode
 	  && trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op))
 	return 0;
 return ((GET_MODE (op) == VOIDmode || GET_MODE (op) == mode
 else
 {
 if (GET_CODE (op) != PRE_MODIFY
 	  || GET_CODE (XEXP (op, 1)) != PLUS
 	  || XEXP (XEXP (op, 1), 0) != XEXP (op, 0)
-	  || GET_CODE (XEXP (XEXP (op, 1), 1)) != CONST_INT
+	  || !CONST_INT_P (XEXP (XEXP (op, 1), 1))
 #ifdef STACK_GROWS_DOWNWARD
 	  || INTVAL (XEXP (XEXP (op, 1), 1)) != - (int) rounded_size
 #else
 	  || INTVAL (XEXP (XEXP (op, 1), 1)) != (int) rounded_size
 #endif
 return 0;
 return XEXP (op, 0) == stack_pointer_rtx;
 }
-/* Return 1 if ADDR is a valid memory address for mode MODE.  */
+/* Return 1 if ADDR is a valid memory address
+for mode MODE in address space AS.  */
-int
-memory_address_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx addr)
+int
-{
+memory_address_addr_space_p (enum machine_mode mode ATTRIBUTE_UNUSED,
+			     rtx addr, addr_space_t as)
+{
+#ifdef GO_IF_LEGITIMATE_ADDRESS
+gcc_assert (ADDR_SPACE_GENERIC_P (as));
 GO_IF_LEGITIMATE_ADDRESS (mode, addr, win);
 return 0;
 win:
 return 1;
+#else
+return targetm.addr_space.legitimate_address_p (mode, addr, 0, as);
+#endif
 }
 /* Return 1 if OP is a valid memory reference with mode MODE,
 including a valid address.
 	 or if the address is (plus Y (const_int -OFFSET)) and Y is an
 	 operand.  */
 return ((offset == 0 && general_operand (XEXP (inner, 0), Pmode))
 	      || (GET_CODE (XEXP (inner, 0)) == PLUS
-		  && GET_CODE (XEXP (XEXP (inner, 0), 1)) == CONST_INT
+		  && CONST_INT_P (XEXP (XEXP (inner, 0), 1))
 		  && INTVAL (XEXP (XEXP (inner, 0), 1)) == -offset
 		  && general_operand (XEXP (XEXP (inner, 0), 0), Pmode)));
 }
 return (MEM_P (op)
 	  && memory_operand (op, mode)
 	  && general_operand (XEXP (op, 0), Pmode));
 }
+/* Return 1 if this is an ordered comparison operator (not including
+ORDERED and UNORDERED).  */
+int
+ordered_comparison_operator (rtx op, enum machine_mode mode)
+{
+if (mode != VOIDmode && GET_MODE (op) != mode)
+return false;
+switch (GET_CODE (op))
+{
+case EQ:
+case NE:
+case LT:
+case LTU:
+case LE:
+case LEU:
+case GT:
+case GTU:
+case GE:
+case GEU:
+return true;
+default:
+return false;
+}
+}
 /* Return 1 if this is a comparison operator.  This allows the use of
 MATCH_OPERATOR to recognize all the branch insns.  */
 int
 comparison_operator (rtx op, enum machine_mode mode)
 {
 return ((mode == VOIDmode || GET_MODE (op) == mode)
 	  && COMPARISON_P (op));
 }
+/* If BODY is an insn body that uses ASM_OPERANDS, return it.  */
+rtx
+extract_asm_operands (rtx body)
+{
+rtx tmp;
+switch (GET_CODE (body))
+{
+case ASM_OPERANDS:
+return body;
+case SET:
+/* Single output operand: BODY is (set OUTPUT (asm_operands ...)).  */
+tmp = SET_SRC (body);
+if (GET_CODE (tmp) == ASM_OPERANDS)
+	return tmp;
+break;
+case PARALLEL:
+tmp = XVECEXP (body, 0, 0);
+if (GET_CODE (tmp) == ASM_OPERANDS)
+	return tmp;
+if (GET_CODE (tmp) == SET)
+	{
+	  tmp = SET_SRC (tmp);
+	  if (GET_CODE (tmp) == ASM_OPERANDS)
+	    return tmp;
+	}
+break;
+default:
+break;
+}
+return NULL;
+}
 /* If BODY is an insn body that uses ASM_OPERANDS,
 return the number of operands (both input and output) in the insn.
 Otherwise return -1.  */
 int
 asm_noperands (const_rtx body)
 {
-switch (GET_CODE (body))
+rtx asm_op = extract_asm_operands (CONST_CAST_RTX (body));
-{
+int n_sets = 0;
-case ASM_OPERANDS:
-/* No output operands: return number of input operands.  */
+if (asm_op == NULL)
-return ASM_OPERANDS_INPUT_LENGTH (body);
+return -1;
-case SET:
-if (GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
+if (GET_CODE (body) == SET)
-	/* Single output operand: BODY is (set OUTPUT (asm_operands ...)).  */
+n_sets = 1;
-	return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (body)) + 1;
+else if (GET_CODE (body) == PARALLEL)
-else
+{
-	return -1;
+int i;
-case PARALLEL:
+if (GET_CODE (XVECEXP (body, 0, 0)) == SET)
-if (GET_CODE (XVECEXP (body, 0, 0)) == SET
-	  && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) == ASM_OPERANDS)
 	{
 	  /* Multiple output operands, or 1 output plus some clobbers:
-	     body is [(set OUTPUT (asm_operands ...))... (clobber (reg ...))...].  */
+	     body is
-	  int i;
+	     [(set OUTPUT (asm_operands ...))... (clobber (reg ...))...].  */
-	  int n_sets;
 	  /* Count backwards through CLOBBERs to determine number of SETs.  */
 	  for (i = XVECLEN (body, 0); i > 0; i--)
 	    {
 	      if (GET_CODE (XVECEXP (body, 0, i - 1)) == SET)
 		break;
 	      if (GET_CODE (SET_SRC (elt)) != ASM_OPERANDS)
 		return -1;
 	      /* If these ASM_OPERANDS rtx's came from different original insns
 	         then they aren't allowed together.  */
 	      if (ASM_OPERANDS_INPUT_VEC (SET_SRC (elt))
-		  != ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (body, 0, 0))))
+		  != ASM_OPERANDS_INPUT_VEC (asm_op))
 		return -1;
 	    }
-	  return (ASM_OPERANDS_INPUT_LENGTH (SET_SRC (XVECEXP (body, 0, 0)))
-		  + n_sets);
 	}
-else if (GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
+else
 	{
 	  /* 0 outputs, but some clobbers:
 	     body is [(asm_operands ...) (clobber (reg ...))...].  */
-	  int i;
 	  /* Make sure all the other parallel things really are clobbers.  */
 	  for (i = XVECLEN (body, 0) - 1; i > 0; i--)
 	    if (GET_CODE (XVECEXP (body, 0, i)) != CLOBBER)
 	      return -1;
-	  return ASM_OPERANDS_INPUT_LENGTH (XVECEXP (body, 0, 0));
 	}
-else
+}
-	return -1;
-default:
+return (ASM_OPERANDS_INPUT_LENGTH (asm_op)
-return -1;
+	  + ASM_OPERANDS_LABEL_LENGTH (asm_op) + n_sets);
-}
 }
 /* Assuming BODY is an insn body that uses ASM_OPERANDS,
 copy its operands (both input and output) into the vector OPERANDS,
 the locations of the operands within the insn into the vector OPERAND_LOCS,
 const char *
 decode_asm_operands (rtx body, rtx *operands, rtx **operand_locs,
 		     const char **constraints, enum machine_mode *modes,
 		     location_t *loc)
 {
-int i;
+int nbase = 0, n, i;
-int noperands;
+rtx asmop;
-rtx asmop = 0;
+switch (GET_CODE (body))
-if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
+{
-{
+case ASM_OPERANDS:
+/* Zero output asm: BODY is (asm_operands ...).  */
+asmop = body;
+break;
+case SET:
+/* Single output asm: BODY is (set OUTPUT (asm_operands ...)).  */
 asmop = SET_SRC (body);
-/* Single output operand: BODY is (set OUTPUT (asm_operands ....)).  */
-noperands = ASM_OPERANDS_INPUT_LENGTH (asmop) + 1;
-for (i = 1; i < noperands; i++)
-	{
-	  if (operand_locs)
-	    operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i - 1);
-	  if (operands)
-	    operands[i] = ASM_OPERANDS_INPUT (asmop, i - 1);
-	  if (constraints)
-	    constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i - 1);
-	  if (modes)
-	    modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i - 1);
-	}
 /* The output is in the SET.
 	 Its constraint is in the ASM_OPERANDS itself.  */
 if (operands)
 	operands[0] = SET_DEST (body);
 	operand_locs[0] = &SET_DEST (body);
 if (constraints)
 	constraints[0] = ASM_OPERANDS_OUTPUT_CONSTRAINT (asmop);
 if (modes)
 	modes[0] = GET_MODE (SET_DEST (body));
-}
+nbase = 1;
-else if (GET_CODE (body) == ASM_OPERANDS)
+break;
-{
-asmop = body;
+case PARALLEL:
-/* No output operands: BODY is (asm_operands ....).  */
+{
+	int nparallel = XVECLEN (body, 0); /* Includes CLOBBERs.  */
-noperands = ASM_OPERANDS_INPUT_LENGTH (asmop);
+	asmop = XVECEXP (body, 0, 0);
-/* The input operands are found in the 1st element vector.  */
+	if (GET_CODE (asmop) == SET)
-/* Constraints for inputs are in the 2nd element vector.  */
+	  {
-for (i = 0; i < noperands; i++)
+	    asmop = SET_SRC (asmop);
-	{
-	  if (operand_locs)
+	    /* At least one output, plus some CLOBBERs.  The outputs are in
-	    operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i);
+	       the SETs.  Their constraints are in the ASM_OPERANDS itself.  */
-	  if (operands)
+	    for (i = 0; i < nparallel; i++)
-	    operands[i] = ASM_OPERANDS_INPUT (asmop, i);
+	      {
-	  if (constraints)
+		if (GET_CODE (XVECEXP (body, 0, i)) == CLOBBER)
-	    constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
+		  break;		/* Past last SET */
-	  if (modes)
+		if (operands)
-	    modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i);
+		  operands[i] = SET_DEST (XVECEXP (body, 0, i));
-	}
+		if (operand_locs)
-}
+		  operand_locs[i] = &SET_DEST (XVECEXP (body, 0, i));
-else if (GET_CODE (body) == PARALLEL
+		if (constraints)
-	   && GET_CODE (XVECEXP (body, 0, 0)) == SET
+		  constraints[i] = XSTR (SET_SRC (XVECEXP (body, 0, i)), 1);
-	   && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) == ASM_OPERANDS)
+		if (modes)
-{
+		  modes[i] = GET_MODE (SET_DEST (XVECEXP (body, 0, i)));
-int nparallel = XVECLEN (body, 0); /* Includes CLOBBERs.  */
+	      }
-int nin;
+	    nbase = i;
-int nout = 0;		/* Does not include CLOBBERs.  */
+	  }
+	break;
-asmop = SET_SRC (XVECEXP (body, 0, 0));
+}
-nin = ASM_OPERANDS_INPUT_LENGTH (asmop);
+default:
-/* At least one output, plus some CLOBBERs.  */
+gcc_unreachable ();
+}
-/* The outputs are in the SETs.
-	 Their constraints are in the ASM_OPERANDS itself.  */
+n = ASM_OPERANDS_INPUT_LENGTH (asmop);
-for (i = 0; i < nparallel; i++)
+for (i = 0; i < n; i++)
-	{
+{
-	  if (GET_CODE (XVECEXP (body, 0, i)) == CLOBBER)
+if (operand_locs)
-	    break;		/* Past last SET */
+	operand_locs[nbase + i] = &ASM_OPERANDS_INPUT (asmop, i);
+if (operands)
-	  if (operands)
+	operands[nbase + i] = ASM_OPERANDS_INPUT (asmop, i);
-	    operands[i] = SET_DEST (XVECEXP (body, 0, i));
+if (constraints)
-	  if (operand_locs)
+	constraints[nbase + i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
-	    operand_locs[i] = &SET_DEST (XVECEXP (body, 0, i));
+if (modes)
-	  if (constraints)
+	modes[nbase + i] = ASM_OPERANDS_INPUT_MODE (asmop, i);
-	    constraints[i] = XSTR (SET_SRC (XVECEXP (body, 0, i)), 1);
+}
-	  if (modes)
+nbase += n;
-	    modes[i] = GET_MODE (SET_DEST (XVECEXP (body, 0, i)));
-	  nout++;
+n = ASM_OPERANDS_LABEL_LENGTH (asmop);
-	}
+for (i = 0; i < n; i++)
+{
-for (i = 0; i < nin; i++)
+if (operand_locs)
-	{
+	operand_locs[nbase + i] = &ASM_OPERANDS_LABEL (asmop, i);
-	  if (operand_locs)
+if (operands)
-	    operand_locs[i + nout] = &ASM_OPERANDS_INPUT (asmop, i);
+	operands[nbase + i] = ASM_OPERANDS_LABEL (asmop, i);
-	  if (operands)
+if (constraints)
-	    operands[i + nout] = ASM_OPERANDS_INPUT (asmop, i);
+	constraints[nbase + i] = "";
-	  if (constraints)
+if (modes)
-	    constraints[i + nout] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
+	modes[nbase + i] = Pmode;
-	  if (modes)
-	    modes[i + nout] = ASM_OPERANDS_INPUT_MODE (asmop, i);
-	}
-}
-else if (GET_CODE (body) == PARALLEL
-	   && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
-{
-/* No outputs, but some CLOBBERs.  */
-int nin;
-asmop = XVECEXP (body, 0, 0);
-nin = ASM_OPERANDS_INPUT_LENGTH (asmop);
-for (i = 0; i < nin; i++)
-	{
-	  if (operand_locs)
-	    operand_locs[i] = &ASM_OPERANDS_INPUT (asmop, i);
-	  if (operands)
-	    operands[i] = ASM_OPERANDS_INPUT (asmop, i);
-	  if (constraints)
-	    constraints[i] = ASM_OPERANDS_INPUT_CONSTRAINT (asmop, i);
-	  if (modes)
-	    modes[i] = ASM_OPERANDS_INPUT_MODE (asmop, i);
-	}
 }
 if (loc)
 *loc = ASM_OPERANDS_SOURCE_LOCATION (asmop);
 {
 int result = 0;
 /* Use constrain_operands after reload.  */
 gcc_assert (!reload_completed);
+/* Empty constraint string is the same as "X,...,X", i.e. X for as
+many alternatives as required to match the other operands.  */
+if (*constraint == '\0')
+return 1;
 while (*constraint)
 {
 char c = *constraint;
 int len;
 	      && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, 'H', constraint))
 	    result = 1;
 	  break;
 	case 's':
-	  if (GET_CODE (op) == CONST_INT
+	  if (CONST_INT_P (op)
 	      || (GET_CODE (op) == CONST_DOUBLE
 		  && GET_MODE (op) == VOIDmode))
 	    break;
 	  /* Fall through.  */
 	  if (CONSTANT_P (op) && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op)))
 	    result = 1;
 	  break;
 	case 'n':
-	  if (GET_CODE (op) == CONST_INT
+	  if (CONST_INT_P (op)
 	      || (GET_CODE (op) == CONST_DOUBLE
 		  && GET_MODE (op) == VOIDmode))
 	    result = 1;
 	  break;
 	case 'I':
-	  if (GET_CODE (op) == CONST_INT
+	  if (CONST_INT_P (op)
 	      && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'I', constraint))
 	    result = 1;
 	  break;
 	case 'J':
-	  if (GET_CODE (op) == CONST_INT
+	  if (CONST_INT_P (op)
 	      && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'J', constraint))
 	    result = 1;
 	  break;
 	case 'K':
-	  if (GET_CODE (op) == CONST_INT
+	  if (CONST_INT_P (op)
 	      && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'K', constraint))
 	    result = 1;
 	  break;
 	case 'L':
-	  if (GET_CODE (op) == CONST_INT
+	  if (CONST_INT_P (op)
 	      && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'L', constraint))
 	    result = 1;
 	  break;
 	case 'M':
-	  if (GET_CODE (op) == CONST_INT
+	  if (CONST_INT_P (op)
 	      && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'M', constraint))
 	    result = 1;
 	  break;
 	case 'N':
-	  if (GET_CODE (op) == CONST_INT
+	  if (CONST_INT_P (op)
 	      && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'N', constraint))
 	    result = 1;
 	  break;
 	case 'O':
-	  if (GET_CODE (op) == CONST_INT
+	  if (CONST_INT_P (op)
 	      && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'O', constraint))
 	    result = 1;
 	  break;
 	case 'P':
-	  if (GET_CODE (op) == CONST_INT
+	  if (CONST_INT_P (op)
 	      && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'P', constraint))
 	    result = 1;
 	  break;
 	case 'X':
 int
 offsettable_memref_p (rtx op)
 {
 return ((MEM_P (op))
-	  && offsettable_address_p (1, GET_MODE (op), XEXP (op, 0)));
+	  && offsettable_address_addr_space_p (1, GET_MODE (op), XEXP (op, 0),
+					       MEM_ADDR_SPACE (op)));
 }
 /* Similar, but don't require a strictly valid mem ref:
 consider pseudo-regs valid as index or base regs.  */
 int
 offsettable_nonstrict_memref_p (rtx op)
 {
 return ((MEM_P (op))
-	  && offsettable_address_p (0, GET_MODE (op), XEXP (op, 0)));
+	  && offsettable_address_addr_space_p (0, GET_MODE (op), XEXP (op, 0),
+					       MEM_ADDR_SPACE (op)));
 }
 /* Return 1 if Y is a memory address which contains no side effects
-and would remain valid after the addition of a positive integer
+and would remain valid for address space AS after the addition of
-less than the size of that mode.
+a positive integer less than the size of that mode.
 We assume that the original address is valid and do not check it.
 We do check that it is valid for narrower modes.
 If STRICTP is nonzero, we require a strictly valid address,
 for the sake of use in reload.c.  */
 int
-offsettable_address_p (int strictp, enum machine_mode mode, rtx y)
+offsettable_address_addr_space_p (int strictp, enum machine_mode mode, rtx y,
+				  addr_space_t as)
 {
 enum rtx_code ycode = GET_CODE (y);
 rtx z;
 rtx y1 = y;
 rtx *y2;
-int (*addressp) (enum machine_mode, rtx) =
+int (*addressp) (enum machine_mode, rtx, addr_space_t) =
-(strictp ? strict_memory_address_p : memory_address_p);
+(strictp ? strict_memory_address_addr_space_p
+	     : memory_address_addr_space_p);
 unsigned int mode_sz = GET_MODE_SIZE (mode);
 if (CONSTANT_ADDRESS_P (y))
 return 1;
 y1 = *y2;
 *y2 = plus_constant (*y2, mode_sz - 1);
 /* Use QImode because an odd displacement may be automatically invalid
 	 for any wider mode.  But it should be valid for a single byte.  */
-good = (*addressp) (QImode, y);
+good = (*addressp) (QImode, y, as);
 /* In any case, restore old contents of memory.  */
 *y2 = y1;
 return good;
 }
 else
 z = plus_constant (y, mode_sz - 1);
 /* Use QImode because an odd displacement may be automatically invalid
 for any wider mode.  But it should be valid for a single byte.  */
-return (*addressp) (QImode, z);
+return (*addressp) (QImode, z, as);
 }
 /* Return 1 if ADDR is an address-expression whose effect depends
 on the mode of the memory reference it is used in.
 case USE:
 case CLOBBER:
 case ASM_INPUT:
 case ADDR_VEC:
 case ADDR_DIFF_VEC:
+case VAR_LOCATION:
 return;
 case SET:
 if (GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
 	goto asm_insn;
 		/* Memory operands must be valid, to the extent
 		   required by STRICT.  */
 		if (MEM_P (op))
 		  {
 		    if (strict > 0
-			&& !strict_memory_address_p (GET_MODE (op),
+			&& !strict_memory_address_addr_space_p
-						     XEXP (op, 0)))
+			     (GET_MODE (op), XEXP (op, 0),
+			      MEM_ADDR_SPACE (op)))
 		      break;
 		    if (strict == 0
-			&& !memory_address_p (GET_MODE (op), XEXP (op, 0)))
+			&& !memory_address_addr_space_p
+			     (GET_MODE (op), XEXP (op, 0),
+			      MEM_ADDR_SPACE (op)))
 		      break;
 		    win = 1;
 		  }
 		/* Before reload, accept what reload can turn into mem.  */
 		else if (strict < 0 && CONSTANT_P (op))
 		    && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, c, p))
 		  win = 1;
 		break;
 	      case 's':
-		if (GET_CODE (op) == CONST_INT
+		if (CONST_INT_P (op)
 		    || (GET_CODE (op) == CONST_DOUBLE
 			&& GET_MODE (op) == VOIDmode))
 		  break;
 	      case 'i':
 		if (CONSTANT_P (op))
 		  win = 1;
 		break;
 	      case 'n':
-		if (GET_CODE (op) == CONST_INT
+		if (CONST_INT_P (op)
 		    || (GET_CODE (op) == CONST_DOUBLE
 			&& GET_MODE (op) == VOIDmode))
 		  win = 1;
 		break;
 	      case 'L':
 	      case 'M':
 	      case 'N':
 	      case 'O':
 	      case 'P':
-		if (GET_CODE (op) == CONST_INT
+		if (CONST_INT_P (op)
 		    && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), c, p))
 		  win = 1;
 		break;
 	      case 'V':
 search_ofs = 0;
 return NULL_RTX;
 }
+/* Forget all currently tracked instructions, only remember current
+LIVE regset.  */
+static void
+peep2_reinit_state (regset live)
+{
+int i;
+/* Indicate that all slots except the last holds invalid data.  */
+for (i = 0; i < MAX_INSNS_PER_PEEP2; ++i)
+peep2_insn_data[i].insn = NULL_RTX;
+peep2_current_count = 0;
+/* Indicate that the last slot contains live_after data.  */
+peep2_insn_data[MAX_INSNS_PER_PEEP2].insn = PEEP2_EOB;
+peep2_current = MAX_INSNS_PER_PEEP2;
+COPY_REG_SET (peep2_insn_data[MAX_INSNS_PER_PEEP2].live_before, live);
+}
 /* Perform the peephole2 optimization pass.  */
 static void
 peephole2_optimize (void)
 {
 live = BITMAP_ALLOC (&reg_obstack);
 FOR_EACH_BB_REVERSE (bb)
 {
 rtl_profile_for_bb (bb);
-/* Indicate that all slots except the last holds invalid data.  */
-for (i = 0; i < MAX_INSNS_PER_PEEP2; ++i)
-	peep2_insn_data[i].insn = NULL_RTX;
-peep2_current_count = 0;
-/* Indicate that the last slot contains live_after data.  */
-peep2_insn_data[MAX_INSNS_PER_PEEP2].insn = PEEP2_EOB;
-peep2_current = MAX_INSNS_PER_PEEP2;
 /* Start up propagation.  */
 bitmap_copy (live, DF_LR_OUT (bb));
 df_simulate_initialize_backwards (bb, live);
-bitmap_copy (peep2_insn_data[MAX_INSNS_PER_PEEP2].live_before, live);
+peep2_reinit_state (live);
 for (insn = BB_END (bb); ; insn = prev)
 	{
 	  prev = PREV_INSN (insn);
-	  if (INSN_P (insn))
+	  if (NONDEBUG_INSN_P (insn))
 	    {
 	      rtx attempt, before_try, x;
 	      int match_len;
 	      rtx note;
 	      bool was_call = false;
 	      if (RTX_FRAME_RELATED_P (insn))
 		{
 		  /* If an insn has RTX_FRAME_RELATED_P set, peephole
 		     substitution would lose the
 		     REG_FRAME_RELATED_EXPR that is attached.  */
-		  peep2_current_count = 0;
+		  peep2_reinit_state (live);
 		  attempt = NULL;
 		}
 	      else
 		/* Match the peephole.  */
 		attempt = peephole2_insns (PATTERN (insn), insn, &match_len);
 		      FOR_EACH_EDGE (eh_edge, ei, bb->succs)
 			if (eh_edge->flags & (EDGE_EH | EDGE_ABNORMAL_CALL))
 			  break;
-		      for (x = attempt ; x != before_try ; x = PREV_INSN (x))
+		      if (note)
-			if (CALL_P (x)
+			copy_reg_eh_region_note_backward (note, attempt,
-			    || (flag_non_call_exceptions
+							  before_try);
-				&& may_trap_p (PATTERN (x))
-				&& !find_reg_note (x, REG_EH_REGION, NULL)))
+		      if (eh_edge)
-			  {
+			for (x = attempt ; x != before_try ; x = PREV_INSN (x))
-			    if (note)
+			  if (x != BB_END (bb)
-			      add_reg_note (x, REG_EH_REGION, XEXP (note, 0));
+			      && (can_throw_internal (x)
+				  || can_nonlocal_goto (x)))
-			    if (x != BB_END (bb) && eh_edge)
+			    {
-			      {
+			      edge nfte, nehe;
-				edge nfte, nehe;
+			      int flags;
-				int flags;
+			      nfte = split_block (bb, x);
-				nfte = split_block (bb, x);
+			      flags = (eh_edge->flags
-				flags = (eh_edge->flags
+				       & (EDGE_EH | EDGE_ABNORMAL));
-					 & (EDGE_EH | EDGE_ABNORMAL));
+			      if (CALL_P (x))
-				if (CALL_P (x))
+				flags |= EDGE_ABNORMAL_CALL;
-				  flags |= EDGE_ABNORMAL_CALL;
+			      nehe = make_edge (nfte->src, eh_edge->dest,
-				nehe = make_edge (nfte->src, eh_edge->dest,
+						flags);
-						  flags);
+			      nehe->probability = eh_edge->probability;
-				nehe->probability = eh_edge->probability;
+			      nfte->probability
-				nfte->probability
+				= REG_BR_PROB_BASE - nehe->probability;
-				  = REG_BR_PROB_BASE - nehe->probability;
+			      do_cleanup_cfg |= purge_dead_edges (nfte->dest);
-			        do_cleanup_cfg |= purge_dead_edges (nfte->dest);
+			      bb = nfte->src;
-				bb = nfte->src;
+			      eh_edge = nehe;
-				eh_edge = nehe;
+			    }
-			      }
-			  }
 		      /* Converting possibly trapping insn to non-trapping is
 			 possible.  Zap dummy outgoing edges.  */
 		      do_cleanup_cfg |= purge_dead_edges (bb);
 		    }
-#ifdef HAVE_conditional_execution
+		  if (targetm.have_conditional_execution ())
-		  for (i = 0; i < MAX_INSNS_PER_PEEP2 + 1; ++i)
-		    peep2_insn_data[i].insn = NULL_RTX;
-		  peep2_insn_data[peep2_current].insn = PEEP2_EOB;
-		  peep2_current_count = 0;
-#else
-		  /* Back up lifetime information past the end of the
-		     newly created sequence.  */
-		  if (++i >= MAX_INSNS_PER_PEEP2 + 1)
-		    i = 0;
-		  bitmap_copy (live, peep2_insn_data[i].live_before);
-		  /* Update life information for the new sequence.  */
-		  x = attempt;
-		  do
 		    {
-		      if (INSN_P (x))
+		      for (i = 0; i < MAX_INSNS_PER_PEEP2 + 1; ++i)
+			peep2_insn_data[i].insn = NULL_RTX;
+		      peep2_insn_data[peep2_current].insn = PEEP2_EOB;
+		      peep2_current_count = 0;
+		    }
+		  else
+		    {
+		      /* Back up lifetime information past the end of the
+			 newly created sequence.  */
+		      if (++i >= MAX_INSNS_PER_PEEP2 + 1)
+			i = 0;
+		      bitmap_copy (live, peep2_insn_data[i].live_before);
+		      /* Update life information for the new sequence.  */
+		      x = attempt;
+		      do
 			{
-			  if (--i < 0)
+			  if (INSN_P (x))
-			    i = MAX_INSNS_PER_PEEP2;
+			    {
-			  if (peep2_current_count < MAX_INSNS_PER_PEEP2
+			      if (--i < 0)
-			      && peep2_insn_data[i].insn == NULL_RTX)
+				i = MAX_INSNS_PER_PEEP2;
-			    peep2_current_count++;
+			      if (peep2_current_count < MAX_INSNS_PER_PEEP2
-			  peep2_insn_data[i].insn = x;
+				  && peep2_insn_data[i].insn == NULL_RTX)
-			  df_insn_rescan (x);
+				peep2_current_count++;
-			  df_simulate_one_insn_backwards (bb, x, live);
+			      peep2_insn_data[i].insn = x;
-			  bitmap_copy (peep2_insn_data[i].live_before, live);
+			      df_insn_rescan (x);
+			      df_simulate_one_insn_backwards (bb, x, live);
+			      bitmap_copy (peep2_insn_data[i].live_before,
+					   live);
+			    }
+			  x = PREV_INSN (x);
 			}
-		      x = PREV_INSN (x);
+		      while (x != prev);
+		      peep2_current = i;
 		    }
-		  while (x != prev);
-		  peep2_current = i;
-#endif
 		  /* If we generated a jump instruction, it won't have
 		     JUMP_LABEL set.  Recompute after we're done.  */
 		  for (x = attempt; x != before_try; x = PREV_INSN (x))
 		    if (JUMP_P (x))
 NULL,                                 /* gate */
 rest_of_handle_split_all_insns,       /* execute */
 NULL,                                 /* sub */
 NULL,                                 /* next */
 0,                                    /* static_pass_number */
-0,                                    /* tv_id */
+TV_NONE,                              /* tv_id */
 0,                                    /* properties_required */
 0,                                    /* properties_provided */
 0,                                    /* properties_destroyed */
 0,                                    /* todo_flags_start */
 TODO_dump_func                        /* todo_flags_finish */
 NULL,                                 /* gate */
 rest_of_handle_split_after_reload,    /* execute */
 NULL,                                 /* sub */
 NULL,                                 /* next */
 0,                                    /* static_pass_number */
-0,                                    /* tv_id */
+TV_NONE,                              /* tv_id */
 0,                                    /* properties_required */
 0,                                    /* properties_provided */
 0,                                    /* properties_destroyed */
 0,                                    /* todo_flags_start */
 TODO_dump_func                        /* todo_flags_finish */
 gate_handle_split_before_regstack,    /* gate */
 rest_of_handle_split_before_regstack, /* execute */
 NULL,                                 /* sub */
 NULL,                                 /* next */
 0,                                    /* static_pass_number */
-0,                                    /* tv_id */
+TV_NONE,                              /* tv_id */
 0,                                    /* properties_required */
 0,                                    /* properties_provided */
 0,                                    /* properties_destroyed */
 0,                                    /* todo_flags_start */
 TODO_dump_func                        /* todo_flags_finish */
 gate_handle_split_before_sched2,      /* gate */
 rest_of_handle_split_before_sched2,   /* execute */
 NULL,                                 /* sub */
 NULL,                                 /* next */
 0,                                    /* static_pass_number */
-0,                                    /* tv_id */
+TV_NONE,                              /* tv_id */
 0,                                    /* properties_required */
 0,                                    /* properties_provided */
 0,                                    /* properties_destroyed */
 0,                                    /* todo_flags_start */
 TODO_verify_flow |
 {
 #if defined (HAVE_ATTR_length) && !defined (STACK_REGS)
 return 1;
 #else
 return 0;
 #endif
 }
 struct rtl_opt_pass pass_split_for_shorten_branches =
 {
 {
 gate_do_final_split,                  /* gate */
 split_all_insns_noflow,               /* execute */
 NULL,                                 /* sub */
 NULL,                                 /* next */
 0,                                    /* static_pass_number */
-0,                                    /* tv_id */
+TV_NONE,                              /* tv_id */
 0,                                    /* properties_required */
 0,                                    /* properties_provided */
 0,                                    /* properties_destroyed */
 0,                                    /* todo_flags_start */
 TODO_dump_func | TODO_verify_rtl_sharing /* todo_flags_finish */
 }
 };

Mercurial > hg > CbC > CbC_gcc

comparison gcc/recog.c @ 55:77e2b8dfacca gcc-4.4.5