Remove trailing white spaces.

2009-11-25  H.J. Lu  <hongjiu.lu@intel.com>

	* alias.c: Remove trailing white spaces.
	* alloc-pool.c: Likewise.
	* alloc-pool.h: Likewise.
	* attribs.c: Likewise.
	* auto-inc-dec.c: Likewise.
	* basic-block.h: Likewise.
	* bb-reorder.c: Likewise.
	* bt-load.c: Likewise.
	* builtins.c: Likewise.
	* builtins.def: Likewise.
	* c-common.c: Likewise.
	* c-common.h: Likewise.
	* c-cppbuiltin.c: Likewise.
	* c-decl.c: Likewise.
	* c-format.c: Likewise.
	* c-lex.c: Likewise.
	* c-omp.c: Likewise.
	* c-opts.c: Likewise.
	* c-parser.c: Likewise.
	* c-pretty-print.c: Likewise.
	* c-tree.h: Likewise.
	* c-typeck.c: Likewise.
	* caller-save.c: Likewise.
	* calls.c: Likewise.
	* cfg.c: Likewise.
	* cfganal.c: Likewise.
	* cfgexpand.c: Likewise.
	* cfghooks.c: Likewise.
	* cfghooks.h: Likewise.
	* cfglayout.c: Likewise.
	* cfgloop.c: Likewise.
	* cfgloop.h: Likewise.
	* cfgloopmanip.c: Likewise.
	* cfgrtl.c: Likewise.
	* cgraph.c: Likewise.
	* cgraph.h: Likewise.
	* cgraphbuild.c: Likewise.
	* cgraphunit.c: Likewise.
	* cif-code.def: Likewise.
	* collect2.c: Likewise.
	* combine.c: Likewise.
	* convert.c: Likewise.
	* coverage.c: Likewise.
	* crtstuff.c: Likewise.
	* cse.c: Likewise.
	* cselib.c: Likewise.
	* dbgcnt.c: Likewise.
	* dbgcnt.def: Likewise.
	* dbgcnt.h: Likewise.
	* dbxout.c: Likewise.
	* dce.c: Likewise.
	* ddg.c: Likewise.
	* ddg.h: Likewise.
	* defaults.h: Likewise.
	* df-byte-scan.c: Likewise.
	* df-core.c: Likewise.
	* df-problems.c: Likewise.
	* df-scan.c: Likewise.
	* df.h: Likewise.
	* dfp.c: Likewise.
	* diagnostic.c: Likewise.
	* diagnostic.h: Likewise.
	* dominance.c: Likewise.
	* domwalk.c: Likewise.
	* double-int.c: Likewise.
	* double-int.h: Likewise.
	* dse.c: Likewise.
	* dwarf2asm.c: Likewise.
	* dwarf2asm.h: Likewise.
	* dwarf2out.c: Likewise.
	* ebitmap.c: Likewise.
	* ebitmap.h: Likewise.
	* emit-rtl.c: Likewise.
	* et-forest.c: Likewise.
	* except.c: Likewise.
	* except.h: Likewise.
	* expmed.c: Likewise.
	* expr.c: Likewise.
	* expr.h: Likewise.
	* final.c: Likewise.
	* flags.h: Likewise.
	* fold-const.c: Likewise.
	* function.c: Likewise.
	* function.h: Likewise.
	* fwprop.c: Likewise.
	* gcc.c: Likewise.
	* gcov-dump.c: Likewise.
	* gcov-io.c: Likewise.
	* gcov-io.h: Likewise.
	* gcov.c: Likewise.
	* gcse.c: Likewise.
	* genattr.c: Likewise.
	* genattrtab.c: Likewise.
	* genautomata.c: Likewise.
	* genchecksum.c: Likewise.
	* genconfig.c: Likewise.
	* genflags.c: Likewise.
	* gengtype-parse.c: Likewise.
	* gengtype.c: Likewise.
	* gengtype.h: Likewise.
	* genmddeps.c: Likewise.
	* genmodes.c: Likewise.
	* genopinit.c: Likewise.
	* genpreds.c: Likewise.
	* gensupport.c: Likewise.
	* ggc-common.c: Likewise.
	* ggc-page.c: Likewise.
	* ggc-zone.c: Likewise.
	* ggc.h: Likewise.
	* gimple-iterator.c: Likewise.
	* gimple-low.c: Likewise.
	* gimple-pretty-print.c: Likewise.
	* gimple.c: Likewise.
	* gimple.def: Likewise.
	* gimple.h: Likewise.
	* gimplify.c: Likewise.
	* graphds.c: Likewise.
	* graphite-clast-to-gimple.c: Likewise.
	* gthr-nks.h: Likewise.
	* gthr-posix.c: Likewise.
	* gthr-posix.h: Likewise.
	* gthr-posix95.h: Likewise.
	* gthr-single.h: Likewise.
	* gthr-tpf.h: Likewise.
	* gthr-vxworks.h: Likewise.
	* gthr.h: Likewise.
	* haifa-sched.c: Likewise.
	* hard-reg-set.h: Likewise.
	* hooks.c: Likewise.
	* hooks.h: Likewise.
	* hosthooks.h: Likewise.
	* hwint.h: Likewise.
	* ifcvt.c: Likewise.
	* incpath.c: Likewise.
	* init-regs.c: Likewise.
	* integrate.c: Likewise.
	* ipa-cp.c: Likewise.
	* ipa-inline.c: Likewise.
	* ipa-prop.c: Likewise.
	* ipa-pure-const.c: Likewise.
	* ipa-reference.c: Likewise.
	* ipa-struct-reorg.c: Likewise.
	* ipa-struct-reorg.h: Likewise.
	* ipa-type-escape.c: Likewise.
	* ipa-type-escape.h: Likewise.
	* ipa-utils.c: Likewise.
	* ipa-utils.h: Likewise.
	* ipa.c: Likewise.
	* ira-build.c: Likewise.
	* ira-color.c: Likewise.
	* ira-conflicts.c: Likewise.
	* ira-costs.c: Likewise.
	* ira-emit.c: Likewise.
	* ira-int.h: Likewise.
	* ira-lives.c: Likewise.
	* ira.c: Likewise.
	* jump.c: Likewise.
	* lambda-code.c: Likewise.
	* lambda-mat.c: Likewise.
	* lambda-trans.c: Likewise.
	* lambda.h: Likewise.
	* langhooks.c: Likewise.
	* lcm.c: Likewise.
	* libgcov.c: Likewise.
	* lists.c: Likewise.
	* loop-doloop.c: Likewise.
	* loop-init.c: Likewise.
	* loop-invariant.c: Likewise.
	* loop-iv.c: Likewise.
	* loop-unroll.c: Likewise.
	* lower-subreg.c: Likewise.
	* lto-cgraph.c: Likewise.
	* lto-compress.c: Likewise.
	* lto-opts.c: Likewise.
	* lto-section-in.c: Likewise.
	* lto-section-out.c: Likewise.
	* lto-streamer-in.c: Likewise.
	* lto-streamer-out.c: Likewise.
	* lto-streamer.c: Likewise.
	* lto-streamer.h: Likewise.
	* lto-symtab.c: Likewise.
	* lto-wpa-fixup.c: Likewise.
	* matrix-reorg.c: Likewise.
	* mcf.c: Likewise.
	* mode-switching.c: Likewise.
	* modulo-sched.c: Likewise.
	* omega.c: Likewise.
	* omega.h: Likewise.
	* omp-low.c: Likewise.
	* optabs.c: Likewise.
	* optabs.h: Likewise.
	* opts-common.c: Likewise.
	* opts.c: Likewise.
	* params.def: Likewise.
	* params.h: Likewise.
	* passes.c: Likewise.
	* plugin.c: Likewise.
	* postreload-gcse.c: Likewise.
	* postreload.c: Likewise.
	* predict.c: Likewise.
	* predict.def: Likewise.
	* pretty-print.c: Likewise.
	* pretty-print.h: Likewise.
	* print-rtl.c: Likewise.
	* print-tree.c: Likewise.
	* profile.c: Likewise.
	* read-rtl.c: Likewise.
	* real.c: Likewise.
	* recog.c: Likewise.
	* reg-stack.c: Likewise.
	* regcprop.c: Likewise.
	* reginfo.c: Likewise.
	* regmove.c: Likewise.
	* regrename.c: Likewise.
	* regs.h: Likewise.
	* regstat.c: Likewise.
	* reload.c: Likewise.
	* reload1.c: Likewise.
	* resource.c: Likewise.
	* rtl.c: Likewise.
	* rtl.def: Likewise.
	* rtl.h: Likewise.
	* rtlanal.c: Likewise.
	* sbitmap.c: Likewise.
	* sched-deps.c: Likewise.
	* sched-ebb.c: Likewise.
	* sched-int.h: Likewise.
	* sched-rgn.c: Likewise.
	* sched-vis.c: Likewise.
	* sdbout.c: Likewise.
	* sel-sched-dump.c: Likewise.
	* sel-sched-dump.h: Likewise.
	* sel-sched-ir.c: Likewise.
	* sel-sched-ir.h: Likewise.
	* sel-sched.c: Likewise.
	* sel-sched.h: Likewise.
	* sese.c: Likewise.
	* sese.h: Likewise.
	* simplify-rtx.c: Likewise.
	* stack-ptr-mod.c: Likewise.
	* stmt.c: Likewise.
	* stor-layout.c: Likewise.
	* store-motion.c: Likewise.
	* stringpool.c: Likewise.
	* stub-objc.c: Likewise.
	* sync-builtins.def: Likewise.
	* target-def.h: Likewise.
	* target.h: Likewise.
	* targhooks.c: Likewise.
	* targhooks.h: Likewise.
	* timevar.c: Likewise.
	* tlink.c: Likewise.
	* toplev.c: Likewise.
	* toplev.h: Likewise.
	* tracer.c: Likewise.
	* tree-affine.c: Likewise.
	* tree-affine.h: Likewise.
	* tree-browser.def: Likewise.
	* tree-call-cdce.c: Likewise.
	* tree-cfg.c: Likewise.
	* tree-cfgcleanup.c: Likewise.
	* tree-chrec.c: Likewise.
	* tree-chrec.h: Likewise.
	* tree-complex.c: Likewise.
	* tree-data-ref.c: Likewise.
	* tree-data-ref.h: Likewise.
	* tree-dfa.c: Likewise.
	* tree-dump.c: Likewise.
	* tree-dump.h: Likewise.
	* tree-eh.c: Likewise.
	* tree-flow-inline.h: Likewise.
	* tree-flow.h: Likewise.
	* tree-if-conv.c: Likewise.
	* tree-inline.c: Likewise.
	* tree-into-ssa.c: Likewise.
	* tree-loop-distribution.c: Likewise.
	* tree-loop-linear.c: Likewise.
	* tree-mudflap.c: Likewise.
	* tree-nested.c: Likewise.
	* tree-nomudflap.c: Likewise.
	* tree-nrv.c: Likewise.
	* tree-object-size.c: Likewise.
	* tree-optimize.c: Likewise.
	* tree-outof-ssa.c: Likewise.
	* tree-parloops.c: Likewise.
	* tree-pass.h: Likewise.
	* tree-phinodes.c: Likewise.
	* tree-predcom.c: Likewise.
	* tree-pretty-print.c: Likewise.
	* tree-profile.c: Likewise.
	* tree-scalar-evolution.c: Likewise.
	* tree-ssa-address.c: Likewise.
	* tree-ssa-alias.c: Likewise.
	* tree-ssa-ccp.c: Likewise.
	* tree-ssa-coalesce.c: Likewise.
	* tree-ssa-copy.c: Likewise.
	* tree-ssa-copyrename.c: Likewise.
	* tree-ssa-dce.c: Likewise.
	* tree-ssa-dom.c: Likewise.
	* tree-ssa-dse.c: Likewise.
	* tree-ssa-forwprop.c: Likewise.
	* tree-ssa-ifcombine.c: Likewise.
	* tree-ssa-live.c: Likewise.
	* tree-ssa-live.h: Likewise.
	* tree-ssa-loop-ch.c: Likewise.
	* tree-ssa-loop-im.c: Likewise.
	* tree-ssa-loop-ivcanon.c: Likewise.
	* tree-ssa-loop-ivopts.c: Likewise.
	* tree-ssa-loop-manip.c: Likewise.
	* tree-ssa-loop-niter.c: Likewise.
	* tree-ssa-loop-prefetch.c: Likewise.
	* tree-ssa-loop-unswitch.c: Likewise.
	* tree-ssa-loop.c: Likewise.
	* tree-ssa-math-opts.c: Likewise.
	* tree-ssa-operands.c: Likewise.
	* tree-ssa-operands.h: Likewise.
	* tree-ssa-phiopt.c: Likewise.
	* tree-ssa-phiprop.c: Likewise.
	* tree-ssa-pre.c: Likewise.
	* tree-ssa-propagate.c: Likewise.
	* tree-ssa-reassoc.c: Likewise.
	* tree-ssa-sccvn.c: Likewise.
	* tree-ssa-sink.c: Likewise.
	* tree-ssa-structalias.c: Likewise.
	* tree-ssa-ter.c: Likewise.
	* tree-ssa-threadedge.c: Likewise.
	* tree-ssa-threadupdate.c: Likewise.
	* tree-ssa-uncprop.c: Likewise.
	* tree-ssa.c: Likewise.
	* tree-ssanames.c: Likewise.
	* tree-switch-conversion.c: Likewise.
	* tree-tailcall.c: Likewise.
	* tree-vect-data-refs.c: Likewise.
	* tree-vect-generic.c: Likewise.
	* tree-vect-loop-manip.c: Likewise.
	* tree-vect-loop.c: Likewise.
	* tree-vect-patterns.c: Likewise.
	* tree-vect-slp.c: Likewise.
	* tree-vect-stmts.c: Likewise.
	* tree-vectorizer.c: Likewise.
	* tree-vectorizer.h: Likewise.
	* tree-vrp.c: Likewise.
	* tree.c: Likewise.
	* tree.def: Likewise.
	* tree.h: Likewise.
	* treestruct.def: Likewise.
	* unwind-compat.c: Likewise.
	* unwind-dw2-fde-glibc.c: Likewise.
	* unwind-dw2.c: Likewise.
	* value-prof.c: Likewise.
	* value-prof.h: Likewise.
	* var-tracking.c: Likewise.
	* varasm.c: Likewise.
	* varpool.c: Likewise.
	* vec.c: Likewise.
	* vec.h: Likewise.
	* vmsdbgout.c: Likewise.
	* web.c: Likewise.
	* xcoffout.c: Likewise.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@154645 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 279 insertions, 279 deletions

diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index ae0a0681479..1b0421c5ef0 100644
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -21,57 +21,57 @@ along with GCC; see the file COPYING3.  If not see
 
 /* This pass walks a given loop structure searching for array
    references.  The information about the array accesses is recorded
-   in DATA_REFERENCE structures. 
-   
-   The basic test for determining the dependences is: 
-   given two access functions chrec1 and chrec2 to a same array, and 
-   x and y two vectors from the iteration domain, the same element of 
+   in DATA_REFERENCE structures.
+
+   The basic test for determining the dependences is:
+   given two access functions chrec1 and chrec2 to a same array, and
+   x and y two vectors from the iteration domain, the same element of
    the array is accessed twice at iterations x and y if and only if:
    |             chrec1 (x) == chrec2 (y).
-   
+
    The goals of this analysis are:
-   
+
    - to determine the independence: the relation between two
      independent accesses is qualified with the chrec_known (this
      information allows a loop parallelization),
-     
+
    - when two data references access the same data, to qualify the
      dependence relation with classic dependence representations:
-     
+
        - distance vectors
        - direction vectors
        - loop carried level dependence
        - polyhedron dependence
      or with the chains of recurrences based representation,
-     
-   - to define a knowledge base for storing the data dependence 
+
+   - to define a knowledge base for storing the data dependence
      information,
-     
+
    - to define an interface to access this data.
-   
-   
+
+
    Definitions:
-   
+
    - subscript: given two array accesses a subscript is the tuple
    composed of the access functions for a given dimension.  Example:
    Given A[f1][f2][f3] and B[g1][g2][g3], there are three subscripts:
    (f1, g1), (f2, g2), (f3, g3).
 
    - Diophantine equation: an equation whose coefficients and
-   solutions are integer constants, for example the equation 
+   solutions are integer constants, for example the equation
    |   3*x + 2*y = 1
    has an integer solution x = 1 and y = -1.
-     
+
    References:
-   
+
    - "Advanced Compilation for High Performance Computing" by Randy
    Allen and Ken Kennedy.
-   http://citeseer.ist.psu.edu/goff91practical.html 
-   
-   - "Loop Transformations for Restructuring Compilers - The Foundations" 
+   http://citeseer.ist.psu.edu/goff91practical.html
+
+   - "Loop Transformations for Restructuring Compilers - The Foundations"
    by Utpal Banerjee.
 
-   
+
 */
 
 #include "config.h"
@@ -127,7 +127,7 @@ static bool subscript_dependence_tester_1 (struct data_dependence_relation *,
 					   struct loop *);
 /* Returns true iff A divides B.  */
 
-static inline bool 
+static inline bool
 tree_fold_divides_p (const_tree a, const_tree b)
 {
   gcc_assert (TREE_CODE (a) == INTEGER_CST);
@@ -137,7 +137,7 @@ tree_fold_divides_p (const_tree a, const_tree b)
 
 /* Returns true iff A divides B.  */
 
-static inline bool 
+static inline bool
 int_divides_p (int a, int b)
 {
   return ((b % a) == 0);
@@ -145,9 +145,9 @@ int_divides_p (int a, int b)
 
 
 
-/* Dump into FILE all the data references from DATAREFS.  */ 
+/* Dump into FILE all the data references from DATAREFS.  */
 
-void 
+void
 dump_data_references (FILE *file, VEC (data_reference_p, heap) *datarefs)
 {
   unsigned int i;
@@ -157,26 +157,26 @@ dump_data_references (FILE *file, VEC (data_reference_p, heap) *datarefs)
     dump_data_reference (file, dr);
 }
 
-/* Dump into STDERR all the data references from DATAREFS.  */ 
+/* Dump into STDERR all the data references from DATAREFS.  */
 
-void 
+void
 debug_data_references (VEC (data_reference_p, heap) *datarefs)
 {
   dump_data_references (stderr, datarefs);
 }
 
-/* Dump to STDERR all the dependence relations from DDRS.  */ 
+/* Dump to STDERR all the dependence relations from DDRS.  */
 
-void 
+void
 debug_data_dependence_relations (VEC (ddr_p, heap) *ddrs)
 {
   dump_data_dependence_relations (stderr, ddrs);
 }
 
-/* Dump into FILE all the dependence relations from DDRS.  */ 
+/* Dump into FILE all the dependence relations from DDRS.  */
 
-void 
-dump_data_dependence_relations (FILE *file, 
+void
+dump_data_dependence_relations (FILE *file,
 				VEC (ddr_p, heap) *ddrs)
 {
   unsigned int i;
@@ -188,7 +188,7 @@ dump_data_dependence_relations (FILE *file,
 
 /* Print to STDERR the data_reference DR.  */
 
-void 
+void
 debug_data_reference (struct data_reference *dr)
 {
   dump_data_reference (stderr, dr);
@@ -196,19 +196,19 @@ debug_data_reference (struct data_reference *dr)
 
 /* Dump function for a DATA_REFERENCE structure.  */
 
-void 
-dump_data_reference (FILE *outf, 
+void
+dump_data_reference (FILE *outf,
 		     struct data_reference *dr)
 {
   unsigned int i;
-  
+
   fprintf (outf, "(Data Ref: \n  stmt: ");
   print_gimple_stmt (outf, DR_STMT (dr), 0, 0);
   fprintf (outf, "  ref: ");
   print_generic_stmt (outf, DR_REF (dr), 0);
   fprintf (outf, "  base_object: ");
   print_generic_stmt (outf, DR_BASE_OBJECT (dr), 0);
-  
+
   for (i = 0; i < DR_NUM_DIMENSIONS (dr); i++)
     {
       fprintf (outf, "  Access function %d: ", i);
@@ -258,7 +258,7 @@ dump_conflict_function (FILE *outf, conflict_function *cf)
 
 /* Dump function for a SUBSCRIPT structure.  */
 
-void 
+void
 dump_subscript (FILE *outf, struct subscript *subscript)
 {
   conflict_function *cf = SUB_CONFLICTS_IN_A (subscript);
@@ -272,7 +272,7 @@ dump_subscript (FILE *outf, struct subscript *subscript)
       fprintf (outf, "  last_conflict: ");
       print_generic_stmt (outf, last_iteration, 0);
     }
-	  
+
   cf = SUB_CONFLICTS_IN_B (subscript);
   fprintf (outf, "  iterations_that_access_an_element_twice_in_B: ");
   dump_conflict_function (outf, cf);
@@ -362,7 +362,7 @@ print_dist_vectors  (FILE *outf, VEC (lambda_vector, heap) *dist_vects,
 
 /* Debug version.  */
 
-void 
+void
 debug_data_dependence_relation (struct data_dependence_relation *ddr)
 {
   dump_data_dependence_relation (stderr, ddr);
@@ -370,8 +370,8 @@ debug_data_dependence_relation (struct data_dependence_relation *ddr)
 
 /* Dump function for a DATA_DEPENDENCE_RELATION structure.  */
 
-void 
-dump_data_dependence_relation (FILE *outf, 
+void
+dump_data_dependence_relation (FILE *outf,
 			       struct data_dependence_relation *ddr)
 {
   struct data_reference *dra, *drb;
@@ -391,7 +391,7 @@ dump_data_dependence_relation (FILE *outf,
 
   if (DDR_ARE_DEPENDENT (ddr) == chrec_known)
     fprintf (outf, "    (no dependence)\n");
-  
+
   else if (DDR_ARE_DEPENDENT (ddr) == NULL_TREE)
     {
       unsigned int i;
@@ -433,40 +433,40 @@ dump_data_dependence_relation (FILE *outf,
 /* Dump function for a DATA_DEPENDENCE_DIRECTION structure.  */
 
 void
-dump_data_dependence_direction (FILE *file, 
+dump_data_dependence_direction (FILE *file,
 				enum data_dependence_direction dir)
 {
   switch (dir)
     {
-    case dir_positive: 
+    case dir_positive:
       fprintf (file, "+");
       break;
-      
+
     case dir_negative:
       fprintf (file, "-");
       break;
-      
+
     case dir_equal:
       fprintf (file, "=");
       break;
-      
+
     case dir_positive_or_negative:
       fprintf (file, "+-");
       break;
-      
-    case dir_positive_or_equal: 
+
+    case dir_positive_or_equal:
       fprintf (file, "+=");
       break;
-      
-    case dir_negative_or_equal: 
+
+    case dir_negative_or_equal:
       fprintf (file, "-=");
       break;
-      
-    case dir_star: 
-      fprintf (file, "*"); 
+
+    case dir_star:
+      fprintf (file, "*");
       break;
-      
-    default: 
+
+    default:
       break;
     }
 }
@@ -476,7 +476,7 @@ dump_data_dependence_direction (FILE *file,
    dependence vectors, or in other words the number of loops in the
    considered nest.  */
 
-void 
+void
 dump_dist_dir_vectors (FILE *file, VEC (ddr_p, heap) *ddrs)
 {
   unsigned int i, j;
@@ -506,7 +506,7 @@ dump_dist_dir_vectors (FILE *file, VEC (ddr_p, heap) *ddrs)
 
 /* Dumps the data dependence relations DDRS in FILE.  */
 
-void 
+void
 dump_ddrs (FILE *file, VEC (ddr_p, heap) *ddrs)
 {
   unsigned int i;
@@ -684,7 +684,7 @@ canonicalize_base_object_address (tree addr)
   return build_fold_addr_expr (TREE_OPERAND (addr, 0));
 }
 
-/* Analyzes the behavior of the memory reference DR in the innermost loop or 
+/* Analyzes the behavior of the memory reference DR in the innermost loop or
    basic block that contains it. Returns true if analysis succeed or false
    otherwise.  */
 
@@ -719,7 +719,7 @@ dr_analyze_innermost (struct data_reference *dr)
   base = build_fold_addr_expr (base);
   if (in_loop)
     {
-      if (!simple_iv (loop, loop_containing_stmt (stmt), base, &base_iv, 
+      if (!simple_iv (loop, loop_containing_stmt (stmt), base, &base_iv,
                       false))
         {
           if (dump_file && (dump_flags & TDF_DETAILS))
@@ -792,10 +792,10 @@ dr_analyze_indices (struct data_reference *dr, struct loop *nest)
   tree ref = unshare_expr (DR_REF (dr)), aref = ref, op;
   tree base, off, access_fn = NULL_TREE;
   basic_block before_loop = NULL;
- 
+
   if (nest)
     before_loop = block_before_loop (nest);
-    
+
   while (handled_component_p (aref))
     {
       if (TREE_CODE (aref) == ARRAY_REF)
@@ -810,7 +810,7 @@ dr_analyze_indices (struct data_reference *dr, struct loop *nest)
 
 	  TREE_OPERAND (aref, 1) = build_int_cst (TREE_TYPE (op), 0);
 	}
-      
+
       aref = TREE_OPERAND (aref, 0);
     }
 
@@ -915,7 +915,7 @@ create_data_ref (struct loop *nest, tree memref, gimple stmt, bool is_read)
       fprintf (dump_file, "\n");
     }
 
-  return dr;  
+  return dr;
 }
 
 /* Returns true if FNA == FNB.  */
@@ -1030,7 +1030,7 @@ affine_fn_op (enum tree_code op, affine_fn fna, affine_fn fnb)
 
       VEC_quick_push (tree, ret,
 		      fold_build2 (op, type,
-				   VEC_index (tree, fna, i), 
+				   VEC_index (tree, fna, i),
 				   VEC_index (tree, fnb, i)));
     }
 
@@ -1082,11 +1082,11 @@ compute_subscript_distance (struct data_dependence_relation *ddr)
   if (DDR_ARE_DEPENDENT (ddr) == NULL_TREE)
     {
       unsigned int i;
-      
+
       for (i = 0; i < DDR_NUM_SUBSCRIPTS (ddr); i++)
  	{
  	  struct subscript *subscript;
- 	  
+
  	  subscript = DDR_SUBSCRIPT (ddr, i);
  	  cf_a = SUB_CONFLICTS_IN_A (subscript);
  	  cf_b = SUB_CONFLICTS_IN_B (subscript);
@@ -1099,7 +1099,7 @@ compute_subscript_distance (struct data_dependence_relation *ddr)
 	      return;
 	    }
 	  diff = affine_fn_minus (fn_a, fn_b);
- 	  
+
  	  if (affine_function_constant_p (diff))
  	    SUB_DISTANCE (subscript) = affine_function_base (diff);
  	  else
@@ -1290,8 +1290,8 @@ dr_may_alias_p (const struct data_reference *a, const struct data_reference *b)
       && TREE_CODE (addr_b) == ADDR_EXPR)
     return TREE_OPERAND (addr_a, 0) == TREE_OPERAND (addr_b, 0);
 
-  /* An instruction writing through a restricted pointer is "independent" of any 
-     instruction reading or writing through a different restricted pointer, 
+  /* An instruction writing through a restricted pointer is "independent" of any
+     instruction reading or writing through a different restricted pointer,
      in the same block/scope.  */
 
   type_a = TREE_TYPE (addr_a);
@@ -1303,7 +1303,7 @@ dr_may_alias_p (const struct data_reference *a, const struct data_reference *b)
   if (TREE_CODE (addr_b) == SSA_NAME)
     decl_b = SSA_NAME_VAR (addr_b);
 
-  if (TYPE_RESTRICT (type_a) && TYPE_RESTRICT (type_b) 
+  if (TYPE_RESTRICT (type_a) && TYPE_RESTRICT (type_b)
       && (!DR_IS_READ (a) || !DR_IS_READ (b))
       && decl_a && DECL_P (decl_a)
       && decl_b && DECL_P (decl_b)
@@ -1322,13 +1322,13 @@ static void compute_self_dependence (struct data_dependence_relation *);
    size of the classic distance/direction vectors.  */
 
 static struct data_dependence_relation *
-initialize_data_dependence_relation (struct data_reference *a, 
+initialize_data_dependence_relation (struct data_reference *a,
 				     struct data_reference *b,
  				     VEC (loop_p, heap) *loop_nest)
 {
   struct data_dependence_relation *res;
   unsigned int i;
-  
+
   res = XNEW (struct data_dependence_relation);
   DDR_A (res) = a;
   DDR_B (res) = b;
@@ -1340,14 +1340,14 @@ initialize_data_dependence_relation (struct data_reference *a,
 
   if (a == NULL || b == NULL)
     {
-      DDR_ARE_DEPENDENT (res) = chrec_dont_know;    
+      DDR_ARE_DEPENDENT (res) = chrec_dont_know;
       return res;
-    }   
+    }
 
   /* If the data references do not alias, then they are independent.  */
   if (!dr_may_alias_p (a, b))
     {
-      DDR_ARE_DEPENDENT (res) = chrec_known;    
+      DDR_ARE_DEPENDENT (res) = chrec_known;
       return res;
     }
 
@@ -1369,18 +1369,18 @@ initialize_data_dependence_relation (struct data_reference *a,
      whether they alias or not.  */
   if (!operand_equal_p (DR_BASE_OBJECT (a), DR_BASE_OBJECT (b), 0))
     {
-      DDR_ARE_DEPENDENT (res) = chrec_dont_know;    
+      DDR_ARE_DEPENDENT (res) = chrec_dont_know;
       return res;
     }
 
   /* If the base of the object is not invariant in the loop nest, we cannot
      analyze it.  TODO -- in fact, it would suffice to record that there may
      be arbitrary dependences in the loops where the base object varies.  */
-  if (loop_nest 
+  if (loop_nest
       && !object_address_invariant_in_loop_p (VEC_index (loop_p, loop_nest, 0),
      					      DR_BASE_OBJECT (a)))
     {
-      DDR_ARE_DEPENDENT (res) = chrec_dont_know;    
+      DDR_ARE_DEPENDENT (res) = chrec_dont_know;
       return res;
     }
 
@@ -1396,7 +1396,7 @@ initialize_data_dependence_relation (struct data_reference *a,
   for (i = 0; i < DR_NUM_DIMENSIONS (a); i++)
     {
       struct subscript *subscript;
-	  
+
       subscript = XNEW (struct subscript);
       SUB_CONFLICTS_IN_A (subscript) = conflict_fn_not_known ();
       SUB_CONFLICTS_IN_B (subscript) = conflict_fn_not_known ();
@@ -1444,7 +1444,7 @@ free_subscripts (VEC (subscript_p, heap) *subscripts)
    description.  */
 
 static inline void
-finalize_ddr_dependent (struct data_dependence_relation *ddr, 
+finalize_ddr_dependent (struct data_dependence_relation *ddr,
 			tree chrec)
 {
   if (dump_file && (dump_flags & TDF_DETAILS))
@@ -1454,7 +1454,7 @@ finalize_ddr_dependent (struct data_dependence_relation *ddr,
       fprintf (dump_file, ")\n");
     }
 
-  DDR_ARE_DEPENDENT (ddr) = chrec;  
+  DDR_ARE_DEPENDENT (ddr) = chrec;
   free_subscripts (DDR_SUBSCRIPTS (ddr));
   DDR_SUBSCRIPTS (ddr) = NULL;
 }
@@ -1496,7 +1496,7 @@ siv_subscript_p (const_tree chrec_a, const_tree chrec_b)
       || (evolution_function_is_constant_p (chrec_b)
 	  && evolution_function_is_univariate_p (chrec_a)))
     return true;
-  
+
   if (evolution_function_is_univariate_p (chrec_a)
       && evolution_function_is_univariate_p (chrec_b))
     {
@@ -1508,16 +1508,16 @@ siv_subscript_p (const_tree chrec_a, const_tree chrec_b)
 	    case POLYNOMIAL_CHREC:
 	      if (CHREC_VARIABLE (chrec_a) != CHREC_VARIABLE (chrec_b))
 		return false;
-	      
+
 	    default:
 	      return true;
 	    }
-	  
+
 	default:
 	  return true;
 	}
     }
-  
+
   return false;
 }
 
@@ -1533,7 +1533,7 @@ conflict_fn (unsigned n, ...)
 
   gcc_assert (0 < n && n <= MAX_DIM);
   va_start(ap, n);
-		       
+
   ret->n = n;
   for (i = 0; i < n; i++)
     ret->fns[i] = va_arg (ap, affine_fn);
@@ -1575,16 +1575,16 @@ affine_fn_univar (tree cst, unsigned dim, tree coef)
 
    CHREC_A (*OVERLAPS_A (k)) = CHREC_B (*OVERLAPS_B (k)).  */
 
-static void 
-analyze_ziv_subscript (tree chrec_a, 
-		       tree chrec_b, 
+static void
+analyze_ziv_subscript (tree chrec_a,
+		       tree chrec_b,
 		       conflict_function **overlaps_a,
-		       conflict_function **overlaps_b, 
+		       conflict_function **overlaps_b,
 		       tree *last_conflicts)
 {
   tree type, difference;
   dependence_stats.num_ziv++;
-  
+
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "(analyze_ziv_subscript \n");
 
@@ -1592,7 +1592,7 @@ analyze_ziv_subscript (tree chrec_a,
   chrec_a = chrec_convert (type, chrec_a, NULL);
   chrec_b = chrec_convert (type, chrec_b, NULL);
   difference = chrec_fold_minus (type, chrec_a, chrec_b);
-  
+
   switch (TREE_CODE (difference))
     {
     case INTEGER_CST:
@@ -1614,9 +1614,9 @@ analyze_ziv_subscript (tree chrec_a,
 	  dependence_stats.num_ziv_independent++;
 	}
       break;
-      
+
     default:
-      /* We're not sure whether the indexes overlap.  For the moment, 
+      /* We're not sure whether the indexes overlap.  For the moment,
 	 conservatively answer "don't know".  */
       if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, "ziv test failed: difference is non-integer.\n");
@@ -1627,7 +1627,7 @@ analyze_ziv_subscript (tree chrec_a,
       dependence_stats.num_ziv_unimplemented++;
       break;
     }
-  
+
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, ")\n");
 }
@@ -1679,7 +1679,7 @@ estimated_loop_iterations_int (struct loop *loop, bool conservative)
 
   return hwi_nit < 0 ? -1 : hwi_nit;
 }
-    
+
 /* Similar to estimated_loop_iterations, but returns the estimate as a tree,
    and only if it fits to the int type.  If this is not the case, or the
    estimate on the number of iterations of LOOP could not be derived, returns
@@ -1710,10 +1710,10 @@ estimated_loop_iterations_tree (struct loop *loop, bool conservative)
    CHREC_A (*OVERLAPS_A (k)) = CHREC_B (*OVERLAPS_B (k)).  */
 
 static void
-analyze_siv_subscript_cst_affine (tree chrec_a, 
+analyze_siv_subscript_cst_affine (tree chrec_a,
 				  tree chrec_b,
-				  conflict_function **overlaps_a, 
-				  conflict_function **overlaps_b, 
+				  conflict_function **overlaps_a,
+				  conflict_function **overlaps_b,
 				  tree *last_conflicts)
 {
   bool value0, value1, value2;
@@ -1723,11 +1723,11 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
   chrec_a = chrec_convert (type, chrec_a, NULL);
   chrec_b = chrec_convert (type, chrec_b, NULL);
   difference = chrec_fold_minus (type, initial_condition (chrec_b), chrec_a);
-  
+
   if (!chrec_is_positive (initial_condition (difference), &value0))
     {
       if (dump_file && (dump_flags & TDF_DETAILS))
-	fprintf (dump_file, "siv test failed: chrec is not positive.\n"); 
+	fprintf (dump_file, "siv test failed: chrec is not positive.\n");
 
       dependence_stats.num_siv_unimplemented++;
       *overlaps_a = conflict_fn_not_known ();
@@ -1745,7 +1745,7 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
 		fprintf (dump_file, "siv test failed: chrec not positive.\n");
 
 	      *overlaps_a = conflict_fn_not_known ();
-	      *overlaps_b = conflict_fn_not_known ();      
+	      *overlaps_b = conflict_fn_not_known ();
 	      *last_conflicts = chrec_dont_know;
 	      dependence_stats.num_siv_unimplemented++;
 	      return;
@@ -1754,11 +1754,11 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
 	    {
 	      if (value1 == true)
 		{
-		  /* Example:  
+		  /* Example:
 		     chrec_a = 12
 		     chrec_b = {10, +, 1}
 		  */
-		  
+
 		  if (tree_fold_divides_p (CHREC_RIGHT (chrec_b), difference))
 		    {
 		      HOST_WIDE_INT numiter;
@@ -1770,7 +1770,7 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
 					 CHREC_RIGHT (chrec_b));
 		      *overlaps_b = conflict_fn (1, affine_fn_cst (tmp));
 		      *last_conflicts = integer_one_node;
-		      
+
 
 		      /* Perform weak-zero siv test to see if overlap is
 			 outside the loop bounds.  */
@@ -1786,29 +1786,29 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
 			  *last_conflicts = integer_zero_node;
 			  dependence_stats.num_siv_independent++;
 			  return;
-			}		
+			}
 		      dependence_stats.num_siv_dependent++;
 		      return;
 		    }
-		  
+
 		  /* When the step does not divide the difference, there are
 		     no overlaps.  */
 		  else
 		    {
 		      *overlaps_a = conflict_fn_no_dependence ();
-		      *overlaps_b = conflict_fn_no_dependence ();      
+		      *overlaps_b = conflict_fn_no_dependence ();
 		      *last_conflicts = integer_zero_node;
 		      dependence_stats.num_siv_independent++;
 		      return;
 		    }
 		}
-	      
+
 	      else
 		{
-		  /* Example:  
+		  /* Example:
 		     chrec_a = 12
 		     chrec_b = {10, +, -1}
-		     
+
 		     In this case, chrec_a will not overlap with chrec_b.  */
 		  *overlaps_a = conflict_fn_no_dependence ();
 		  *overlaps_b = conflict_fn_no_dependence ();
@@ -1818,7 +1818,7 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
 		}
 	    }
 	}
-      else 
+      else
 	{
 	  if (!chrec_is_positive (CHREC_RIGHT (chrec_b), &value2))
 	    {
@@ -1826,7 +1826,7 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
 		fprintf (dump_file, "siv test failed: chrec not positive.\n");
 
 	      *overlaps_a = conflict_fn_not_known ();
-	      *overlaps_b = conflict_fn_not_known ();      
+	      *overlaps_b = conflict_fn_not_known ();
 	      *last_conflicts = chrec_dont_know;
 	      dependence_stats.num_siv_unimplemented++;
 	      return;
@@ -1835,7 +1835,7 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
 	    {
 	      if (value2 == false)
 		{
-		  /* Example:  
+		  /* Example:
 		     chrec_a = 3
 		     chrec_b = {10, +, -1}
 		  */
@@ -1864,17 +1864,17 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
 			  *last_conflicts = integer_zero_node;
 			  dependence_stats.num_siv_independent++;
 			  return;
-			}	
+			}
 		      dependence_stats.num_siv_dependent++;
 		      return;
 		    }
-		  
+
 		  /* When the step does not divide the difference, there
 		     are no overlaps.  */
 		  else
 		    {
 		      *overlaps_a = conflict_fn_no_dependence ();
-		      *overlaps_b = conflict_fn_no_dependence ();      
+		      *overlaps_b = conflict_fn_no_dependence ();
 		      *last_conflicts = integer_zero_node;
 		      dependence_stats.num_siv_independent++;
 		      return;
@@ -1882,10 +1882,10 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
 		}
 	      else
 		{
-		  /* Example:  
-		     chrec_a = 3  
+		  /* Example:
+		     chrec_a = 3
 		     chrec_b = {4, +, 1}
-		 
+
 		     In this case, chrec_a will not overlap with chrec_b.  */
 		  *overlaps_a = conflict_fn_no_dependence ();
 		  *overlaps_b = conflict_fn_no_dependence ();
@@ -1949,7 +1949,7 @@ initialize_matrix_A (lambda_matrix A, tree chrec, unsigned index, int mult)
 
 #define FLOOR_DIV(x,y) ((x) / (y))
 
-/* Solves the special case of the Diophantine equation: 
+/* Solves the special case of the Diophantine equation:
    | {0, +, STEP_A}_x (OVERLAPS_A) = {0, +, STEP_B}_y (OVERLAPS_B)
 
    Computes the descriptions OVERLAPS_A and OVERLAPS_B.  NITER is the
@@ -1957,9 +1957,9 @@ initialize_matrix_A (lambda_matrix A, tree chrec, unsigned index, int mult)
    constructed as evolutions in dimension DIM.  */
 
 static void
-compute_overlap_steps_for_affine_univar (int niter, int step_a, int step_b, 
+compute_overlap_steps_for_affine_univar (int niter, int step_a, int step_b,
 					 affine_fn *overlaps_a,
-					 affine_fn *overlaps_b, 
+					 affine_fn *overlaps_b,
 					 tree *last_conflicts, int dim)
 {
   if (((step_a > 0 && step_b > 0)
@@ -1982,11 +1982,11 @@ compute_overlap_steps_for_affine_univar (int niter, int step_a, int step_b,
       else
 	*last_conflicts = chrec_dont_know;
 
-      *overlaps_a = affine_fn_univar (integer_zero_node, dim, 
+      *overlaps_a = affine_fn_univar (integer_zero_node, dim,
 				      build_int_cst (NULL_TREE,
 						     step_overlaps_a));
-      *overlaps_b = affine_fn_univar (integer_zero_node, dim, 
-				      build_int_cst (NULL_TREE, 
+      *overlaps_b = affine_fn_univar (integer_zero_node, dim,
+				      build_int_cst (NULL_TREE,
 						     step_overlaps_b));
     }
 
@@ -2000,11 +2000,11 @@ compute_overlap_steps_for_affine_univar (int niter, int step_a, int step_b,
 
 /* Solves the special case of a Diophantine equation where CHREC_A is
    an affine bivariate function, and CHREC_B is an affine univariate
-   function.  For example, 
+   function.  For example,
 
    | {{0, +, 1}_x, +, 1335}_y = {0, +, 1336}_z
-   
-   has the following overlapping functions: 
+
+   has the following overlapping functions:
 
    | x (t, u, v) = {{0, +, 1336}_t, +, 1}_v
    | y (t, u, v) = {{0, +, 1336}_u, +, 1}_v
@@ -2014,9 +2014,9 @@ compute_overlap_steps_for_affine_univar (int niter, int step_a, int step_b,
    a common benchmark.  Implement the general algorithm.  */
 
 static void
-compute_overlap_steps_for_affine_1_2 (tree chrec_a, tree chrec_b, 
+compute_overlap_steps_for_affine_1_2 (tree chrec_a, tree chrec_b,
 				      conflict_function **overlaps_a,
-				      conflict_function **overlaps_b, 
+				      conflict_function **overlaps_b,
 				      tree *last_conflicts)
 {
   bool xz_p, yz_p, xyz_p;
@@ -2032,17 +2032,17 @@ compute_overlap_steps_for_affine_1_2 (tree chrec_a, tree chrec_b,
   step_y = int_cst_value (CHREC_RIGHT (chrec_a));
   step_z = int_cst_value (CHREC_RIGHT (chrec_b));
 
-  niter_x = 
+  niter_x =
     estimated_loop_iterations_int (get_chrec_loop (CHREC_LEFT (chrec_a)),
 				   false);
   niter_y = estimated_loop_iterations_int (get_chrec_loop (chrec_a), false);
   niter_z = estimated_loop_iterations_int (get_chrec_loop (chrec_b), false);
-  
+
   if (niter_x < 0 || niter_y < 0 || niter_z < 0)
     {
       if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, "overlap steps test failed: no iteration counts.\n");
-	   
+
       *overlaps_a = conflict_fn_not_known ();
       *overlaps_b = conflict_fn_not_known ();
       *last_conflicts = chrec_dont_know;
@@ -2135,10 +2135,10 @@ compute_overlap_steps_for_affine_1_2 (tree chrec_a, tree chrec_b,
    parameters, because it uses lambda matrices of integers.  */
 
 static void
-analyze_subscript_affine_affine (tree chrec_a, 
+analyze_subscript_affine_affine (tree chrec_a,
 				 tree chrec_b,
-				 conflict_function **overlaps_a, 
-				 conflict_function **overlaps_b, 
+				 conflict_function **overlaps_a,
+				 conflict_function **overlaps_b,
 				 tree *last_conflicts)
 {
   unsigned nb_vars_a, nb_vars_b, dim;
@@ -2156,10 +2156,10 @@ analyze_subscript_affine_affine (tree chrec_a,
     }
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "(analyze_subscript_affine_affine \n");
-  
+
   /* For determining the initial intersection, we have to solve a
      Diophantine equation.  This is the most time consuming part.
-     
+
      For answering to the question: "Is there a dependence?" we have
      to prove that there exists a solution to the Diophantine
      equation, and that the solution is in the iteration domain,
@@ -2181,11 +2181,11 @@ analyze_subscript_affine_affine (tree chrec_a,
   gamma = init_b - init_a;
 
   /* Don't do all the hard work of solving the Diophantine equation
-     when we already know the solution: for example, 
+     when we already know the solution: for example,
      | {3, +, 1}_1
      | {3, +, 4}_2
      | gamma = 3 - 3 = 0.
-     Then the first overlap occurs during the first iterations: 
+     Then the first overlap occurs during the first iterations:
      | {3, +, 1}_1 ({0, +, 4}_x) = {3, +, 4}_2 ({0, +, 1}_x)
   */
   if (gamma == 0)
@@ -2204,8 +2204,8 @@ analyze_subscript_affine_affine (tree chrec_a,
 	  step_a = int_cst_value (CHREC_RIGHT (chrec_a));
 	  step_b = int_cst_value (CHREC_RIGHT (chrec_b));
 
-	  compute_overlap_steps_for_affine_univar (niter, step_a, step_b, 
-						   &ova, &ovb, 
+	  compute_overlap_steps_for_affine_univar (niter, step_a, step_b,
+						   &ova, &ovb,
 						   last_conflicts, 1);
 	  *overlaps_a = conflict_fn (1, ova);
 	  *overlaps_b = conflict_fn (1, ovb);
@@ -2269,20 +2269,20 @@ analyze_subscript_affine_affine (tree chrec_a,
 	   || (A[0][0] < 0 && -A[1][0] < 0)))
 	{
 	  /* The solutions are given by:
-	     | 
+	     |
 	     | [GAMMA/GCD_ALPHA_BETA  t].[u11 u12]  = [x0]
 	     |                           [u21 u22]    [y0]
-	 
+
 	     For a given integer t.  Using the following variables,
-	 
+
 	     | i0 = u11 * gamma / gcd_alpha_beta
 	     | j0 = u12 * gamma / gcd_alpha_beta
 	     | i1 = u21
 	     | j1 = u22
-	 
+
 	     the solutions are:
-	 
-	     | x0 = i0 + i1 * t, 
+
+	     | x0 = i0 + i1 * t,
 	     | y0 = j0 + j1 * t.  */
       	  HOST_WIDE_INT i0, j0, i1, j1;
 
@@ -2294,9 +2294,9 @@ analyze_subscript_affine_affine (tree chrec_a,
 	  if ((i1 == 0 && i0 < 0)
 	      || (j1 == 0 && j0 < 0))
 	    {
-	      /* There is no solution.  
-		 FIXME: The case "i0 > nb_iterations, j0 > nb_iterations" 
-		 falls in here, but for the moment we don't look at the 
+	      /* There is no solution.
+		 FIXME: The case "i0 > nb_iterations, j0 > nb_iterations"
+		 falls in here, but for the moment we don't look at the
 		 upper bound of the iteration domain.  */
 	      *overlaps_a = conflict_fn_no_dependence ();
 	      *overlaps_b = conflict_fn_no_dependence ();
@@ -2387,7 +2387,7 @@ analyze_subscript_affine_affine (tree chrec_a,
       *last_conflicts = chrec_dont_know;
     }
 
-end_analyze_subs_aa:  
+end_analyze_subs_aa:
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
       fprintf (dump_file, "  (overlaps_a = ");
@@ -2403,12 +2403,12 @@ end_analyze_subs_aa:
    determining the dependence relation between chrec_a and chrec_b,
    that contain symbols.  This function modifies chrec_a and chrec_b
    such that the analysis result is the same, and such that they don't
-   contain symbols, and then can safely be passed to the analyzer.  
+   contain symbols, and then can safely be passed to the analyzer.
 
    Example: The analysis of the following tuples of evolutions produce
    the same results: {x+1, +, 1}_1 vs. {x+3, +, 1}_1, and {-2, +, 1}_1
    vs. {0, +, 1}_1
-   
+
    {x+1, +, 1}_1 ({2, +, 1}_1) = {x+3, +, 1}_1 ({0, +, 1}_1)
    {-2, +, 1}_1 ({2, +, 1}_1) = {0, +, 1}_1 ({0, +, 1}_1)
 */
@@ -2434,7 +2434,7 @@ can_use_analyze_subscript_affine_affine (tree *chrec_a, tree *chrec_b)
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "can_use_subscript_aff_aff_for_symbolic \n");
 
-  *chrec_a = build_polynomial_chrec (CHREC_VARIABLE (*chrec_a), 
+  *chrec_a = build_polynomial_chrec (CHREC_VARIABLE (*chrec_a),
 				     diff, CHREC_RIGHT (*chrec_a));
   right_b = chrec_convert (type, CHREC_RIGHT (*chrec_b), NULL);
   *chrec_b = build_polynomial_chrec (CHREC_VARIABLE (*chrec_b),
@@ -2451,36 +2451,36 @@ can_use_analyze_subscript_affine_affine (tree *chrec_a, tree *chrec_b)
    CHREC_A (*OVERLAPS_A (k)) = CHREC_B (*OVERLAPS_B (k)).  */
 
 static void
-analyze_siv_subscript (tree chrec_a, 
+analyze_siv_subscript (tree chrec_a,
 		       tree chrec_b,
-		       conflict_function **overlaps_a, 
-		       conflict_function **overlaps_b, 
+		       conflict_function **overlaps_a,
+		       conflict_function **overlaps_b,
 		       tree *last_conflicts,
 		       int loop_nest_num)
 {
   dependence_stats.num_siv++;
-  
+
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "(analyze_siv_subscript \n");
-  
+
   if (evolution_function_is_constant_p (chrec_a)
       && evolution_function_is_affine_in_loop (chrec_b, loop_nest_num))
-    analyze_siv_subscript_cst_affine (chrec_a, chrec_b, 
+    analyze_siv_subscript_cst_affine (chrec_a, chrec_b,
 				      overlaps_a, overlaps_b, last_conflicts);
-  
+
   else if (evolution_function_is_affine_in_loop (chrec_a, loop_nest_num)
 	   && evolution_function_is_constant_p (chrec_b))
-    analyze_siv_subscript_cst_affine (chrec_b, chrec_a, 
+    analyze_siv_subscript_cst_affine (chrec_b, chrec_a,
 				      overlaps_b, overlaps_a, last_conflicts);
-  
+
   else if (evolution_function_is_affine_in_loop (chrec_a, loop_nest_num)
 	   && evolution_function_is_affine_in_loop (chrec_b, loop_nest_num))
     {
       if (!chrec_contains_symbols (chrec_a)
 	  && !chrec_contains_symbols (chrec_b))
 	{
-	  analyze_subscript_affine_affine (chrec_a, chrec_b, 
-					   overlaps_a, overlaps_b, 
+	  analyze_subscript_affine_affine (chrec_a, chrec_b,
+					   overlaps_a, overlaps_b,
 					   last_conflicts);
 
 	  if (CF_NOT_KNOWN_P (*overlaps_a)
@@ -2492,11 +2492,11 @@ analyze_siv_subscript (tree chrec_a,
 	  else
 	    dependence_stats.num_siv_dependent++;
 	}
-      else if (can_use_analyze_subscript_affine_affine (&chrec_a, 
+      else if (can_use_analyze_subscript_affine_affine (&chrec_a,
 							&chrec_b))
 	{
-	  analyze_subscript_affine_affine (chrec_a, chrec_b, 
-					   overlaps_a, overlaps_b, 
+	  analyze_subscript_affine_affine (chrec_a, chrec_b,
+					   overlaps_a, overlaps_b,
 					   last_conflicts);
 
 	  if (CF_NOT_KNOWN_P (*overlaps_a)
@@ -2522,7 +2522,7 @@ analyze_siv_subscript (tree chrec_a,
       *last_conflicts = chrec_dont_know;
       dependence_stats.num_siv_unimplemented++;
     }
-  
+
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, ")\n");
 }
@@ -2561,17 +2561,17 @@ gcd_of_steps_may_divide_p (const_tree chrec, const_tree cst)
    CHREC_A (*OVERLAPS_A (k)) = CHREC_B (*OVERLAPS_B (k)).  */
 
 static void
-analyze_miv_subscript (tree chrec_a, 
-		       tree chrec_b, 
-		       conflict_function **overlaps_a, 
-		       conflict_function **overlaps_b, 
+analyze_miv_subscript (tree chrec_a,
+		       tree chrec_b,
+		       conflict_function **overlaps_a,
+		       conflict_function **overlaps_b,
 		       tree *last_conflicts,
 		       struct loop *loop_nest)
 {
   /* FIXME:  This is a MIV subscript, not yet handled.
-     Example: (A[{1, +, 1}_1] vs. A[{1, +, 1}_2]) that comes from 
-     (A[i] vs. A[j]).  
-     
+     Example: (A[{1, +, 1}_1] vs. A[{1, +, 1}_2]) that comes from
+     (A[i] vs. A[j]).
+
      In the SIV test we had to solve a Diophantine equation with two
      variables.  In the MIV case we have to solve a Diophantine
      equation with 2*n variables (if the subscript uses n IVs).
@@ -2586,7 +2586,7 @@ analyze_miv_subscript (tree chrec_a,
   chrec_a = chrec_convert (type, chrec_a, NULL);
   chrec_b = chrec_convert (type, chrec_b, NULL);
   difference = chrec_fold_minus (type, chrec_a, chrec_b);
-  
+
   if (eq_evolutions_p (chrec_a, chrec_b))
     {
       /* Access functions are the same: all the elements are accessed
@@ -2597,7 +2597,7 @@ analyze_miv_subscript (tree chrec_a,
 				(get_chrec_loop (chrec_a), true);
       dependence_stats.num_miv_dependent++;
     }
-  
+
   else if (evolution_function_is_constant_p (difference)
 	   /* For the moment, the following is verified:
 	      evolution_function_is_affine_multivariate_p (chrec_a,
@@ -2605,8 +2605,8 @@ analyze_miv_subscript (tree chrec_a,
 	   && !gcd_of_steps_may_divide_p (chrec_a, difference))
     {
       /* testsuite/.../ssa-chrec-33.c
-	 {{21, +, 2}_1, +, -2}_2  vs.  {{20, +, 2}_1, +, -2}_2 
-	 
+	 {{21, +, 2}_1, +, -2}_2  vs.  {{20, +, 2}_1, +, -2}_2
+
 	 The difference is 1, and all the evolution steps are multiples
 	 of 2, consequently there are no overlapping elements.  */
       *overlaps_a = conflict_fn_no_dependence ();
@@ -2614,7 +2614,7 @@ analyze_miv_subscript (tree chrec_a,
       *last_conflicts = integer_zero_node;
       dependence_stats.num_miv_independent++;
     }
-  
+
   else if (evolution_function_is_affine_multivariate_p (chrec_a, loop_nest->num)
 	   && !chrec_contains_symbols (chrec_a)
 	   && evolution_function_is_affine_multivariate_p (chrec_b, loop_nest->num)
@@ -2623,18 +2623,18 @@ analyze_miv_subscript (tree chrec_a,
       /* testsuite/.../ssa-chrec-35.c
 	 {0, +, 1}_2  vs.  {0, +, 1}_3
 	 the overlapping elements are respectively located at iterations:
-	 {0, +, 1}_x and {0, +, 1}_x, 
-	 in other words, we have the equality: 
+	 {0, +, 1}_x and {0, +, 1}_x,
+	 in other words, we have the equality:
 	 {0, +, 1}_2 ({0, +, 1}_x) = {0, +, 1}_3 ({0, +, 1}_x)
-	 
-	 Other examples: 
-	 {{0, +, 1}_1, +, 2}_2 ({0, +, 1}_x, {0, +, 1}_y) = 
+
+	 Other examples:
+	 {{0, +, 1}_1, +, 2}_2 ({0, +, 1}_x, {0, +, 1}_y) =
 	 {0, +, 1}_1 ({{0, +, 1}_x, +, 2}_y)
 
-	 {{0, +, 2}_1, +, 3}_2 ({0, +, 1}_y, {0, +, 1}_x) = 
+	 {{0, +, 2}_1, +, 3}_2 ({0, +, 1}_y, {0, +, 1}_x) =
 	 {{0, +, 3}_1, +, 2}_2 ({0, +, 1}_x, {0, +, 1}_y)
       */
-      analyze_subscript_affine_affine (chrec_a, chrec_b, 
+      analyze_subscript_affine_affine (chrec_a, chrec_b,
 				       overlaps_a, overlaps_b, last_conflicts);
 
       if (CF_NOT_KNOWN_P (*overlaps_a)
@@ -2646,7 +2646,7 @@ analyze_miv_subscript (tree chrec_a,
       else
 	dependence_stats.num_miv_dependent++;
     }
-  
+
   else
     {
       /* When the analysis is too difficult, answer "don't know".  */
@@ -2658,7 +2658,7 @@ analyze_miv_subscript (tree chrec_a,
       *last_conflicts = chrec_dont_know;
       dependence_stats.num_miv_unimplemented++;
     }
-  
+
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, ")\n");
 }
@@ -2667,23 +2667,23 @@ analyze_miv_subscript (tree chrec_a,
    with respect to LOOP_NEST.  OVERLAP_ITERATIONS_A and
    OVERLAP_ITERATIONS_B are initialized with two functions that
    describe the iterations that contain conflicting elements.
-   
+
    Remark: For an integer k >= 0, the following equality is true:
-   
+
    CHREC_A (OVERLAP_ITERATIONS_A (k)) == CHREC_B (OVERLAP_ITERATIONS_B (k)).
 */
 
-static void 
-analyze_overlapping_iterations (tree chrec_a, 
-				tree chrec_b, 
-				conflict_function **overlap_iterations_a, 
-				conflict_function **overlap_iterations_b, 
+static void
+analyze_overlapping_iterations (tree chrec_a,
+				tree chrec_b,
+				conflict_function **overlap_iterations_a,
+				conflict_function **overlap_iterations_b,
 				tree *last_conflicts, struct loop *loop_nest)
 {
   unsigned int lnn = loop_nest->num;
 
   dependence_stats.num_subscript_tests++;
-  
+
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
       fprintf (dump_file, "(analyze_overlapping_iterations \n");
@@ -2700,12 +2700,12 @@ analyze_overlapping_iterations (tree chrec_a,
       || chrec_contains_undetermined (chrec_b))
     {
       dependence_stats.num_subscript_undetermined++;
-      
+
       *overlap_iterations_a = conflict_fn_not_known ();
       *overlap_iterations_b = conflict_fn_not_known ();
     }
 
-  /* If they are the same chrec, and are affine, they overlap 
+  /* If they are the same chrec, and are affine, they overlap
      on every iteration.  */
   else if (eq_evolutions_p (chrec_a, chrec_b)
 	   && evolution_function_is_affine_multivariate_p (chrec_a, lnn))
@@ -2718,7 +2718,7 @@ analyze_overlapping_iterations (tree chrec_a,
 
   /* If they aren't the same, and aren't affine, we can't do anything
      yet. */
-  else if ((chrec_contains_symbols (chrec_a) 
+  else if ((chrec_contains_symbols (chrec_a)
 	    || chrec_contains_symbols (chrec_b))
 	   && (!evolution_function_is_affine_multivariate_p (chrec_a, lnn)
 	       || !evolution_function_is_affine_multivariate_p (chrec_b, lnn)))
@@ -2729,20 +2729,20 @@ analyze_overlapping_iterations (tree chrec_a,
     }
 
   else if (ziv_subscript_p (chrec_a, chrec_b))
-    analyze_ziv_subscript (chrec_a, chrec_b, 
+    analyze_ziv_subscript (chrec_a, chrec_b,
 			   overlap_iterations_a, overlap_iterations_b,
 			   last_conflicts);
-  
+
   else if (siv_subscript_p (chrec_a, chrec_b))
-    analyze_siv_subscript (chrec_a, chrec_b, 
-			   overlap_iterations_a, overlap_iterations_b, 
+    analyze_siv_subscript (chrec_a, chrec_b,
+			   overlap_iterations_a, overlap_iterations_b,
 			   last_conflicts, lnn);
-  
+
   else
-    analyze_miv_subscript (chrec_a, chrec_b, 
+    analyze_miv_subscript (chrec_a, chrec_b,
 			   overlap_iterations_a, overlap_iterations_b,
 			   last_conflicts, loop_nest);
-  
+
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
       fprintf (dump_file, "  (overlap_iterations_a = ");
@@ -2842,7 +2842,7 @@ build_classic_dist_vector_1 (struct data_dependence_relation *ddr,
       access_fn_a = DR_ACCESS_FN (ddr_a, i);
       access_fn_b = DR_ACCESS_FN (ddr_b, i);
 
-      if (TREE_CODE (access_fn_a) == POLYNOMIAL_CHREC 
+      if (TREE_CODE (access_fn_a) == POLYNOMIAL_CHREC
 	  && TREE_CODE (access_fn_b) == POLYNOMIAL_CHREC)
 	{
 	  int dist, index;
@@ -2867,7 +2867,7 @@ build_classic_dist_vector_1 (struct data_dependence_relation *ddr,
 	      non_affine_dependence_relation (ddr);
 	      return false;
 	    }
-	  
+
 	  dist = int_cst_value (SUB_DISTANCE (subscript));
 
 	  /* This is the subscript coupling test.  If we have already
@@ -3147,7 +3147,7 @@ build_classic_dist_vector (struct data_dependence_relation *ddr,
 	     |       T[j][i] = t + 2;  // B
 	     |     }
 
-	     the vectors are: 
+	     the vectors are:
 	     (0,  1, -1)
 	     (1,  1, -1)
 	     (1, -1,  1)
@@ -3269,9 +3269,9 @@ subscript_dependence_tester_1 (struct data_dependence_relation *ddr,
     {
       conflict_function *overlaps_a, *overlaps_b;
 
-      analyze_overlapping_iterations (DR_ACCESS_FN (dra, i), 
+      analyze_overlapping_iterations (DR_ACCESS_FN (dra, i),
 				      DR_ACCESS_FN (drb, i),
-				      &overlaps_a, &overlaps_b, 
+				      &overlaps_a, &overlaps_b,
 				      &last_conflicts, loop_nest);
 
       if (CF_NOT_KNOWN_P (overlaps_a)
@@ -3316,10 +3316,10 @@ static void
 subscript_dependence_tester (struct data_dependence_relation *ddr,
 			     struct loop *loop_nest)
 {
-  
+
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "(subscript_dependence_tester \n");
-  
+
   if (subscript_dependence_tester_1 (ddr, DDR_A (ddr), DDR_B (ddr), loop_nest))
     dependence_stats.num_dependence_dependent++;
 
@@ -3334,7 +3334,7 @@ subscript_dependence_tester (struct data_dependence_relation *ddr,
 /* Returns true when all the access functions of A are affine or
    constant with respect to LOOP_NEST.  */
 
-static bool 
+static bool
 access_functions_are_affine_or_constant_p (const struct data_reference *a,
 					   const struct loop *loop_nest)
 {
@@ -3346,7 +3346,7 @@ access_functions_are_affine_or_constant_p (const struct data_reference *a,
     if (!evolution_function_is_invariant_p (t, loop_nest->num)
 	&& !evolution_function_is_affine_multivariate_p (t, loop_nest->num))
       return false;
-  
+
   return true;
 }
 
@@ -3363,8 +3363,8 @@ access_functions_are_affine_or_constant_p (const struct data_reference *a,
    ACCESS_FUN is expected to be an affine chrec.  */
 
 static bool
-init_omega_eq_with_af (omega_pb pb, unsigned eq, 
-		       unsigned int offset, tree access_fun, 
+init_omega_eq_with_af (omega_pb pb, unsigned eq,
+		       unsigned int offset, tree access_fun,
 		       struct data_dependence_relation *ddr)
 {
   switch (TREE_CODE (access_fun))
@@ -3386,7 +3386,7 @@ init_omega_eq_with_af (omega_pb pb, unsigned eq,
 	DDR_INNER_LOOP (ddr) = MAX (DDR_INNER_LOOP (ddr), var_idx);
 
 	if (offset == 0)
-	  pb->eqs[eq].coef[var_idx + DDR_NB_LOOPS (ddr) + 1] 
+	  pb->eqs[eq].coef[var_idx + DDR_NB_LOOPS (ddr) + 1]
 	    += int_cst_value (right);
 
 	switch (TREE_CODE (left))
@@ -3429,7 +3429,7 @@ omega_extract_distance_vectors (omega_pb pb,
   /* Set a new problem for each loop in the nest.  The basis is the
      problem that we have initialized until now.  On top of this we
      add new constraints.  */
-  for (i = 0; i <= DDR_INNER_LOOP (ddr) 
+  for (i = 0; i <= DDR_INNER_LOOP (ddr)
 	 && VEC_iterate (loop_p, DDR_LOOP_NEST (ddr), i, loopi); i++)
     {
       int dist = 0;
@@ -3453,7 +3453,7 @@ omega_extract_distance_vectors (omega_pb pb,
       /* Reduce the constraint system, and test that the current
 	 problem is feasible.  */
       res = omega_simplify_problem (copy);
-      if (res == omega_false 
+      if (res == omega_false
 	  || res == omega_unknown
 	  || copy->num_geqs > (int) DDR_NB_LOOPS (ddr))
 	goto next_problem;
@@ -3482,7 +3482,7 @@ omega_extract_distance_vectors (omega_pb pb,
 	  copy->eqs[eq].coef[0] = -1;
 
 	  res = omega_simplify_problem (copy);
-	  if (res == omega_false 
+	  if (res == omega_false
 	      || res == omega_unknown
 	      || copy->num_geqs > (int) DDR_NB_LOOPS (ddr))
 	    goto next_problem;
@@ -3562,7 +3562,7 @@ omega_setup_subscript (tree access_fun_a, tree access_fun_b,
 
   /* GCD test.  */
   if (DDR_NB_LOOPS (ddr) != 0 && pb->eqs[eq].coef[0]
-      && !int_divides_p (lambda_vector_gcd 
+      && !int_divides_p (lambda_vector_gcd
 			 ((lambda_vector) &(pb->eqs[eq].coef[1]),
 			  2 * DDR_NB_LOOPS (ddr)),
 			 pb->eqs[eq].coef[0]))
@@ -3611,7 +3611,7 @@ init_omega_for_ddr_1 (struct data_reference *dra, struct data_reference *drb,
      removed by the solver: the "dx"
      - coef[nb_loops + 1, 2*nb_loops] are the loop variables: "loop_x".
   */
-  for (i = 0; i <= DDR_INNER_LOOP (ddr) 
+  for (i = 0; i <= DDR_INNER_LOOP (ddr)
 	 && VEC_iterate (loop_p, DDR_LOOP_NEST (ddr), i, loopi); i++)
     {
       HOST_WIDE_INT nbi = estimated_loop_iterations_int (loopi, false);
@@ -3663,7 +3663,7 @@ init_omega_for_ddr_1 (struct data_reference *dra, struct data_reference *drb,
    set MAYBE_DEPENDENT to true.
 
    Example: for setting up the dependence system corresponding to the
-   conflicting accesses 
+   conflicting accesses
 
    | loop_i
    |   loop_j
@@ -3671,7 +3671,7 @@ init_omega_for_ddr_1 (struct data_reference *dra, struct data_reference *drb,
    |     ... A[2*j, 2*(i + j)]
    |   endloop_j
    | endloop_i
-   
+
    the following constraints come from the iteration domain:
 
    0 <= i <= Ni
@@ -3872,14 +3872,14 @@ ddr_consistent_p (FILE *file,
 	}
     }
 
-  return true;  
+  return true;
 }
 
 /* This computes the affine dependence relation between A and B with
    respect to LOOP_NEST.  CHREC_KNOWN is used for representing the
    independence between two accesses, while CHREC_DONT_KNOW is used
    for representing the unknown relation.
-   
+
    Note that it is possible to stop the computation of the dependence
    relation the first time we detect a CHREC_KNOWN element for a given
    subscript.  */
@@ -3890,7 +3890,7 @@ compute_affine_dependence (struct data_dependence_relation *ddr,
 {
   struct data_reference *dra = DDR_A (ddr);
   struct data_reference *drb = DDR_B (ddr);
-  
+
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
       fprintf (dump_file, "(compute_affine_dependence\n");
@@ -3953,7 +3953,7 @@ compute_affine_dependence (struct data_dependence_relation *ddr,
 	  else
 	    subscript_dependence_tester (ddr, loop_nest);
 	}
-     
+
       /* As a last case, if the dependence cannot be determined, or if
 	 the dependence is considered too difficult to determine, answer
 	 "don't know".  */
@@ -3973,7 +3973,7 @@ compute_affine_dependence (struct data_dependence_relation *ddr,
 	  finalize_ddr_dependent (ddr, chrec_dont_know);
 	}
     }
-  
+
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, ")\n");
 }
@@ -4016,7 +4016,7 @@ compute_self_dependence (struct data_dependence_relation *ddr)
    COMPUTE_SELF_AND_RR is FALSE, don't compute read-read and self
    relations.  */
 
-void 
+void
 compute_all_dependences (VEC (data_reference_p, heap) *datarefs,
 			 VEC (ddr_p, heap) **dependence_relations,
 			 VEC (loop_p, heap) *loop_nest,
@@ -4075,7 +4075,7 @@ get_references_in_stmt (gimple stmt, VEC (data_ref_loc, heap) **references)
       tree base;
       op0 = gimple_assign_lhs_ptr (stmt);
       op1 = gimple_assign_rhs1_ptr (stmt);
-		
+
       if (DECL_P (*op1)
 	  || (REFERENCE_CLASS_P (*op1)
 	      && (base = get_base_address (*op1))
@@ -4139,8 +4139,8 @@ find_data_references_in_stmt (struct loop *nest, gimple stmt,
     {
       dr = create_data_ref (nest, *ref->pos, stmt, ref->is_read);
       gcc_assert (dr != NULL);
-  
-      /* FIXME -- data dependence analysis does not work correctly for objects 
+
+      /* FIXME -- data dependence analysis does not work correctly for objects
          with invariant addresses in loop nests.  Let us fail here until the
 	 problem is fixed.  */
       if (dr_address_invariant_p (dr) && nest)
@@ -4223,7 +4223,7 @@ find_data_references_in_bb (struct loop *loop, basic_block bb,
    TODO: This function should be made smarter so that it can handle address
    arithmetic as if they were array accesses, etc.  */
 
-tree 
+tree
 find_data_references_in_loop (struct loop *loop,
 			      VEC (data_reference_p, heap) **datarefs)
 {
@@ -4291,13 +4291,13 @@ find_loop_nest (struct loop *loop, VEC (loop_p, heap) **loop_nest)
 
 /* Returns true when the data dependences have been computed, false otherwise.
    Given a loop nest LOOP, the following vectors are returned:
-   DATAREFS is initialized to all the array elements contained in this loop, 
-   DEPENDENCE_RELATIONS contains the relations between the data references.  
-   Compute read-read and self relations if 
+   DATAREFS is initialized to all the array elements contained in this loop,
+   DEPENDENCE_RELATIONS contains the relations between the data references.
+   Compute read-read and self relations if
    COMPUTE_SELF_AND_READ_READ_DEPENDENCES is TRUE.  */
 
 bool
-compute_data_dependences_for_loop (struct loop *loop, 
+compute_data_dependences_for_loop (struct loop *loop,
 				   bool compute_self_and_read_read_dependences,
 				   VEC (data_reference_p, heap) **datarefs,
 				   VEC (ddr_p, heap) **dependence_relations)
@@ -4307,7 +4307,7 @@ compute_data_dependences_for_loop (struct loop *loop,
 
   memset (&dependence_stats, 0, sizeof (dependence_stats));
 
-  /* If the loop nest is not well formed, or one of the data references 
+  /* If the loop nest is not well formed, or one of the data references
      is not computable, give up without spending time to compute other
      dependences.  */
   if (!loop
@@ -4330,20 +4330,20 @@ compute_data_dependences_for_loop (struct loop *loop,
     {
       fprintf (dump_file, "Dependence tester statistics:\n");
 
-      fprintf (dump_file, "Number of dependence tests: %d\n", 
+      fprintf (dump_file, "Number of dependence tests: %d\n",
 	       dependence_stats.num_dependence_tests);
-      fprintf (dump_file, "Number of dependence tests classified dependent: %d\n", 
+      fprintf (dump_file, "Number of dependence tests classified dependent: %d\n",
 	       dependence_stats.num_dependence_dependent);
-      fprintf (dump_file, "Number of dependence tests classified independent: %d\n", 
+      fprintf (dump_file, "Number of dependence tests classified independent: %d\n",
 	       dependence_stats.num_dependence_independent);
-      fprintf (dump_file, "Number of undetermined dependence tests: %d\n", 
+      fprintf (dump_file, "Number of undetermined dependence tests: %d\n",
 	       dependence_stats.num_dependence_undetermined);
 
-      fprintf (dump_file, "Number of subscript tests: %d\n", 
+      fprintf (dump_file, "Number of subscript tests: %d\n",
 	       dependence_stats.num_subscript_tests);
-      fprintf (dump_file, "Number of undetermined subscript tests: %d\n", 
+      fprintf (dump_file, "Number of undetermined subscript tests: %d\n",
 	       dependence_stats.num_subscript_undetermined);
-      fprintf (dump_file, "Number of same subscript function: %d\n", 
+      fprintf (dump_file, "Number of same subscript function: %d\n",
 	       dependence_stats.num_same_subscript_function);
 
       fprintf (dump_file, "Number of ziv tests: %d\n",
@@ -4353,9 +4353,9 @@ compute_data_dependences_for_loop (struct loop *loop,
       fprintf (dump_file, "Number of ziv tests returning independent: %d\n",
 	       dependence_stats.num_ziv_independent);
       fprintf (dump_file, "Number of ziv tests unimplemented: %d\n",
-	       dependence_stats.num_ziv_unimplemented);      
+	       dependence_stats.num_ziv_unimplemented);
 
-      fprintf (dump_file, "Number of siv tests: %d\n", 
+      fprintf (dump_file, "Number of siv tests: %d\n",
 	       dependence_stats.num_siv);
       fprintf (dump_file, "Number of siv tests returning dependent: %d\n",
 	       dependence_stats.num_siv_dependent);
@@ -4364,7 +4364,7 @@ compute_data_dependences_for_loop (struct loop *loop,
       fprintf (dump_file, "Number of siv tests unimplemented: %d\n",
 	       dependence_stats.num_siv_unimplemented);
 
-      fprintf (dump_file, "Number of miv tests: %d\n", 
+      fprintf (dump_file, "Number of miv tests: %d\n",
 	       dependence_stats.num_miv);
       fprintf (dump_file, "Number of miv tests returning dependent: %d\n",
 	       dependence_stats.num_miv_dependent);
@@ -4377,9 +4377,9 @@ compute_data_dependences_for_loop (struct loop *loop,
   return res;
 }
 
-/* Returns true when the data dependences for the basic block BB have been 
+/* Returns true when the data dependences for the basic block BB have been
    computed, false otherwise.
-   DATAREFS is initialized to all the array elements contained in this basic 
+   DATAREFS is initialized to all the array elements contained in this basic
    block, DEPENDENCE_RELATIONS contains the relations between the data
    references. Compute read-read and self relations if
    COMPUTE_SELF_AND_READ_READ_DEPENDENCES is TRUE.  */
@@ -4400,32 +4400,32 @@ compute_data_dependences_for_bb (basic_block bb,
 /* Entry point (for testing only).  Analyze all the data references
    and the dependence relations in LOOP.
 
-   The data references are computed first.  
-   
+   The data references are computed first.
+
    A relation on these nodes is represented by a complete graph.  Some
    of the relations could be of no interest, thus the relations can be
    computed on demand.
-   
+
    In the following function we compute all the relations.  This is
    just a first implementation that is here for:
-   - for showing how to ask for the dependence relations, 
+   - for showing how to ask for the dependence relations,
    - for the debugging the whole dependence graph,
    - for the dejagnu testcases and maintenance.
-   
+
    It is possible to ask only for a part of the graph, avoiding to
    compute the whole dependence graph.  The computed dependences are
    stored in a knowledge base (KB) such that later queries don't
    recompute the same information.  The implementation of this KB is
    transparent to the optimizer, and thus the KB can be changed with a
    more efficient implementation, or the KB could be disabled.  */
-static void 
+static void
 analyze_all_data_dependences (struct loop *loop)
 {
   unsigned int i;
   int nb_data_refs = 10;
-  VEC (data_reference_p, heap) *datarefs = 
+  VEC (data_reference_p, heap) *datarefs =
     VEC_alloc (data_reference_p, heap, nb_data_refs);
-  VEC (ddr_p, heap) *dependence_relations = 
+  VEC (ddr_p, heap) *dependence_relations =
     VEC_alloc (ddr_p, heap, nb_data_refs * nb_data_refs);
 
   /* Compute DDs on the whole function.  */
@@ -4451,14 +4451,14 @@ analyze_all_data_dependences (struct loop *loop)
 	    {
 	      if (chrec_contains_undetermined (DDR_ARE_DEPENDENT (ddr)))
 		nb_top_relations++;
-	  
+
 	      else if (DDR_ARE_DEPENDENT (ddr) == chrec_known)
 		nb_bot_relations++;
-	  
-	      else 
+
+	      else
 		nb_chrec_relations++;
 	    }
-      
+
 	  gather_stats_on_scev_database ();
 	}
     }
@@ -4501,7 +4501,7 @@ free_dependence_relation (struct data_dependence_relation *ddr)
 /* Free the memory used by the data dependence relations from
    DEPENDENCE_RELATIONS.  */
 
-void 
+void
 free_dependence_relations (VEC (ddr_p, heap) *dependence_relations)
 {
   unsigned int i;
@@ -4548,7 +4548,7 @@ dump_rdg_vertex (FILE *file, struct graph *rdg, int i)
   struct vertex *v = &(rdg->vertices[i]);
   struct graph_edge *e;
 
-  fprintf (file, "(vertex %d: (%s%s) (in:", i, 
+  fprintf (file, "(vertex %d: (%s%s) (in:", i,
 	   RDG_MEM_WRITE_STMT (rdg, i) ? "w" : "",
 	   RDG_MEM_READS_STMT (rdg, i) ? "r" : "");
 
@@ -4773,7 +4773,7 @@ create_rdg_edges_for_scalar (struct graph *rdg, tree def, int idef)
 {
   use_operand_p imm_use_p;
   imm_use_iterator iterator;
-           
+
   FOR_EACH_IMM_USE_FAST (imm_use_p, iterator, def)
     {
       struct graph_edge *e;
@@ -4896,7 +4896,7 @@ known_dependences_p (VEC (ddr_p, heap) *dependence_relations)
   for (i = 0; VEC_iterate (ddr_p, dependence_relations, i, ddr); i++)
     if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know)
       return false;
- 
+
   return true;
 }
 
@@ -4958,10 +4958,10 @@ build_rdg (struct loop *loop)
   VEC (ddr_p, heap) *dependence_relations;
   VEC (data_reference_p, heap) *datarefs;
   VEC (gimple, heap) *stmts = VEC_alloc (gimple, heap, nb_data_refs);
-  
+
   dependence_relations = VEC_alloc (ddr_p, heap, nb_data_refs * nb_data_refs) ;
   datarefs = VEC_alloc (data_reference_p, heap, nb_data_refs);
-  compute_data_dependences_for_loop (loop, 
+  compute_data_dependences_for_loop (loop,
                                      false,
                                      &datarefs,
                                      &dependence_relations);
@@ -5184,8 +5184,8 @@ remove_similar_memory_refs (VEC (gimple, heap) **stmts)
 /* Returns the index of PARAMETER in the parameters vector of the
    ACCESS_MATRIX.  If PARAMETER does not exist return -1.  */
 
-int 
-access_matrix_get_index_for_parameter (tree parameter, 
+int
+access_matrix_get_index_for_parameter (tree parameter,
 				       struct access_matrix *access_matrix)
 {
   int i;