1 /* Operations with affine combinations of trees.
2 Copyright (C) 2005-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 3, or (at your option) any
11 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
24 #include "tree-pretty-print.h"
25 #include "pointer-set.h"
26 #include "tree-affine.h"
32 /* Extends CST as appropriate for the affine combinations COMB. */
35 double_int_ext_for_comb (double_int cst
, aff_tree
*comb
)
37 return cst
.sext (TYPE_PRECISION (comb
->type
));
40 /* Initializes affine combination COMB so that its value is zero in TYPE. */
43 aff_combination_zero (aff_tree
*comb
, tree type
)
46 comb
->offset
= double_int_zero
;
48 comb
->rest
= NULL_TREE
;
51 /* Sets COMB to CST. */
54 aff_combination_const (aff_tree
*comb
, tree type
, double_int cst
)
56 aff_combination_zero (comb
, type
);
57 comb
->offset
= double_int_ext_for_comb (cst
, comb
);
60 /* Sets COMB to single element ELT. */
63 aff_combination_elt (aff_tree
*comb
, tree type
, tree elt
)
65 aff_combination_zero (comb
, type
);
68 comb
->elts
[0].val
= elt
;
69 comb
->elts
[0].coef
= double_int_one
;
72 /* Scales COMB by SCALE. */
75 aff_combination_scale (aff_tree
*comb
, double_int scale
)
79 scale
= double_int_ext_for_comb (scale
, comb
);
85 aff_combination_zero (comb
, comb
->type
);
90 = double_int_ext_for_comb (scale
* comb
->offset
, comb
);
91 for (i
= 0, j
= 0; i
< comb
->n
; i
++)
96 = double_int_ext_for_comb (scale
* comb
->elts
[i
].coef
, comb
);
97 /* A coefficient may become zero due to overflow. Remove the zero
99 if (new_coef
.is_zero ())
101 comb
->elts
[j
].coef
= new_coef
;
102 comb
->elts
[j
].val
= comb
->elts
[i
].val
;
109 tree type
= comb
->type
;
110 if (POINTER_TYPE_P (type
))
112 if (comb
->n
< MAX_AFF_ELTS
)
114 comb
->elts
[comb
->n
].coef
= scale
;
115 comb
->elts
[comb
->n
].val
= comb
->rest
;
116 comb
->rest
= NULL_TREE
;
120 comb
->rest
= fold_build2 (MULT_EXPR
, type
, comb
->rest
,
121 double_int_to_tree (type
, scale
));
125 /* Adds ELT * SCALE to COMB. */
128 aff_combination_add_elt (aff_tree
*comb
, tree elt
, double_int scale
)
133 scale
= double_int_ext_for_comb (scale
, comb
);
134 if (scale
.is_zero ())
137 for (i
= 0; i
< comb
->n
; i
++)
138 if (operand_equal_p (comb
->elts
[i
].val
, elt
, 0))
142 new_coef
= comb
->elts
[i
].coef
+ scale
;
143 new_coef
= double_int_ext_for_comb (new_coef
, comb
);
144 if (!new_coef
.is_zero ())
146 comb
->elts
[i
].coef
= new_coef
;
151 comb
->elts
[i
] = comb
->elts
[comb
->n
];
155 gcc_assert (comb
->n
== MAX_AFF_ELTS
- 1);
156 comb
->elts
[comb
->n
].coef
= double_int_one
;
157 comb
->elts
[comb
->n
].val
= comb
->rest
;
158 comb
->rest
= NULL_TREE
;
163 if (comb
->n
< MAX_AFF_ELTS
)
165 comb
->elts
[comb
->n
].coef
= scale
;
166 comb
->elts
[comb
->n
].val
= elt
;
172 if (POINTER_TYPE_P (type
))
176 elt
= fold_convert (type
, elt
);
178 elt
= fold_build2 (MULT_EXPR
, type
,
179 fold_convert (type
, elt
),
180 double_int_to_tree (type
, scale
));
183 comb
->rest
= fold_build2 (PLUS_EXPR
, type
, comb
->rest
,
192 aff_combination_add_cst (aff_tree
*c
, double_int cst
)
194 c
->offset
= double_int_ext_for_comb (c
->offset
+ cst
, c
);
197 /* Adds COMB2 to COMB1. */
200 aff_combination_add (aff_tree
*comb1
, aff_tree
*comb2
)
204 aff_combination_add_cst (comb1
, comb2
->offset
);
205 for (i
= 0; i
< comb2
->n
; i
++)
206 aff_combination_add_elt (comb1
, comb2
->elts
[i
].val
, comb2
->elts
[i
].coef
);
208 aff_combination_add_elt (comb1
, comb2
->rest
, double_int_one
);
211 /* Converts affine combination COMB to TYPE. */
214 aff_combination_convert (aff_tree
*comb
, tree type
)
217 tree comb_type
= comb
->type
;
219 if (TYPE_PRECISION (type
) > TYPE_PRECISION (comb_type
))
221 tree val
= fold_convert (type
, aff_combination_to_tree (comb
));
222 tree_to_aff_combination (val
, type
, comb
);
227 if (comb
->rest
&& !POINTER_TYPE_P (type
))
228 comb
->rest
= fold_convert (type
, comb
->rest
);
230 if (TYPE_PRECISION (type
) == TYPE_PRECISION (comb_type
))
233 comb
->offset
= double_int_ext_for_comb (comb
->offset
, comb
);
234 for (i
= j
= 0; i
< comb
->n
; i
++)
236 double_int new_coef
= double_int_ext_for_comb (comb
->elts
[i
].coef
, comb
);
237 if (new_coef
.is_zero ())
239 comb
->elts
[j
].coef
= new_coef
;
240 comb
->elts
[j
].val
= fold_convert (type
, comb
->elts
[i
].val
);
245 if (comb
->n
< MAX_AFF_ELTS
&& comb
->rest
)
247 comb
->elts
[comb
->n
].coef
= double_int_one
;
248 comb
->elts
[comb
->n
].val
= comb
->rest
;
249 comb
->rest
= NULL_TREE
;
254 /* Splits EXPR into an affine combination of parts. */
257 tree_to_aff_combination (tree expr
, tree type
, aff_tree
*comb
)
261 tree cst
, core
, toffset
;
262 HOST_WIDE_INT bitpos
, bitsize
;
263 enum machine_mode mode
;
264 int unsignedp
, volatilep
;
268 code
= TREE_CODE (expr
);
272 aff_combination_const (comb
, type
, tree_to_double_int (expr
));
275 case POINTER_PLUS_EXPR
:
276 tree_to_aff_combination (TREE_OPERAND (expr
, 0), type
, comb
);
277 tree_to_aff_combination (TREE_OPERAND (expr
, 1), sizetype
, &tmp
);
278 aff_combination_add (comb
, &tmp
);
283 tree_to_aff_combination (TREE_OPERAND (expr
, 0), type
, comb
);
284 tree_to_aff_combination (TREE_OPERAND (expr
, 1), type
, &tmp
);
285 if (code
== MINUS_EXPR
)
286 aff_combination_scale (&tmp
, double_int_minus_one
);
287 aff_combination_add (comb
, &tmp
);
291 cst
= TREE_OPERAND (expr
, 1);
292 if (TREE_CODE (cst
) != INTEGER_CST
)
294 tree_to_aff_combination (TREE_OPERAND (expr
, 0), type
, comb
);
295 aff_combination_scale (comb
, tree_to_double_int (cst
));
299 tree_to_aff_combination (TREE_OPERAND (expr
, 0), type
, comb
);
300 aff_combination_scale (comb
, double_int_minus_one
);
305 tree_to_aff_combination (TREE_OPERAND (expr
, 0), type
, comb
);
306 aff_combination_scale (comb
, double_int_minus_one
);
307 aff_combination_add_cst (comb
, double_int_minus_one
);
311 /* Handle &MEM[ptr + CST] which is equivalent to POINTER_PLUS_EXPR. */
312 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == MEM_REF
)
314 expr
= TREE_OPERAND (expr
, 0);
315 tree_to_aff_combination (TREE_OPERAND (expr
, 0), type
, comb
);
316 tree_to_aff_combination (TREE_OPERAND (expr
, 1), sizetype
, &tmp
);
317 aff_combination_add (comb
, &tmp
);
320 core
= get_inner_reference (TREE_OPERAND (expr
, 0), &bitsize
, &bitpos
,
321 &toffset
, &mode
, &unsignedp
, &volatilep
,
323 if (bitpos
% BITS_PER_UNIT
!= 0)
325 aff_combination_const (comb
, type
,
326 double_int::from_uhwi (bitpos
/ BITS_PER_UNIT
));
327 core
= build_fold_addr_expr (core
);
328 if (TREE_CODE (core
) == ADDR_EXPR
)
329 aff_combination_add_elt (comb
, core
, double_int_one
);
332 tree_to_aff_combination (core
, type
, &tmp
);
333 aff_combination_add (comb
, &tmp
);
337 tree_to_aff_combination (toffset
, type
, &tmp
);
338 aff_combination_add (comb
, &tmp
);
343 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == ADDR_EXPR
)
344 tree_to_aff_combination (TREE_OPERAND (TREE_OPERAND (expr
, 0), 0),
346 else if (integer_zerop (TREE_OPERAND (expr
, 1)))
348 aff_combination_elt (comb
, type
, expr
);
352 aff_combination_elt (comb
, type
,
353 build2 (MEM_REF
, TREE_TYPE (expr
),
354 TREE_OPERAND (expr
, 0),
356 (TREE_TYPE (TREE_OPERAND (expr
, 1)), 0)));
357 tree_to_aff_combination (TREE_OPERAND (expr
, 1), sizetype
, &tmp
);
358 aff_combination_add (comb
, &tmp
);
365 aff_combination_elt (comb
, type
, expr
);
368 /* Creates EXPR + ELT * SCALE in TYPE. EXPR is taken from affine
372 add_elt_to_tree (tree expr
, tree type
, tree elt
, double_int scale
,
377 if (POINTER_TYPE_P (type
))
380 scale
= double_int_ext_for_comb (scale
, comb
);
382 if (scale
.is_minus_one ()
383 && POINTER_TYPE_P (TREE_TYPE (elt
)))
385 elt
= convert_to_ptrofftype (elt
);
386 elt
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (elt
), elt
);
387 scale
= double_int_one
;
394 if (POINTER_TYPE_P (TREE_TYPE (elt
)))
397 return fold_convert (type1
, elt
);
400 if (POINTER_TYPE_P (TREE_TYPE (expr
)))
401 return fold_build_pointer_plus (expr
, elt
);
402 if (POINTER_TYPE_P (TREE_TYPE (elt
)))
403 return fold_build_pointer_plus (elt
, expr
);
404 return fold_build2 (PLUS_EXPR
, type1
,
405 expr
, fold_convert (type1
, elt
));
408 if (scale
.is_minus_one ())
411 return fold_build1 (NEGATE_EXPR
, type1
,
412 fold_convert (type1
, elt
));
414 if (POINTER_TYPE_P (TREE_TYPE (expr
)))
416 elt
= convert_to_ptrofftype (elt
);
417 elt
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (elt
), elt
);
418 return fold_build_pointer_plus (expr
, elt
);
420 return fold_build2 (MINUS_EXPR
, type1
,
421 expr
, fold_convert (type1
, elt
));
424 elt
= fold_convert (type1
, elt
);
426 return fold_build2 (MULT_EXPR
, type1
, elt
,
427 double_int_to_tree (type1
, scale
));
429 if (scale
.is_negative ())
437 elt
= fold_build2 (MULT_EXPR
, type1
, elt
,
438 double_int_to_tree (type1
, scale
));
439 if (POINTER_TYPE_P (TREE_TYPE (expr
)))
441 if (code
== MINUS_EXPR
)
442 elt
= fold_build1 (NEGATE_EXPR
, type1
, elt
);
443 return fold_build_pointer_plus (expr
, elt
);
445 return fold_build2 (code
, type1
, expr
, elt
);
448 /* Makes tree from the affine combination COMB. */
451 aff_combination_to_tree (aff_tree
*comb
)
453 tree type
= comb
->type
;
454 tree expr
= NULL_TREE
;
458 if (POINTER_TYPE_P (type
))
461 gcc_assert (comb
->n
== MAX_AFF_ELTS
|| comb
->rest
== NULL_TREE
);
463 for (i
= 0; i
< comb
->n
; i
++)
464 expr
= add_elt_to_tree (expr
, type
, comb
->elts
[i
].val
, comb
->elts
[i
].coef
,
468 expr
= add_elt_to_tree (expr
, type
, comb
->rest
, double_int_one
, comb
);
470 /* Ensure that we get x - 1, not x + (-1) or x + 0xff..f if x is
472 if (comb
->offset
.is_negative ())
475 sgn
= double_int_minus_one
;
480 sgn
= double_int_one
;
482 return add_elt_to_tree (expr
, type
, double_int_to_tree (type1
, off
), sgn
,
486 /* Copies the tree elements of COMB to ensure that they are not shared. */
489 unshare_aff_combination (aff_tree
*comb
)
493 for (i
= 0; i
< comb
->n
; i
++)
494 comb
->elts
[i
].val
= unshare_expr (comb
->elts
[i
].val
);
496 comb
->rest
= unshare_expr (comb
->rest
);
499 /* Remove M-th element from COMB. */
502 aff_combination_remove_elt (aff_tree
*comb
, unsigned m
)
506 comb
->elts
[m
] = comb
->elts
[comb
->n
];
509 comb
->elts
[comb
->n
].coef
= double_int_one
;
510 comb
->elts
[comb
->n
].val
= comb
->rest
;
511 comb
->rest
= NULL_TREE
;
516 /* Adds C * COEF * VAL to R. VAL may be NULL, in that case only
517 C * COEF is added to R. */
521 aff_combination_add_product (aff_tree
*c
, double_int coef
, tree val
,
527 for (i
= 0; i
< c
->n
; i
++)
529 aval
= c
->elts
[i
].val
;
532 type
= TREE_TYPE (aval
);
533 aval
= fold_build2 (MULT_EXPR
, type
, aval
,
534 fold_convert (type
, val
));
537 aff_combination_add_elt (r
, aval
, coef
* c
->elts
[i
].coef
);
545 type
= TREE_TYPE (aval
);
546 aval
= fold_build2 (MULT_EXPR
, type
, aval
,
547 fold_convert (type
, val
));
550 aff_combination_add_elt (r
, aval
, coef
);
554 aff_combination_add_elt (r
, val
, coef
* c
->offset
);
556 aff_combination_add_cst (r
, coef
* c
->offset
);
559 /* Multiplies C1 by C2, storing the result to R */
562 aff_combination_mult (aff_tree
*c1
, aff_tree
*c2
, aff_tree
*r
)
565 gcc_assert (TYPE_PRECISION (c1
->type
) == TYPE_PRECISION (c2
->type
));
567 aff_combination_zero (r
, c1
->type
);
569 for (i
= 0; i
< c2
->n
; i
++)
570 aff_combination_add_product (c1
, c2
->elts
[i
].coef
, c2
->elts
[i
].val
, r
);
572 aff_combination_add_product (c1
, double_int_one
, c2
->rest
, r
);
573 aff_combination_add_product (c1
, c2
->offset
, NULL
, r
);
576 /* Returns the element of COMB whose value is VAL, or NULL if no such
577 element exists. If IDX is not NULL, it is set to the index of VAL in
580 static struct aff_comb_elt
*
581 aff_combination_find_elt (aff_tree
*comb
, tree val
, unsigned *idx
)
585 for (i
= 0; i
< comb
->n
; i
++)
586 if (operand_equal_p (comb
->elts
[i
].val
, val
, 0))
591 return &comb
->elts
[i
];
597 /* Element of the cache that maps ssa name NAME to its expanded form
598 as an affine expression EXPANSION. */
600 struct name_expansion
604 /* True if the expansion for the name is just being generated. */
605 unsigned in_progress
: 1;
608 /* Expands SSA names in COMB recursively. CACHE is used to cache the
612 aff_combination_expand (aff_tree
*comb ATTRIBUTE_UNUSED
,
613 struct pointer_map_t
**cache ATTRIBUTE_UNUSED
)
616 aff_tree to_add
, current
, curre
;
621 struct name_expansion
*exp
;
623 aff_combination_zero (&to_add
, comb
->type
);
624 for (i
= 0; i
< comb
->n
; i
++)
629 e
= comb
->elts
[i
].val
;
630 type
= TREE_TYPE (e
);
632 /* Look through some conversions. */
633 if (TREE_CODE (e
) == NOP_EXPR
634 && (TYPE_PRECISION (type
)
635 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (e
, 0)))))
636 name
= TREE_OPERAND (e
, 0);
637 if (TREE_CODE (name
) != SSA_NAME
)
639 def
= SSA_NAME_DEF_STMT (name
);
640 if (!is_gimple_assign (def
) || gimple_assign_lhs (def
) != name
)
643 code
= gimple_assign_rhs_code (def
);
645 && !IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
))
646 && (get_gimple_rhs_class (code
) != GIMPLE_SINGLE_RHS
647 || !is_gimple_min_invariant (gimple_assign_rhs1 (def
))))
650 /* We do not know whether the reference retains its value at the
651 place where the expansion is used. */
652 if (TREE_CODE_CLASS (code
) == tcc_reference
)
656 *cache
= pointer_map_create ();
657 slot
= pointer_map_insert (*cache
, e
);
658 exp
= (struct name_expansion
*) *slot
;
662 exp
= XNEW (struct name_expansion
);
663 exp
->in_progress
= 1;
665 /* In principle this is a generally valid folding, but
666 it is not unconditionally an optimization, so do it
667 here and not in fold_unary. */
668 /* Convert (T1)(X *+- CST) into (T1)X *+- (T1)CST if T1 is wider
669 than the type of X and overflow for the type of X is
672 && INTEGRAL_TYPE_P (type
)
673 && INTEGRAL_TYPE_P (TREE_TYPE (name
))
674 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (name
))
675 && TYPE_PRECISION (type
) > TYPE_PRECISION (TREE_TYPE (name
))
676 && (code
== PLUS_EXPR
|| code
== MINUS_EXPR
|| code
== MULT_EXPR
)
677 && TREE_CODE (gimple_assign_rhs2 (def
)) == INTEGER_CST
)
678 rhs
= fold_build2 (code
, type
,
679 fold_convert (type
, gimple_assign_rhs1 (def
)),
680 fold_convert (type
, gimple_assign_rhs2 (def
)));
683 rhs
= gimple_assign_rhs_to_tree (def
);
685 rhs
= fold_convert (type
, rhs
);
687 tree_to_aff_combination_expand (rhs
, comb
->type
, ¤t
, cache
);
688 exp
->expansion
= current
;
689 exp
->in_progress
= 0;
693 /* Since we follow the definitions in the SSA form, we should not
694 enter a cycle unless we pass through a phi node. */
695 gcc_assert (!exp
->in_progress
);
696 current
= exp
->expansion
;
699 /* Accumulate the new terms to TO_ADD, so that we do not modify
700 COMB while traversing it; include the term -coef * E, to remove
702 scale
= comb
->elts
[i
].coef
;
703 aff_combination_zero (&curre
, comb
->type
);
704 aff_combination_add_elt (&curre
, e
, -scale
);
705 aff_combination_scale (¤t
, scale
);
706 aff_combination_add (&to_add
, ¤t
);
707 aff_combination_add (&to_add
, &curre
);
709 aff_combination_add (comb
, &to_add
);
712 /* Similar to tree_to_aff_combination, but follows SSA name definitions
713 and expands them recursively. CACHE is used to cache the expansions
714 of the ssa names, to avoid exponential time complexity for cases
723 tree_to_aff_combination_expand (tree expr
, tree type
, aff_tree
*comb
,
724 struct pointer_map_t
**cache
)
726 tree_to_aff_combination (expr
, type
, comb
);
727 aff_combination_expand (comb
, cache
);
730 /* Frees memory occupied by struct name_expansion in *VALUE. Callback for
731 pointer_map_traverse. */
734 free_name_expansion (const void *key ATTRIBUTE_UNUSED
, void **value
,
735 void *data ATTRIBUTE_UNUSED
)
737 struct name_expansion
*const exp
= (struct name_expansion
*) *value
;
743 /* Frees memory allocated for the CACHE used by
744 tree_to_aff_combination_expand. */
747 free_affine_expand_cache (struct pointer_map_t
**cache
)
752 pointer_map_traverse (*cache
, free_name_expansion
, NULL
);
753 pointer_map_destroy (*cache
);
757 /* If VAL != CST * DIV for any constant CST, returns false.
758 Otherwise, if *MULT_SET is true, additionally compares CST and MULT,
759 and if they are different, returns false. Finally, if neither of these
760 two cases occur, true is returned, and CST is stored to MULT and MULT_SET
764 double_int_constant_multiple_p (double_int val
, double_int div
,
765 bool *mult_set
, double_int
*mult
)
771 if (*mult_set
&& !mult
->is_zero ())
774 *mult
= double_int_zero
;
781 cst
= val
.sdivmod (div
, FLOOR_DIV_EXPR
, &rem
);
785 if (*mult_set
&& *mult
!= cst
)
793 /* Returns true if VAL = X * DIV for some constant X. If this is the case,
794 X is stored to MULT. */
797 aff_combination_constant_multiple_p (aff_tree
*val
, aff_tree
*div
,
800 bool mult_set
= false;
803 if (val
->n
== 0 && val
->offset
.is_zero ())
805 *mult
= double_int_zero
;
808 if (val
->n
!= div
->n
)
811 if (val
->rest
|| div
->rest
)
814 if (!double_int_constant_multiple_p (val
->offset
, div
->offset
,
818 for (i
= 0; i
< div
->n
; i
++)
820 struct aff_comb_elt
*elt
821 = aff_combination_find_elt (val
, div
->elts
[i
].val
, NULL
);
824 if (!double_int_constant_multiple_p (elt
->coef
, div
->elts
[i
].coef
,
829 gcc_assert (mult_set
);
833 /* Prints the affine VAL to the FILE. */
836 print_aff (FILE *file
, aff_tree
*val
)
839 bool uns
= TYPE_UNSIGNED (val
->type
);
840 if (POINTER_TYPE_P (val
->type
))
842 fprintf (file
, "{\n type = ");
843 print_generic_expr (file
, val
->type
, TDF_VOPS
|TDF_MEMSYMS
);
844 fprintf (file
, "\n offset = ");
845 dump_double_int (file
, val
->offset
, uns
);
848 fprintf (file
, "\n elements = {\n");
849 for (i
= 0; i
< val
->n
; i
++)
851 fprintf (file
, " [%d] = ", i
);
852 print_generic_expr (file
, val
->elts
[i
].val
, TDF_VOPS
|TDF_MEMSYMS
);
854 fprintf (file
, " * ");
855 dump_double_int (file
, val
->elts
[i
].coef
, uns
);
857 fprintf (file
, ", \n");
859 fprintf (file
, "\n }");
863 fprintf (file
, "\n rest = ");
864 print_generic_expr (file
, val
->rest
, TDF_VOPS
|TDF_MEMSYMS
);
866 fprintf (file
, "\n}");
869 /* Prints the affine VAL to the standard error, used for debugging. */
872 debug_aff (aff_tree
*val
)
874 print_aff (stderr
, val
);
875 fprintf (stderr
, "\n");
878 /* Computes address of the reference REF in ADDR. The size of the accessed
879 location is stored to SIZE. Returns the ultimate containing object to
883 get_inner_reference_aff (tree ref
, aff_tree
*addr
, double_int
*size
)
885 HOST_WIDE_INT bitsize
, bitpos
;
887 enum machine_mode mode
;
890 tree base
= get_inner_reference (ref
, &bitsize
, &bitpos
, &toff
, &mode
,
892 tree base_addr
= build_fold_addr_expr (base
);
894 /* ADDR = &BASE + TOFF + BITPOS / BITS_PER_UNIT. */
896 tree_to_aff_combination (base_addr
, sizetype
, addr
);
900 tree_to_aff_combination (toff
, sizetype
, &tmp
);
901 aff_combination_add (addr
, &tmp
);
904 aff_combination_const (&tmp
, sizetype
,
905 double_int::from_shwi (bitpos
/ BITS_PER_UNIT
));
906 aff_combination_add (addr
, &tmp
);
908 *size
= double_int::from_shwi ((bitsize
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
);
913 /* Returns true if a region of size SIZE1 at position 0 and a region of
914 size SIZE2 at position DIFF cannot overlap. */
917 aff_comb_cannot_overlap_p (aff_tree
*diff
, double_int size1
, double_int size2
)
921 /* Unless the difference is a constant, we fail. */
926 if (d
.is_negative ())
928 /* The second object is before the first one, we succeed if the last
929 element of the second object is before the start of the first one. */
930 bound
= d
+ size2
+ double_int_minus_one
;
931 return bound
.is_negative ();
935 /* We succeed if the second object starts after the first one ends. */
936 return size1
.sle (d
);