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)
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: