llvm-gcc-4.2/gcc/testsuite/g++.apple/4786728.C

/* APPLE LOCAL file 4786728 */
/* { dg-do compile { target i?86-*-* x86_64-*-* } } */
/* { dg-options "-m64 -O1 -g -fstrict-aliasing" } */
typedef __SIZE_TYPE__ size_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;
  template<> struct char_traits<char>;
  typedef basic_string<char> string;
}

namespace __gnu_cxx
{
  template<typename _Tp> class new_allocator
  {
    public:
      typedef _Tp* pointer;
      new_allocator () throw () { }
      new_allocator (const new_allocator&) throw () { }
      template<typename _Tp1>
        new_allocator (const new_allocator<_Tp1>&) throw () { }
      ~new_allocator () throw () { }
      pointer allocate (size_t __n, const void* = 0)
      { return (pointer)0; }
      void deallocate (pointer __p, size_t) 
      { ::operator delete (__p); }
  };
}

namespace std
{
  template<typename _Tp> class allocator;
  template<typename _Tp>
    class allocator: public __gnu_cxx::new_allocator<_Tp>
    {
      public:
        allocator () throw () { }
        allocator(const allocator& __a) throw ()
          : __gnu_cxx::new_allocator<_Tp> (__a) { }
        template<typename _Tp1>
          allocator (const allocator<_Tp1>&) throw () { }
        ~allocator () throw () { }
    };
}

namespace std
{
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_string
    {
      private:
        struct _Rep
        {
          static size_t _S_empty_rep_storage[];
          static _Rep& _S_empty_rep ()
            { return *reinterpret_cast<_Rep*>(&_S_empty_rep_storage); }
          _CharT* _M_refdata () throw ()
          { return reinterpret_cast<_CharT*> (this + 1); }
          void _M_dispose (const _Alloc& __a)
          {
            if (__builtin_expect (this != &_S_empty_rep (), false))
              _M_destroy (__a);
          }
          void _M_destroy (const _Alloc&) throw ();
        };
        struct _Alloc_hider : _Alloc
        {
          _Alloc_hider (_CharT* __dat, const _Alloc& __a)
          : _Alloc (__a), _M_p (__dat) { }
          _CharT* _M_p;
        };
        mutable _Alloc_hider _M_dataplus;
        _CharT* _M_data () const
        { return _M_dataplus._M_p; }
        _Rep* _M_rep() const
        { return &((reinterpret_cast<_Rep*> (_M_data ()))[-1]); }
        static _Rep& _S_empty_rep () { return _Rep::_S_empty_rep (); }
      public:
        basic_string ();
        basic_string (const _Alloc& __a);
        basic_string (const basic_string& __str);
        basic_string (const basic_string& __str, size_t __pos, size_t __n);
        basic_string (const basic_string& __str, size_t __pos,
          size_t __n, const _Alloc& __a);
        basic_string (const _CharT* __s, size_t __n,
          const _Alloc& __a = _Alloc());
        basic_string (const _CharT* __s, const _Alloc& __a = _Alloc());
        basic_string (size_t __n, _CharT __c, const _Alloc& __a = _Alloc ());
        template<class _InputIterator>
          basic_string (_InputIterator __beg, _InputIterator __end,
          const _Alloc& __a = _Alloc ());
        ~basic_string ()
        { _M_rep ()->_M_dispose(this->get_allocator ()); }
    private:
      _Alloc get_allocator () const { return _M_dataplus; }
  };

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>::
    basic_string()
    : _M_dataplus (_S_empty_rep()._M_refdata (), _Alloc ()) { }
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>
    operator+ (const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      basic_string<_CharT, _Traits, _Alloc> __str (__lhs);
      return __str;
    }
}

namespace std
{
  template<typename _Tp, typename _Alloc>
    struct _Vector_base
    {
      struct _Vector_impl : public _Alloc
      {
        _Tp* _M_start;
        _Tp* _M_finish;
        _Tp* _M_end_of_storage;
       _Vector_impl (_Alloc const& __a)
       : _Alloc (__a), _M_start (0), _M_finish (0), _M_end_of_storage (0) {}
      };
    public:
      typedef _Alloc allocator_type;
      allocator_type
      get_allocator () const
      { return *static_cast<const _Alloc*> (&this->_M_impl); }
      _Vector_base (const allocator_type& __a) 
      : _M_impl(__a) {}
      _Vector_base(size_t __n, const allocator_type& __a) {}
      ~_Vector_base()
      { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
        - this->_M_impl._M_start); }
    public:
      _Vector_impl _M_impl;
      _Tp* _M_allocate (size_t __n) { return _M_impl.allocate (__n); }
      void _M_deallocate (_Tp* __p, size_t __n)
      {
        _M_impl.deallocate (__p, __n);
      }
    };
  template<typename _Tp, typename _Alloc = allocator<_Tp> >
    class vector : protected _Vector_base<_Tp, _Alloc>
    {
      typedef _Vector_base<_Tp, _Alloc> _Base;
      typedef vector<_Tp, _Alloc> vector_type;
    public:
      typedef typename _Base::allocator_type allocator_type;
      vector (const allocator_type& __a = allocator_type ())
      : _Base (__a) {}
    };
}

namespace llvm {
  class GlobalVariable;
  class SourceFile;
  class SourceLanguage;
  struct SourceLanguageCache {
    virtual ~SourceLanguageCache () {}
  };
  class SourceFileInfo {
    std::string BaseName;
    const SourceLanguage *Language;
    const GlobalVariable *Descriptor;
    mutable SourceFile *SourceText;
  public:
    SourceFileInfo (const GlobalVariable *Desc, const SourceLanguage &Lang);
    ~SourceFileInfo ();
    SourceFile &getSourceText () const;
  };
}

namespace llvm {
  namespace sys {
    class Path {
      public:
        Path() : path() {}
        Path(const std::string& p) : path(p) {}
        const std::string &toString() const { return path; }
      private:
        mutable std::string path;
    };
  }
}

namespace llvm {
  namespace sys {
    struct MappedFileInfo;
    class MappedFile {
    public:
      MappedFile() : path_(), info_(0) {}
      ~MappedFile() { if (info_) terminate(); }
    private:
      void terminate();
      sys::Path path_;
      mutable MappedFileInfo* info_;
    };
  }
}

namespace llvm {
  class GlobalVariable;
  class SourceFile {
    sys::Path Filename;
    const GlobalVariable *Descriptor;
    sys::MappedFile File;
    mutable std::vector<unsigned> LineOffset;
  public:
    SourceFile(const std::string &fn, const GlobalVariable *Desc)
      : Filename(fn), Descriptor(Desc), File()
    {
      std::string ErrMsg;
      readFile();
    }
    ~SourceFile() {}
  private:
    void readFile();
  };
}

using namespace llvm;
SourceFile &SourceFileInfo::getSourceText() const
{
  sys::Path tmpPath;
  SourceText = new SourceFile(tmpPath.toString(), Descriptor);
  SourceText = new SourceFile(BaseName, Descriptor);
  return *SourceText;
}