gcc/testsuite/gcc.dg/tree-ssa/ssa-ccp-3.c

   1 /* { dg-do compile } */
   2 /* { dg-options "-O -fdump-tree-ccp2" } */
   3
   4 extern void link_error (void);
   5
   6 /* Some addresses clearly cannot be equal, check that some address
   7    expressions can be evaluated as constants.
   8    Most of the tests are folding tests, but at least some require
   9    points-to analysis, so we scan the first CCP dump after PTA.  */
  10
  11 char g1, g2;
  12 void test6 (char p1, char p2)
  13 {
  14   char l1 = 1, l2 = 2;
  15   static char s1 = 5, s2 = 7;
  16   if (&l1 == &l2)
  17     link_error ();
  18
  19   if (&p1 == &p2)
  20     link_error ();
  21
  22   if (&s1 == &s2)
  23     link_error ();
  24
  25   if (&g1 == &g2)
  26     link_error ();
  27
  28   if (&p1 == &l1)
  29     link_error ();
  30
  31   if (&p1 == &s1)
  32     link_error ();
  33
  34   if (&p1 == &l2)
  35     link_error ();
  36
  37   if (&p1 == &g1)
  38     link_error ();
  39
  40   if (&l1 == &g1)
  41     link_error ();
  42
  43   if (&s1 == &g1)
  44     link_error ();
  45 }
  46
  47 extern void *alloc (int) __attribute__ ((malloc));
  48 char gca1[128];
  49 char* __restrict__ rgc1;
  50 char* test66 (char * __restrict__ rp1, char * __restrict__ rp2, char *p1)
  51 {
  52   char * __restrict__ rl1 = p1;
  53   char * l1 = (char*) alloc (20);
  54
  55   if (l1 == rgc1)
  56     link_error ();
  57
  58   if (l1 == rp1)
  59     link_error ();
  60
  61   if (l1 == rl1)
  62     link_error ();
  63
  64   if (l1 == gca1)
  65     link_error ();
  66
  67   if (rl1 == rgc1)
  68     link_error ();
  69
  70   if (rl1 == rp1)
  71     link_error ();
  72
  73   if (rl1 == gca1)
  74     link_error ();
  75
  76   if (rp1 == rp2)
  77     link_error ();
  78
  79   if (rp1 == rgc1)
  80     link_error ();
  81
  82   if (rp1 == gca1)
  83     link_error ();
  84
  85   if (gca1 == rgc1)
  86     link_error ();
  87
  88 }
  89
  90 int gci1[128];
  91 int* __restrict__ rgi1;
  92 int* test666 (int * __restrict__ rp1, int * __restrict__ rp2, int *p1)
  93 {
  94   int * __restrict__ rl1 = p1;
  95   int * l1 = (int*) alloc (20);
  96
  97   if (l1 == rgi1)
  98     link_error ();
  99
 100   if (l1 == rp1)
 101     link_error ();
 102
 103   if (l1 == rl1)
 104     link_error ();
 105
 106   if (l1 == gci1)
 107     link_error ();
 108
 109   if (rl1 == rgi1)
 110     link_error ();
 111
 112   if (rl1 == rp1)
 113     link_error ();
 114
 115   if (rl1 == gci1)
 116     link_error ();
 117
 118   if (rp1 == rp2)
 119     link_error ();
 120
 121   if (rp1 == rgi1)
 122     link_error ();
 123
 124   if (rp1 == gci1)
 125     link_error ();
 126
 127   if (gci1 == rgi1)
 128     link_error ();
 129 }
 130
 131
 132 /* There should be not link_error calls, if there is any the
 133    optimization has failed */
 134 /* ??? While we indeed don't handle some of these, a couple of the
 135    restrict tests are incorrect.  */
 136 /* { dg-final { scan-tree-dump-times "link_error" 0 "ccp2" { xfail *-*-* } } } */