URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [testsuite/] [g++.dg/] [tree-ssa/] [pr27291.C] - Blame information for rev 478

Go to most recent revision | Details | Compare with Previous | View Log


/* { dg-do compile } */
/* { dg-options "-O2" } */
 
namespace std
{
  template < class _T1, class _T2 > struct pair
  {
  };
}
extern "C"
{
  extern "C"
  {
    typedef int int32_t __attribute__ ((__mode__ (__SI__)));
    struct _pthread_fastlock
    {
    }
    pthread_mutexattr_t;
  }
}
namespace std
{
  struct __numeric_limits_base
  {
  };
    template < typename _Tp >
    struct numeric_limits:public __numeric_limits_base
  {
    static const bool is_integer = true;
  };
};
typedef unsigned int uint32_t;
namespace std
{
  template < typename _Alloc > class allocator;
  template < class _CharT > struct char_traits;
    template < typename _CharT, typename _Traits =
    char_traits < _CharT >, typename _Alloc =
    allocator < _CharT > >class basic_string;
  typedef basic_string < char >string;
}
namespace __gnu_cxx
{
  template < typename _Tp > class new_allocator
  {
  };
}
namespace std
{
  template < typename _Tp > class allocator:public __gnu_cxx::new_allocator <
    _Tp >
  {
  };
  template < typename _CharT, typename _Traits,
    typename _Alloc > class basic_string
  {
  public:inline basic_string ();
    basic_string (const _CharT * __s, const _Alloc & __a = _Alloc ());
  };
}
namespace boost
{
  template < class T > class integer_traits:public std::numeric_limits < T >
  {
  };
  namespace detail
  {
    template < class T, T min_val, T max_val > class integer_traits_base
    {
    };
  }
  template <> class integer_traits < int >:public std::numeric_limits < int >,
    public detail::integer_traits_base < int, (-2147483647 - 1), 2147483647 >
  {
  };
  namespace random
  {
    template < class IntType, IntType m > class const_mod
    {
    public:static IntType add (IntType x, IntType c)
      {
      }
      static IntType mult (IntType a, IntType x)
      {
        return mult_schrage (a, x);
      }
      static IntType mult_add (IntType a, IntType x, IntType c)
      {
        return add (mult (a, x), c);
      }
      static IntType mult_schrage (IntType a, IntType value)
      {
        for (;;)
          {
            if (value > 0)
              break;
            value += m;
          }
      }
    };
    template < class IntType, IntType a, IntType c, IntType m,
      IntType val > class linear_congruential
    {
    public:typedef IntType result_type;
      static const IntType modulus = m;
    explicit linear_congruential (IntType x0 = 1):_modulus (modulus),
        _x (_modulus ? (x0 % _modulus) :
            x0)
      {
      }
      IntType operator    () ()
      {
        _x = const_mod < IntType, m >::mult_add (a, _x, c);
      }
    private:IntType _modulus;
      IntType _x;
    };
  }
  typedef random::linear_congruential < int32_t, 16807, 0, 2147483647,
    1043618065 > minstd_rand0;
  namespace random
  {
    namespace detail
    {
      template < class T > struct ptr_helper
      {
        typedef T value_type;
        typedef T & reference_type;
        typedef const T & rvalue_type;
        static reference_type ref (T & r)
        {
        }
      };
        template < class T > struct ptr_helper 
      {
        typedef T value_type;
        typedef T & rvalue_type;
      };
    }
  }
  template < class UniformRandomNumberGenerator, class RealType =
    double >class uniform_01
  {
  public:typedef UniformRandomNumberGenerator base_type;
    typedef RealType result_type;
    explicit uniform_01 (base_type rng):_rng (rng),
      _factor (result_type (1) /
               (result_type ((_rng.max) () - (_rng.min) ()) +
                result_type (std::numeric_limits <
                             base_result >::is_integer ? 1 : 0)))
    {
    }
    result_type operator    () ()
    {
      return result_type (_rng () - (_rng.min) ()) * _factor;
    }
  private:typedef typename base_type::result_type base_result;
    base_type _rng;
    result_type _factor;
  };
  namespace random
  {
    namespace detail
    {
      template < class UniformRandomNumberGenerator >
        class pass_through_engine
      {
      private:typedef ptr_helper < UniformRandomNumberGenerator >
          helper_type;
      public:typedef typename helper_type::value_type base_type;
        typedef typename base_type::result_type result_type;
        explicit pass_through_engine (UniformRandomNumberGenerator
                                      rng):_rng (static_cast <
                                                 typename helper_type::
                                                 rvalue_type > (rng))
        {
        }
        result_type min () const
        {
        }
        result_type max () const
        {
        }
        base_type & base ()
        {
        }
        result_type operator    () ()
        {
          return base ()();
        }
      private:UniformRandomNumberGenerator _rng;
      };
    }
    template < class RealType, int w, unsigned int p,
      unsigned int q > class lagged_fibonacci_01
    {
    public:typedef RealType result_type;
      static const unsigned int long_lag = p;
        lagged_fibonacci_01 ()
      {
        seed ();
      }
    public:void seed (uint32_t value = 331u)
      {
        minstd_rand0 intgen (value);
        seed (intgen);
      }
      template < class Generator > void seed (Generator & gen)
      {
        typedef detail::pass_through_engine < Generator & >ref_gen;
        uniform_01 < ref_gen, RealType > gen01 =
          uniform_01 < ref_gen, RealType > (ref_gen (gen));
        for (unsigned int j = 0; j < long_lag; ++j)
          x[j] = gen01 ();
      }
      RealType x[long_lag];
    };
  }
  typedef random::lagged_fibonacci_01 < double, 48, 607,
    273 > lagged_fibonacci607;
  namespace random
  {
    namespace detail
    {
      template < bool have_int, bool want_int > struct engine_helper;
        template <> struct engine_helper 
      {
        template < class Engine, class DistInputType > struct impl
        {
          typedef pass_through_engine < Engine > type;
        };
      };
    }
  }
  template < class Engine, class Distribution > class variate_generator
  {
  private:typedef random::detail::pass_through_engine < Engine >
      decorated_engine;
  public:typedef typename decorated_engine::base_type engine_value_type;
    typedef Distribution distribution_type;
  variate_generator (Engine e, Distribution d):_eng (decorated_engine (e)),
      _dist (d)
    {
    }
  private:enum
    {
      have_int =
        std::numeric_limits <
        typename decorated_engine::result_type >::is_integer, want_int =
        std::numeric_limits < typename Distribution::input_type >::is_integer
    };
    typedef typename random::detail::engine_helper < have_int,
      want_int >::template impl < decorated_engine,
      typename Distribution::input_type >::type internal_engine_type;
    internal_engine_type _eng;
    distribution_type _dist;
  };
  template < class RealType = double >class uniform_real
  {
  public:typedef RealType input_type;
  };
}
namespace alps
{
  class BufferedRandomNumberGeneratorBase
  {
  };
    template < class RNG >
    class BufferedRandomNumberGenerator:public
    BufferedRandomNumberGeneratorBase
  {
  public: BufferedRandomNumberGenerator ():rng_ (), gen_ (rng_,
                   boost::
                   uniform_real <> ())
    {
    }
  protected:  RNG rng_;
    boost::variate_generator < RNG &, boost::uniform_real <> >gen_;
  };
}
namespace boost
{
  namespace detail
  {
    class sp_counted_base
    {
    };
    class shared_count
    {
    private:sp_counted_base * pi_;
    public:shared_count ():pi_ (0)
      {
      }
      template < class Y > explicit shared_count (Y * p):pi_ (0)
      {
      }
    };
  }
  template < class T > class shared_ptr
  {
  public:typedef T element_type;
  template < class Y > explicit shared_ptr (Y * p):px (p), pn (p)
    {
    }
    T *px;
    detail::shared_count pn;
  };
}
namespace std
{
  template < typename _Key, typename _Tp, typename _Compare =
    std::allocator < std::pair < const _Key, _Tp > > > class map
  {
  public:typedef _Key key_type;
    typedef _Tp mapped_type;
      mapped_type & operator[] (const key_type & __k)
    {
    }
  };
}
namespace alps
{
  namespace detail
  {
    template < class BASE > class abstract_creator
    {
    public:typedef BASE base_type;
      virtual base_type *create () const = 0;
    };
      template < class BASE,
      class T > class creator:public abstract_creator < BASE >
    {
    public:typedef BASE base_type;
      base_type *create () const
      {
        return new T ();
      }
    };
  }
  template < class KEY, class BASE > class factory
  {
  public:typedef BASE base_type;
    typedef KEY key_type;
    typedef boost::shared_ptr < detail::abstract_creator < base_type >
      >pointer_type;
    template < class T > bool register_type (key_type k)
    {
      creators_[k] = pointer_type (new detail::creator < BASE, T > ());
    }
  private:typedef std::map < key_type, pointer_type > map_type;
    map_type creators_;
  };
  class RNGFactory:public factory < std::string,
    BufferedRandomNumberGeneratorBase >
  {
  public:RNGFactory ();
  };
}
alps::RNGFactory::RNGFactory ()
{
  register_type < BufferedRandomNumberGenerator < boost::lagged_fibonacci607 >
    >("lagged_fibonacci607");
}

Line No.	Rev	Author	Line
1	301	jeremybenn	`/* { dg-do compile } */`
2			`/* { dg-options "-O2" } */`
3
4			`namespace std`
5			`{`
6			`template < class _T1, class _T2 > struct pair`
7			`{`
8			`};`
9			`}`
10			`extern "C"`
11			`{`
12			`extern "C"`
13			`{`
14			`typedef int int32_t __attribute__ ((__mode__ (__SI__)));`
15			`struct _pthread_fastlock`
16			`{`
17			`}`
18			`pthread_mutexattr_t;`
19			`}`
20			`}`
21			`namespace std`
22			`{`
23			`struct __numeric_limits_base`
24			`{`
25			`};`
26			`template < typename _Tp >`
27			`struct numeric_limits:public __numeric_limits_base`
28			`{`
29			`static const bool is_integer = true;`
30			`};`
31			`};`
32			`typedef unsigned int uint32_t;`
33			`namespace std`
34			`{`
35			`template < typename _Alloc > class allocator;`
36			`template < class _CharT > struct char_traits;`
37			`template < typename _CharT, typename _Traits =`
38			`char_traits < _CharT >, typename _Alloc =`
39			`allocator < _CharT > >class basic_string;`
40			`typedef basic_string < char >string;`
41			`}`
42			`namespace __gnu_cxx`
43			`{`
44			`template < typename _Tp > class new_allocator`
45			`{`
46			`};`
47			`}`
48			`namespace std`
49			`{`
50			`template < typename _Tp > class allocator:public __gnu_cxx::new_allocator <`
51			`_Tp >`
52			`{`
53			`};`
54			`template < typename _CharT, typename _Traits,`
55			`typename _Alloc > class basic_string`
56			`{`
57			`public:inline basic_string ();`
58			`basic_string (const _CharT * __s, const _Alloc & __a = _Alloc ());`
59			`};`
60			`}`
61			`namespace boost`
62			`{`
63			`template < class T > class integer_traits:public std::numeric_limits < T >`
64			`{`
65			`};`
66			`namespace detail`
67			`{`
68			`template < class T, T min_val, T max_val > class integer_traits_base`
69			`{`
70			`};`
71			`}`
72			`template <> class integer_traits < int >:public std::numeric_limits < int >,`
73			`public detail::integer_traits_base < int, (-2147483647 - 1), 2147483647 >`
74			`{`
75			`};`
76			`namespace random`
77			`{`
78			`template < class IntType, IntType m > class const_mod`
79			`{`
80			`public:static IntType add (IntType x, IntType c)`
81			`{`
82			`}`
83			`static IntType mult (IntType a, IntType x)`
84			`{`
85			`return mult_schrage (a, x);`
86			`}`
87			`static IntType mult_add (IntType a, IntType x, IntType c)`
88			`{`
89			`return add (mult (a, x), c);`
90			`}`
91			`static IntType mult_schrage (IntType a, IntType value)`
92			`{`
93			`for (;;)`
94			`{`
95			`if (value > 0)`
96			`break;`
97			`value += m;`
98			`}`
99			`}`
100			`};`
101			`template < class IntType, IntType a, IntType c, IntType m,`
102			`IntType val > class linear_congruential`
103			`{`
104			`public:typedef IntType result_type;`
105			`static const IntType modulus = m;`
106			`explicit linear_congruential (IntType x0 = 1):_modulus (modulus),`
107			`_x (_modulus ? (x0 % _modulus) :`
108			`x0)`
109			`{`
110			`}`
111			`IntType operator () ()`
112			`{`
113			`_x = const_mod < IntType, m >::mult_add (a, _x, c);`
114			`}`
115			`private:IntType _modulus;`
116			`IntType _x;`
117			`};`
118			`}`
119			`typedef random::linear_congruential < int32_t, 16807, 0, 2147483647,`
120			`1043618065 > minstd_rand0;`
121			`namespace random`
122			`{`
123			`namespace detail`
124			`{`
125			`template < class T > struct ptr_helper`
126			`{`
127			`typedef T value_type;`
128			`typedef T & reference_type;`
129			`typedef const T & rvalue_type;`
130			`static reference_type ref (T & r)`
131			`{`
132			`}`
133			`};`
134			`template < class T > struct ptr_helper`
135			`{`
136			`typedef T value_type;`
137			`typedef T & rvalue_type;`
138			`};`
139			`}`
140			`}`
141			`template < class UniformRandomNumberGenerator, class RealType =`
142			`double >class uniform_01`
143			`{`
144			`public:typedef UniformRandomNumberGenerator base_type;`
145			`typedef RealType result_type;`
146			`explicit uniform_01 (base_type rng):_rng (rng),`
147			`_factor (result_type (1) /`
148			`(result_type ((_rng.max) () - (_rng.min) ()) +`
149			`result_type (std::numeric_limits <`
150			`base_result >::is_integer ? 1 : 0)))`
151			`{`
152			`}`
153			`result_type operator () ()`
154			`{`
155			`return result_type (_rng () - (_rng.min) ()) * _factor;`
156			`}`
157			`private:typedef typename base_type::result_type base_result;`
158			`base_type _rng;`
159			`result_type _factor;`
160			`};`
161			`namespace random`
162			`{`
163			`namespace detail`
164			`{`
165			`template < class UniformRandomNumberGenerator >`
166			`class pass_through_engine`
167			`{`
168			`private:typedef ptr_helper < UniformRandomNumberGenerator >`
169			`helper_type;`
170			`public:typedef typename helper_type::value_type base_type;`
171			`typedef typename base_type::result_type result_type;`
172			`explicit pass_through_engine (UniformRandomNumberGenerator`
173			`rng):_rng (static_cast <`
174			`typename helper_type::`
175			`rvalue_type > (rng))`
176			`{`
177			`}`
178			`result_type min () const`
179			`{`
180			`}`
181			`result_type max () const`
182			`{`
183			`}`
184			`base_type & base ()`
185			`{`
186			`}`
187			`result_type operator () ()`
188			`{`
189			`return base ()();`
190			`}`
191			`private:UniformRandomNumberGenerator _rng;`
192			`};`
193			`}`
194			`template < class RealType, int w, unsigned int p,`
195			`unsigned int q > class lagged_fibonacci_01`
196			`{`
197			`public:typedef RealType result_type;`
198			`static const unsigned int long_lag = p;`
199			`lagged_fibonacci_01 ()`
200			`{`
201			`seed ();`
202			`}`
203			`public:void seed (uint32_t value = 331u)`
204			`{`
205			`minstd_rand0 intgen (value);`
206			`seed (intgen);`
207			`}`
208			`template < class Generator > void seed (Generator & gen)`
209			`{`
210			`typedef detail::pass_through_engine < Generator & >ref_gen;`
211			`uniform_01 < ref_gen, RealType > gen01 =`
212			`uniform_01 < ref_gen, RealType > (ref_gen (gen));`
213			`for (unsigned int j = 0; j < long_lag; ++j)`
214			`x[j] = gen01 ();`
215			`}`
216			`RealType x[long_lag];`
217			`};`
218			`}`
219			`typedef random::lagged_fibonacci_01 < double, 48, 607,`
220			`273 > lagged_fibonacci607;`
221			`namespace random`
222			`{`
223			`namespace detail`
224			`{`
225			`template < bool have_int, bool want_int > struct engine_helper;`
226			`template <> struct engine_helper`
227			`{`
228			`template < class Engine, class DistInputType > struct impl`
229			`{`
230			`typedef pass_through_engine < Engine > type;`
231			`};`
232			`};`
233			`}`
234			`}`
235			`template < class Engine, class Distribution > class variate_generator`
236			`{`
237			`private:typedef random::detail::pass_through_engine < Engine >`
238			`decorated_engine;`
239			`public:typedef typename decorated_engine::base_type engine_value_type;`
240			`typedef Distribution distribution_type;`
241			`variate_generator (Engine e, Distribution d):_eng (decorated_engine (e)),`
242			`_dist (d)`
243			`{`
244			`}`
245			`private:enum`
246			`{`
247			`have_int =`
248			`std::numeric_limits <`
249			`typename decorated_engine::result_type >::is_integer, want_int =`
250			`std::numeric_limits < typename Distribution::input_type >::is_integer`
251			`};`
252			`typedef typename random::detail::engine_helper < have_int,`
253			`want_int >::template impl < decorated_engine,`
254			`typename Distribution::input_type >::type internal_engine_type;`
255			`internal_engine_type _eng;`
256			`distribution_type _dist;`
257			`};`
258			`template < class RealType = double >class uniform_real`
259			`{`
260			`public:typedef RealType input_type;`
261			`};`
262			`}`
263			`namespace alps`
264			`{`
265			`class BufferedRandomNumberGeneratorBase`
266			`{`
267			`};`
268			`template < class RNG >`
269			`class BufferedRandomNumberGenerator:public`
270			`BufferedRandomNumberGeneratorBase`
271			`{`
272			`public: BufferedRandomNumberGenerator ():rng_ (), gen_ (rng_,`
273			`boost::`
274			`uniform_real <> ())`
275			`{`
276			`}`
277			`protected: RNG rng_;`
278			`boost::variate_generator < RNG &, boost::uniform_real <> >gen_;`
279			`};`
280			`}`
281			`namespace boost`
282			`{`
283			`namespace detail`
284			`{`
285			`class sp_counted_base`
286			`{`
287			`};`
288			`class shared_count`
289			`{`
290			`private:sp_counted_base * pi_;`
291			`public:shared_count ():pi_ (0)`
292			`{`
293			`}`
294			`template < class Y > explicit shared_count (Y * p):pi_ (0)`
295			`{`
296			`}`
297			`};`
298			`}`
299			`template < class T > class shared_ptr`
300			`{`
301			`public:typedef T element_type;`
302			`template < class Y > explicit shared_ptr (Y * p):px (p), pn (p)`
303			`{`
304			`}`
305			`T *px;`
306			`detail::shared_count pn;`
307			`};`
308			`}`
309			`namespace std`
310			`{`
311			`template < typename _Key, typename _Tp, typename _Compare =`
312			`std::allocator < std::pair < const _Key, _Tp > > > class map`
313			`{`
314			`public:typedef _Key key_type;`
315			`typedef _Tp mapped_type;`
316			`mapped_type & operator[] (const key_type & __k)`
317			`{`
318			`}`
319			`};`
320			`}`
321			`namespace alps`
322			`{`
323			`namespace detail`
324			`{`
325			`template < class BASE > class abstract_creator`
326			`{`
327			`public:typedef BASE base_type;`
328			`virtual base_type *create () const = 0;`
329			`};`
330			`template < class BASE,`
331			`class T > class creator:public abstract_creator < BASE >`
332			`{`
333			`public:typedef BASE base_type;`
334			`base_type *create () const`
335			`{`
336			`return new T ();`
337			`}`
338			`};`
339			`}`
340			`template < class KEY, class BASE > class factory`
341			`{`
342			`public:typedef BASE base_type;`
343			`typedef KEY key_type;`
344			`typedef boost::shared_ptr < detail::abstract_creator < base_type >`
345			`>pointer_type;`
346			`template < class T > bool register_type (key_type k)`
347			`{`
348			`creators_[k] = pointer_type (new detail::creator < BASE, T > ());`
349			`}`
350			`private:typedef std::map < key_type, pointer_type > map_type;`
351			`map_type creators_;`
352			`};`
353			`class RNGFactory:public factory < std::string,`
354			`BufferedRandomNumberGeneratorBase >`
355			`{`
356			`public:RNGFactory ();`
357			`};`
358			`}`
359			`alps::RNGFactory::RNGFactory ()`
360			`{`
361			`register_type < BufferedRandomNumberGenerator < boost::lagged_fibonacci607 >`
362			`>("lagged_fibonacci607");`
363			`}`

Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [testsuite/] [g++.dg/] [tree-ssa/] [pr27291.C] - Blame information for rev 478