自学教程：C++ CHREC_LEFT函数代码示例

boolevolution_function_is_affine_multivariate_p (const_tree chrec, int loopnum){  if (chrec == NULL_TREE)    return false;  switch (TREE_CODE (chrec))    {    case POLYNOMIAL_CHREC:      if (evolution_function_is_invariant_rec_p (CHREC_LEFT (chrec), loopnum))	{	  if (evolution_function_is_invariant_rec_p (CHREC_RIGHT (chrec), loopnum))	    return true;	  else	    {	      if (TREE_CODE (CHREC_RIGHT (chrec)) == POLYNOMIAL_CHREC		  && CHREC_VARIABLE (CHREC_RIGHT (chrec))		     != CHREC_VARIABLE (chrec)		  && evolution_function_is_affine_multivariate_p		  (CHREC_RIGHT (chrec), loopnum))		return true;	      else		return false;	    }	}      else	{	  if (evolution_function_is_invariant_rec_p (CHREC_RIGHT (chrec), loopnum)	      && TREE_CODE (CHREC_LEFT (chrec)) == POLYNOMIAL_CHREC	      && CHREC_VARIABLE (CHREC_LEFT (chrec)) != CHREC_VARIABLE (chrec)	      && evolution_function_is_affine_multivariate_p	      (CHREC_LEFT (chrec), loopnum))	    return true;	  else	    return false;	}    default:      return false;    }}

static inline treechrec_fold_multiply_poly_poly (tree type,			       tree poly0,			       tree poly1){  tree t0, t1, t2;  int var;  struct loop *loop0 = get_chrec_loop (poly0);  struct loop *loop1 = get_chrec_loop (poly1);  gcc_assert (poly0);  gcc_assert (poly1);  gcc_assert (TREE_CODE (poly0) == POLYNOMIAL_CHREC);  gcc_assert (TREE_CODE (poly1) == POLYNOMIAL_CHREC);  gcc_checking_assert (useless_type_conversion_p (type, chrec_type (poly0))		       && useless_type_conversion_p (type, chrec_type (poly1)));  /* {a, +, b}_1 * {c, +, d}_2  ->  {c*{a, +, b}_1, +, d}_2,     {a, +, b}_2 * {c, +, d}_1  ->  {a*{c, +, d}_1, +, b}_2,     {a, +, b}_x * {c, +, d}_x  ->  {a*c, +, a*d + b*c + b*d, +, 2*b*d}_x.  */  if (flow_loop_nested_p (loop0, loop1))    /* poly0 is a constant wrt. poly1.  */    return build_polynomial_chrec      (CHREC_VARIABLE (poly1),       chrec_fold_multiply (type, CHREC_LEFT (poly1), poly0),       CHREC_RIGHT (poly1));  if (flow_loop_nested_p (loop1, loop0))    /* poly1 is a constant wrt. poly0.  */    return build_polynomial_chrec      (CHREC_VARIABLE (poly0),       chrec_fold_multiply (type, CHREC_LEFT (poly0), poly1),       CHREC_RIGHT (poly0));  gcc_assert (loop0 == loop1);  /* poly0 and poly1 are two polynomials in the same variable,     {a, +, b}_x * {c, +, d}_x  ->  {a*c, +, a*d + b*c + b*d, +, 2*b*d}_x.  */  /* "a*c".  */  t0 = chrec_fold_multiply (type, CHREC_LEFT (poly0), CHREC_LEFT (poly1));  /* "a*d + b*c".  */  t1 = chrec_fold_multiply (type, CHREC_LEFT (poly0), CHREC_RIGHT (poly1));  t1 = chrec_fold_plus (type, t1, chrec_fold_multiply (type,						       CHREC_RIGHT (poly0),						       CHREC_LEFT (poly1)));  /* "b*d".  */  t2 = chrec_fold_multiply (type, CHREC_RIGHT (poly0), CHREC_RIGHT (poly1));  /* "a*d + b*c + b*d".  */  t1 = chrec_fold_plus (type, t1, t2);  /* "2*b*d".  */  t2 = chrec_fold_multiply (type, SCALAR_FLOAT_TYPE_P (type)			    ? build_real (type, dconst2)			    : build_int_cst (type, 2), t2);  var = CHREC_VARIABLE (poly0);  return build_polynomial_chrec (var, t0,				 build_polynomial_chrec (var, t1, t2));}

boolevolution_function_is_univariate_p (const_tree chrec){  if (chrec == NULL_TREE)    return true;    switch (TREE_CODE (chrec))    {    case POLYNOMIAL_CHREC:      switch (TREE_CODE (CHREC_LEFT (chrec)))	{	case POLYNOMIAL_CHREC:	  if (CHREC_VARIABLE (chrec) != CHREC_VARIABLE (CHREC_LEFT (chrec)))	    return false;	  if (!evolution_function_is_univariate_p (CHREC_LEFT (chrec)))	    return false;	  break;	  	default:	  break;	}            switch (TREE_CODE (CHREC_RIGHT (chrec)))	{	case POLYNOMIAL_CHREC:	  if (CHREC_VARIABLE (chrec) != CHREC_VARIABLE (CHREC_RIGHT (chrec)))	    return false;	  if (!evolution_function_is_univariate_p (CHREC_RIGHT (chrec)))	    return false;	  break;	  	default:	  break;	  	}          default:      return true;    }}

booleq_evolutions_p (const_tree chrec0, const_tree chrec1){  if (chrec0 == NULL_TREE      || chrec1 == NULL_TREE      || TREE_CODE (chrec0) != TREE_CODE (chrec1))    return false;  if (chrec0 == chrec1)    return true;  if (! types_compatible_p (TREE_TYPE (chrec0), TREE_TYPE (chrec1)))    return false;  switch (TREE_CODE (chrec0))    {    case POLYNOMIAL_CHREC:      return (CHREC_VARIABLE (chrec0) == CHREC_VARIABLE (chrec1)	      && eq_evolutions_p (CHREC_LEFT (chrec0), CHREC_LEFT (chrec1))	      && eq_evolutions_p (CHREC_RIGHT (chrec0), CHREC_RIGHT (chrec1)));    case PLUS_EXPR:    case MULT_EXPR:    case MINUS_EXPR:    case POINTER_PLUS_EXPR:      return eq_evolutions_p (TREE_OPERAND (chrec0, 0),			      TREE_OPERAND (chrec1, 0))	  && eq_evolutions_p (TREE_OPERAND (chrec0, 1),			      TREE_OPERAND (chrec1, 1));    CASE_CONVERT:      return eq_evolutions_p (TREE_OPERAND (chrec0, 0),			      TREE_OPERAND (chrec1, 0));    default:      return operand_equal_p (chrec0, chrec1, 0);    }}

tree reset_evolution_in_loop (unsigned loop_num,			 tree chrec, 			 tree new_evol){  if (TREE_CODE (chrec) == POLYNOMIAL_CHREC      && CHREC_VARIABLE (chrec) > loop_num)    {      tree left = reset_evolution_in_loop (loop_num, CHREC_LEFT (chrec),					   new_evol);      tree right = reset_evolution_in_loop (loop_num, CHREC_RIGHT (chrec),					    new_evol);      return build3 (POLYNOMIAL_CHREC, TREE_TYPE (left),		     build_int_cst (NULL_TREE, CHREC_VARIABLE (chrec)),		     left, right);    }  while (TREE_CODE (chrec) == POLYNOMIAL_CHREC	 && CHREC_VARIABLE (chrec) == loop_num)    chrec = CHREC_LEFT (chrec);    return build_polynomial_chrec (loop_num, chrec, new_evol);}

static boolgraphite_can_represent_scev (tree scev){  if (chrec_contains_undetermined (scev))    return false;  switch (TREE_CODE (scev))    {    case NEGATE_EXPR:    case BIT_NOT_EXPR:    CASE_CONVERT:    case NON_LVALUE_EXPR:      return graphite_can_represent_scev (TREE_OPERAND (scev, 0));    case PLUS_EXPR:    case POINTER_PLUS_EXPR:    case MINUS_EXPR:      return graphite_can_represent_scev (TREE_OPERAND (scev, 0))	&& graphite_can_represent_scev (TREE_OPERAND (scev, 1));    case MULT_EXPR:      return !CONVERT_EXPR_CODE_P (TREE_CODE (TREE_OPERAND (scev, 0)))	&& !CONVERT_EXPR_CODE_P (TREE_CODE (TREE_OPERAND (scev, 1)))	&& !(chrec_contains_symbols (TREE_OPERAND (scev, 0))	     && chrec_contains_symbols (TREE_OPERAND (scev, 1)))	&& graphite_can_represent_init (scev)	&& graphite_can_represent_scev (TREE_OPERAND (scev, 0))	&& graphite_can_represent_scev (TREE_OPERAND (scev, 1));    case POLYNOMIAL_CHREC:      /* Check for constant strides.  With a non constant stride of	 'n' we would have a value of 'iv * n'.  Also check that the	 initial value can represented: for example 'n * m' cannot be	 represented.  */      if (!evolution_function_right_is_integer_cst (scev)	  || !graphite_can_represent_init (scev))	return false;      return graphite_can_represent_scev (CHREC_LEFT (scev));    default:      break;    }  /* Only affine functions can be represented.  */  if (tree_contains_chrecs (scev, NULL)      || !scev_is_linear_expression (scev))    return false;  return true;}

boolis_multivariate_chrec (const_tree chrec){  if (chrec == NULL_TREE)    return false;  if (TREE_CODE (chrec) == POLYNOMIAL_CHREC)    return (is_multivariate_chrec_rec (CHREC_LEFT (chrec),				       CHREC_VARIABLE (chrec))	    || is_multivariate_chrec_rec (CHREC_RIGHT (chrec),					  CHREC_VARIABLE (chrec)));  else    return false;}

boolevolution_function_right_is_integer_cst (const_tree chrec){  if (chrec == NULL_TREE)    return false;  switch (TREE_CODE (chrec))    {    case INTEGER_CST:      return true;    case POLYNOMIAL_CHREC:      return TREE_CODE (CHREC_RIGHT (chrec)) == INTEGER_CST	&& (TREE_CODE (CHREC_LEFT (chrec)) != POLYNOMIAL_CHREC	    || evolution_function_right_is_integer_cst (CHREC_LEFT (chrec)));    CASE_CONVERT:      return evolution_function_right_is_integer_cst (TREE_OPERAND (chrec, 0));    default:      return false;    }}

tree chrec_convert (tree type, 	       tree chrec){  tree ct;    if (automatically_generated_chrec_p (chrec))    return chrec;    ct = chrec_type (chrec);  if (ct == type)    return chrec;  if (TYPE_PRECISION (ct) < TYPE_PRECISION (type))    return count_ev_in_wider_type (type, chrec);  switch (TREE_CODE (chrec))    {    case POLYNOMIAL_CHREC:      return build_polynomial_chrec (CHREC_VARIABLE (chrec),				     chrec_convert (type,						    CHREC_LEFT (chrec)),				     chrec_convert (type,						    CHREC_RIGHT (chrec)));    default:      {	tree res = fold_convert (type, chrec);	/* Don't propagate overflows.  */	TREE_OVERFLOW (res) = 0;	if (CONSTANT_CLASS_P (res))	  TREE_CONSTANT_OVERFLOW (res) = 0;	/* But reject constants that don't fit in their type after conversion.	   This can happen if TYPE_MIN_VALUE or TYPE_MAX_VALUE are not the	   natural values associated with TYPE_PRECISION and TYPE_UNSIGNED,	   and can cause problems later when computing niters of loops.  Note	   that we don't do the check before converting because we don't want	   to reject conversions of negative chrecs to unsigned types.  */	if (TREE_CODE (res) == INTEGER_CST	    && TREE_CODE (type) == INTEGER_TYPE	    && !int_fits_type_p (res, type))	  res = chrec_dont_know;	return res;      }    }}

bool eq_evolutions_p (const_tree chrec0, const_tree chrec1){  if (chrec0 == NULL_TREE      || chrec1 == NULL_TREE      || TREE_CODE (chrec0) != TREE_CODE (chrec1))    return false;  if (chrec0 == chrec1)    return true;  switch (TREE_CODE (chrec0))    {    case INTEGER_CST:      return operand_equal_p (chrec0, chrec1, 0);    case POLYNOMIAL_CHREC:      return (CHREC_VARIABLE (chrec0) == CHREC_VARIABLE (chrec1)	      && eq_evolutions_p (CHREC_LEFT (chrec0), CHREC_LEFT (chrec1))	      && eq_evolutions_p (CHREC_RIGHT (chrec0), CHREC_RIGHT (chrec1)));    default:      return false;    }  }

static inline treechrec_fold_poly_cst (enum tree_code code,		     tree type,		     tree poly,		     tree cst){  gcc_assert (poly);  gcc_assert (cst);  gcc_assert (TREE_CODE (poly) == POLYNOMIAL_CHREC);  gcc_checking_assert (!is_not_constant_evolution (cst));  gcc_checking_assert (useless_type_conversion_p (type, chrec_type (poly)));  switch (code)    {    case PLUS_EXPR:      return build_polynomial_chrec	(CHREC_VARIABLE (poly),	 chrec_fold_plus (type, CHREC_LEFT (poly), cst),	 CHREC_RIGHT (poly));    case MINUS_EXPR:      return build_polynomial_chrec	(CHREC_VARIABLE (poly),	 chrec_fold_minus (type, CHREC_LEFT (poly), cst),	 CHREC_RIGHT (poly));    case MULT_EXPR:      return build_polynomial_chrec	(CHREC_VARIABLE (poly),	 chrec_fold_multiply (type, CHREC_LEFT (poly), cst),	 chrec_fold_multiply (type, CHREC_RIGHT (poly), cst));    default:      return chrec_dont_know;    }}

static boolis_multivariate_chrec_rec (const_tree chrec, unsigned int rec_var){  if (chrec == NULL_TREE)    return false;  if (TREE_CODE (chrec) == POLYNOMIAL_CHREC)    {      if (CHREC_VARIABLE (chrec) != rec_var)	return true;      else	return (is_multivariate_chrec_rec (CHREC_LEFT (chrec), rec_var)		|| is_multivariate_chrec_rec (CHREC_RIGHT (chrec), rec_var));    }  else    return false;}

tree chrec_replace_initial_condition (tree chrec, 				 tree init_cond){  if (automatically_generated_chrec_p (chrec))    return chrec;    switch (TREE_CODE (chrec))    {    case POLYNOMIAL_CHREC:      return build_polynomial_chrec 	(CHREC_VARIABLE (chrec),	 chrec_replace_initial_condition (CHREC_LEFT (chrec), init_cond),	 CHREC_RIGHT (chrec));          default:      return init_cond;    }}

static boolevolution_function_is_invariant_rec_p (tree chrec, int loopnum){  if (evolution_function_is_constant_p (chrec))    return true;  if (TREE_CODE (chrec) == SSA_NAME      && (loopnum == 0	  || expr_invariant_in_loop_p (get_loop (cfun, loopnum), chrec)))    return true;  if (TREE_CODE (chrec) == POLYNOMIAL_CHREC)    {      if (CHREC_VARIABLE (chrec) == (unsigned) loopnum	  || flow_loop_nested_p (get_loop (cfun, loopnum),				 get_chrec_loop (chrec))	  || !evolution_function_is_invariant_rec_p (CHREC_RIGHT (chrec),						     loopnum)	  || !evolution_function_is_invariant_rec_p (CHREC_LEFT (chrec),						     loopnum))	return false;      return true;    }  switch (TREE_OPERAND_LENGTH (chrec))    {    case 2:      if (!evolution_function_is_invariant_rec_p (TREE_OPERAND (chrec, 1),						  loopnum))	return false;    case 1:      if (!evolution_function_is_invariant_rec_p (TREE_OPERAND (chrec, 0),						  loopnum))	return false;      return true;    default:      return false;    }  return false;}

static treechrec_convert_1 (tree type, tree chrec, gimple *at_stmt,		 bool use_overflow_semantics){  tree ct, res;  tree base, step;  struct loop *loop;  if (automatically_generated_chrec_p (chrec))    return chrec;  ct = chrec_type (chrec);  if (useless_type_conversion_p (type, ct))    return chrec;  if (!evolution_function_is_affine_p (chrec))    goto keep_cast;  loop = get_chrec_loop (chrec);  base = CHREC_LEFT (chrec);  step = CHREC_RIGHT (chrec);  if (convert_affine_scev (loop, type, &base, &step, at_stmt,			   use_overflow_semantics))    return build_polynomial_chrec (loop->num, base, step);  /* If we cannot propagate the cast inside the chrec, just keep the cast.  */keep_cast:  /* Fold will not canonicalize (long)(i - 1) to (long)i - 1 because that     may be more expensive.  We do want to perform this optimization here     though for canonicalization reasons.  */  if (use_overflow_semantics      && (TREE_CODE (chrec) == PLUS_EXPR	  || TREE_CODE (chrec) == MINUS_EXPR)      && TREE_CODE (type) == INTEGER_TYPE      && TREE_CODE (ct) == INTEGER_TYPE      && TYPE_PRECISION (type) > TYPE_PRECISION (ct)      && TYPE_OVERFLOW_UNDEFINED (ct))    res = fold_build2 (TREE_CODE (chrec), type,		       fold_convert (type, TREE_OPERAND (chrec, 0)),		       fold_convert (type, TREE_OPERAND (chrec, 1)));  /* Similar perform the trick that (signed char)((int)x + 2) can be     narrowed to (signed char)((unsigned char)x + 2).  */  else if (use_overflow_semantics	   && TREE_CODE (chrec) == POLYNOMIAL_CHREC	   && TREE_CODE (ct) == INTEGER_TYPE	   && TREE_CODE (type) == INTEGER_TYPE	   && TYPE_OVERFLOW_UNDEFINED (type)	   && TYPE_PRECISION (type) < TYPE_PRECISION (ct))    {      tree utype = unsigned_type_for (type);      res = build_polynomial_chrec (CHREC_VARIABLE (chrec),				    fold_convert (utype,						  CHREC_LEFT (chrec)),				    fold_convert (utype,						  CHREC_RIGHT (chrec)));      res = chrec_convert_1 (type, res, at_stmt, use_overflow_semantics);    }  else    res = fold_convert (type, chrec);  /* Don't propagate overflows.  */  if (CONSTANT_CLASS_P (res))    TREE_OVERFLOW (res) = 0;  /* But reject constants that don't fit in their type after conversion.     This can happen if TYPE_MIN_VALUE or TYPE_MAX_VALUE are not the     natural values associated with TYPE_PRECISION and TYPE_UNSIGNED,     and can cause problems later when computing niters of loops.  Note     that we don't do the check before converting because we don't want     to reject conversions of negative chrecs to unsigned types.  */  if (TREE_CODE (res) == INTEGER_CST      && TREE_CODE (type) == INTEGER_TYPE      && !int_fits_type_p (res, type))    res = chrec_dont_know;  return res;}

treechrec_apply (unsigned var,	     tree chrec,	     tree x){  tree type = chrec_type (chrec);  tree res = chrec_dont_know;  if (automatically_generated_chrec_p (chrec)      || automatically_generated_chrec_p (x)      /* When the symbols are defined in an outer loop, it is possible	 to symbolically compute the apply, since the symbols are	 constants with respect to the varying loop.  */      || chrec_contains_symbols_defined_in_loop (chrec, var))    return chrec_dont_know;  if (dump_file && (dump_flags & TDF_SCEV))    fprintf (dump_file, "(chrec_apply /n");  if (TREE_CODE (x) == INTEGER_CST && SCALAR_FLOAT_TYPE_P (type))    x = build_real_from_int_cst (type, x);  switch (TREE_CODE (chrec))    {    case POLYNOMIAL_CHREC:      if (evolution_function_is_affine_p (chrec))	{	  if (CHREC_VARIABLE (chrec) != var)	    return build_polynomial_chrec	      (CHREC_VARIABLE (chrec),	       chrec_apply (var, CHREC_LEFT (chrec), x),	       chrec_apply (var, CHREC_RIGHT (chrec), x));	  /* "{a, +, b} (x)"  ->  "a + b*x".  */	  x = chrec_convert_rhs (type, x, NULL);	  res = chrec_fold_multiply (TREE_TYPE (x), CHREC_RIGHT (chrec), x);	  res = chrec_fold_plus (type, CHREC_LEFT (chrec), res);	}      else if (TREE_CODE (x) == INTEGER_CST	       && tree_int_cst_sgn (x) == 1)	/* testsuite/.../ssa-chrec-38.c.  */	res = chrec_evaluate (var, chrec, x, 0);      else	res = chrec_dont_know;      break;    CASE_CONVERT:      res = chrec_convert (TREE_TYPE (chrec),			   chrec_apply (var, TREE_OPERAND (chrec, 0), x),			   NULL);      break;    default:      res = chrec;      break;    }  if (dump_file && (dump_flags & TDF_SCEV))    {      fprintf (dump_file, "  (varying_loop = %d/n", var);      fprintf (dump_file, ")/n  (chrec = ");      print_generic_expr (dump_file, chrec, 0);      fprintf (dump_file, ")/n  (x = ");      print_generic_expr (dump_file, x, 0);      fprintf (dump_file, ")/n  (res = ");      print_generic_expr (dump_file, res, 0);      fprintf (dump_file, "))/n");    }  return res;}

treechrec_fold_multiply (tree type,		     tree op0,		     tree op1){  if (automatically_generated_chrec_p (op0)      || automatically_generated_chrec_p (op1))    return chrec_fold_automatically_generated_operands (op0, op1);  switch (TREE_CODE (op0))    {    case POLYNOMIAL_CHREC:      gcc_checking_assert	(!chrec_contains_symbols_defined_in_loop (op0, CHREC_VARIABLE (op0)));      switch (TREE_CODE (op1))	{	case POLYNOMIAL_CHREC:	  gcc_checking_assert	    (!chrec_contains_symbols_defined_in_loop (op1,						      CHREC_VARIABLE (op1)));	  return chrec_fold_multiply_poly_poly (type, op0, op1);	CASE_CONVERT:	  if (tree_contains_chrecs (op1, NULL))	    return chrec_dont_know;	default:	  if (integer_onep (op1))	    return op0;	  if (integer_zerop (op1))	    return build_int_cst (type, 0);	  return build_polynomial_chrec	    (CHREC_VARIABLE (op0),	     chrec_fold_multiply (type, CHREC_LEFT (op0), op1),	     chrec_fold_multiply (type, CHREC_RIGHT (op0), op1));	}    CASE_CONVERT:      if (tree_contains_chrecs (op0, NULL))	return chrec_dont_know;    default:      if (integer_onep (op0))	return op1;      if (integer_zerop (op0))    	return build_int_cst (type, 0);      switch (TREE_CODE (op1))	{	case POLYNOMIAL_CHREC:	  gcc_checking_assert	    (!chrec_contains_symbols_defined_in_loop (op1,						      CHREC_VARIABLE (op1)));	  return build_polynomial_chrec	    (CHREC_VARIABLE (op1),	     chrec_fold_multiply (type, CHREC_LEFT (op1), op0),	     chrec_fold_multiply (type, CHREC_RIGHT (op1), op0));	CASE_CONVERT:	  if (tree_contains_chrecs (op1, NULL))	    return chrec_dont_know;	default:	  if (integer_onep (op1))	    return op0;	  if (integer_zerop (op1))	    return build_int_cst (type, 0);	  return fold_build2 (MULT_EXPR, type, op0, op1);	}    }}

static treechrec_fold_plus_1 (enum tree_code code, tree type,		   tree op0, tree op1){  if (automatically_generated_chrec_p (op0)      || automatically_generated_chrec_p (op1))    return chrec_fold_automatically_generated_operands (op0, op1);  switch (TREE_CODE (op0))    {    case POLYNOMIAL_CHREC:      gcc_checking_assert	(!chrec_contains_symbols_defined_in_loop (op0, CHREC_VARIABLE (op0)));      switch (TREE_CODE (op1))	{	case POLYNOMIAL_CHREC:	  gcc_checking_assert	    (!chrec_contains_symbols_defined_in_loop (op1,						      CHREC_VARIABLE (op1)));	  return chrec_fold_plus_poly_poly (code, type, op0, op1);	CASE_CONVERT:	  if (tree_contains_chrecs (op1, NULL))	    return chrec_dont_know;	default:	  if (code == PLUS_EXPR || code == POINTER_PLUS_EXPR)	    return build_polynomial_chrec	      (CHREC_VARIABLE (op0),	       chrec_fold_plus (type, CHREC_LEFT (op0), op1),	       CHREC_RIGHT (op0));	  else	    return build_polynomial_chrec	      (CHREC_VARIABLE (op0),	       chrec_fold_minus (type, CHREC_LEFT (op0), op1),	       CHREC_RIGHT (op0));	}    CASE_CONVERT:      if (tree_contains_chrecs (op0, NULL))	return chrec_dont_know;    default:      switch (TREE_CODE (op1))	{	case POLYNOMIAL_CHREC:	  gcc_checking_assert	    (!chrec_contains_symbols_defined_in_loop (op1,						      CHREC_VARIABLE (op1)));	  if (code == PLUS_EXPR || code == POINTER_PLUS_EXPR)	    return build_polynomial_chrec	      (CHREC_VARIABLE (op1),	       chrec_fold_plus (type, op0, CHREC_LEFT (op1)),	       CHREC_RIGHT (op1));	  else	    return build_polynomial_chrec	      (CHREC_VARIABLE (op1),	       chrec_fold_minus (type, op0, CHREC_LEFT (op1)),	       chrec_fold_multiply (type, CHREC_RIGHT (op1),				    SCALAR_FLOAT_TYPE_P (type)				    ? build_real (type, dconstm1)				    : build_int_cst_type (type, -1)));	CASE_CONVERT:	  if (tree_contains_chrecs (op1, NULL))	    return chrec_dont_know;	default:	  {	    int size = 0;	    if ((tree_contains_chrecs (op0, &size)		 || tree_contains_chrecs (op1, &size))		&& size < PARAM_VALUE (PARAM_SCEV_MAX_EXPR_SIZE))	      return build2 (code, type, op0, op1);	    else if (size < PARAM_VALUE (PARAM_SCEV_MAX_EXPR_SIZE))	      {		if (code == POINTER_PLUS_EXPR)		  return fold_build_pointer_plus (fold_convert (type, op0),						  op1);		else		  return fold_build2 (code, type,				      fold_convert (type, op0),				      fold_convert (type, op1));	      }	    else	      return chrec_dont_know;	  }	}    }}

static treechrec_fold_plus_1 (enum tree_code code, 		   tree type, 		   tree op0,		   tree op1){  if (automatically_generated_chrec_p (op0)      || automatically_generated_chrec_p (op1))    return chrec_fold_automatically_generated_operands (op0, op1);    switch (TREE_CODE (op0))    {    case POLYNOMIAL_CHREC:      switch (TREE_CODE (op1))	{	case POLYNOMIAL_CHREC:	  return chrec_fold_plus_poly_poly (code, type, op0, op1);	default:	  if (code == PLUS_EXPR)	    return build_polynomial_chrec 	      (CHREC_VARIABLE (op0), 	       chrec_fold_plus (type, CHREC_LEFT (op0), op1),	       CHREC_RIGHT (op0));	  else	    return build_polynomial_chrec 	      (CHREC_VARIABLE (op0), 	       chrec_fold_minus (type, CHREC_LEFT (op0), op1),	       CHREC_RIGHT (op0));	}    default:      switch (TREE_CODE (op1))	{	case POLYNOMIAL_CHREC:	  if (code == PLUS_EXPR)	    return build_polynomial_chrec 	      (CHREC_VARIABLE (op1), 	       chrec_fold_plus (type, op0, CHREC_LEFT (op1)),	       CHREC_RIGHT (op1));	  else	    return build_polynomial_chrec 	      (CHREC_VARIABLE (op1), 	       chrec_fold_minus (type, op0, CHREC_LEFT (op1)),	       chrec_fold_multiply (type, CHREC_RIGHT (op1),				    build_int_cst_type (type, -1)));	default:	  {	    int size = 0;	    if ((tree_contains_chrecs (op0, &size)		 || tree_contains_chrecs (op1, &size))		&& size < PARAM_VALUE (PARAM_SCEV_MAX_EXPR_SIZE))	      return build2 (code, type, op0, op1);	    else if (size < PARAM_VALUE (PARAM_SCEV_MAX_EXPR_SIZE))	      return fold (build2 (code, type, op0, op1));	    else	      return chrec_dont_know;	  }	}    }}

static inline treechrec_fold_plus_poly_poly (enum tree_code code,			   tree type,			   tree poly0,			   tree poly1){  tree left, right;  struct loop *loop0 = get_chrec_loop (poly0);  struct loop *loop1 = get_chrec_loop (poly1);  tree rtype = code == POINTER_PLUS_EXPR ? chrec_type (poly1) : type;  gcc_assert (poly0);  gcc_assert (poly1);  gcc_assert (TREE_CODE (poly0) == POLYNOMIAL_CHREC);  gcc_assert (TREE_CODE (poly1) == POLYNOMIAL_CHREC);  if (POINTER_TYPE_P (chrec_type (poly0)))    gcc_checking_assert (ptrofftype_p (chrec_type (poly1))			 && useless_type_conversion_p (type, chrec_type (poly0)));  else    gcc_checking_assert (useless_type_conversion_p (type, chrec_type (poly0))			 && useless_type_conversion_p (type, chrec_type (poly1)));  /*    {a, +, b}_1 + {c, +, d}_2  ->  {{a, +, b}_1 + c, +, d}_2,    {a, +, b}_2 + {c, +, d}_1  ->  {{c, +, d}_1 + a, +, b}_2,    {a, +, b}_x + {c, +, d}_x  ->  {a+c, +, b+d}_x.  */  if (flow_loop_nested_p (loop0, loop1))    {      if (code == PLUS_EXPR || code == POINTER_PLUS_EXPR)	return build_polynomial_chrec	  (CHREC_VARIABLE (poly1),	   chrec_fold_plus (type, poly0, CHREC_LEFT (poly1)),	   CHREC_RIGHT (poly1));      else	return build_polynomial_chrec	  (CHREC_VARIABLE (poly1),	   chrec_fold_minus (type, poly0, CHREC_LEFT (poly1)),	   chrec_fold_multiply (type, CHREC_RIGHT (poly1),				SCALAR_FLOAT_TYPE_P (type)				? build_real (type, dconstm1)				: build_int_cst_type (type, -1)));    }  if (flow_loop_nested_p (loop1, loop0))    {      if (code == PLUS_EXPR || code == POINTER_PLUS_EXPR)	return build_polynomial_chrec	  (CHREC_VARIABLE (poly0),	   chrec_fold_plus (type, CHREC_LEFT (poly0), poly1),	   CHREC_RIGHT (poly0));      else	return build_polynomial_chrec	  (CHREC_VARIABLE (poly0),	   chrec_fold_minus (type, CHREC_LEFT (poly0), poly1),	   CHREC_RIGHT (poly0));    }  /* This function should never be called for chrecs of loops that     do not belong to the same loop nest.  */  gcc_assert (loop0 == loop1);  if (code == PLUS_EXPR || code == POINTER_PLUS_EXPR)    {      left = chrec_fold_plus	(type, CHREC_LEFT (poly0), CHREC_LEFT (poly1));      right = chrec_fold_plus	(rtype, CHREC_RIGHT (poly0), CHREC_RIGHT (poly1));    }  else    {      left = chrec_fold_minus	(type, CHREC_LEFT (poly0), CHREC_LEFT (poly1));      right = chrec_fold_minus	(type, CHREC_RIGHT (poly0), CHREC_RIGHT (poly1));    }  if (chrec_zerop (right))    return left;  else    return build_polynomial_chrec      (CHREC_VARIABLE (poly0), left, right);}