Bug#334006: gcc-snapshot: [PR 21123, 4.0, 41 regression] ICE on arm, m68k and hppa when compiling arts and others (in cp_expr_size, at cp/cp-objcp-common.c:101)

To: Debian Bug Tracking System <submit@bugs.debian.org>
Subject: Bug#334006: gcc-snapshot: [PR 21123, 4.0, 41 regression] ICE on arm, m68k and hppa when compiling arts and others (in cp_expr_size, at cp/cp-objcp-common.c:101)
From: Riku Voipio <nchip@uittosatama.fi>
Date: Sat, 15 Oct 2005 01:56:31 +0300
Message-id: <[🔎] 20051014225631.127F3EC826A@uittosatama.fi>
Reply-to: Riku Voipio <nchip@uittosatama.fi>, 334006@bugs.debian.org

Package: gcc-snapshot
Version: 20051008-1
Severity: important


While researching #323133, I noticed this bug reproducible with
gcc-snapshot as well, so it seems the "fixed-upstream" tag for 
#323133 incorrect. This time using aleph[1] (same error as with gcc-4.0) 
as a test case,

gcc -v -save-temps -Wall -Werror -MMD -fno-builtin  -fPIC -nostdinc
-nostdinc++ -O2    -D_REENTRANT       -I. -I../../../bld/hdr/plt -o
BitSet.o -c BitSet.cpp
Using built-in specs.
Target: arm-linux-gnu
Configured with: ../src/configure -v
--enable-languages=c,c++,java,f95,objc,obj-c++,treelang
--prefix=/usr/lib/gcc-snapshot --enable-shared --with-system-zlib
--disable-nls --enable-__cxa_atexit --enable-libstdcxx-allocator=mt
--enable-clocale=gnu --enable-libstdcxx-debug --enable-java-gc=boehm
--enable-java-awt=gtk --enable-gtk-cairo
--with-java-home=/usr/lib/gcc-snapshot/jre --enable-mpfr
--disable-werror arm-linux-gnu
Thread model: posix
gcc version 4.1.0 20051008 (experimental)
 /usr/lib/gcc-snapshot/libexec/gcc/arm-linux-gnu/4.1.0/cc1plus -E -quiet
-nostdinc -nostdinc++ -v -I. -I../../../bld/hdr/plt -MMD BitSet.d -MQ
BitSet.o -D_GNU_SOURCE -D_REENTRANT BitSet.cpp -Wall -Werror
-fno-builtin -fPIC -O2 -fpch-preprocess -o BitSet.ii
#include "..." search starts here:
#include <...> search starts here:
 .
 ../../../bld/hdr/plt
End of search list.
 /usr/lib/gcc-snapshot/libexec/gcc/arm-linux-gnu/4.1.0/cc1plus
-fpreprocessed BitSet.ii -quiet -dumpbase BitSet.cpp -auxbase-strip
BitSet.o -O2 -Wall -Werror -version -fno-builtin -fPIC -o BitSet.s
GNU C++ version 4.1.0 20051008 (experimental) (arm-linux-gnu)
        compiled by GNU C version 4.1.0 20051008 (experimental).
GGC heuristics: --param ggc-min-expand=30 --param ggc-min-heapsize=4096
Compiler executable checksum: 17337f107248f5cb4d392bed3dfaece3
BitSet.cpp: In member function 'aleph::String
aleph::BitSet::_ZTv0_n16_NK5aleph6BitSet4reprEv() const':
BitSet.cpp:250: internal compiler error: in cp_expr_size, at
cp/cp-objcp-common.c:101
Please submit a full bug report,
with preprocessed source if appropriate.
See <URL:http://gcc.gnu.org/bugs.html> for instructions.

[1] http://buildd.debian.org/fetch.php?&pkg=aleph&ver=0.9.0-2.1&arch=arm&stamp=1123271687&file=log&as=raw



-- System Information:
Debian Release: 3.1
Architecture: arm
Shell:  /bin/sh linked to /bin/bash
Kernel: Linux 2.6.13
Locale: LANG=C, LC_CTYPE=fi_FI@euro (charmap=ISO-8859-15)

# 1 "BitSet.cpp"
# 0 "<built-in>"
# 1 "<command line>"
# 1 "BitSet.cpp"
# 17 "BitSet.cpp"
# 1 "Vector.hpp" 1
# 21 "Vector.hpp"
# 1 "Iterable.hpp" 1
# 21 "Iterable.hpp"
# 1 "Iterator.hpp" 1
# 21 "Iterator.hpp"
# 1 "Object.hpp" 1
# 21 "Object.hpp"
# 1 "../../../bld/hdr/plt/ccnf.hpp" 1
# 72 "../../../bld/hdr/plt/ccnf.hpp"
namespace aleph {

  typedef unsigned char t_byte;
  typedef unsigned short t_word;
  typedef unsigned int t_quad;
  typedef unsigned long long t_octa;
  typedef long long t_long;
  typedef double t_real;
  typedef unsigned int t_size;


  const char nilc = '\0';
  const char eofc = '\4';
  const char eolc = '\n';
  const char crlc = '\r';
  const char tabc = '\t';
}
# 22 "Object.hpp" 2


namespace aleph {
# 47 "Object.hpp"
  class Object {
  public:
    enum t_oper {ADD, SUB, MUL, DIV, MINUS, EQL, NEQ, GEQ, LEQ, GTH, LTH};

  private:

    long d_rcount;

  protected:

    struct s_shared* p_shared;

  public:

    Object (void);


    virtual ~Object (void);


    virtual class String repr (void) const =0;


    static const class String repr (Object* object);


    virtual Object* clone (void) const;


    virtual void mksho (void);


    virtual void rdlock (void) const;


    virtual void wrlock (void) const;


    virtual void unlock (void) const;


    bool issho (void) {
      return (p_shared != 0);
    }


    static void clrfnl (void);



    static Object* iref (Object* object);



    static void dref (Object* object);



    static void cref (Object* object);



    static void tref (Object* object);



    static bool uref (Object* object);





    virtual Object* oper (class Runnable* robj, t_oper type, Object* object);





    virtual Object* cdef (class Runnable* robj, class Nameset* nset,
     Object* object);






    virtual Object* cdef (class Runnable* robj, class Nameset* nset,
     const long quark, Object* object);





    virtual Object* vdef (class Runnable* robj, class Nameset* nset,
     Object* object);






    virtual Object* vdef (class Runnable* robj, class Nameset* nset,
     const long quark, Object* object);




    virtual Object* eval (class Runnable* robj, class Nameset* nset);





    virtual Object* eval (class Runnable* robj, class Nameset* nset,
     const long quark);





    virtual Object* apply (class Runnable* robj, class Nameset* nset,
      class Cons* args);






    virtual Object* apply (class Runnable* robj, class Nameset* nset,
      const long quark, class Cons* args);






    virtual Object* apply (class Runnable* robj, class Nameset* nset,
      Object* object, class Cons* args);






    virtual Object* apply (class Runnable* robj, class Nameset* nset,
      const long quark, class Vector* argv);

  public:

    void* operator new (const t_size size);
    void* operator new [] (const t_size size);
    void operator delete (void* handle);
    void operator delete [] (void* handle);
  };
}
# 22 "Iterator.hpp" 2


namespace aleph {
# 34 "Iterator.hpp"
  class Iterator : public virtual Object {
  public:

    virtual void begin (void) =0;


    virtual void end (void) =0;


    virtual void next (void) =0;


    virtual void prev (void) =0;


    virtual Object* getobj (void) =0;


    virtual bool isend (void) =0;


    bool valid (void) {
      return (isend () == true) ? false : true;
    }






    Object* apply (Runnable* robj, Nameset* nset, const long quark,
     Vector* argv);
  };
}
# 22 "Iterable.hpp" 2


namespace aleph {







  class Iterable : public virtual Object {
  public:

    virtual Iterator* makeit (void) =0;
  };
}
# 22 "Vector.hpp" 2



# 1 "Serial.hpp" 1
# 24 "Serial.hpp"
namespace aleph {
# 34 "Serial.hpp"
  class Serial : public virtual Object {
  public:

    static const t_byte SERIAL_NILP_ID = 0x00;
    static const t_byte SERIAL_BOOL_ID = 0x01;
    static const t_byte SERIAL_INTG_ID = 0x02;
    static const t_byte SERIAL_REAL_ID = 0x03;
    static const t_byte SERIAL_STRG_ID = 0x04;
    static const t_byte SERIAL_CHAR_ID = 0x05;
    static const t_byte SERIAL_RELT_ID = 0x06;
    static const t_byte SERIAL_REGX_ID = 0x07;
    static const t_byte SERIAL_CONS_ID = 0x08;
    static const t_byte SERIAL_VECT_ID = 0x09;


    typedef Serial* (*t_genser) (void);

  public:

    virtual t_byte serialid (void) const;



    virtual void wrstream (class Output& os) const;



    virtual void rdstream (class Input& is);



    virtual void serialize (class Output& os) const;


    static t_byte setsid (const t_byte sid, t_genser cbk);


    static Serial* getserial (const t_byte sid);


    static Object* deserialize (Input& is);
  };
}
# 26 "Vector.hpp" 2


namespace aleph {






  class Vector : public Iterable, public Serial {
  private:

    long d_length;

    long d_size;

    Object** p_vector;

  public:

    Vector (void);



    Vector (const long size);



    Vector (const Vector& that);


    ~Vector (void);


    String repr (void) const;



    Vector& operator = (const Vector& that);


    void mksho (void);


    t_byte serialid (void) const;



    void wrstream (class Output& os) const;



    void rdstream (class Input& is);



    void append (Object* object);




    void set (const long index, Object* object);




    Object* get (const long index) const;


    void back (void);


    Object* first (void) const {
      return get (0);
    }


    Object* last (void) const {
      return get (d_length-1);
    }


    long length (void) const;


    bool exists (Object* object) const;



    long find (Object* object);



    void remove (const long index);



    void remove (Object* object);


    void merge (const Vector& v);


    void reset (void);


    Iterator* makeit (void);


    t_long getint (const long index) const;


    t_real getreal (const long index) const;


    t_real getireal (const long index) const;


    bool getbool (const long index) const;


    char getchar (const long index) const;


    String getstring (const long index) const;






    static Vector* eval (Runnable*robj, Nameset* nset, Cons* args);



    static Object* mknew (Vector* argv);






    Object* apply (Runnable* robj, Nameset* nset, const long quark,
     Vector* argv);

  private:

    friend class Vectorit;
  };






  class Vectorit : public Iterator {
  private:

    Vector* p_vector;

    long d_index;

  public:


    Vectorit (Vector* vec);


    ~Vectorit (void);


    String repr (void) const;


    void mksho (void);


    void begin (void);


    void end (void);


    void next (void);


    void prev (void);


    Object* getobj (void);


    bool isend (void);

  private:

    Vectorit (const Vectorit&);

    Vectorit& operator = (const Vectorit&);
  };
}
# 18 "BitSet.cpp" 2
# 1 "BitSet.hpp" 1
# 21 "BitSet.hpp"
# 1 "String.hpp" 1
# 21 "String.hpp"
# 1 "Literal.hpp" 1
# 24 "Literal.hpp"
namespace aleph {







  class Literal : public Serial {
  public:

    virtual class String toliteral (void) const =0;


    virtual class String tostring (void) const =0;


    virtual Object* clone (void) const =0;






    Object* apply (Runnable* robj, Nameset* nset, const long quark,
     Vector* argv);
  };
}
# 22 "String.hpp" 2


namespace aleph {
# 35 "String.hpp"
  class String : public Literal {
  private:

    struct s_string* p_string;

  public:

    String (void);



    String (const char* s);



    String (const char c);



    String (const String& that);


    ~String (void);


    String repr (void) const;


    String toliteral (void) const;


    String tostring (void) const;


    Object* clone (void) const;


    t_byte serialid (void) const;



    void wrstream (class Output& os) const;



    void rdstream (class Input& is);


    long toquark (void) const;



    static long intern (const char* name);



    static const String& qmap (const long quark);


    bool isnil (void) const;




    String& operator = (const char* s);




    String& operator = (const char c);




    String& operator = (const String& s);




    char operator [] (const long index) const;




    String operator + (const String& s) const;




    String operator + (const char c) const;




    String operator + (const long value) const;




    bool operator == (const String& s) const;




    bool operator == (const char* s) const;




    bool operator != (const String& s) const;




    bool operator != (const char* s) const;




    bool operator < (const String& s) const;




    bool operator < (const char* s) const;




    bool operator <= (const String& s) const;




    bool operator <= (const char* s) const;




    bool operator > (const String& s) const;




    bool operator > (const char* s) const;




    bool operator >= (const String& s) const;




    bool operator >= (const char* s) const;


    long length (void) const;


    static long length (const char* s);


    char* tochar (void) const;



    String stripl (void) const;



    String stripr (void) const;



    String strip (void) const;


    String toupper (void) const;


    String tolower (void) const;




    String rsubstr (const long index) const;




    String lsubstr (const long index) const;




    String substr (const long lidx, const long ridx) const;


    long hashid (void) const;




    String lfill (const char c, const long size) const;




    String rfill (const char c, const long size) const;


    Vector* split (void) const;



    Vector* split (const String& sbrk) const;


    Vector* extract (const char cbrk) const;



    static Object* mknew (Vector* argv);





    Object* oper (Runnable* robj, t_oper type, Object* object);





    Object* vdef (Runnable* robj, Nameset* nset, Object* object);






    Object* apply (Runnable* robj, Nameset* nset, const long quark,
     Vector* argv);
  };
}
# 22 "BitSet.hpp" 2


namespace aleph {






  class BitSet : public virtual Object {
  private:

    long d_size;

    t_byte* p_byte;

  public:

    BitSet (void);



    BitSet (const long size);



    BitSet (const BitSet& that);


    ~BitSet (void);


    String repr (void) const;



    BitSet& operator = (const BitSet& that);


    bool operator == (const BitSet& bset) const;


    long length (void) const;



    bool get (const long pos) const;



    void mark (const long pos);



    void clear (const long pos);




    void set (const long pos, const bool bit);




    void set (const long idx, const t_byte val);



    void reserve (const long size);



    static Object* mknew (Vector* argv);






    Object* apply (Runnable* robj, Nameset* nset, const long quark,
     Vector* argv);
  };
}
# 19 "BitSet.cpp" 2
# 1 "Boolean.hpp" 1
# 24 "Boolean.hpp"
namespace aleph {







  class Boolean : public Literal {
  private:

    bool d_value;

  public:

    Boolean (void);



    Boolean (const bool value);



    Boolean (const String& value);



    Boolean (const Boolean& that);


    String repr (void) const;


    String toliteral (void) const;


    String tostring (void) const;


    Object* clone (void) const;


    t_byte serialid (void) const;



    void wrstream (class Output& os) const;



    void rdstream (class Input& is);


    bool toboolean (void) const;



    Boolean& operator = (const bool value);



    Boolean& operator = (const Boolean& value);




    bool operator == (const bool value) const;




    bool operator != (const bool value) const;




    bool operator == (const Boolean& value) const;




    bool operator != (const Boolean& value) const;





    static bool evalto (Runnable* robj, Nameset* nset, Object* object);



    static Object* mknew (Vector* argv);





    Object* oper (Runnable* robj, t_oper type, Object* object);





    Object* vdef (Runnable* robj, Nameset* nset, Object* object);






    Object* apply (Runnable* robj, Nameset* nset, const long quark,
     Vector* argv);
  public:

    void* operator new (const t_size size);
    void operator delete (void* handle);
  };
}
# 20 "BitSet.cpp" 2
# 1 "Integer.hpp" 1
# 24 "Integer.hpp"
namespace aleph {
# 33 "Integer.hpp"
  class Integer : public Literal {
  private:

    t_long d_value;

  public:

    Integer (void);



    Integer (const t_long value);



    Integer (const String& value);



    Integer (const Integer& that);


    String repr (void) const;


    String toliteral (void) const;


    String tostring (void) const;


    Object* clone (void) const;


    t_byte serialid (void) const;



    void wrstream (class Output& os) const;



    void rdstream (class Input& is);



    Integer& operator = (const long value);



    Integer& operator = (const Integer& value);




    bool operator == (const long value) const;




    bool operator != (const long value) const;




    bool operator == (const Integer& value) const;




    bool operator != (const Integer& value) const;




    bool operator < (const Integer& value) const;




    bool operator <= (const Integer& value) const;




    bool operator > (const Integer& value) const;




    bool operator >= (const Integer& value) const;




    friend Integer operator - (const Integer& x);





    friend Integer operator + (const Integer& x, const Integer& y);





    friend Integer operator - (const Integer& x, const Integer& y);





    friend Integer operator * (const Integer& x, const Integer& y);





    friend Integer operator / (const Integer& x, const Integer& y);





    friend Integer operator % (const Integer& x, const Integer& y);




    Integer& operator += (const Integer& x);




    Integer& operator -= (const Integer& x);




    Integer& operator *= (const Integer& x);




    Integer& operator /= (const Integer& x);


    Integer abs (void) const;


    t_long tointeger (void) const;




    static t_long tointeger (const String& value);


    static t_long random (void);





    static t_long evalto (Runnable* robj, Nameset* nset, Object* object);



    static Object* mknew (Vector* argv);





    Object* oper (Runnable* robj, t_oper type, Object* object);





    Object* vdef (Runnable* robj, Nameset* nset, Object* object);






    Object* apply (Runnable* robj, Nameset* nset, const long quark,
     Vector* argv);

  private:

    friend class Real;
  public:

    void* operator new (const t_size size);
    void operator delete (void* handle);
  };
}
# 21 "BitSet.cpp" 2
# 1 "Exception.hpp" 1
# 24 "Exception.hpp"
namespace aleph {







  class Exception : public virtual Object {
  private:

    String d_eid;

    String d_reason;

    Object* p_object;

    String d_fname;

    long d_lnum;

    bool d_nlf;

    bool d_abf;

  public:


    Exception (const String& eid);




    Exception (const String& eid, const String& reason);





    Exception (const String& eid, const String& reason, const String& name);




    Exception (const String& eid, Object* object);





    Exception (const String& eid, const String& reason, Object* object);



    Exception (const Exception& that);


    ~Exception (void);


    String repr (void) const;


    String geteid (void) const {
      return d_eid;
    }


    String getval (void) const {
      return d_reason;
    }


    Object* getobj (void) const {
      return p_object;
    }


    void setnlf (const bool flag);


    bool getnlf (void) const {
      return d_nlf;
    }


    void setabf (const bool flag);


    bool getabf (void) const {
      return d_abf;
    }



    void setfname (const String& fname);


    String getfname (void) const {
      return d_fname;
    }



    void setlnum (const long lnum);


    long getlnum (void) const {
      return d_lnum;
    }





    Object* eval (Runnable* robj, Nameset* nset, const long quark);

  private:

    Exception& operator = (const Exception&);
  };
}
# 22 "BitSet.cpp" 2

namespace aleph {


  static const long QUARK_GET = String::intern ("get");
  static const long QUARK_SET = String::intern ("set");
  static const long QUARK_MARK = String::intern ("mark");
  static const long QUARK_CLEAR = String::intern ("clear");
  static const long QUARK_LENGTH = String::intern ("length");


  static long get_length (const long size) {
    long result = (size <= 0) ? 1 : (size / 8);
    if ((size % 8) == 0) return result;
    return (result + 1);
  }



  BitSet::BitSet (void) {
    d_size = 32;
    long len = get_length (d_size);
    p_byte = new t_byte[len];
    for (long i = 0; i < len; i++) p_byte[i] = nilc;
  }



  BitSet::BitSet (const long size) {
    d_size = (size <= 0) ? 32 : size;
    long len = get_length (d_size);
    p_byte = new t_byte[len];
    for (long i = 0; i < len; i++) p_byte[i] = nilc;
  }



  BitSet::BitSet (const BitSet& that) {
    d_size = that.d_size;
    long len = get_length(d_size);
    p_byte = new t_byte[len];
    for (long i = 0; i < len; i++) p_byte[i] = that.p_byte[i];
  }



  BitSet::~BitSet (void) {
    delete [] p_byte;
  }



  String BitSet::repr (void) const {
    return "BitSet";
  }



  BitSet& BitSet::operator = (const BitSet& that) {
    wrlock ();
    if (this == &that) {
      unlock ();
      return *this;
    }

    delete [] p_byte;

    d_size = that.d_size;
    long len = get_length (d_size);
    p_byte = new t_byte[len];
    for (long i = 0; i < len; i++) p_byte[i] = that.p_byte[i];
    unlock ();
    return *this;
  }



  bool BitSet::operator == (const BitSet& bset) const {
    if (d_size != bset.d_size) return false;
    for (long i = 0; i < d_size; i++) {
      if (p_byte[i] != bset.p_byte[i]) return false;
    }
    return true;
  }



  long BitSet::length (void) const {
    return d_size;
  }



  bool BitSet::get (const long pos) const {
    rdlock ();
    if ((pos < 0) || (pos >= d_size)) {
      unlock ();
      throw Exception ("bound-error", "invalid bit position in bitset");
    }
    t_byte byte = p_byte[pos/8];
    long boff = pos % 8;
    t_byte mask = (boff == 0) ? 0x01 : (0x01 << (boff-1));
    unlock ();
    return ((byte & mask) == mask);
  }



  void BitSet::mark (const long pos) {
    if (pos < 0) throw Exception ("bound-error", "negative bit position");
    wrlock ();
    if (pos >= d_size) reserve (pos+1);
    long boff = pos % 8;
    t_byte mask = (boff == 0) ? 0x01 : (0x01 << (boff-1));
    p_byte[pos/8] |= mask;
    unlock ();
  }



  void BitSet::clear (const long pos) {
    if (pos < 0) throw Exception ("bound-error", "negative bit position");
    wrlock ();
    if (pos >= d_size) reserve (pos+1);
    long boff = pos % 8;
    t_byte mask = (boff == 0) ? 0x01 : (0x01 << (boff-1));
    p_byte[pos/8] &= (~mask);
    unlock ();
  }



  void BitSet::set (const long pos, const bool bit) {
    if (bit == true)
      mark (pos);
    else
      clear (pos);
  }



  void BitSet::set (const long idx, const t_byte val) {

    long pos = idx * 8;
    if (pos >= d_size) reserve (pos+1);

    p_byte[idx] = val;
  }



  void BitSet::reserve (const long size) {
    wrlock ();

    if (size <= d_size) {
      unlock ();
      return;
    }

    long nlen = get_length (size);
    t_byte* bytes = new t_byte[nlen];
    for (long i = 0; i < nlen; i++) bytes[i] = nilc;

    long olen = get_length (d_size);
    for (long i = 0; i < olen; i++) bytes[i] |= p_byte[i];

    delete [] p_byte;
    p_byte = bytes;
    d_size = size;
    unlock ();
  }



  Object* BitSet::mknew (Vector* argv) {
    long argc = (argv == 0) ? 0 : argv->length ();
    if (argc == 0) return new BitSet;
    if (argc == 1) {
      long size = argv->getint (0);
      return new BitSet (size);
    }
    throw Exception ("argument-error", "too many argument for bitset");
  }



  Object* BitSet::apply (Runnable* robj, Nameset* nset, const long quark,
    Vector* argv) {

    long argc = (argv == 0) ? 0 : argv->length ();


    if (argc == 0) {
      if (quark == QUARK_LENGTH) return new Integer (length ());
    }


    if (argc == 1) {
      if (quark == QUARK_GET) {
 long pos = argv->getint (0);
 return new Boolean (get (pos));
      }
      if (quark == QUARK_MARK) {
 long pos = argv->getint (0);
 mark (pos);
 return 0;
      }
      if (quark == QUARK_CLEAR) {
 long pos = argv->getint (0);
 clear (pos);
 return 0;
      }
    }


    if (argc == 2) {
      if (quark == QUARK_SET) {
 long pos = argv->getint (0);
 bool bit = argv->getbool (1);
 set (pos, bit);
 return 0;
      }
    }


    return Object::apply (robj, nset, quark, argv);
  }
}

Reply to:

Prev by Date: Bug#333954: gcc-4.0: on alpha, gcc generated lituse_jsrdirect relocation tag is killing the assembler
Next by Date: Processed: tag gcc report
Previous by thread: Processed: merge gcc report
Next by thread: Processed: tag gcc report
Index(es):
- Date
- Thread