Subversion Repositories openrisc

pr42760.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr32563.C =================================================================== --- pr32563.C (nonexistent) +++ pr32563.C (revision 338) @@ -0,0 +1,8 @@ +/* { dg-do compile } */ + +struct A +{ + char c[1]; +} a; + +const __SIZE_TYPE__ i = (__SIZE_TYPE__)&a.c[0] - 1;

pr32563.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr36444.C =================================================================== --- pr36444.C (nonexistent) +++ pr36444.C (revision 338) @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +#define vector __attribute__((vector_size(16) )) +struct struct1 { + union {} vmx; + struct struct2 { + struct2(const struct2& r) {} + } w; +} __attribute__((aligned(16))); +struct struct3 { + vector float vmx; + operator const struct1& () const{ + return *reinterpret_cast(this); + } +}; +struct3 func3( struct3 V1); +struct3 func2( void ); +void func1( ) { + struct1 vVec = func2() ; + func3 ( (struct3&)vVec ); +} +

pr36444.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr33735.C =================================================================== --- pr33735.C (nonexistent) +++ pr33735.C (revision 338) @@ -0,0 +1,21 @@ +// { dg-do compile } +#include +typedef struct _ts { } PyThreadState; +PyThreadState * Py_NewInterpreter(void); +void Py_EndInterpreter(PyThreadState *); +class ApplicationError { +public: + ApplicationError(std::string errormsg) : errormsg(errormsg) { } + std::string errormsg; +}; +void run() +{ + PyThreadState *py_state=__null; + try { + if (!(py_state=Py_NewInterpreter())) + throw ApplicationError("error"); + } + catch(ApplicationError e) { + Py_EndInterpreter(py_state); + } +}

pr33735.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr43257.C =================================================================== --- pr43257.C (nonexistent) +++ pr43257.C (revision 338) @@ -0,0 +1,30 @@ +/* { dg-do assemble } */ + +class A {}; +class B {}; + +static void *func (int n) +{ + void *p; + if (p == 0) throw ::A (); +} + +static void *func (int n, B const &) +{ + try { + return func (n); + } + catch (::A const &) { + } + return func (n); +} + +void *f1 (int n) +{ + return func (n, B()); +} + +void *f2 (int n) +{ + return func (n, B()); +}

pr43257.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr37354.C =================================================================== --- pr37354.C (nonexistent) +++ pr37354.C (revision 338) @@ -0,0 +1,14 @@ +/* { dg-do compile } */ + +class GenericClass; +struct AlsaDriver +{ + virtual int _read (unsigned nframes); +}; +typedef void (GenericClass::*GenericMemFuncType) (); +GenericMemFuncType m_pFunction; +void AlsaDriver1 () +{ + m_pFunction = reinterpret_cast < GenericMemFuncType > (&AlsaDriver::_read); +} +

pr37354.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr39713.C =================================================================== --- pr39713.C (nonexistent) +++ pr39713.C (revision 338) @@ -0,0 +1,25 @@ +/* { dg-do compile } */ + +template +static inline To +bitwise_cast (From from) +{ + union + { + From f; + To t; + } u; + u.f = from; + return u.t; +} + +extern void foo (unsigned char *); + +double +bar () +{ + unsigned char b[sizeof (unsigned long long)]; + foo (b); + return bitwise_cast (*(unsigned long long *) b); +} +

pr39713.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr38705.C =================================================================== --- pr38705.C (nonexistent) +++ pr38705.C (revision 338) @@ -0,0 +1,27 @@ +// PR c++/38705 +// { dg-do compile } + +typedef int T; +typedef __SIZE_TYPE__ size_t; +extern "C" void *memcpy (void *, const void *, size_t); + +void +foo (char *p, const int q) +{ + memcpy (p, &q, sizeof (int)); +} + +struct S +{ + T t; + int u; + int bar () const; + template void foo (const T &x) const {} +}; + +int +S::bar () const +{ + foo (u); + foo (t); +}

pr38705.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr40388.C =================================================================== --- pr40388.C (nonexistent) +++ pr40388.C (revision 338) @@ -0,0 +1,21 @@ +void foo(); + +struct A +{ + ~A() + { + try + { + foo(); + foo(); + } + catch (...) + { + } + } +}; + +void bar() +{ + A a1, a2; +}

pr40388.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr44069.C =================================================================== --- pr44069.C (nonexistent) +++ pr44069.C (revision 338) @@ -0,0 +1,25 @@ +/* { dg-do run } */ + +template +class M { +public: + M(const int* arr) { + for (unsigned long r = 0; r < R; ++r) + for (unsigned long c = 0; c < C; ++c) + m[r*C+c] = arr[r*C+c]; + } + int operator()(unsigned r, unsigned c) const + { return m[r*C+c]; } +private: + int m[R*C]; +}; +extern "C" void abort (void); +int main() +{ + int vals[2][2] = { { 1, 2 }, { 5, 6 } }; + M<2,2> m( &(vals[0][0]) ); + if (m(1,0) != 5) + abort (); + return 0; +} +

pr44069.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr39732.C =================================================================== --- pr39732.C (nonexistent) +++ pr39732.C (revision 338) @@ -0,0 +1,29 @@ +/* { dg-do compile } */ +/* { dg-options "-fprofile-generate" } */ + +template struct char_traits; +template +_OI __copy_move_a2(_OI __result); +template inline _OI +copy(_OI __result) +{ + return __copy_move_a2 (__result); +} +template +class basic_ostream { }; +template > +class ostream_iterator { + typedef basic_ostream<_CharT, _Traits> ostream_type; + ostream_type* _M_stream; + const _CharT* _M_string; +public: + ostream_iterator(ostream_type& __s, const _CharT* __c) + : _M_stream(&__s), _M_string(__c) { } + ostream_iterator(const ostream_iterator& __obj) + : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { } +}; +int f(void) +{ + basic_ostream > os; + copy(ostream_iterator(os, ",")); +}

pr39732.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr37716.C =================================================================== --- pr37716.C (nonexistent) +++ pr37716.C (revision 338) @@ -0,0 +1,56 @@ +// PR tree-optimization/37716 +// { dg-do compile } + +struct A +{ + struct B + { + int a, b, c, d; + void *e[1]; + }; + B *d; + inline void **f1 (int i) const + { + return d->e + d->c + i; + } +}; + +template +struct C +{ + struct D + { + void *v; + inline T & f3 () + { + return *reinterpret_cast (this); + } + }; + union + { + A p; + A::B *d; + }; + T & operator[](int i) + { + if (d->a != 1) + f2 (); + return reinterpret_cast (p.f1 (i))->f3 (); + } + void f2 (); + void f3 (int i, const T & t); +}; + +class E +{ + int e, f; +}; + +C c; + +void +foo (int x) +{ + E e = c[x]; + c.f3 (x, e); +}

pr37716.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr41775.C =================================================================== --- pr41775.C (nonexistent) +++ pr41775.C (revision 338) @@ -0,0 +1,284 @@ +/* { dg-do compile } */ +/* { dg-require-visibility "" } */ + +typedef unsigned int size_t; +namespace std __attribute__ ((__visibility__ ("default"))) +{ + template < typename _Iterator > struct iterator_traits + { + }; + template < typename _Tp > struct iterator_traits <_Tp * > + { + typedef _Tp & reference; + }; +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + using std::iterator_traits; + template < typename _Iterator, typename _Container > class __normal_iterator + { + public:typedef _Iterator iterator_type; + typedef typename iterator_traits < _Iterator >::reference reference; + reference operator* () const + { + } + __normal_iterator operator++ (int) + { + } + }; + template < typename _IteratorL, typename _IteratorR, + typename _Container > inline bool operator!= (const __normal_iterator < + _IteratorL, + _Container > &__lhs, + const __normal_iterator < + _IteratorR, + _Container > &__rhs) + { + } +} + +extern "C" +{ + extern "C" + { + __extension__ typedef __SIZE_TYPE__ __intptr_t; + } +} +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + template < typename _Tp > class new_allocator + { + public:typedef size_t size_type; + typedef _Tp *pointer; + template < typename _Tp1 > struct rebind + { + typedef new_allocator < _Tp1 > other; + }; + }; +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +template < typename _Tp > class allocator:public __gnu_cxx::new_allocator < + _Tp > + { + }; +} + +extern "C" +{ + typedef __intptr_t intptr_t; +} +namespace llvm +{ + template < typename NodeTy > class ilist_half_node + { + }; +template < typename NodeTy > class ilist_node:private ilist_half_node < + NodeTy > + { + }; + class MachineBasicBlock; + class MachineOperand + { + public:enum MachineOperandType + { + } + Contents; + unsigned getReg () const + { + } + }; + class TargetRegisterInfo; +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + template < typename _Tp, typename _Alloc > struct _Vector_base + { + typedef typename _Alloc::template rebind < _Tp >::other _Tp_alloc_type; + }; +template < typename _Tp, typename _Alloc = std::allocator < _Tp > >class vector:protected _Vector_base < _Tp, + _Alloc + > + { + typedef _Vector_base < _Tp, _Alloc > _Base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + public:typedef _Tp value_type; + typedef typename _Tp_alloc_type::pointer pointer; + typedef __gnu_cxx::__normal_iterator < pointer, vector > iterator; + iterator begin () + { + } + iterator end () + { + } + }; +} + +namespace llvm +{ + class MachineFunction; + class MachineInstr:public ilist_node < MachineInstr > + { + public:const MachineBasicBlock *getParent () const + { + } + const MachineOperand & getOperand (unsigned i) const + { + } + bool registerDefIsDead (unsigned Reg, const TargetRegisterInfo * TRI = + __null) const + { + } + }; + class AnalysisResolver; + class Pass + { + AnalysisResolver *Resolver; + intptr_t PassID; + public: explicit Pass (intptr_t pid):Resolver (0), PassID (pid) + { + } + explicit Pass (const void *pid):Resolver (0), PassID ((intptr_t) pid) + { + } + template < typename AnalysisType > AnalysisType & getAnalysis () const; + }; + class FunctionPass:public Pass + { + public:explicit FunctionPass (intptr_t pid):Pass (pid) + { + } + explicit FunctionPass (const void *pid):Pass (pid) + { + } + }; + class PassInfo + { + public:typedef Pass *(*NormalCtor_t) (); + private:const char *const PassName; + const char *const PassArgument; + const intptr_t PassID; + const bool IsCFGOnlyPass; + const bool IsAnalysis; + const bool IsAnalysisGroup; + NormalCtor_t NormalCtor; + public: PassInfo (const char *name, const char *arg, intptr_t pi, NormalCtor_t normal = 0, bool isCFGOnly = false, bool is_analysis = false):PassName (name), PassArgument (arg), PassID (pi), + IsCFGOnlyPass (isCFGOnly), IsAnalysis (is_analysis), + IsAnalysisGroup (false), NormalCtor (normal) + { + } + }; + template < typename PassName > Pass * callDefaultCtor () + { + return new PassName (); + } + template < typename passName > struct RegisterPass:public PassInfo + { + RegisterPass (const char *PassArg, const char *Name, bool CFGOnly = false, bool is_analysis = false):PassInfo (Name, PassArg, intptr_t (&passName::ID), + PassInfo::NormalCtor_t (callDefaultCtor < passName >), CFGOnly, + is_analysis) + { + } + }; + template < typename T > class SmallVectorImpl + { + }; + template < typename T, + unsigned N > class SmallVector:public SmallVectorImpl < T > + { + }; + class MachineFunctionPass:public FunctionPass + { + protected:explicit MachineFunctionPass (intptr_t ID):FunctionPass (ID) + { + } + explicit MachineFunctionPass (void *ID):FunctionPass (ID) + { + } + virtual bool runOnMachineFunction (MachineFunction & MF) = 0; + }; + class LiveIndex + { + private:unsigned index; + }; + class VNInfo + { + }; + struct LiveRange + { + LiveIndex start; + LiveIndex end; + VNInfo *valno; + }; + class LiveInterval + { + public:typedef SmallVector < LiveRange, 4 > Ranges; + bool containsOneValue () const + { + } + LiveRange *getLiveRangeContaining (LiveIndex Idx) + { + } + void removeRange (LiveIndex Start, LiveIndex End, bool RemoveDeadValNo = + false); + void removeRange (LiveRange LR, bool RemoveDeadValNo = false) + { + removeRange (LR.start, LR.end, RemoveDeadValNo); + } + }; + class LiveIntervals:public MachineFunctionPass + { + public:static char ID; + LiveIndex getDefIndex (LiveIndex index) + { + } + LiveInterval & getInterval (unsigned reg) + { + } + LiveIndex getInstructionIndex (const MachineInstr * instr) const + { + } + }; +} + +using namespace llvm; +namespace +{ +struct __attribute__ ((visibility ("hidden"))) StrongPHIElimination:public + MachineFunctionPass + { + static char ID; + StrongPHIElimination ():MachineFunctionPass (&ID) + { + } + bool runOnMachineFunction (MachineFunction & Fn); + }; +} + +static RegisterPass < StrongPHIElimination > X ("strong-phi-node-elimination", + "Eliminate PHI nodes for register allocation, intelligently"); +bool +StrongPHIElimination::runOnMachineFunction (MachineFunction & Fn) +{ + LiveIntervals & LI = getAnalysis < LiveIntervals > (); + std::vector < MachineInstr * >phis; + for (std::vector < MachineInstr * >::iterator I = phis.begin (), E = + phis.end (); I != E;) + { + MachineInstr *PInstr = *(I++); + unsigned DestReg = PInstr->getOperand (0).getReg (); + LiveInterval & PI = LI.getInterval (DestReg); + if (PInstr->registerDefIsDead (DestReg)) + { + if (PI.containsOneValue ()) + { + LiveIndex idx = + LI.getDefIndex (LI.getInstructionIndex (PInstr)); + PI.removeRange (*PI.getLiveRangeContaining (idx), true); + } + } + } +}

pr41775.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr37456.C =================================================================== --- pr37456.C (nonexistent) +++ pr37456.C (revision 338) @@ -0,0 +1,14 @@ +/* { dg-do compile } */ + +int zot(int); +struct bar { + ~bar() { } +}; +int x; +void doit(int a, int b, int c) +{ + bar pn; + int b1 = zot(a) * c; + int b2 = zot(b) * c; + x = b1 + b2; +}

pr37456.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr42883.C =================================================================== --- pr42883.C (nonexistent) +++ pr42883.C (revision 338) @@ -0,0 +1,63 @@ +// { dg-do compile } + +typedef __SIZE_TYPE__ size_t; +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { + template class new_allocator { + public: + typedef size_t size_type; + typedef _Tp* pointer; + typedef _Tp& reference; + void deallocate(pointer __p, size_type) { + ::operator delete(__p); + } + }; +} +namespace std __attribute__ ((__visibility__ ("default"))) { + template class allocator: public __gnu_cxx::new_allocator<_Tp> { + public: + template struct rebind { + typedef allocator<_Tp1> other; + }; + }; + template struct _Vector_base { + typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type; + struct _Vector_impl : public _Tp_alloc_type { + typename _Tp_alloc_type::pointer _M_start; + typename _Tp_alloc_type::pointer _M_end_of_storage; + }; + ~_Vector_base() { + _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage - this->_M_impl._M_start); + } + _Vector_impl _M_impl; + void _M_deallocate(typename _Tp_alloc_type::pointer __p, size_t __n) { + if (__p) _M_impl.deallocate(__p, __n); + } + }; + template > class vector : protected _Vector_base<_Tp, _Alloc> { + typedef _Vector_base<_Tp, _Alloc> _Base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + public: + typedef typename _Tp_alloc_type::reference reference; + typedef size_t size_type; + size_type size() const { + } + reference operator[](size_type __n) { + } + }; +}; +class vtkConvexPointSet { +public: + static vtkConvexPointSet *New(); +}; +void MakeInternalMesh() { + std::vector< int > tempFaces[2]; + std::vector< int > firstFace; + int i, j, k; + for(i = 0; i < 1000; i++) { + for(int pointCount = 0; pointCount < 1000; pointCount++) { + for(j = 0; j < (int)tempFaces[0].size(); k++) + if(tempFaces[0][j] == tempFaces[1][k]) break; + } + vtkConvexPointSet::New(); + } +}

pr42883.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr38745.C =================================================================== --- pr38745.C (nonexistent) +++ pr38745.C (revision 338) @@ -0,0 +1,36 @@ +/* { dg-do compile } */ + +union u_u16 +{ + unsigned short v; + struct + { + unsigned char lo8, hi8; + } __attribute__ ((__may_alias__)) u; +} __attribute__ ((__may_alias__)); +union u_u32 +{ + unsigned int v; + struct + { + u_u16 lo16, hi16; + } u; +} __attribute__ ((__may_alias__)); +union u_u64 +{ + struct + { + u_u32 lo32, hi32; + } u; +}; +struct Record +{ +}; +long long +UnpackFullKey (Record & rec, const char *&p) +{ + long long c64 = 0; + (*(u_u16 *) & (*(u_u32 *) & ( *(u_u64*)&c64).u.lo32.v).u.lo16.v).u.hi8 = 1; + return c64; +} +

pr38745.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr39259.C =================================================================== --- pr39259.C (nonexistent) +++ pr39259.C (revision 338) @@ -0,0 +1,40 @@ +// PR tree-optimization/39259 +// { dg-do compile } +// { dg-options "-O2" } + + +extern "C" int __mysetjmp () __attribute__ ((__returns_twice__)); + +class TContStatus {}; + +class TContEvent +{ +public: + inline void Execute () throw(); +}; + +class TCont +{ +public: + TContStatus ReadD (void* buf, int deadline) + { + TContEvent event; + event.Execute (); + return TContStatus(); + } + TContStatus ReadI (void *buf) + { + return ReadD (buf, 1); + } +}; + +void TContEvent::Execute () throw () +{ + __mysetjmp(); +} + +void Broken (TCont *mCont) +{ + mCont->ReadI(0); + mCont->ReadI(0); +}

pr39259.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr38747.C =================================================================== --- pr38747.C (nonexistent) +++ pr38747.C (revision 338) @@ -0,0 +1,19 @@ +/* { dg-do run } */ + +extern "C" void abort (void); +inline void *operator new (__SIZE_TYPE__, void *__p) throw () { return __p; } + +int __attribute__((noinline)) +foo(void) +{ + float f = 0; + int *i = new (&f) int (1); + return *(int *)&f; +} + +int main() +{ + if (foo() != 1) + abort (); + return 0; +}

pr38747.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr39678.C =================================================================== --- pr39678.C (nonexistent) +++ pr39678.C (revision 338) @@ -0,0 +1,26 @@ +/* PR target/39678 */ +/* { dg-do run } */ +/* { dg-options "-Wno-psabi" } */ +struct Y {}; +struct X { + struct Y y; + __complex__ float val; +}; + +struct X __attribute__((noinline)) +foo (float *p) +{ + struct X x; + __real x.val = p[0]; + __imag x.val = p[1]; + return x; +} +extern "C" void abort (void); +float a[2] = { 3., -2. }; +int main() +{ + struct X x = foo(a); + if (__real x.val != 3. || __imag x.val != -2.) + abort (); + return 0; +}

pr39678.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr42110.C =================================================================== --- pr42110.C (nonexistent) +++ pr42110.C (revision 338) @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +bool foo(); + +struct A +{ + A* fooA() { if (foo()) foo(); return this; } + + virtual void barA(char); +}; + +template struct B +{ + A *p, *q; + + void fooB(char c) { p->fooA()->barA(c); } +}; + +template inline void bar(B b) { b.fooB(0); } + +extern template void bar(B<0>); + +void (*f)(B<0>) = bar; + +void baz() +{ + B<0>().fooB(0); +}

pr42110.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr31081-2.C =================================================================== --- pr31081-2.C (nonexistent) +++ pr31081-2.C (revision 338) @@ -0,0 +1,48 @@ +/* { dg-do compile } */ + +class CString +{ +public: + CString(); + ~CString() { operator delete(_rep); } + operator const char*() const { return _rep; } +private: + CString(char* cstr); + char* _rep; +}; + +class String +{ +public: + + String(); + String(const char* str); + ~String(); + CString getCString() const; +}; + +int is_absolute_path(const char *path); + +inline void getAbsolutePath( + const char* path, + const String& filename) +{ + (!is_absolute_path(filename.getCString()) && path); + return; +} + +int foo(int &value); + +int main(int argc, char** argv) +{ + int repeatTestCount = 0; + if (foo(repeatTestCount)) + { + repeatTestCount = 1; + } + for (int numTests = 1; numTests <= repeatTestCount; numTests++) + { + getAbsolutePath("blah", "blah"); + } + return 0; +}

pr31081-2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr30252.C =================================================================== --- pr30252.C (nonexistent) +++ pr30252.C (revision 338) @@ -0,0 +1,226 @@ +/* { dg-do run } */ +/* { dg-options "-fstrict-aliasing" } */ + +extern "C" void abort (void); +namespace sigc { + template + struct type_trait + { + typedef T_type& pass; + typedef const T_type& take; + typedef T_type* pointer; + }; + template + struct is_base_and_derived + { + struct big { + char memory[64]; + }; + static big is_base_class_(...); + static char is_base_class_(typename type_trait::pointer); + static const bool value = + sizeof(is_base_class_(reinterpret_cast::pointer>(0))) == + sizeof(char); + }; + struct nil; + struct functor_base {}; + template ::value> + struct functor_trait + { + }; + template + struct functor_trait + { + typedef typename T_functor::result_type result_type; + typedef T_functor functor_type; + }; + template + class pointer_functor1 : public functor_base + { + typedef T_return (*function_type)(T_arg1); + function_type func_ptr_; + public: + typedef T_return result_type; + explicit pointer_functor1(function_type _A_func): func_ptr_(_A_func) {} + T_return operator()(typename type_trait::take _A_a1) const + { return func_ptr_(_A_a1); } + }; + template + inline pointer_functor1 + ptr_fun1(T_return (*_A_func)(T_arg1)) + { return pointer_functor1(_A_func); } + struct adaptor_base : public functor_base {}; + template ::value> + struct deduce_result_type + { typedef typename functor_trait::result_type type; }; + template + struct adaptor_functor : public adaptor_base + { + template + struct deduce_result_type + { typedef typename sigc::deduce_result_type::type type; }; + typedef typename functor_trait::result_type result_type; + result_type + operator()() const; + template + typename deduce_result_type::type + operator()(T_arg1 _A_arg1) const + { return functor_(_A_arg1); } + explicit adaptor_functor(const T_functor& _A_functor) + : functor_(_A_functor) + {} + mutable T_functor functor_; + }; + template + typename adaptor_functor::result_type + adaptor_functor::operator()() const + { return functor_(); } + template ::value> struct adaptor_trait; + template + struct adaptor_trait + { + typedef T_functor adaptor_type; + }; + template + struct adaptor_trait + { + typedef typename functor_trait::functor_type functor_type; + typedef adaptor_functor adaptor_type; + }; + template + struct adapts : public adaptor_base + { + typedef typename adaptor_trait::adaptor_type adaptor_type; + explicit adapts(const T_functor& _A_functor) + : functor_(_A_functor) + {} + mutable adaptor_type functor_; + }; + template + struct reference_wrapper + { + }; + template + struct unwrap_reference + { + typedef T_type type; + }; + template + class bound_argument + { + public: + bound_argument(const T_type& _A_argument) + : visited_(_A_argument) + {} + inline T_type& invoke() + { return visited_; } + T_type visited_; + }; + template + class bound_argument< reference_wrapper > + { + }; + template + struct bind_functor; + template + struct bind_functor<-1, T_functor, T_type1> : public adapts + { + typedef typename adapts::adaptor_type adaptor_type; + typedef typename adaptor_type::result_type result_type; + result_type + operator()() + { + return this->functor_.template operator()::type>::pass> (bound1_.invoke()); + } + bind_functor(typename type_trait::take _A_func, typename type_trait::take _A_bound1) + : adapts(_A_func), bound1_(_A_bound1) + {} + bound_argument bound1_; + }; + template + inline bind_functor<-1, T_functor, + T_type1> + bind(const T_functor& _A_func, T_type1 _A_b1) + { return bind_functor<-1, T_functor, + T_type1> + (_A_func, _A_b1); + } + namespace internal { + struct slot_rep; + typedef void* (*hook)(slot_rep *); + struct slot_rep + { + hook call_; + }; + } + class slot_base : public functor_base + { + public: + typedef internal::slot_rep rep_type; + explicit slot_base(rep_type* rep) + : rep_(rep) + { + } + mutable rep_type *rep_; + }; + namespace internal { + template + struct typed_slot_rep : public slot_rep + { + typedef typename adaptor_trait::adaptor_type adaptor_type; + adaptor_type functor_; + inline typed_slot_rep(const T_functor& functor) + : functor_(functor) + { + } + }; + template + struct slot_call0 + { + static void *call_it(slot_rep* rep) + { + typedef typed_slot_rep typed_slot; + typed_slot *typed_rep = static_cast(rep); + return (typed_rep->functor_)(); + } + static hook address() + { + return &call_it; + } + }; + } + + class slot0 : public slot_base + { + public: + typedef void * (*call_type)(rep_type*); + inline void *operator()() const + { + return slot_base::rep_->call_ (slot_base::rep_); + } + template + slot0(const T_functor& _A_func) + : slot_base(new internal::typed_slot_rep(_A_func)) + { + slot_base::rep_->call_ = internal::slot_call0::address(); + } + }; +} +struct A +{ + static void *foo (void *p) { return p; } + typedef sigc::slot0 C; + C bar(); +}; +A::C A::bar () +{ + return sigc::bind (sigc::ptr_fun1 (&A::foo), (void*)0); +} +int main (void) +{ + A a; + if (a.bar ()() != 0) + abort (); +}

pr30252.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr33340.C =================================================================== --- pr33340.C (nonexistent) +++ pr33340.C (revision 338) @@ -0,0 +1,27 @@ +void* operator new(__SIZE_TYPE__, void* __p) { } + +struct auto_ptr { + int* p; + ~auto_ptr() { delete p; } +}; + +typedef void* T; +struct vector { + void push_back(const T& __x) { + ::new(0) T(__x); + insert(__x); + } + void insert(const T& __x); +} v; + +void g(); +void f() { + auto_ptr ap; + if (ap.p) { + ap.p = new int(); + } + g(); + int* tmp = ap.p; + ap.p = 0; + v.push_back(tmp); +}

pr33340.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr41144.C =================================================================== --- pr41144.C (nonexistent) +++ pr41144.C (revision 338) @@ -0,0 +1,23 @@ +/* { dg-do compile } */ + +struct rgba8; +template class span_gouraud { +public: + struct coord_type { }; + coord_type m_coord[3]; +}; +template class span_gouraud_rgba : public span_gouraud +{ + typedef ColorT color_type; + typedef span_gouraud base_type; + typedef typename base_type::coord_type coord_type; +public: + void prepare() { + coord_type coord[3]; + } +}; +void the_application() { + typedef span_gouraud_rgba gouraud_span_gen_type; + gouraud_span_gen_type span_gouraud; + span_gouraud.prepare(); +}

pr41144.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr42450.C =================================================================== --- pr42450.C (nonexistent) +++ pr42450.C (revision 338) @@ -0,0 +1,112 @@ +/* { dg-do compile } */ + +template < typename > class basic_stringstream; + +struct basic_string { + basic_string(); +}; + +struct ios_base { + virtual ~ios_base(); +}; + +class ostream:ios_base {}; +class istream:virtual ios_base {}; + +template < typename > struct basic_iostream:public istream, ostream { + ~basic_iostream () {} +}; +extern template class basic_iostream < char >; + +template < typename > struct basic_stringstream:public basic_iostream < char > { + basic_string _M_stringbuf; + ~basic_stringstream () {} +}; +extern template class basic_stringstream < char >; + +template < typename > struct AnyMatrixBase; +template < typename, int _Rows, int _Cols, int = _Rows, int = _Cols > class Matrix; +template < typename > class CwiseNullaryOp; + +template < typename Derived > struct MatrixBase:public AnyMatrixBase < Derived > { + typedef CwiseNullaryOp < Derived > ConstantReturnType; + ConstantReturnType Constant (); + template < typename > Derived cast (); + static CwiseNullaryOp < Derived > Random (int); +}; + +template < typename Derived > struct AnyMatrixBase { + Derived derived () {} + Derived & derived () const {} +}; + +template < typename, int > struct ei_matrix_storage {}; + +template < typename _Scalar, int, int, int _MaxRows, int _MaxCols > struct Matrix:MatrixBase < Matrix < _Scalar, _MaxRows, _MaxCols > > { + typedef MatrixBase < Matrix > Base; + ei_matrix_storage < int, _MaxCols > m_storage; + Matrix operator= (const Matrix other) { + _resize_to_match (other); + lazyAssign (other.derived ()); + } + template < typename OtherDerived > Matrix lazyAssign (MatrixBase < OtherDerived > other) { + _resize_to_match (other); + return Base (other.derived ()); + } + Matrix (); + template < typename OtherDerived > Matrix (const MatrixBase < OtherDerived > &other) { + *this = other; + } + template < typename OtherDerived > void _resize_to_match (const MatrixBase < OtherDerived > &) { + throw 1; + } +}; + +template < typename MatrixType > class CwiseNullaryOp: +public MatrixBase < CwiseNullaryOp < MatrixType > > {}; + +int f() +{ + bool align_cols; + if (align_cols) { + basic_stringstream sstr; + f(); + } +} + +template < typename > struct AutoDiffScalar; +template < typename Functor > struct AutoDiffJacobian:Functor { + AutoDiffJacobian (Functor); + typedef typename Functor::InputType InputType; + typedef typename Functor::ValueType ValueType; + typedef Matrix < int, Functor::InputsAtCompileTime, 1 > DerivativeType; + typedef AutoDiffScalar < DerivativeType > ActiveScalar; + typedef Matrix < ActiveScalar, Functor::InputsAtCompileTime, 1 > ActiveInput; + void operator () (InputType x, ValueType *) { + ActiveInput ax = x.template cast < ActiveScalar > (); + } +}; + +template < int NX, int NY > struct TestFunc1 { + enum { + InputsAtCompileTime = NX + }; + typedef Matrix < float, NX, 1 > InputType; + typedef Matrix < float, NY, 1 > ValueType; + typedef Matrix < float, NY, NX > JacobianType; + int inputs (); +}; + +template < typename Func > void forward_jacobian (Func f) { + typename Func::InputType x = Func::InputType::Random (f.inputs ()); + typename Func::ValueType y; + typename Func::JacobianType jref = jref.Constant (); + AutoDiffJacobian < Func > autoj (f); + autoj (x, &y); +} + +void test_autodiff_scalar () +{ + forward_jacobian (TestFunc1 < 2, 2 > ()); + forward_jacobian (TestFunc1 < 3, 2 > ()); +}

pr42450.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr43801.C =================================================================== --- pr43801.C (nonexistent) +++ pr43801.C (revision 338) @@ -0,0 +1,22 @@ +// PR tree-optimization/43801 +// { dg-do compile } +// { dg-options "-fipa-cp -fipa-cp-clone" } + +struct A +{ + virtual void f (int); +}; +struct B : virtual A +{ + virtual void f (int i) { if (i) A::f(0); } +}; +struct C : virtual B +{ + virtual void f (int) { B::f(0); } +}; + +void +foo () +{ + C (); +}

pr43801.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr37421.C =================================================================== --- pr37421.C (nonexistent) +++ pr37421.C (revision 338) @@ -0,0 +1,39 @@ +/* { dg-do compile } */ + +#include +#include + +inline int +bci (const float &source) +{ + int dest; + memcpy (&dest, &source, sizeof (dest)); + return dest; +} + +inline float +bcf (const int &source) +{ + float dest; + memcpy (&dest, &source, sizeof (dest)); + return dest; +} + +float +Foo () +{ + const int foo = bci (0.0f); + int bar = foo; + const int baz = foo & 1; + if (!baz && (foo & 2)) + bar = 0; + return bcf (bar); +} + +int +main () +{ + printf ("Foo() = %f\n", Foo()); + return 0; +} +

pr37421.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr34235.C =================================================================== --- pr34235.C (nonexistent) +++ pr34235.C (revision 338) @@ -0,0 +1,11 @@ +/* { dg-do run } */ + +extern "C" void abort (void); +int main() +{ + short x = -1; + unsigned int c = ((unsigned int)x) >> 1; + if (c != 0x7fffffff) + abort(); + return 0; +}

pr34235.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr35164-2.C =================================================================== --- pr35164-2.C (nonexistent) +++ pr35164-2.C (revision 338) @@ -0,0 +1,27 @@ +struct __shared_count { + __shared_count() { _M_pi = new int; } + int * _M_pi; +}; +template +class __shared_ptr { +public: + __shared_ptr(_Tp* __p); + void reset(int * __p) { + __shared_ptr(__p).swap(*this); + } + void swap(__shared_ptr<_Tp>& __other) { + __other._M_refcount._M_pi = _M_refcount._M_pi; + } + __shared_count _M_refcount; +}; +template class shared_ptr : public __shared_ptr<_Tp> {}; +int main() { + for (shared_ptr *iter;;) + { + try { + (iter++)->reset(new int); + } + catch (...) { + } + } +}

pr35164-2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr42714.C =================================================================== --- pr42714.C (nonexistent) +++ pr42714.C (revision 338) @@ -0,0 +1,37 @@ +struct QVectorData { + static QVectorData shared_null; +}; +template class QVector { + union { + QVectorData *d; + }; +public: + inline QVector() : d(&QVectorData::shared_null) { } + inline QVector(const QVector &v) : d(v.d) { } +}; +class QXmlStreamAttribute { }; +class QXmlStreamAttributes : public QVector { }; +class __attribute__ ((visibility("default"))) Smoke { +public: + union StackItem; + typedef StackItem* Stack; + typedef short Index; +}; +class SmokeBinding { }; +namespace __smokeqt { + class x_QXmlStreamAttributes : public QXmlStreamAttributes { + SmokeBinding* _binding; + public: + static void x_11(Smoke::Stack x) { + x_QXmlStreamAttributes* xret = new x_QXmlStreamAttributes(); + } + explicit x_QXmlStreamAttributes() : QXmlStreamAttributes() { } + }; + void xcall_QXmlStreamAttributes(Smoke::Index xi, void *obj, + Smoke::Stack args) + { + switch(xi) { + case 11: x_QXmlStreamAttributes::x_11(args); + } + } +}

pr42714.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr40834.C =================================================================== --- pr40834.C (nonexistent) +++ pr40834.C (revision 338) @@ -0,0 +1,52 @@ +/* { dg-do run } */ + +extern "C" void abort (void); +class XalanDOMString +{ +public: + int y; +}; + +class XObject +{ +public: + const XalanDOMString& str() const { return x; } + XalanDOMString x; +}; + +class XObjectPtr +{ +public: + XObjectPtr(const XObjectPtr& theSource) + { + m_xobjectPtr = theSource.m_xobjectPtr; + } + const XObject* operator->() const + { + return m_xobjectPtr; + }; + XObjectPtr(XObject *p) { m_xobjectPtr = p; } + XObject* m_xobjectPtr; +}; + +class FunctionSubstringBefore +{ +public: + int execute( const XObjectPtr arg1) const + { + const XalanDOMString& theFirstString = arg1->str(); + return theFirstString.y; + } +}; + +int +main () +{ + XObject x; + XObjectPtr y (&x); + x.x.y = -1; + FunctionSubstringBefore z; + if (z.execute (y) != -1) + abort (); + return 0; +}

pr40834.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr41680.C =================================================================== --- pr41680.C (nonexistent) +++ pr41680.C (revision 338) @@ -0,0 +1,23 @@ +// PR target/41680 +// { dg-do compile } + +extern void baz (float); + +inline bool +bar (float x) +{ + union { float f; int i; } u; + u.f = x; + return (u.i & 1); +} + +void +foo (float *x) +{ + for (int i = 0; i < 10; i++) + { + float f = x[i]; + if (!bar (f)) + baz (f); + } +}

pr41680.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr37146-2.C =================================================================== --- pr37146-2.C (nonexistent) +++ pr37146-2.C (revision 338) @@ -0,0 +1,67 @@ +// PR c++/37146 +// { dg-do run } + +extern "C" void abort (); +int a, b; +struct A { int i:8; int j:8; int k:16; int l:32; } c; + +int +f1 (int x) +{ + return x ? a : b; +} + +int +f2 (int x) +{ + return x ? c.i : c.j; +} + +int +f3 (int x) +{ + return x ? c.i : a; +} + +int +f4 (int x) +{ + return x ? c.i : c.k; +} + +int +f5 (int x) +{ + return x ? c.l : b; +} + +int +main () +{ + a = 17; + b = 18; + c.i = 19; + c.j = 20; + c.k = 21; + c.l = 22; + if (f1 (1) != a) + abort (); + if (f1 (0) != b) + abort (); + if (f2 (1) != c.i) + abort (); + if (f2 (0) != c.j) + abort (); + if (f3 (1) != c.i) + abort (); + if (f3 (0) != a) + abort (); + if (f4 (1) != c.i) + abort (); + if (f4 (0) != c.k) + abort (); + if (f5 (1) != c.l) + abort (); + if (f5 (0) != b) + abort (); +}

pr37146-2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr36191.C =================================================================== --- pr36191.C (nonexistent) +++ pr36191.C (revision 338) @@ -0,0 +1,17 @@ +// PR c++/36191 +// { dg-do compile } +// { dg-options "-fnon-call-exceptions" } +// { dg-skip-if "Frame pointer required for unwind tables" { sh*-*-* m68k*-*-* fido*-*-* } "-fomit-frame-pointer" "" } + +__complex__ double +foo (__complex__ double x, double y) +{ + try + { + return x / y; + } + catch (char *s) + { + return x; + } +}

pr36191.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr34850.C =================================================================== --- pr34850.C (nonexistent) +++ pr34850.C (revision 338) @@ -0,0 +1,74 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +typedef unsigned char uint8_t; +typedef unsigned int uint32_t; +typedef uint8_t byte; +typedef uint32_t u32bit; +__extension__ typedef __SIZE_TYPE__ size_t; +extern "C" { + extern void __warn_memset_zero_len (void) __attribute__((__warning__ (""))); + extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) + void * memset (void *__dest, int __ch, size_t __len) throw () { + if (__builtin_constant_p (__len) && __len == 0) + __warn_memset_zero_len (); /* { dg-warning "" } */ + } +} +inline void clear_mem(void* ptr, u32bit n) { + memset(ptr, 0, n); +} +template class MemoryRegion { +public: + u32bit size() const { + } + const T* begin() const { + } + void set(const T in[], u32bit n) { + create(n); + } + void set(const MemoryRegion& in) { + set(in.begin(), in.size()); + } + void clear() { + clear_mem(buf, allocated); + } + void create(u32bit); + MemoryRegion() { + used = allocated = 0; + } + mutable T* buf; + mutable u32bit used; + mutable u32bit allocated; +}; +template void MemoryRegion::create(u32bit n) { + if(n <= allocated) { + clear(); + } +} +template class SecureVector : public MemoryRegion { +public: + SecureVector& operator=(const MemoryRegion& in) { + if(this != &in) set(in); + } +}; +class OctetString { +public: + SecureVector bits_of() const { + } + OctetString& operator^=(const OctetString&); + void change(const MemoryRegion& in) { + bits = in; + } + OctetString(const MemoryRegion& in) { + change(in); + } + SecureVector bits; +}; +OctetString& OctetString::operator^=(const OctetString& k) { + if(&k == this) { + bits.clear(); + } +} +bool operator==(const OctetString& s1, const OctetString& s2) { + return (s1.bits_of() == s2.bits_of()); +}

pr34850.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr41186.C =================================================================== --- pr41186.C (nonexistent) +++ pr41186.C (revision 338) @@ -0,0 +1,29 @@ +/* { dg-do run } */ + +struct Foo { + Foo() {}; + int i; + short f; +}; +struct Bar : public Foo { + Bar() {}; + short b; +}; + +extern "C" void abort(void); + +int main() +{ + Bar b1, b2; + b2.i = 0; + b1.f = 0; + b1.b = 1; + b2.f = 1; + b2.b = 2; + static_cast(b1) = static_cast(b2); + if (b1.i != 0 || b1.b != 1) + abort (); + if (b1.f != 1) + abort (); + return 0; +}

pr41186.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr35526.C =================================================================== --- pr35526.C (nonexistent) +++ pr35526.C (revision 338) @@ -0,0 +1,18 @@ +/* { dg-do compile } */ + +extern void *memcpy (void *__dest, __const void *__src, __SIZE_TYPE__ __n); + +char internal_crash_read_ip[] = { 0xb8 }; + +struct u_internal_crash_read_t +{ + char ip[sizeof (internal_crash_read_ip)]; +} +u_internal_crash_read; + +void +gSignalHandler (int psignalNr, int pinfo, int pctx) +{ + memcpy (u_internal_crash_read.ip, internal_crash_read_ip, + sizeof (internal_crash_read_ip)); +}

pr35526.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr33627.C =================================================================== --- pr33627.C (nonexistent) +++ pr33627.C (revision 338) @@ -0,0 +1,57 @@ +/* { dg-do compile } */ + +typedef unsigned int UT_uint32; +typedef UT_uint32 PT_DocPosition; +typedef UT_uint32 PT_BlockOffset; +typedef enum _PTStruxType { PTX_Block } PTStruxType; +typedef UT_uint32 PL_ListenerId; +typedef const void * PL_StruxFmtHandle; +class PX_ChangeRecord; +class pf_Frag { + public: + typedef enum _PFType { PFT_Object } PFType; + inline PFType getType(void) const { } + inline pf_Frag * getNext(void) const { } + PT_DocPosition getPos(void) const { } +}; +class pf_Fragments { + public: + pf_Frag * getFirst() const; +}; +class pt_PieceTable { + bool getStruxOfTypeFromPosition(PL_ListenerId listenerId, PT_DocPosition docPos, PTStruxType pts, PL_StruxFmtHandle * psfh) const; + bool _tellAndMaybeAddListener(PL_ListenerId listenerId, bool bAdd); + pf_Fragments m_fragments; +}; +class pf_Frag_Object : public pf_Frag +{ + public: + virtual bool createSpecialChangeRecord(PX_ChangeRecord ** ppcr, PT_DocPosition dpos, PT_BlockOffset blockOffset) const; +}; +bool pt_PieceTable::_tellAndMaybeAddListener(PL_ListenerId listenerId, bool bAdd) +{ + PL_StruxFmtHandle sfh = 0; + PT_DocPosition sum = 0; + UT_uint32 blockOffset = 0; + for (pf_Frag * pf = m_fragments.getFirst(); (pf); pf=pf->getNext()) + { + pf_Frag_Object * pfo = static_cast (pf); + PX_ChangeRecord * pcr = __null; + bool bStatus1 = false; + if(sfh != __null) { + bStatus1 = pfo->createSpecialChangeRecord(&pcr,sum,blockOffset); + if (!(bStatus1)) + return (false); + } + else + { + PT_DocPosition pos = pf->getPos(); + getStruxOfTypeFromPosition(listenerId,pos,PTX_Block,&sfh); + bStatus1 = pfo->createSpecialChangeRecord(&pcr,pos,blockOffset); + if (!(bStatus1)) + return (false); + } + if (!(bStatus1)) + return (false); + } +}

pr33627.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr43068.C =================================================================== --- pr43068.C (nonexistent) +++ pr43068.C (revision 338) @@ -0,0 +1,10 @@ +/* { dg-do compile } */ +/* { dg-options "-freorder-blocks -ftracer} */ + +struct A { + virtual A *f(); +}; +struct B : virtual A { + virtual B *f(); +}; +B *B::f() { return 0; }

pr43068.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr43905.C =================================================================== --- pr43905.C (nonexistent) +++ pr43905.C (revision 338) @@ -0,0 +1,13 @@ +extern void sf ( __const char *); +struct Matrix{ + int operator[](int n){ + sf ( __PRETTY_FUNCTION__); + } + int operator[](int n)const{ + sf ( __PRETTY_FUNCTION__); + } +}; +void calcmy(Matrix const &b, Matrix &c, int k){ + b[k]; + c[k]; +}

pr43905.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr42871.C =================================================================== --- pr42871.C (nonexistent) +++ pr42871.C (revision 338) @@ -0,0 +1,40 @@ +struct C +{ + ~C (); + int c3; +}; + +C *b2; + +static void +b1 (const C &x, unsigned b3, unsigned b4) +{ + unsigned i = 0; + for (; i < b3; i++) + if (i < b4) + { + b2[0].c3 = x.c3; + return; + } +} + +int a (); + +void +bar (unsigned b3, unsigned b4) +{ + C c[100]; + for (int i = 0; i < 100; i++) + { + c[i].c3 = i; + for (int j = 0; j < b3; j++) + if (j < b4) + { + b2[0].c3 = 0; + break; + } + b1 (c[i], b3, b4); + a (); + } +} +

pr42871.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: predcom-1.C =================================================================== --- predcom-1.C (nonexistent) +++ predcom-1.C (revision 338) @@ -0,0 +1,29 @@ +/* Test for ICE in predictive commoning with empty loop header block + on arm-none-linux-gnueabi. */ + +struct Foo +{ + double *ptr; + + Foo (double *ptr_) + : ptr (ptr_) + { + } + + Foo PostInc () + { + return Foo (ptr++); + } +}; + +bool Baz (Foo first, double *last) +{ + Foo prev (first.ptr); + + first.ptr++; + + while (first.ptr != last) + if (*first.PostInc ().ptr < *prev.PostInc ().ptr) + return false; +} +

predcom-1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr39362.C =================================================================== --- pr39362.C (nonexistent) +++ pr39362.C (revision 338) @@ -0,0 +1,105 @@ +/* { dg-do compile } */ + +void *fastMalloc (int n); +void fastFree (void *p); +template struct C +{ + void deref () { delete static_cast (this); } +}; +template +struct D +{ + D (T *ptr) : m_ptr (ptr) { } + ~D () { if (T * ptr = m_ptr) ptr->deref (); } + T *operator-> () const; + T *m_ptr; + typedef T *UnspecifiedBoolType; + operator UnspecifiedBoolType () const; +}; +template struct E +{ + static void destruct (T * begin, T * end) + { + for (T * cur = begin; cur != end; ++cur) + cur->~T (); + } +}; +template class F; +template struct G +{ + static void destruct (T * begin, T * end) + { + E ::destruct (begin, end); + } + static void uninitializedFill (T * dst, T * dstEnd, const T & val) + { + F::uninitializedFill (dst, dstEnd, val); + } +}; +template struct H +{ + void allocateBuffer (int newCapacity) + { + m_buffer = static_cast (fastMalloc (newCapacity * sizeof (T))); + } + void deallocateBuffer (T * bufferToDeallocate) + { + if (m_buffer == bufferToDeallocate) + fastFree (bufferToDeallocate); + } + T *buffer () { } + int capacity () const { } + T *m_buffer; +}; +template class I; +template struct I : H +{ + I (int capacity) { allocateBuffer (capacity); } + ~I () { deallocateBuffer (buffer ()); } + using H ::allocateBuffer; + H ::buffer; +}; +template struct J +{ + typedef T *iterator; + ~J () { if (m_size) shrink (0); } + J (const J &); + int capacity () const { m_buffer.capacity (); } + T & operator[](int i) { } + iterator begin () { } + iterator end () { return begin () + m_size; } + void shrink (int size); + template void append (const U &); + int m_size; + I m_buffer; +}; +template +J ::J (const J & other) : m_buffer (other.capacity ()) +{ +} +template +void J ::shrink (int size) +{ + G ::destruct (begin () + size, end ()); + m_size = size; +} +struct A : public C +{ + virtual ~A (); + typedef J > B; + virtual A *firstChild () const; + virtual A *nextSibling () const; + virtual const B & children (int length); + B m_children; +}; +const A::B & +A::children (int length) +{ + for (D obj = firstChild (); obj; obj = obj->nextSibling ()) + { + B children = obj->children (2); + for (unsigned i = 0; i

pr39362.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr40991.C =================================================================== --- pr40991.C (nonexistent) +++ pr40991.C (revision 338) @@ -0,0 +1,113 @@ +/* { dg-options "-std=gnu++0x" } */ + +typedef __SIZE_TYPE__ size_t; +namespace std __attribute__ ((__visibility__ ("default"))) { + using ::size_t; + void __throw_bad_function_call() __attribute__((__noreturn__)); +} +inline void* operator new(std::size_t, void* __p) throw() { + return __p; +} +namespace std { + class type_info { + public: + bool operator==(const type_info& __arg) const { } + }; + namespace tr1 { + template struct integral_constant { }; + typedef integral_constant true_type; + template + struct _Maybe_unary_or_binary_function { }; + class _Undefined_class; + union _Nocopy_types { + void (_Undefined_class::*_M_member_pointer)(); + }; + union _Any_data { + void* _M_access() { + return &_M_pod_data[0]; + } + char _M_pod_data[sizeof(_Nocopy_types)]; + }; + enum _Manager_operation { __get_type_info, __get_functor_ptr, __clone_functor, __destroy_functor }; + template struct _Simple_type_wrapper { + _Simple_type_wrapper(_Tp __value) : __value(__value) { } + _Tp __value; + }; + template class function; + class _Function_base { + public: + static const std::size_t _M_max_size = sizeof(_Nocopy_types); + static const std::size_t _M_max_align = __alignof__(_Nocopy_types); + template class _Base_manager { + static const bool __stored_locally = (sizeof(_Functor) <= _M_max_size && __alignof__(_Functor) <= _M_max_align && (_M_max_align % __alignof__(_Functor) == 0)); + typedef integral_constant _Local_storage; + public: + static bool _M_manager(_Any_data& __dest, const _Any_data& __source, _Manager_operation __op) { } + static void _M_init_functor(_Any_data& __functor, const _Functor& __f) { + _M_init_functor(__functor, __f, _Local_storage()); + } + template static bool _M_not_empty_function(_Tp _Class::* const& __mp) { + return __mp; + } + static void _M_init_functor(_Any_data& __functor, const _Functor& __f, true_type) { + new (__functor._M_access()) _Functor(__f); + } + }; + ~_Function_base() { + if (_M_manager) _M_manager(_M_functor, _M_functor, __destroy_functor); + } + bool _M_empty() const { + return !_M_manager; + } + typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, _Manager_operation); + _Any_data _M_functor; + _Manager_type _M_manager; + }; + template class _Function_handler; + template class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> : public _Function_handler { + public: + static _Res _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { } + }; + template class _Function_handler : public _Function_base::_Base_manager< _Simple_type_wrapper< _Member _Class::* > > { }; + template class function<_Res(_ArgTypes...)> : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, private _Function_base { + typedef _Res _Signature_type(_ArgTypes...); + struct _Useless { }; + public: + template function(_Functor __f, _Useless = _Useless()); + _Res operator()(_ArgTypes... __args) const; + const type_info& target_type() const; + typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...); + _Invoker_type _M_invoker; + }; + template template function<_Res(_ArgTypes...)>:: function(_Functor __f, _Useless) : _Function_base() { + typedef _Function_handler<_Signature_type, _Functor> _My_handler; + if (_My_handler::_M_not_empty_function(__f)) { + _M_invoker = &_My_handler::_M_invoke; + _M_manager = &_My_handler::_M_manager; + _My_handler::_M_init_functor(_M_functor, __f); + } + } + template _Res function<_Res(_ArgTypes...)>:: operator()(_ArgTypes... __args) const { + if (_M_empty()) { + __throw_bad_function_call(); + } + return _M_invoker(_M_functor, __args...); + } + template const type_info& function<_Res(_ArgTypes...)>:: target_type() const { + if (_M_manager) { + _Any_data __typeinfo_result; + _M_manager(__typeinfo_result, _M_functor, __get_type_info); + } + } + } +} +struct X { + int bar; +}; +void test05() { + using std::tr1::function; + X x; + function frm(&X::bar); + frm(x) == 17; + typeid(int X::*) == frm.target_type(); +}

pr40991.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr42773.C =================================================================== --- pr42773.C (nonexistent) +++ pr42773.C (revision 338) @@ -0,0 +1,54 @@ +// { dg-do compile } +// { dg-options "-fno-exceptions" } + +typedef unsigned int uint; +struct QShared { + bool deref() { + return !--count; + } + uint count; +}; +template class QValueListNode { +public: + QValueListNode* next; + QValueListNode* prev; +}; +template class QValueListPrivate : public QShared { +public: + typedef QValueListNode Node; + typedef QValueListNode* NodePtr; + QValueListPrivate(); + void derefAndDelete() { + if ( deref() ) delete this; + } + ~QValueListPrivate(); + NodePtr node; +}; +template QValueListPrivate::QValueListPrivate() { + node = new Node; + node->next = node->prev = node; +} +template QValueListPrivate::~QValueListPrivate() { + NodePtr p = node->next; + while( p != node ) { + NodePtr x = p->next; + delete p; + p = x; + } +} +template class QValueList { +public: + QValueList() { + sh = new QValueListPrivate; + } + ~QValueList() { + sh->derefAndDelete(); + } + QValueListPrivate* sh; +}; +class Cell { + QValueList obscuringCells() const; +}; +QValueList Cell::obscuringCells() const { + QValueList empty; +}

pr42773.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr42890.C =================================================================== --- pr42890.C (nonexistent) +++ pr42890.C (revision 338) @@ -0,0 +1,25 @@ +// PR tree-optimization/42890 +// { dg-do compile } + +extern "C" int puts (const char *) throw (); + +struct S +{ + const char *a; + const char **b; + S (const char *s) { a = s; b = &a; } + ~S () { puts (a); } +}; + +void +foo (int (*fn) (const char *)) +{ + S a ("foo"); + fn ("bar"); +} + +int +main () +{ + foo (puts); +}

pr42890.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: type-generic-1.C =================================================================== --- type-generic-1.C (nonexistent) +++ type-generic-1.C (revision 338) @@ -0,0 +1,13 @@ +/* Do the type-generic tests. Unlike pr28796-2.c, we test these + without any fast-math flags. */ + +/* { dg-do run } */ +/* { dg-add-options ieee } */ +/* { dg-skip-if "No Inf/NaN support" { spu-*-* } } */ + +#include "../../gcc.dg/tg-tests.h" + +int main(void) +{ + return main_tests (); +}

type-generic-1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr42739.C =================================================================== --- pr42739.C (nonexistent) +++ pr42739.C (revision 338) @@ -0,0 +1,16 @@ +/* { dg-do compile } */ + +struct s { ~s() { s(); } }; + +int f() +{ + M: + s o = s(); + f(); + f(); + + L: + goto *(f() ? &&L : &&M); + + return 0; +}

pr42739.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr33589-2.C =================================================================== --- pr33589-2.C (nonexistent) +++ pr33589-2.C (revision 338) @@ -0,0 +1,13 @@ +// { dg-do compile } + +void f(void*) throw(); + +void somefunction() +{ +try { + void (*g)(void*) = (void (*)(void*))f; + void (*g2)(int*) = (void (*)(int*))g; + g2(0); +} catch (...) +{throw;} +}

pr33589-2.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: pr33887-1.C =================================================================== --- pr33887-1.C (nonexistent) +++ pr33887-1.C (revision 338) @@ -0,0 +1,44 @@ +/* { dg-do run } */ + +extern "C" void abort (void); +struct S { unsigned int i : 24; } x; +void __attribute__((noinline)) test1() +{ + if (--x.i != 0x00ffffff) + abort (); + if (x.i != 0x00ffffff) + abort (); +} +void __attribute__((noinline)) test2() +{ + if (x.i-- != 0) + abort (); + if (x.i != 0x00ffffff) + abort (); +} +void __attribute__((noinline)) test3() +{ + if (++x.i != 0) + abort (); + if (x.i != 0) + abort (); +} +void __attribute__((noinline)) test4() +{ + if (x.i++ != 0x00ffffff) + abort (); + if (x.i != 0) + abort (); +} +int main() +{ + x.i = 0; + test1(); + x.i = 0; + test2(); + x.i = 0x00ffffff; + test3(); + x.i = 0x00ffffff; + test4(); + return 0; +}

pr33887-1.C Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property