// PR optimization/11198
|
// PR optimization/11198
|
// Origin: Joerg Walter
|
// Origin: Joerg Walter
|
// Reduced testcase by: Volker Reichelt
|
// Reduced testcase by: Volker Reichelt
|
// Wolfgang Bangerth
|
// Wolfgang Bangerth
|
|
|
// The compiler used to allocate the same stack slot for two aggregates,
|
// The compiler used to allocate the same stack slot for two aggregates,
|
// overlooking that assignments to members given the same address on the
|
// overlooking that assignments to members given the same address on the
|
// stack may not alias and thus may be reordered by the scheduling passes.
|
// stack may not alias and thus may be reordered by the scheduling passes.
|
|
|
// { dg-do run }
|
// { dg-do run }
|
// { dg-options "-O2 -frename-registers" }
|
// { dg-options "-O2 -frename-registers" }
|
|
|
|
|
double zero_;
|
double zero_;
|
|
|
inline const int&
|
inline const int&
|
min(const int& a, const int& b) {
|
min(const int& a, const int& b) {
|
if (b < a) return b; return a;
|
if (b < a) return b; return a;
|
}
|
}
|
|
|
struct barrier { barrier () {} };
|
struct barrier { barrier () {} };
|
|
|
template struct unbounded_array {
|
template struct unbounded_array {
|
inline unbounded_array (): data_ (new double [9]) {}
|
inline unbounded_array (): data_ (new double [9]) {}
|
inline double& operator [] (int i) { return data_ [i]; }
|
inline double& operator [] (int i) { return data_ [i]; }
|
double* data_;
|
double* data_;
|
};
|
};
|
|
|
inline int element (int i, int j) {
|
inline int element (int i, int j) {
|
return i + j;
|
return i + j;
|
}
|
}
|
|
|
template
|
template
|
struct matrix {
|
struct matrix {
|
inline matrix () : size2_ (3) {}
|
inline matrix () : size2_ (3) {}
|
|
|
inline unbounded_array<> &data () { return data_; }
|
inline unbounded_array<> &data () { return data_; }
|
|
|
inline double& el (int i, int j) {
|
inline double& el (int i, int j) {
|
int dead1 = j;
|
int dead1 = j;
|
int dead2 = 1 + i - j;
|
int dead2 = 1 + i - j;
|
if (j < size2_ && i-j < 2)
|
if (j < size2_ && i-j < 2)
|
return data () [element (j,i-j+1)];
|
return data () [element (j,i-j+1)];
|
barrier ();
|
barrier ();
|
return zero_;
|
return zero_;
|
}
|
}
|
|
|
struct iterator2;
|
struct iterator2;
|
|
|
inline iterator2 find () {
|
inline iterator2 find () {
|
return iterator2 (*this);
|
return iterator2 (*this);
|
}
|
}
|
|
|
struct iterator1 {
|
struct iterator1 {
|
inline iterator1 (matrix *m):
|
inline iterator1 (matrix *m):
|
dead1 (m), i (0) {}
|
dead1 (m), i (0) {}
|
void *dead1;
|
void *dead1;
|
int i;
|
int i;
|
int dead2;
|
int dead2;
|
};
|
};
|
|
|
const int size2_;
|
const int size2_;
|
unbounded_array<> data_;
|
unbounded_array<> data_;
|
};
|
};
|
|
|
|
|
template
|
template
|
struct adaptor {
|
struct adaptor {
|
adaptor (matrix<> &m) : m(&m), upper_ (1) {}
|
adaptor (matrix<> &m) : m(&m), upper_ (1) {}
|
|
|
int size1 () const;
|
int size1 () const;
|
int size2 () const { return 3; }
|
int size2 () const { return 3; }
|
int lower () const { return 1; }
|
int lower () const { return 1; }
|
int upper () const { return upper_; }
|
int upper () const { return upper_; }
|
matrix<> &data () { return *m; }
|
matrix<> &data () { return *m; }
|
|
|
double& el (int i, int j) {
|
double& el (int i, int j) {
|
int dead1, dead2;
|
int dead1, dead2;
|
if (j < size2 () && i-j < 1)
|
if (j < size2 () && i-j < 1)
|
return data ().el (i, j);
|
return data ().el (i, j);
|
|
|
barrier ();
|
barrier ();
|
return zero_;
|
return zero_;
|
}
|
}
|
|
|
struct a_iterator2;
|
struct a_iterator2;
|
|
|
struct a_iterator1 {
|
struct a_iterator1 {
|
a_iterator1 (adaptor &a, const matrix<>::iterator1 &it1):
|
a_iterator1 (adaptor &a, const matrix<>::iterator1 &it1):
|
a (&a), dead1 (it1) {}
|
a (&a), dead1 (it1) {}
|
|
|
a_iterator2 begin () const {
|
a_iterator2 begin () const {
|
return a_iterator2(*a);
|
return a_iterator2(*a);
|
}
|
}
|
adaptor *a;
|
adaptor *a;
|
matrix<>::iterator1 dead1;
|
matrix<>::iterator1 dead1;
|
};
|
};
|
|
|
struct a_iterator2 {
|
struct a_iterator2 {
|
a_iterator2 (adaptor &a) : a (&a) {}
|
a_iterator2 (adaptor &a) : a (&a) {}
|
|
|
double& f () const {
|
double& f () const {
|
int i = 0;
|
int i = 0;
|
int l = a->upper () + i;
|
int l = a->upper () + i;
|
int q = a->size2 ();
|
int q = a->size2 ();
|
if (0 < q &&
|
if (0 < q &&
|
l < a->lower () + 1 + a->upper ())
|
l < a->lower () + 1 + a->upper ())
|
return a->m->el(0,0);
|
return a->m->el(0,0);
|
|
|
return a->el (i, 0);
|
return a->el (i, 0);
|
}
|
}
|
|
|
adaptor *a;
|
adaptor *a;
|
};
|
};
|
|
|
matrix<> *m;
|
matrix<> *m;
|
int upper_;
|
int upper_;
|
};
|
};
|
|
|
void matrix_swap (adaptor<> &bam1, adaptor<> &bam2)
|
void matrix_swap (adaptor<> &bam1, adaptor<> &bam2)
|
{
|
{
|
adaptor<>::a_iterator1 it1 (bam1,matrix<>::iterator1(bam1.m)),
|
adaptor<>::a_iterator1 it1 (bam1,matrix<>::iterator1(bam1.m)),
|
it2 (bam2,matrix<>::iterator1(bam2.m));
|
it2 (bam2,matrix<>::iterator1(bam2.m));
|
int dead;
|
int dead;
|
double x = it1.begin().f();
|
double x = it1.begin().f();
|
it2.begin().f() = x;
|
it2.begin().f() = x;
|
}
|
}
|
|
|
int main ()
|
int main ()
|
{
|
{
|
matrix<> m1,m2;
|
matrix<> m1,m2;
|
adaptor<> bam1 (m1), bam2 (m2);
|
adaptor<> bam1 (m1), bam2 (m2);
|
matrix_swap (bam1, bam2);
|
matrix_swap (bam1, bam2);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
