GCC Middle and Back End API Reference
tree-data-ref.h
Go to the documentation of this file.
1/* Data references and dependences detectors.
2 Copyright (C) 2003-2024 Free Software Foundation, Inc.
3 Contributed by Sebastian Pop <pop@cri.ensmp.fr>
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#ifndef GCC_TREE_DATA_REF_H
22#define GCC_TREE_DATA_REF_H
23
24#include "graphds.h"
25#include "tree-chrec.h"
26#include "opt-problem.h"
27
28/*
29 innermost_loop_behavior describes the evolution of the address of the memory
30 reference in the innermost enclosing loop. The address is expressed as
31 BASE + STEP * # of iteration, and base is further decomposed as the base
32 pointer (BASE_ADDRESS), loop invariant offset (OFFSET) and
33 constant offset (INIT). Examples, in loop nest
34
35 for (i = 0; i < 100; i++)
36 for (j = 3; j < 100; j++)
37
38 Example 1 Example 2
39 data-ref a[j].b[i][j] *(p + x + 16B + 4B * j)
40
41
42 innermost_loop_behavior
43 base_address &a p
44 offset i * D_i x
45 init 3 * D_j + offsetof (b) 28
46 step D_j 4
47
48 */
50{
55
56 /* BASE_ADDRESS is known to be misaligned by BASE_MISALIGNMENT bytes
57 from an alignment boundary of BASE_ALIGNMENT bytes. For example,
58 if we had:
59
60 struct S __attribute__((aligned(16))) { ... };
61
62 char *ptr;
63 ... *(struct S *) (ptr - 4) ...;
64
65 the information would be:
66
67 base_address: ptr
68 base_aligment: 16
69 base_misalignment: 4
70 init: -4
71
72 where init cancels the base misalignment. If instead we had a
73 reference to a particular field:
74
75 struct S __attribute__((aligned(16))) { ... int f; ... };
76
77 char *ptr;
78 ... ((struct S *) (ptr - 4))->f ...;
79
80 the information would be:
81
82 base_address: ptr
83 base_aligment: 16
84 base_misalignment: 4
85 init: -4 + offsetof (S, f)
86
87 where base_address + init might also be misaligned, and by a different
88 amount from base_address. */
89 unsigned int base_alignment;
90 unsigned int base_misalignment;
91
92 /* The largest power of two that divides OFFSET, capped to a suitably
93 high value if the offset is zero. This is a byte rather than a bit
94 quantity. */
95 unsigned int offset_alignment;
96
97 /* Likewise for STEP. */
98 unsigned int step_alignment;
99};
100
101/* Describes the evolutions of indices of the memory reference. The indices
102 are indices of the ARRAY_REFs, indexes in artificial dimensions
103 added for member selection of records and the operands of MEM_REFs.
104 BASE_OBJECT is the part of the reference that is loop-invariant
105 (note that this reference does not have to cover the whole object
106 being accessed, in which case UNCONSTRAINED_BASE is set; hence it is
107 not recommended to use BASE_OBJECT in any code generation).
108 For the examples above,
109
110 base_object: a *(p + x + 4B * j_0)
111 indices: {j_0, +, 1}_2 {16, +, 4}_2
112 4
113 {i_0, +, 1}_1
114 {j_0, +, 1}_2
115*/
116
118{
119 /* The object. */
121
122 /* A list of chrecs. Access functions of the indices. */
124
125 /* Whether BASE_OBJECT is an access representing the whole object
126 or whether the access could not be constrained. */
128};
129
131{
132 /* The alias information that should be used for new pointers to this
133 location. */
135};
136
137/* An integer vector. A vector formally consists of an element of a vector
138 space. A vector space is a set that is closed under vector addition
139 and scalar multiplication. In this vector space, an element is a list of
140 integers. */
143
144/* An integer matrix. A matrix consists of m vectors of length n (IE
145 all vectors are the same length). */
147
148
149
151{
152 /* A pointer to the statement that contains this DR. */
154
155 /* A pointer to the memory reference. */
157
158 /* Auxiliary info specific to a pass. */
159 void *aux;
160
161 /* True when the data reference is in RHS of a stmt. */
163
164 /* True when the data reference is conditional within STMT,
165 i.e. if it might not occur even when the statement is executed
166 and runs to completion. */
168
169 /* Alias information for the data reference. */
171
172 /* Behavior of the memory reference in the innermost loop. */
174
175 /* Subscripts of this data reference. */
177
178 /* Alternate subscripts initialized lazily and used by data-dependence
179 analysis only when the main indices of two DRs are not comparable.
180 Keep last to keep vec_info_shared::check_datarefs happy. */
182};
183
184#define DR_STMT(DR) (DR)->stmt
185#define DR_REF(DR) (DR)->ref
186#define DR_BASE_OBJECT(DR) (DR)->indices.base_object
187#define DR_UNCONSTRAINED_BASE(DR) (DR)->indices.unconstrained_base
188#define DR_ACCESS_FNS(DR) (DR)->indices.access_fns
189#define DR_ACCESS_FN(DR, I) DR_ACCESS_FNS (DR)[I]
190#define DR_NUM_DIMENSIONS(DR) DR_ACCESS_FNS (DR).length ()
191#define DR_IS_READ(DR) (DR)->is_read
192#define DR_IS_WRITE(DR) (!DR_IS_READ (DR))
193#define DR_IS_CONDITIONAL_IN_STMT(DR) (DR)->is_conditional_in_stmt
194#define DR_BASE_ADDRESS(DR) (DR)->innermost.base_address
195#define DR_OFFSET(DR) (DR)->innermost.offset
196#define DR_INIT(DR) (DR)->innermost.init
197#define DR_STEP(DR) (DR)->innermost.step
198#define DR_PTR_INFO(DR) (DR)->alias.ptr_info
199#define DR_BASE_ALIGNMENT(DR) (DR)->innermost.base_alignment
200#define DR_BASE_MISALIGNMENT(DR) (DR)->innermost.base_misalignment
201#define DR_OFFSET_ALIGNMENT(DR) (DR)->innermost.offset_alignment
202#define DR_STEP_ALIGNMENT(DR) (DR)->innermost.step_alignment
203#define DR_INNERMOST(DR) (DR)->innermost
204
206
207/* This struct is used to store the information of a data reference,
208 including the data ref itself and the segment length for aliasing
209 checks. This is used to merge alias checks. */
210
212{
213public:
215 unsigned int a)
216 : dr (d), seg_len (len), access_size (size), align (a) {}
217
219 /* The offset of the last access that needs to be checked minus
220 the offset of the first. */
222 /* A value that, when added to abs (SEG_LEN), gives the total number of
223 bytes in the segment. */
225 /* The minimum common alignment of DR's start address, SEG_LEN and
226 ACCESS_SIZE. */
227 unsigned int align;
228};
229
230/* Flags that describe a potential alias between two dr_with_seg_lens.
231 In general, each pair of dr_with_seg_lens represents a composite of
232 multiple access pairs P, so testing flags like DR_IS_READ on the DRs
233 does not give meaningful information.
234
235 DR_ALIAS_RAW:
236 There is a pair in P for which the second reference is a read
237 and the first is a write.
238
239 DR_ALIAS_WAR:
240 There is a pair in P for which the second reference is a write
241 and the first is a read.
242
243 DR_ALIAS_WAW:
244 There is a pair in P for which both references are writes.
245
246 DR_ALIAS_ARBITRARY:
247 Either
248 (a) it isn't possible to classify one pair in P as RAW, WAW or WAR; or
249 (b) there is a pair in P that breaks the ordering assumption below.
250
251 This flag overrides the RAW, WAR and WAW flags above.
252
253 DR_ALIAS_UNSWAPPED:
254 DR_ALIAS_SWAPPED:
255 Temporary flags that indicate whether there is a pair P whose
256 DRs have or haven't been swapped around.
257
258 DR_ALIAS_MIXED_STEPS:
259 The DR_STEP for one of the data references in the pair does not
260 accurately describe that reference for all members of P. (Note
261 that the flag does not say anything about whether the DR_STEPs
262 of the two references in the pair are the same.)
263
264 The ordering assumption mentioned above is that for every pair
265 (DR_A, DR_B) in P:
266
267 (1) The original code accesses n elements for DR_A and n elements for DR_B,
268 interleaved as follows:
269
270 one access of size DR_A.access_size at DR_A.dr
271 one access of size DR_B.access_size at DR_B.dr
272 one access of size DR_A.access_size at DR_A.dr + STEP_A
273 one access of size DR_B.access_size at DR_B.dr + STEP_B
274 one access of size DR_A.access_size at DR_A.dr + STEP_A * 2
275 one access of size DR_B.access_size at DR_B.dr + STEP_B * 2
276 ...
277
278 (2) The new code accesses the same data in exactly two chunks:
279
280 one group of accesses spanning |DR_A.seg_len| + DR_A.access_size
281 one group of accesses spanning |DR_B.seg_len| + DR_B.access_size
282
283 A pair might break this assumption if the DR_A and DR_B accesses
284 in the original or the new code are mingled in some way. For example,
285 if DR_A.access_size represents the effect of two individual writes
286 to nearby locations, the pair breaks the assumption if those writes
287 occur either side of the access for DR_B.
288
289 Note that DR_ALIAS_ARBITRARY describes whether the ordering assumption
290 fails to hold for any individual pair in P. If the assumption *does*
291 hold for every pair in P, it doesn't matter whether it holds for the
292 composite pair or not. In other words, P should represent the complete
293 set of pairs that the composite pair is testing, so only the ordering
294 of two accesses in the same member of P matters. */
295const unsigned int DR_ALIAS_RAW = 1U << 0;
296const unsigned int DR_ALIAS_WAR = 1U << 1;
297const unsigned int DR_ALIAS_WAW = 1U << 2;
298const unsigned int DR_ALIAS_ARBITRARY = 1U << 3;
299const unsigned int DR_ALIAS_SWAPPED = 1U << 4;
300const unsigned int DR_ALIAS_UNSWAPPED = 1U << 5;
301const unsigned int DR_ALIAS_MIXED_STEPS = 1U << 6;
302
303/* This struct contains two dr_with_seg_len objects with aliasing data
304 refs. Two comparisons are generated from them. */
305
307{
308public:
309 /* WELL_ORDERED indicates that the ordering assumption described above
310 DR_ALIAS_ARBITRARY holds. REORDERED indicates that it doesn't. */
312
314 const dr_with_seg_len &, sequencing);
315
318 unsigned int flags;
319};
320
323 sequencing seq)
324 : first (d1), second (d2), flags (0)
325{
326 if (DR_IS_READ (d1.dr) && DR_IS_WRITE (d2.dr))
328 else if (DR_IS_WRITE (d1.dr) && DR_IS_READ (d2.dr))
330 else if (DR_IS_WRITE (d1.dr) && DR_IS_WRITE (d2.dr))
332 else
334 if (seq == REORDERED)
336}
337
348
349/* The description of the grid of iterations that overlap. At most
350 two loops are considered at the same time just now, hence at most
351 two functions are needed. For each of the functions, we store
352 the vector of coefficients, f[0] + x * f[1] + y * f[2] + ...,
353 where x, y, ... are variables. */
354
355#define MAX_DIM 2
356
357/* Special values of N. */
358#define NO_DEPENDENCE 0
359#define NOT_KNOWN (MAX_DIM + 1)
360#define CF_NONTRIVIAL_P(CF) ((CF)->n != NO_DEPENDENCE && (CF)->n != NOT_KNOWN)
361#define CF_NOT_KNOWN_P(CF) ((CF)->n == NOT_KNOWN)
362#define CF_NO_DEPENDENCE_P(CF) ((CF)->n == NO_DEPENDENCE)
363
365
367{
368 unsigned n;
370};
371
372/* What is a subscript? Given two array accesses a subscript is the
373 tuple composed of the access functions for a given dimension.
374 Example: Given A[f1][f2][f3] and B[g1][g2][g3], there are three
375 subscripts: (f1, g1), (f2, g2), (f3, g3). These three subscripts
376 are stored in the data_dependence_relation structure under the form
377 of an array of subscripts. */
378
380{
381 /* The access functions of the two references. */
383
384 /* A description of the iterations for which the elements are
385 accessed twice. */
388
389 /* This field stores the information about the iteration domain
390 validity of the dependence relation. */
392
393 /* Distance from the iteration that access a conflicting element in
394 A to the iteration that access this same conflicting element in
395 B. The distance is a tree scalar expression, i.e. a constant or a
396 symbolic expression, but certainly not a chrec function. */
398};
399
400typedef struct subscript *subscript_p;
401
402#define SUB_ACCESS_FN(SUB, I) (SUB)->access_fn[I]
403#define SUB_CONFLICTS_IN_A(SUB) (SUB)->conflicting_iterations_in_a
404#define SUB_CONFLICTS_IN_B(SUB) (SUB)->conflicting_iterations_in_b
405#define SUB_LAST_CONFLICT(SUB) (SUB)->last_conflict
406#define SUB_DISTANCE(SUB) (SUB)->distance
407
408/* A data_dependence_relation represents a relation between two
409 data_references A and B. */
410
412{
413
416
417 /* A "yes/no/maybe" field for the dependence relation:
418
419 - when "ARE_DEPENDENT == NULL_TREE", there exist a dependence
420 relation between A and B, and the description of this relation
421 is given in the SUBSCRIPTS array,
422
423 - when "ARE_DEPENDENT == chrec_known", there is no dependence and
424 SUBSCRIPTS is empty,
425
426 - when "ARE_DEPENDENT == chrec_dont_know", there may be a dependence,
427 but the analyzer cannot be more specific. */
429
430 /* If nonnull, COULD_BE_INDEPENDENT_P is true and the accesses are
431 independent when the runtime addresses of OBJECT_A and OBJECT_B
432 are different. The addresses of both objects are invariant in the
433 loop nest. */
436
437 /* For each subscript in the dependence test, there is an element in
438 this array. This is the attribute that labels the edge A->B of
439 the data_dependence_relation. */
441
442 /* The analyzed loop nest. */
444
445 /* The classic direction vector. */
447
448 /* The classic distance vector. */
450
451 /* Is the dependence reversed with respect to the lexicographic order? */
453
454 /* When the dependence relation is affine, it can be represented by
455 a distance vector. */
457
458 /* Set to true when the dependence relation is on the same data
459 access. */
461
462 /* True if the dependence described is conservatively correct rather
463 than exact, and if it is still possible for the accesses to be
464 conditionally independent. For example, the a and b references in:
465
466 struct s *a, *b;
467 for (int i = 0; i < n; ++i)
468 a->f[i] += b->f[i];
469
470 conservatively have a distance vector of (0), for the case in which
471 a == b, but the accesses are independent if a != b. Similarly,
472 the a and b references in:
473
474 struct s *a, *b;
475 for (int i = 0; i < n; ++i)
476 a[0].f[i] += b[i].f[i];
477
478 conservatively have a distance vector of (0), but they are indepenent
479 when a != b + i. In contrast, the references in:
480
481 struct s *a;
482 for (int i = 0; i < n; ++i)
483 a->f[i] += a->f[i];
484
485 have the same distance vector of (0), but the accesses can never be
486 independent. */
488};
489
491
492#define DDR_A(DDR) (DDR)->a
493#define DDR_B(DDR) (DDR)->b
494#define DDR_AFFINE_P(DDR) (DDR)->affine_p
495#define DDR_ARE_DEPENDENT(DDR) (DDR)->are_dependent
496#define DDR_OBJECT_A(DDR) (DDR)->object_a
497#define DDR_OBJECT_B(DDR) (DDR)->object_b
498#define DDR_SUBSCRIPTS(DDR) (DDR)->subscripts
499#define DDR_SUBSCRIPT(DDR, I) DDR_SUBSCRIPTS (DDR)[I]
500#define DDR_NUM_SUBSCRIPTS(DDR) DDR_SUBSCRIPTS (DDR).length ()
501
502#define DDR_LOOP_NEST(DDR) (DDR)->loop_nest
503/* The size of the direction/distance vectors: the number of loops in
504 the loop nest. */
505#define DDR_NB_LOOPS(DDR) (DDR_LOOP_NEST (DDR).length ())
506#define DDR_SELF_REFERENCE(DDR) (DDR)->self_reference_p
507
508#define DDR_DIST_VECTS(DDR) ((DDR)->dist_vects)
509#define DDR_DIR_VECTS(DDR) ((DDR)->dir_vects)
510#define DDR_NUM_DIST_VECTS(DDR) \
511 (DDR_DIST_VECTS (DDR).length ())
512#define DDR_NUM_DIR_VECTS(DDR) \
513 (DDR_DIR_VECTS (DDR).length ())
514#define DDR_DIR_VECT(DDR, I) \
515 DDR_DIR_VECTS (DDR)[I]
516#define DDR_DIST_VECT(DDR, I) \
517 DDR_DIST_VECTS (DDR)[I]
518#define DDR_REVERSED_P(DDR) (DDR)->reversed_p
519#define DDR_COULD_BE_INDEPENDENT_P(DDR) (DDR)->could_be_independent_p
520
521
523 class loop *, const gimple *);
524extern bool compute_data_dependences_for_loop (class loop *, bool,
525 vec<loop_p> *,
527 vec<ddr_p> *);
528extern void debug_ddrs (vec<ddr_p> );
529extern void dump_data_reference (FILE *, struct data_reference *);
530extern void debug (data_reference &ref);
531extern void debug (data_reference *ptr);
532extern void debug_data_reference (struct data_reference *);
534extern void debug (vec<data_reference_p> &ref);
535extern void debug (vec<data_reference_p> *ptr);
537extern void dump_data_dependence_relations (FILE *, const vec<ddr_p> &);
538extern void debug (vec<ddr_p> &ref);
539extern void debug (vec<ddr_p> *ptr);
543extern void free_data_ref (data_reference_p);
552 bool);
553extern bool find_loop_nest (class loop *, vec<loop_p> *);
555 (struct data_reference *, struct data_reference *, vec<loop_p>);
557 loop_p);
560 vec<ddr_p> *,
561 const vec<loop_p> &, bool);
564extern unsigned int dr_alignment (innermost_loop_behavior *);
565extern tree get_base_for_alignment (tree, unsigned int *);
566
567/* Return the alignment in bytes that DR is guaranteed to have at all
568 times. */
569
570inline unsigned int
572{
573 return dr_alignment (&DR_INNERMOST (dr));
574}
575
576extern bool dr_may_alias_p (const struct data_reference *,
577 const struct data_reference *, class loop *);
578extern bool dr_equal_offsets_p (struct data_reference *,
579 struct data_reference *);
580
581extern opt_result runtime_alias_check_p (ddr_p, class loop *, bool);
582extern int data_ref_compare_tree (tree, tree);
585extern void create_runtime_alias_checks (class loop *,
587 tree*);
590extern bool dr_known_forward_stride_p (struct data_reference *);
591
592/* Return true when the base objects of data references A and B are
593 the same memory object. */
594
595inline bool
601
602/* Return true when the data references A and B are accessing the same
603 memory object with the same access functions. Optionally skip the
604 last OFFSET dimensions in the data reference. */
605
606inline bool
608{
609 unsigned int i;
610
611 /* The references are exactly the same. */
612 if (operand_equal_p (DR_REF (a), DR_REF (b), 0))
613 return true;
614
616 return false;
617
618 for (i = offset; i < DR_NUM_DIMENSIONS (a); i++)
620 return false;
621
622 return true;
623}
624
625/* Returns true when all the dependences are computable. */
626
627inline bool
629{
630 ddr_p ddr;
631 unsigned int i;
632
635 return false;
636
637 return true;
638}
639
640/* Returns the dependence level for a vector DIST of size LENGTH.
641 LEVEL = 0 means a lexicographic dependence, i.e. a dependence due
642 to the sequence of statements, not carried by any loop. */
643
644inline unsigned
646{
647 int i;
648
649 for (i = 0; i < length; i++)
650 if (dist_vect[i] != 0)
651 return i + 1;
652
653 return 0;
654}
655
656/* Return the dependence level for the DDR relation. */
657
658inline unsigned
660{
661 unsigned vector;
662 unsigned level = 0;
663
664 if (DDR_DIST_VECTS (ddr).exists ())
666
667 for (vector = 1; vector < DDR_NUM_DIST_VECTS (ddr); vector++)
668 level = MIN (level, dependence_level (DDR_DIST_VECT (ddr, vector),
669 DDR_NB_LOOPS (ddr)));
670 return level;
671}
672
673/* Return the index of the variable VAR in the LOOP_NEST array. */
674
675inline int
677{
678 class loop *loopi;
679 int var_index;
680
681 for (var_index = 0; loop_nest.iterate (var_index, &loopi); var_index++)
682 if (loopi->num == var)
683 return var_index;
684
686}
687
688/* Returns true when the data reference DR the form "A[i] = ..."
689 with a stride equal to its unit type size. */
690
691inline bool
693{
694 /* If this is a bitfield store bail out. */
695 if (TREE_CODE (DR_REF (dr)) == COMPONENT_REF
696 && DECL_BIT_FIELD (TREE_OPERAND (DR_REF (dr), 1)))
697 return false;
698
699 if (!DR_STEP (dr)
700 || TREE_CODE (DR_STEP (dr)) != INTEGER_CST)
701 return false;
702
704 DR_STEP (dr)),
706}
707
708void split_constant_offset (tree , tree *, tree *);
709
710/* Compute the greatest common divisor of a VECTOR of SIZE numbers. */
711
712inline lambda_int
714{
715 int i;
716 lambda_int gcd1 = 0;
717
718 if (size > 0)
719 {
720 gcd1 = vector[0];
721 for (i = 1; i < size; i++)
722 gcd1 = gcd (gcd1, vector[i]);
723 }
724 return gcd1;
725}
726
727/* Allocate a new vector of given SIZE. */
728
729inline lambda_vector
731{
732 /* ??? We shouldn't abuse the GC allocator here. */
734}
735
736/* Clear out vector VEC1 of length SIZE. */
737
738inline void
740{
741 memset (vec1, 0, size * sizeof (*vec1));
742}
743
744/* Returns true when the vector V is lexicographically positive, in
745 other words, when the first nonzero element is positive. */
746
747inline bool
749 unsigned n)
750{
751 unsigned i;
752 for (i = 0; i < n; i++)
753 {
754 if (v[i] == 0)
755 continue;
756 if (v[i] < 0)
757 return false;
758 if (v[i] > 0)
759 return true;
760 }
761 return true;
762}
763
764/* Return true if vector VEC1 of length SIZE is the zero vector. */
765
766inline bool
768{
769 int i;
770 for (i = 0; i < size; i++)
771 if (vec1[i] != 0)
772 return false;
773 return true;
774}
775
776/* Allocate a matrix of M rows x N cols. */
777
778inline lambda_matrix
780{
782 int i;
783
785
786 for (i = 0; i < m; i++)
788
789 return mat;
790}
791
792#endif /* GCC_TREE_DATA_REF_H */
class loop * loop_p
Definition cfgloop.h:98
Definition tree-data-ref.h:307
sequencing
Definition tree-data-ref.h:311
@ REORDERED
Definition tree-data-ref.h:311
@ WELL_ORDERED
Definition tree-data-ref.h:311
dr_with_seg_len_pair_t(const dr_with_seg_len &, const dr_with_seg_len &, sequencing)
Definition tree-data-ref.h:322
dr_with_seg_len second
Definition tree-data-ref.h:317
dr_with_seg_len first
Definition tree-data-ref.h:316
unsigned int flags
Definition tree-data-ref.h:318
Definition tree-data-ref.h:212
poly_uint64 access_size
Definition tree-data-ref.h:224
unsigned int align
Definition tree-data-ref.h:227
data_reference_p dr
Definition tree-data-ref.h:218
tree seg_len
Definition tree-data-ref.h:221
dr_with_seg_len(data_reference_p d, tree len, unsigned HOST_WIDE_INT size, unsigned int a)
Definition tree-data-ref.h:214
Definition cfgloop.h:120
Definition opt-problem.h:179
bool debug
Definition collect-utils.cc:34
class edge_def * edge
Definition coretypes.h:342
union tree_node * tree
Definition coretypes.h:97
bool operand_equal_p(const_tree arg0, const_tree arg1, unsigned int flags)
Definition fold-const.cc:4223
#define fold_unary(CODE, T1, T2)
Definition fold-const.h:56
volatile double d2
Definition fp-test.cc:81
volatile double d1
Definition fp-test.cc:81
static struct obstack obstack
Definition gcc.cc:357
T * ggc_alloc(ALONE_CXX_MEM_STAT_INFO)
Definition ggc.h:184
HOST_WIDE_INT gcd(HOST_WIDE_INT a, HOST_WIDE_INT b)
Definition hwint.cc:132
i
Definition poly-int.h:772
Ca const poly_int< N, Cb > & b
Definition poly-int.h:767
Ca & a
Definition poly-int.h:766
rtx offset
Definition postreload.cc:691
Definition basic-block.h:117
Definition tree-data-ref.h:367
affine_fn fns[MAX_DIM]
Definition tree-data-ref.h:369
unsigned n
Definition tree-data-ref.h:368
Definition tree-data-ref.h:412
vec< lambda_vector > dir_vects
Definition tree-data-ref.h:446
vec< subscript_p > subscripts
Definition tree-data-ref.h:440
bool could_be_independent_p
Definition tree-data-ref.h:487
vec< loop_p > loop_nest
Definition tree-data-ref.h:443
struct data_reference * a
Definition tree-data-ref.h:414
struct data_reference * b
Definition tree-data-ref.h:415
tree are_dependent
Definition tree-data-ref.h:428
tree object_b
Definition tree-data-ref.h:435
bool affine_p
Definition tree-data-ref.h:456
bool self_reference_p
Definition tree-data-ref.h:460
tree object_a
Definition tree-data-ref.h:434
bool reversed_p
Definition tree-data-ref.h:452
vec< lambda_vector > dist_vects
Definition tree-data-ref.h:449
Definition tree-data-ref.h:151
tree ref
Definition tree-data-ref.h:156
struct dr_alias alias
Definition tree-data-ref.h:170
void * aux
Definition tree-data-ref.h:159
struct indices alt_indices
Definition tree-data-ref.h:181
bool is_read
Definition tree-data-ref.h:162
gimple * stmt
Definition tree-data-ref.h:153
bool is_conditional_in_stmt
Definition tree-data-ref.h:167
struct innermost_loop_behavior innermost
Definition tree-data-ref.h:173
Definition tree-data-ref.h:131
struct ptr_info_def * ptr_info
Definition tree-data-ref.h:134
Definition gimple.h:225
Definition tree-data-ref.h:118
vec< tree > access_fns
Definition tree-data-ref.h:123
bool unconstrained_base
Definition tree-data-ref.h:127
tree base_object
Definition tree-data-ref.h:120
Definition tree-data-ref.h:50
unsigned int base_misalignment
Definition tree-data-ref.h:90
tree base_address
Definition tree-data-ref.h:51
tree step
Definition tree-data-ref.h:54
tree offset
Definition tree-data-ref.h:52
tree init
Definition tree-data-ref.h:53
unsigned int base_alignment
Definition tree-data-ref.h:89
unsigned int step_alignment
Definition tree-data-ref.h:98
unsigned int offset_alignment
Definition tree-data-ref.h:95
Definition tree-ssanames.h:26
Definition tree-data-ref.h:380
tree access_fn[2]
Definition tree-data-ref.h:382
tree distance
Definition tree-data-ref.h:397
conflict_function * conflicting_iterations_in_a
Definition tree-data-ref.h:386
tree last_conflict
Definition tree-data-ref.h:391
conflict_function * conflicting_iterations_in_b
Definition tree-data-ref.h:387
Definition vec.h:450
#define gcc_unreachable()
Definition system.h:848
#define MIN(X, Y)
Definition system.h:392
bool eq_evolutions_p(const_tree chrec0, const_tree chrec1)
Definition tree-chrec.cc:1712
#define DDR_DIST_VECT(DDR, I)
Definition tree-data-ref.h:516
#define DR_IS_WRITE(DR)
Definition tree-data-ref.h:192
struct data_reference * create_data_ref(edge, loop_p, tree, gimple *, bool, bool)
Definition tree-data-ref.cc:1496
bool dr_known_forward_stride_p(struct data_reference *)
Definition tree-data-ref.cc:6430
bool lambda_vector_zerop(lambda_vector vec1, int size)
Definition tree-data-ref.h:767
lambda_vector * lambda_matrix
Definition tree-data-ref.h:146
tree find_data_references_in_loop(class loop *, vec< data_reference_p > *)
Definition tree-data-ref.cc:6061
bool lambda_vector_lexico_pos(lambda_vector v, unsigned n)
Definition tree-data-ref.h:748
lambda_vector lambda_vector_new(int size)
Definition tree-data-ref.h:730
void free_dependence_relation(struct data_dependence_relation *)
Definition tree-data-ref.cc:6307
#define DR_IS_READ(DR)
Definition tree-data-ref.h:191
bool known_dependences_p(vec< ddr_p > dependence_relations)
Definition tree-data-ref.h:628
void debug_ddrs(vec< ddr_p >)
Definition tree-data-ref.cc:562
#define DDR_DIST_VECTS(DDR)
Definition tree-data-ref.h:508
void debug_data_references(vec< data_reference_p >)
Definition tree-data-ref.cc:200
const unsigned int DR_ALIAS_UNSWAPPED
Definition tree-data-ref.h:300
bool compute_data_dependences_for_loop(class loop *, bool, vec< loop_p > *, vec< data_reference_p > *, vec< ddr_p > *)
Definition tree-data-ref.cc:6233
bool compute_all_dependences(const vec< data_reference_p > &, vec< ddr_p > *, const vec< loop_p > &, bool)
Definition tree-data-ref.cc:5739
tree find_data_references_in_bb(class loop *, basic_block, vec< data_reference_p > *)
Definition tree-data-ref.cc:6031
const unsigned int DR_ALIAS_WAW
Definition tree-data-ref.h:297
void prune_runtime_alias_test_list(vec< dr_with_seg_len_pair_t > *, poly_uint64)
Definition tree-data-ref.cc:1802
struct data_dependence_relation * initialize_data_dependence_relation(struct data_reference *, struct data_reference *, vec< loop_p >)
Definition tree-data-ref.cc:3470
void debug_data_dependence_relation(const data_dependence_relation *)
void compute_self_dependence(struct data_dependence_relation *)
lambda_int * lambda_vector
Definition tree-data-ref.h:142
void lambda_vector_clear(lambda_vector vec1, int size)
Definition tree-data-ref.h:739
void free_dependence_relations(vec< ddr_p > &)
Definition tree-data-ref.cc:6324
const unsigned int DR_ALIAS_ARBITRARY
Definition tree-data-ref.h:298
tree get_base_for_alignment(tree, unsigned int *)
Definition tree-data-ref.cc:6171
void dump_data_dependence_relations(FILE *, const vec< ddr_p > &)
Definition tree-data-ref.cc:491
bool dr_equal_offsets_p(struct data_reference *, struct data_reference *)
Definition tree-data-ref.cc:2724
bool graphite_find_data_references_in_stmt(edge, loop_p, gimple *, vec< data_reference_p > *)
Definition tree-data-ref.cc:6005
struct subscript * subscript_p
Definition tree-data-ref.h:400
#define DDR_NB_LOOPS(DDR)
Definition tree-data-ref.h:505
lambda_matrix lambda_matrix_new(int m, int n, struct obstack *lambda_obstack)
Definition tree-data-ref.h:779
opt_result dr_analyze_innermost(innermost_loop_behavior *, tree, class loop *, const gimple *)
Definition tree-data-ref.cc:1129
#define MAX_DIM
Definition tree-data-ref.h:355
#define DR_ACCESS_FN(DR, I)
Definition tree-data-ref.h:189
#define DR_REF(DR)
Definition tree-data-ref.h:185
const unsigned int DR_ALIAS_MIXED_STEPS
Definition tree-data-ref.h:301
unsigned dependence_level(lambda_vector dist_vect, int length)
Definition tree-data-ref.h:645
void debug_data_dependence_relations(vec< ddr_p >)
Definition tree-data-ref.cc:516
lambda_int lambda_vector_gcd(lambda_vector vector, int size)
Definition tree-data-ref.h:713
tree dr_zero_step_indicator(struct data_reference *)
Definition tree-data-ref.cc:6421
#define DR_BASE_OBJECT(DR)
Definition tree-data-ref.h:186
const unsigned int DR_ALIAS_RAW
Definition tree-data-ref.h:295
bool same_data_refs(data_reference_p a, data_reference_p b, int offset=0)
Definition tree-data-ref.h:607
void compute_affine_dependence(struct data_dependence_relation *, loop_p)
int index_in_loop_nest(int var, const vec< loop_p > &loop_nest)
Definition tree-data-ref.h:676
bool same_data_refs_base_objects(data_reference_p a, data_reference_p b)
Definition tree-data-ref.h:596
void create_runtime_alias_checks(class loop *, const vec< dr_with_seg_len_pair_t > *, tree *)
Definition tree-data-ref.cc:2666
opt_result runtime_alias_check_p(ddr_p, class loop *, bool)
Definition tree-data-ref.cc:1629
bool dr_may_alias_p(const struct data_reference *, const struct data_reference *, class loop *)
Definition tree-data-ref.cc:2978
int data_ref_compare_tree(tree, tree)
Definition tree-data-ref.cc:1554
void free_data_ref(data_reference_p)
Definition tree-data-ref.cc:1477
void free_data_refs(vec< data_reference_p > &)
Definition tree-data-ref.cc:6336
struct data_dependence_relation * ddr_p
Definition tree-data-ref.h:490
#define DR_STEP(DR)
Definition tree-data-ref.h:197
void split_constant_offset(tree, tree *, tree *)
Definition tree-data-ref.cc:1075
unsigned ddr_dependence_level(ddr_p ddr)
Definition tree-data-ref.h:659
void dump_data_reference(FILE *, struct data_reference *)
Definition tree-data-ref.cc:216
unsigned int dr_alignment(innermost_loop_behavior *)
Definition tree-data-ref.cc:6088
bool find_loop_nest(class loop *, vec< loop_p > *)
Definition tree-data-ref.cc:6217
bool loop_nest_has_data_refs(loop_p loop)
Definition tree-data-ref.cc:5946
#define DDR_ARE_DEPENDENT(DDR)
Definition tree-data-ref.h:495
void debug_data_reference(struct data_reference *)
Definition tree-data-ref.cc:208
bool adjacent_dr_p(struct data_reference *dr)
Definition tree-data-ref.h:692
opt_result find_data_references_in_stmt(class loop *, gimple *, vec< data_reference_p > *)
Definition tree-data-ref.cc:5976
struct data_reference * data_reference_p
Definition tree-data-ref.h:205
data_dependence_direction
Definition tree-data-ref.h:338
@ dir_positive
Definition tree-data-ref.h:339
@ dir_positive_or_equal
Definition tree-data-ref.h:343
@ dir_star
Definition tree-data-ref.h:345
@ dir_negative
Definition tree-data-ref.h:340
@ dir_positive_or_negative
Definition tree-data-ref.h:342
@ dir_independent
Definition tree-data-ref.h:346
@ dir_negative_or_equal
Definition tree-data-ref.h:344
@ dir_equal
Definition tree-data-ref.h:341
#define DDR_NUM_DIST_VECTS(DDR)
Definition tree-data-ref.h:510
const unsigned int DR_ALIAS_WAR
Definition tree-data-ref.h:296
const unsigned int DR_ALIAS_SWAPPED
Definition tree-data-ref.h:299
HOST_WIDE_INT lambda_int
Definition tree-data-ref.h:141
tree dr_direction_indicator(struct data_reference *)
Definition tree-data-ref.cc:6413
vec< tree > affine_fn
Definition tree-data-ref.h:364
#define DR_NUM_DIMENSIONS(DR)
Definition tree-data-ref.h:190
#define DR_INNERMOST(DR)
Definition tree-data-ref.h:203
bool tree_int_cst_equal(const_tree t1, const_tree t2)
Definition tree.cc:6376
#define chrec_dont_know
Definition tree.h:4628
#define TREE_OPERAND(NODE, I)
Definition tree.h:1285
#define TYPE_SIZE_UNIT(NODE)
Definition tree.h:2242
#define TREE_CODE(NODE)
Definition tree.h:324
#define DECL_BIT_FIELD(NODE)
Definition tree.h:3051
#define TREE_TYPE(NODE)
Definition tree.h:512
#define FOR_EACH_VEC_ELT(V, I, P)
Definition vec.h:1884