CbC/CbC_gcc: gcc/tree-affine.c comparison

comparison gcc/tree-affine.c @ 132:d34655255c78

update gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 10:21:07 +0900
parents	84e7813d76e9
children	1830386684a0

comparison

equal deleted inserted replaced

-:e108057fa461
+:d34655255c78
 /* Operations with affine combinations of trees.
-Copyright (C) 2005-2017 Free Software Foundation, Inc.
+Copyright (C) 2005-2018 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 #include "dumpfile.h"
 #include "cfgexpand.h"
 /* Extends CST as appropriate for the affine combinations COMB.  */
-widest_int
+static widest_int
 wide_int_ext_for_comb (const widest_int &cst, tree type)
+{
+return wi::sext (cst, TYPE_PRECISION (type));
+}
+/* Likewise for polynomial offsets.  */
+static poly_widest_int
+wide_int_ext_for_comb (const poly_widest_int &cst, tree type)
 {
 return wi::sext (cst, TYPE_PRECISION (type));
 }
 /* Initializes affine combination COMB so that its value is zero in TYPE.  */
 }
 /* Sets COMB to CST.  */
 void
-aff_combination_const (aff_tree *comb, tree type, const widest_int &cst)
+aff_combination_const (aff_tree *comb, tree type, const poly_widest_int &cst)
 {
 aff_combination_zero (comb, type);
 comb->offset = wide_int_ext_for_comb (cst, comb->type);;
 }
 }
 /* Adds CST to C.  */
 static void
-aff_combination_add_cst (aff_tree *c, const widest_int &cst)
+aff_combination_add_cst (aff_tree *c, const poly_widest_int &cst)
 {
 c->offset = wide_int_ext_for_comb (c->offset + cst, c->type);
 }
 /* Adds COMB2 to COMB1.  */
 tree_to_aff_combination (tree expr, tree type, aff_tree *comb)
 {
 aff_tree tmp;
 enum tree_code code;
 tree cst, core, toffset;
-HOST_WIDE_INT bitpos, bitsize;
+poly_int64 bitpos, bitsize, bytepos;
 machine_mode mode;
 int unsignedp, reversep, volatilep;
 STRIP_NOPS (expr);
 code = TREE_CODE (expr);
 switch (code)
 {
-case INTEGER_CST:
-aff_combination_const (comb, type, wi::to_widest (expr));
-return;
 case POINTER_PLUS_EXPR:
 tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb);
 tree_to_aff_combination (TREE_OPERAND (expr, 1), sizetype, &tmp);
 aff_combination_add (comb, &tmp);
 return;
 	  return;
 	}
 core = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize, &bitpos,
 				  &toffset, &mode, &unsignedp, &reversep,
 				  &volatilep);
-if (bitpos % BITS_PER_UNIT != 0)
+if (!multiple_p (bitpos, BITS_PER_UNIT, &bytepos))
 	break;
-aff_combination_const (comb, type, bitpos / BITS_PER_UNIT);
+aff_combination_const (comb, type, bytepos);
 if (TREE_CODE (core) == MEM_REF)
 	{
-	  aff_combination_add_cst (comb, wi::to_widest (TREE_OPERAND (core, 1)));
+	  tree mem_offset = TREE_OPERAND (core, 1);
+	  aff_combination_add_cst (comb, wi::to_poly_widest (mem_offset));
 	  core = TREE_OPERAND (core, 0);
 	}
 else
 	core = build_fold_addr_expr (core);
 	  }
 }
 break;
 default:
-break;
+{
+	if (poly_int_tree_p (expr))
+	  {
+	    aff_combination_const (comb, type, wi::to_poly_widest (expr));
+	    return;
+	  }
+	break;
+}
 }
 aff_combination_elt (comb, type, expr);
 }
 tree
 aff_combination_to_tree (aff_tree *comb)
 {
 tree type = comb->type, base = NULL_TREE, expr = NULL_TREE;
 unsigned i;
-widest_int off, sgn;
+poly_widest_int off;
+int sgn;
 gcc_assert (comb->n == MAX_AFF_ELTS || comb->rest == NULL_TREE);
 i = 0;
 if (POINTER_TYPE_P (type))
 if (comb->rest)
 expr = add_elt_to_tree (expr, type, comb->rest, 1);
 /* Ensure that we get x - 1, not x + (-1) or x + 0xff..f if x is
 unsigned.  */
-if (wi::neg_p (comb->offset))
+if (known_lt (comb->offset, 0))
 {
 off = -comb->offset;
 sgn = -1;
 }
 else
 aff_combination_add_elt (r, aval, coef);
 }
 if (val)
-aff_combination_add_elt (r, val, coef * c->offset);
+{
+if (c->offset.is_constant ())
+	/* Access coeffs[0] directly, for efficiency.  */
+	aff_combination_add_elt (r, val, coef * c->offset.coeffs[0]);
+else
+	{
+	  /* c->offset is polynomial, so multiply VAL rather than COEF
+	     by it.  */
+	  tree offset = wide_int_to_tree (TREE_TYPE (val), c->offset);
+	  val = fold_build2 (MULT_EXPR, TREE_TYPE (val), val, offset);
+	  aff_combination_add_elt (r, val, coef);
+	}
+}
 else
 aff_combination_add_cst (r, coef * c->offset);
 }
 /* Multiplies C1 by C2, storing the result to R  */
 for (i = 0; i < c2->n; i++)
 aff_combination_add_product (c1, c2->elts[i].coef, c2->elts[i].val, r);
 if (c2->rest)
 aff_combination_add_product (c1, 1, c2->rest, r);
-aff_combination_add_product (c1, c2->offset, NULL, r);
+if (c2->offset.is_constant ())
+/* Access coeffs[0] directly, for efficiency.  */
+aff_combination_add_product (c1, c2->offset.coeffs[0], NULL, r);
+else
+{
+/* c2->offset is polynomial, so do the multiplication in tree form.  */
+tree offset = wide_int_to_tree (c2->type, c2->offset);
+aff_combination_add_product (c1, 1, offset, r);
+}
 }
 /* Returns the element of COMB whose value is VAL, or NULL if no such
 element exists.  If IDX is not NULL, it is set to the index of VAL in
 COMB.  */
 and if they are different, returns false.  Finally, if neither of these
 two cases occur, true is returned, and CST is stored to MULT and MULT_SET
 is set to true.  */
 static bool
-wide_int_constant_multiple_p (const widest_int &val, const widest_int &div,
+wide_int_constant_multiple_p (const poly_widest_int &val,
-			      bool *mult_set, widest_int *mult)
+			      const poly_widest_int &div,
-{
+			      bool *mult_set, poly_widest_int *mult)
-widest_int rem, cst;
+{
+poly_widest_int rem, cst;
-if (val == 0)
-{
+if (known_eq (val, 0))
-if (*mult_set && *mult != 0)
+{
+if (*mult_set && maybe_ne (*mult, 0))
 	return false;
 *mult_set = true;
 *mult = 0;
 return true;
 }
-if (div == 0)
+if (maybe_eq (div, 0))
 return false;
-if (!wi::multiple_of_p (val, div, SIGNED, &cst))
+if (!multiple_p (val, div, &cst))
 return false;
-if (*mult_set && *mult != cst)
+if (*mult_set && maybe_ne (*mult, cst))
 return false;
 *mult_set = true;
 *mult = cst;
 return true;
 /* Returns true if VAL = X * DIV for some constant X.  If this is the case,
 X is stored to MULT.  */
 bool
 aff_combination_constant_multiple_p (aff_tree *val, aff_tree *div,
-				     widest_int *mult)
+				     poly_widest_int *mult)
 {
 bool mult_set = false;
 unsigned i;
-if (val->n == 0 && val->offset == 0)
+if (val->n == 0 && known_eq (val->offset, 0))
 {
 *mult = 0;
 return true;
 }
 if (val->n != div->n)
 /* Computes address of the reference REF in ADDR.  The size of the accessed
 location is stored to SIZE.  Returns the ultimate containing object to
 which REF refers.  */
 tree
-get_inner_reference_aff (tree ref, aff_tree *addr, widest_int *size)
+get_inner_reference_aff (tree ref, aff_tree *addr, poly_widest_int *size)
 {
-HOST_WIDE_INT bitsize, bitpos;
+poly_int64 bitsize, bitpos;
 tree toff;
 machine_mode mode;
 int uns, rev, vol;
 aff_tree tmp;
 tree base = get_inner_reference (ref, &bitsize, &bitpos, &toff, &mode,
 {
 tree_to_aff_combination (toff, sizetype, &tmp);
 aff_combination_add (addr, &tmp);
 }
-aff_combination_const (&tmp, sizetype, bitpos / BITS_PER_UNIT);
+aff_combination_const (&tmp, sizetype, bits_to_bytes_round_down (bitpos));
 aff_combination_add (addr, &tmp);
-*size = (bitsize + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
+*size = bits_to_bytes_round_up (bitsize);
 return base;
 }
 /* Returns true if a region of size SIZE1 at position 0 and a region of
 size SIZE2 at position DIFF cannot overlap.  */
 bool
-aff_comb_cannot_overlap_p (aff_tree *diff, const widest_int &size1,
+aff_comb_cannot_overlap_p (aff_tree *diff, const poly_widest_int &size1,
-			   const widest_int &size2)
+			   const poly_widest_int &size2)
 {
 /* Unless the difference is a constant, we fail.  */
 if (diff->n != 0)
 return false;
-if (wi::neg_p (diff->offset))
+if (!ordered_p (diff->offset, 0))
+return false;
+if (maybe_lt (diff->offset, 0))
 {
 /* The second object is before the first one, we succeed if the last
 	 element of the second object is before the start of the first one.  */
-return wi::neg_p (diff->offset + size2 - 1);
+return known_le (diff->offset + size2, 0);
 }
 else
 {
 /* We succeed if the second object starts after the first one ends.  */
-return size1 <= diff->offset;
+return known_le (size1, diff->offset);
 }
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-affine.c @ 132:d34655255c78