Article View: gnu.gcc.bug
Article #1107ld errors on decstation
From: Karl Berry
Date: Wed, 09 Sep 1992 15:40
Date: Wed, 09 Sep 1992 15:40
3032 lines
32706 bytes
32706 bytes
GCC 2.2.2 on a DECstation 3100 running Ultrix 4.2a, configured as `decstation'.
I get strange errors from ld after compiling the following file with -g -O.
If I remove the -O, the problem goes away, and I just get the (expected)
message that main is undefined.
gcc -g -O -v temp.c
Reading specs from /usr/local/gnu/lib/gcc-lib/decstation/2.2.2/specs
gcc version 2.2.2
/usr/local/gnu/lib/gcc-lib/decstation/2.2.2/cpp -lang-c -v -undef -D__GNUC__=2 -D__ANSI_COMPAT -DMIPSEL -DR3000 -DSYSTYPE_BSD -D_SYSTYPE_BSD -Dbsd4_2 -Dhost_mips -Dmips -Dultrix -Dunix -D__ANSI_COMPAT -D__MIPSEL__ -D__R3000__ -D__SYSTYPE_BSD__ -D___SYSTYPE_BSD__ -D__bsd4_2__ -D__host_mips__ -D__mips__ -D__ultrix__ -D__unix__ -D__ANSI_COMPAT -D__MIPSEL -D__R3000 -D__SYSTYPE_BSD -D___SYSTYPE_BSD -D__bsd4_2 -D__host_mips -D__mips -D__ultrix -D__unix -D__OPTIMIZE__ -g -D__LANGUAGE_C__ -D__LANGUAGE_C -DLANGUAG
E_C temp.c /tmp/cca09238.i
GNU CPP version 2.2.2 [AL 1.1, MM 19] DECstation running ultrix
/usr/local/gnu/lib/gcc-lib/decstation/2.2.2/cc1 /tmp/cca09238.i -mgpopt -quiet -dumpbase temp.c -g -O -version -o /tmp/cca09238.s
GNU C version 2.2.2 [AL 1.1, MM 19] DECstation running ultrix compiled by GNU C version 2.2.1.
as -nocpp -EL -O2 -g -v -o temp.o /tmp/cca09238.s
/usr/lib/cmplrs/cc/as0 -v -G 8 -EL -g2 -O2 /tmp/cca09238.s -o /tmp/ctmaa09340 -t /tmp/ctmsta09340
as0: malloc_user_error my_bzero my_bcopy gcd malloc_from_sys malloc_find_space malloc free calloc cfree malloc_usable_size realloc memalign valloc malloc_stats
0.5u 0.1s 0:03 18% 74+126k 0+14io 8pf+0w
/usr/lib/cmplrs/cc/as1 -v -G 8 -p0 -EL -g2 -O2 /tmp/ctmaa09340 -o temp.o -t /tmp/ctmsta09340
as1: malloc_user_error my_bzero my_bcopy gcd malloc_from_sys malloc_find_space malloc free calloc cfree malloc_usable_size realloc memalign valloc malloc_stats
0.4u 0.3s 0:04 16% 131+200k 3+4io 7pf+0w
/usr/local/gnu/lib/gcc-lib/decstation/2.2.2/mips-tfile -v -o temp.o /tmp/cca09238.s
mips-tfile version 2.2.2 [AL 1.1, MM 19] DECstation running ultrix
/usr/local/gnu/lib/gcc-lib/decstation/2.2.2/ld -EL /usr/lib/cmplrs/cc/crt0.o -L/usr/local/gnu/lib/gcc-lib/decstation/2.2.2 -L/usr/lib/cmplrs/cc -L/usr/lib/cmplrs/cc -L/usr/local/gnu/lib temp.o -lgcc -lc -lgcc
ld:
Undefined:
main
__new_handler: both a large and small symbol (possible gp relocation errors may result)
temp.o: gp relocation out-of-range in .text section for relocation entry 9 for symbol: __new_handler
temp.o: above gp relocation entry for non .sdata or .sbss symbol
gp relocation out-of-range for small data or bss by,
0 in the positive direction,
2448 in the negative direction.
All data will fit into the global pointer area
Best -G num value to compile all -count'ed objects
creating a.out with is 1920 (or greater)
Best -G num value calculation reliable only if all
-count'ed objects were compiled with -G num greater or
equal to maximum size of a literal pool item (8).
collect: /usr/bin/ld returned 1 exit status
# 1 "malloc.c"
# 1 "//usr/include/stdio.h" 1
# 1 "/usr/include/ansi_compat.h" 1 3
# 116 "/usr/include/ansi_compat.h" 3
# 89 "//usr/include/stdio.h" 2
typedef unsigned int size_t;
extern struct _iobuf {
int _cnt;
char *_ptr;
char *_base;
int _bufsiz;
short _flag;
short _file;
} _iob[3 ];
typedef struct _iobuf FILE;
typedef long fpos_t;
extern int getc( FILE *__stream );
extern int getchar( void );
extern int putc( int __c, FILE *__stream);
extern int putchar( int __c);
extern int feof( FILE *__stream );
extern int ferror( FILE *__stream );
extern int fileno( FILE *__stream );
extern int _filbuf( FILE *p);
extern int _flsbuf( unsigned char x , FILE *p);
typedef char *va_list;
extern void clearerr( FILE *__stream);
extern int fclose( FILE *__stream );
extern FILE * fdopen( int __filedes, char *__type );
extern int fflush( FILE *__stream );
extern int fgetc( FILE *__stream );
extern int fgetpos( FILE *__stream, fpos_t *__pos );
extern char * fgets( char *__s, int __n, FILE *__stream );
extern FILE * fopen( const char *__filename, const char *__type );
extern int fprintf( FILE *__stream, const char *__format, ... );
extern int fputc( int __c, FILE *__stream );
extern int fputs( const char *__s, FILE *__stream );
extern size_t fread( void *__ptr, size_t __size,
size_t __nitems, FILE *__stream );
extern FILE * freopen( const char *__filename, const char *__type,
FILE *__stream );
extern int fscanf( FILE *__stream, const char *__format, ... );
extern int fseek( FILE *__stream, long __offset, int __ptrname );
extern int fsetpos( FILE *__stream, const fpos_t *__pos );
extern long ftell( FILE *__stream );
extern size_t fwrite( const void *__ptr, size_t __size,
size_t __nitems, FILE *__stream );
extern char * gets( char *__s );
extern void perror( const char *__s );
extern FILE * popen(const char *__command, const char *__type );
extern int printf( const char *__format, ... );
extern int puts( const char *__s );
extern int remove( const char *__filename );
extern int rename( const char *__from, const char *__to );
extern void rewind( FILE *__stream );
extern int scanf( const char *__format, ... );
extern void setbuf( FILE *__stream, char *__buf );
extern int setvbuf( FILE *__stream, char *__buf,
int __type, size_t __size );
extern int sscanf( const char *__s, const char *__format, ... );
extern FILE * tmpfile( void );
extern char * tmpnam( char *__s );
extern int ungetc( int __c, FILE *__stream );
extern int vfprintf( FILE *__stream, const char *__format, va_list __ap );
extern int vprintf( const char *__format, va_list __ap );
extern int vsprintf( char *__s, const char *__format, va_list __ap);
extern char * tempnam( const char *__dir, const char *__pfx);
extern int putw( int __w, FILE *__stream );
extern int getw(FILE *__stream);
extern int pclose( FILE *__stream );
# 298 "//usr/include/stdio.h"
extern int sprintf( char *__s, const char *__format, ... );
# 239 "malloc.c" 2
# 1 "/usr/include/sys/types.h" 1 3
# 1 "/usr/include/ansi_compat.h" 1 3
# 116 "/usr/include/ansi_compat.h" 3
# 79 "/usr/include/sys/types.h" 2 3
typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned int uint;
typedef unsigned long u_long;
typedef unsigned short ushort;
typedef volatile char v_char;
typedef volatile short v_short;
typedef volatile long v_long;
typedef volatile unsigned char vu_char;
typedef volatile unsigned short vu_short;
typedef volatile unsigned long vu_long;
typedef
signed
char s_char;
typedef struct _physadr { int r[1]; } *physadr;
typedef struct label_t {
int val[12];
} label_t;
typedef struct _quad { long val[2]; } quad;
typedef long daddr_t;
typedef char * caddr_t;
typedef u_long gno_t;
typedef short cnt_t;
typedef long swblk_t;
typedef long paddr_t;
typedef long audit_ID_t;
typedef short dev_t;
typedef short gid_t;
typedef unsigned long ino_t;
typedef unsigned short mode_t;
typedef short nlink_t;
typedef int off_t;
typedef int pid_t;
typedef short uid_t;
typedef int time_t;
typedef int clock_t;
typedef long key_t;
typedef long fd_mask;
typedef struct fd_set {
fd_mask fds_bits[(((4096 )+(( (sizeof(fd_mask) * 8 ) )-1))/( (sizeof(fd_mask) * 8 ) )) ];
} fd_set;
# 246 "malloc.c" 2
extern void* sbrk(size_t );
extern volatile void abort();
static volatile void malloc_user_error()
{
fputs("malloc/free/realloc: clobbered space detected\n", (&_iob[2]) ); abort();
}
static void
my_bzero (mem, len)
char *mem;
unsigned len;
{
int i;
for (i = 0; i < len; i++)
mem[i] = 0;
}
static void
my_bcopy (from, to, size)
char *from, *to;
int size;
{
int i;
for (i = 0; i < size; i++)
to[i] = from[i];
}
struct malloc_chunk
{
size_t size;
struct malloc_chunk* fd;
struct malloc_chunk* bk;
};
typedef struct malloc_chunk* mchunkptr;
struct malloc_bin
{
struct malloc_chunk hd;
size_t dirty;
};
typedef struct malloc_bin* mbinptr;
static inline size_t request2size(size_t request)
{
return (request == 0) ? (sizeof(struct malloc_chunk) + (sizeof(size_t )) ) :
((request + ( (sizeof(size_t )) + (sizeof(size_t )) ) + ( ( (sizeof(size_t )) + (sizeof(size_t )) ) - 1) )
& ~( ( ( (sizeof(size_t )) + (sizeof(size_t )) ) - 1) ));
}
static inline int aligned_OK(void* m)
{
return ((size_t )(m) & ( ( ( (sizeof(size_t )) + (sizeof(size_t )) ) - 1) )) == 0;
}
static struct malloc_bin av[120 ] =
{
{ { 0, &(av[0].hd), &(av[0].hd) }, 0 },
{ { 0, &(av[1].hd), &(av[1].hd) }, 0 },
{ { 0, &(av[2].hd), &(av[2].hd) }, 0 },
{ { 0, &(av[3].hd), &(av[3].hd) }, 0 },
{ { 0, &(av[4].hd), &(av[4].hd) }, 0 },
{ { 0, &(av[5].hd), &(av[5].hd) }, 0 },
{ { 0, &(av[6].hd), &(av[6].hd) }, 0 },
{ { 0, &(av[7].hd), &(av[7].hd) }, 0 },
{ { 0, &(av[8].hd), &(av[8].hd) }, 0 },
{ { 0, &(av[9].hd), &(av[9].hd) }, 0 },
{ { 0, &(av[10].hd), &(av[10].hd) }, 0 },
{ { 0, &(av[11].hd), &(av[11].hd) }, 0 },
{ { 0, &(av[12].hd), &(av[12].hd) }, 0 },
{ { 0, &(av[13].hd), &(av[13].hd) }, 0 },
{ { 0, &(av[14].hd), &(av[14].hd) }, 0 },
{ { 0, &(av[15].hd), &(av[15].hd) }, 0 },
{ { 0, &(av[16].hd), &(av[16].hd) }, 0 },
{ { 0, &(av[17].hd), &(av[17].hd) }, 0 },
{ { 0, &(av[18].hd), &(av[18].hd) }, 0 },
{ { 0, &(av[19].hd), &(av[19].hd) }, 0 },
{ { 0, &(av[20].hd), &(av[20].hd) }, 0 },
{ { 0, &(av[21].hd), &(av[21].hd) }, 0 },
{ { 0, &(av[22].hd), &(av[22].hd) }, 0 },
{ { 0, &(av[23].hd), &(av[23].hd) }, 0 },
{ { 0, &(av[24].hd), &(av[24].hd) }, 0 },
{ { 0, &(av[25].hd), &(av[25].hd) }, 0 },
{ { 0, &(av[26].hd), &(av[26].hd) }, 0 },
{ { 0, &(av[27].hd), &(av[27].hd) }, 0 },
{ { 0, &(av[28].hd), &(av[28].hd) }, 0 },
{ { 0, &(av[29].hd), &(av[29].hd) }, 0 },
{ { 0, &(av[30].hd), &(av[30].hd) }, 0 },
{ { 0, &(av[31].hd), &(av[31].hd) }, 0 },
{ { 0, &(av[32].hd), &(av[32].hd) }, 0 },
{ { 0, &(av[33].hd), &(av[33].hd) }, 0 },
{ { 0, &(av[34].hd), &(av[34].hd) }, 0 },
{ { 0, &(av[35].hd), &(av[35].hd) }, 0 },
{ { 0, &(av[36].hd), &(av[36].hd) }, 0 },
{ { 0, &(av[37].hd), &(av[37].hd) }, 0 },
{ { 0, &(av[38].hd), &(av[38].hd) }, 0 },
{ { 0, &(av[39].hd), &(av[39].hd) }, 0 },
{ { 0, &(av[40].hd), &(av[40].hd) }, 0 },
{ { 0, &(av[41].hd), &(av[41].hd) }, 0 },
{ { 0, &(av[42].hd), &(av[42].hd) }, 0 },
{ { 0, &(av[43].hd), &(av[43].hd) }, 0 },
{ { 0, &(av[44].hd), &(av[44].hd) }, 0 },
{ { 0, &(av[45].hd), &(av[45].hd) }, 0 },
{ { 0, &(av[46].hd), &(av[46].hd) }, 0 },
{ { 0, &(av[47].hd), &(av[47].hd) }, 0 },
{ { 0, &(av[48].hd), &(av[48].hd) }, 0 },
{ { 0, &(av[49].hd), &(av[49].hd) }, 0 },
{ { 0, &(av[50].hd), &(av[50].hd) }, 0 },
{ { 0, &(av[51].hd), &(av[51].hd) }, 0 },
{ { 0, &(av[52].hd), &(av[52].hd) }, 0 },
{ { 0, &(av[53].hd), &(av[53].hd) }, 0 },
{ { 0, &(av[54].hd), &(av[54].hd) }, 0 },
{ { 0, &(av[55].hd), &(av[55].hd) }, 0 },
{ { 0, &(av[56].hd), &(av[56].hd) }, 0 },
{ { 0, &(av[57].hd), &(av[57].hd) }, 0 },
{ { 0, &(av[58].hd), &(av[58].hd) }, 0 },
{ { 0, &(av[59].hd), &(av[59].hd) }, 0 },
{ { 0, &(av[60].hd), &(av[60].hd) }, 0 },
{ { 0, &(av[61].hd), &(av[61].hd) }, 0 },
{ { 0, &(av[62].hd), &(av[62].hd) }, 0 },
{ { 0, &(av[63].hd), &(av[63].hd) }, 0 },
{ { 0, &(av[64].hd), &(av[64].hd) }, 0 },
{ { 0, &(av[65].hd), &(av[65].hd) }, 0 },
{ { 0, &(av[66].hd), &(av[66].hd) }, 0 },
{ { 0, &(av[67].hd), &(av[67].hd) }, 0 },
{ { 0, &(av[68].hd), &(av[68].hd) }, 0 },
{ { 0, &(av[69].hd), &(av[69].hd) }, 0 },
{ { 0, &(av[70].hd), &(av[70].hd) }, 0 },
{ { 0, &(av[71].hd), &(av[71].hd) }, 0 },
{ { 0, &(av[72].hd), &(av[72].hd) }, 0 },
{ { 0, &(av[73].hd), &(av[73].hd) }, 0 },
{ { 0, &(av[74].hd), &(av[74].hd) }, 0 },
{ { 0, &(av[75].hd), &(av[75].hd) }, 0 },
{ { 0, &(av[76].hd), &(av[76].hd) }, 0 },
{ { 0, &(av[77].hd), &(av[77].hd) }, 0 },
{ { 0, &(av[78].hd), &(av[78].hd) }, 0 },
{ { 0, &(av[79].hd), &(av[79].hd) }, 0 },
{ { 0, &(av[80].hd), &(av[80].hd) }, 0 },
{ { 0, &(av[81].hd), &(av[81].hd) }, 0 },
{ { 0, &(av[82].hd), &(av[82].hd) }, 0 },
{ { 0, &(av[83].hd), &(av[83].hd) }, 0 },
{ { 0, &(av[84].hd), &(av[84].hd) }, 0 },
{ { 0, &(av[85].hd), &(av[85].hd) }, 0 },
{ { 0, &(av[86].hd), &(av[86].hd) }, 0 },
{ { 0, &(av[87].hd), &(av[87].hd) }, 0 },
{ { 0, &(av[88].hd), &(av[88].hd) }, 0 },
{ { 0, &(av[89].hd), &(av[89].hd) }, 0 },
{ { 0, &(av[90].hd), &(av[90].hd) }, 0 },
{ { 0, &(av[91].hd), &(av[91].hd) }, 0 },
{ { 0, &(av[92].hd), &(av[92].hd) }, 0 },
{ { 0, &(av[93].hd), &(av[93].hd) }, 0 },
{ { 0, &(av[94].hd), &(av[94].hd) }, 0 },
{ { 0, &(av[95].hd), &(av[95].hd) }, 0 },
{ { 0, &(av[96].hd), &(av[96].hd) }, 0 },
{ { 0, &(av[97].hd), &(av[97].hd) }, 0 },
{ { 0, &(av[98].hd), &(av[98].hd) }, 0 },
{ { 0, &(av[99].hd), &(av[99].hd) }, 0 },
{ { 0, &(av[100].hd), &(av[100].hd) }, 0 },
{ { 0, &(av[101].hd), &(av[101].hd) }, 0 },
{ { 0, &(av[102].hd), &(av[102].hd) }, 0 },
{ { 0, &(av[103].hd), &(av[103].hd) }, 0 },
{ { 0, &(av[104].hd), &(av[104].hd) }, 0 },
{ { 0, &(av[105].hd), &(av[105].hd) }, 0 },
{ { 0, &(av[106].hd), &(av[106].hd) }, 0 },
{ { 0, &(av[107].hd), &(av[107].hd) }, 0 },
{ { 0, &(av[108].hd), &(av[108].hd) }, 0 },
{ { 0, &(av[109].hd), &(av[109].hd) }, 0 },
{ { 0, &(av[110].hd), &(av[110].hd) }, 0 },
{ { 0, &(av[111].hd), &(av[111].hd) }, 0 },
{ { 0, &(av[112].hd), &(av[112].hd) }, 0 },
{ { 0, &(av[113].hd), &(av[113].hd) }, 0 },
{ { 0, &(av[114].hd), &(av[114].hd) }, 0 },
{ { 0, &(av[115].hd), &(av[115].hd) }, 0 },
{ { 0, &(av[116].hd), &(av[116].hd) }, 0 },
{ { 0, &(av[117].hd), &(av[117].hd) }, 0 },
{ { 0, &(av[118].hd), &(av[118].hd) }, 0 },
{ { 0, &(av[119].hd), &(av[119].hd) }, 0 }
};
static inline mbinptr size2bin(size_t sz)
{
mbinptr b = av;
while (sz >= ((sizeof(struct malloc_chunk) + (sizeof(size_t )) ) * 2)) { b += 4; sz >>= 1; }
b += (sz - (sizeof(struct malloc_chunk) + (sizeof(size_t )) ) ) >> 2;
return b;
}
# 561 "malloc.c"
static size_t gcd(size_t a, size_t b)
{
size_t tmp;
if (b > a)
{
tmp = a; a = b; b = tmp;
}
for(;;)
{
if (b == 0)
return a;
else if (b == 1)
return b;
else
{
tmp = b;
b = a % b;
a = tmp;
}
}
}
static inline size_t lcm(size_t x, size_t y)
{
return x / gcd(x, y) * y;
}
static inline void set_size(mchunkptr p, size_t sz)
{
p->size = *((int*)((char*)(p) + sz - (sizeof(size_t )) )) = sz;
}
static inline void* chunk2mem(mchunkptr p)
{
((p)->size |= 0x1 ) ;
return (void*)((char*)(p) + (sizeof(size_t )) );
}
static inline mchunkptr mem2chunk(void* mem)
{
mchunkptr p = (mchunkptr)((char*)(mem) - (sizeof(size_t )) );
size_t sz = p->size & ~( 0x1 );
if (p->size == sz || sz != *((int*)((char*)(p) + sz - (sizeof(size_t )) )))
malloc_user_error();
p->size = sz;
return p;
}
static mbinptr malloc_maxbin = (&(av[0])) ;
static inline void unlink(mchunkptr p)
{
mchunkptr b = p->bk;
mchunkptr f = p->fd;
f->bk = b; b->fd = f;
;
}
static inline void split(mchunkptr p, size_t offset)
{
size_t room = p->size - offset;
if (room >= (sizeof(struct malloc_chunk) + (sizeof(size_t )) ) )
{
mbinptr bn = size2bin(room);
mchunkptr h = &(bn->hd);
mchunkptr b = h->bk;
mchunkptr t = (mchunkptr)((char*)(p) + offset);
t->size = *((int*)((char*)(t) + room - (sizeof(size_t )) )) = room;
t->bk = b; t->fd = h; h->bk = b->fd = t;
if (h == b && bn > malloc_maxbin) malloc_maxbin = bn;
p->size = *((int*)((char*)(p) + offset - (sizeof(size_t )) )) = offset;
;
}
}
static inline void consollink(mchunkptr p)
{
mbinptr bn = size2bin(p->size);
mchunkptr h = &(bn->hd);
mchunkptr b = h->bk;
p->bk = b; p->fd = h; h->bk = b->fd = p;
if (h == b && bn > malloc_maxbin) malloc_maxbin = bn;
;
}
static inline void frontlink(mchunkptr p)
{
mbinptr bn = size2bin(p->size);
mchunkptr h = &(bn->hd);
mchunkptr f = h->fd;
p->bk = h; p->fd = f; f->bk = h->fd = p;
if (h == f && bn > malloc_maxbin) malloc_maxbin = bn;
bn->dirty = 1;
;
}
static int* last_sbrk_end;
typedef volatile void (*vfp)();
extern vfp __new_handler;
static mchunkptr malloc_from_sys(unsigned nb)
{
mchunkptr p;
size_t sbrk_size;
int* ip;
sbrk_size = ((nb + 4096 - 1 + (sizeof(size_t )) + (sizeof(size_t )) )
/ 4096 ) * 4096 ;
ip = (int*)(sbrk(sbrk_size));
if ((char*)ip == (char*)(-1))
{
(*__new_handler) ();
return 0;
}
;
if (last_sbrk_end != &ip[-1])
{
while (!aligned_OK(ip)) { ++ip; sbrk_size -= (sizeof(size_t )) ; }
*ip++ = (sizeof(size_t )) | 0x1 ;
p = (mchunkptr)ip;
set_size(p,sbrk_size - ( (sizeof(size_t )) + (sizeof(size_t )) ));
}
else
{
mchunkptr l;
p = (mchunkptr)(last_sbrk_end);
set_size(p, sbrk_size);
l = ((mchunkptr)((char*)(p)-((((int*)(p))[-1]) & ~( 0x1 )))) ;
if (! ((l)->size & 0x1 ) )
{
unlink(l);
set_size(l, p->size + l->size);
p = l;
}
}
last_sbrk_end = (int*)((char*)p + p->size);
*last_sbrk_end = (sizeof(size_t )) | 0x1 ;
;
;
p->fd = p->bk = p;
return p;
}
static mchunkptr malloc_find_space(size_t nb)
{
mbinptr b;
while (malloc_maxbin >= (&(av[0])) &&
malloc_maxbin->hd.bk == &(malloc_maxbin->hd))
{
malloc_maxbin->dirty = 0;
--malloc_maxbin;
}
for (b = malloc_maxbin; b >= (&(av[0])) ; --b)
{
;
if (b->dirty)
{
mchunkptr h = &(b->hd);
mchunkptr p = h->fd;
while (p != h)
{
mchunkptr nextp = p->fd;
int consolidated = 0;
mchunkptr t;
;
while (! ((t = ((mchunkptr)((char*)(p)-((((int*)(p))[-1]) & ~( 0x1 )))) )->size & 0x1 ) )
{
if (!consolidated) { consolidated = 1; unlink(p); }
if (t == nextp) nextp = t->fd;
unlink(t);
set_size(t, t->size + p->size);
p = t;
;
}
while (! ((t = ((mchunkptr)((char*)(p) + (p)->size)) )->size & 0x1 ) )
{
if (!consolidated) { consolidated = 1; unlink(p); }
if (t == nextp) nextp = t->fd;
unlink(t);
set_size(p, p->size + t->size);
;
}
if (consolidated)
{
if (p->size >= nb)
{
;
p->fd = p->bk = p;
return p;
}
else
consollink(p);
}
p = nextp;
}
b->dirty = 0;
}
}
return malloc_from_sys(nb);
}
void* malloc(size_t bytes)
{
size_t nb = request2size(bytes);
mbinptr b = size2bin(nb);
mchunkptr hd = &(b->hd);
mchunkptr p = hd->fd;
;
while (p != hd)
{
;
if (p->size >= nb)
goto found;
else
{
mchunkptr nextp = p->fd;
int consolidated = 0;
mchunkptr t;
while (! ((t = ((mchunkptr)((char*)(p)-((((int*)(p))[-1]) & ~( 0x1 )))) )->size & 0x1 ) )
{
if (!consolidated) { consolidated = 1; unlink(p); }
if (t == nextp) nextp = t->fd;
unlink(t);
set_size(t, t->size + p->size);
p = t;
;
}
while (! ((t = ((mchunkptr)((char*)(p) + (p)->size)) )->size & 0x1 ) )
{
if (!consolidated) { consolidated = 1; unlink(p); }
if (t == nextp) nextp = t->fd;
unlink(t);
set_size(p, p->size + t->size);
;
}
if (consolidated)
{
if (p->size >= nb)
{
;
p->fd = p->bk = p;
goto found;
}
else
consollink(p);
}
p = nextp;
}
}
b->dirty = 0;
while (++b <= malloc_maxbin)
{
;
if ((p = b->hd.bk) != &(b->hd))
goto found;
}
p = malloc_find_space(nb);
if (p == 0) return 0;
found:
unlink(p);
split(p, nb);
;
return chunk2mem(p);
}
void free(void* mem)
{
if (mem != 0)
{
mchunkptr p = mem2chunk(mem);
;
frontlink(p);
}
}
void* calloc(size_t n, size_t elem_size)
{
size_t sz = n * elem_size;
void* p = malloc(sz);
my_bzero (p, sz);
return p;
};
void cfree(void *mem)
{
free(mem);
}
size_t malloc_usable_size(void* mem)
{
if (mem == 0)
return 0;
else
{
mchunkptr p = (mchunkptr)((char*)(mem) - (sizeof(size_t )) );
size_t sz = p->size & ~( 0x1 );
if (p->size == sz || sz != *((int*)((char*)(p) + sz - (sizeof(size_t )) )))
return 0;
else
return sz - ( (sizeof(size_t )) + (sizeof(size_t )) ) ;
}
}
void* realloc(void* mem, size_t bytes)
{
if (mem == 0)
return malloc(bytes);
else
{
size_t nb = request2size(bytes);
mchunkptr p = mem2chunk(mem);
size_t oldsize = p->size;
int room;
mchunkptr nxt;
;
while (! ((nxt = ((mchunkptr)((char*)(p) + (p)->size)) )->size & 0x1 ) )
{
;
unlink(nxt);
set_size(p, p->size + nxt->size);
}
room = p->size - nb;
if (room >= 0)
{
split(p, nb);
;
return chunk2mem(p);
}
else
{
void* newmem;
((p)->size |= 0x1 ) ;
newmem = malloc(nb);
my_bcopy (mem, newmem, oldsize - (sizeof(size_t )) );
free(mem);
;
return newmem;
}
}
}
void* memalign(size_t alignment, size_t bytes)
{
mchunkptr p;
size_t nb = request2size(bytes);
size_t align = lcm(alignment, ( (sizeof(size_t )) + (sizeof(size_t )) ) );
size_t mask = align - 1;
size_t req = nb + align + (sizeof(struct malloc_chunk) + (sizeof(size_t )) ) ;
void* m = malloc(req);
if (m == 0) return m;
p = mem2chunk(m);
;
;
;
;
if (((int)(m) & (mask)) != 0)
{
mchunkptr ap = (mchunkptr)(( ((int)(m) + mask) & -align) - (sizeof(size_t )) );
size_t gap = (size_t )(ap) - (size_t )(p);
size_t room;
if (gap < (sizeof(struct malloc_chunk) + (sizeof(size_t )) ) )
{
ap = (mchunkptr)( (int)(ap) + align );
gap += align;
}
if (gap + nb > p->size)
malloc_user_error();
room = p->size - gap;
set_size(p, gap);
consollink(p);
p = ap;
set_size(p, room);
}
split(p, nb);
;
return chunk2mem(p);
}
# 1 "../include/getpagesize.h" 1 3
# 1 "/usr/include/sys/param.h" 1 3
# 1 "/usr/include/ansi_compat.h" 1 3
# 116 "/usr/include/ansi_compat.h" 3
# 121 "/usr/include/sys/param.h" 2 3
# 1 "/usr/include/machine/param.h" 1 3
extern unsigned int sr_usermask;
# 122 "/usr/include/sys/param.h" 2 3
# 164 "/usr/include/sys/param.h" 3
# 1 "/usr/include/signal.h" 1 3
# 1 "/usr/include/ansi_compat.h" 1 3
# 116 "/usr/include/ansi_compat.h" 3
# 74 "/usr/include/signal.h" 2 3
typedef long sig_atomic_t;
typedef int sigset_t;
struct sigvec {
void (*sv_handler)();
sigset_t sv_mask;
int sv_flags;
};
struct sigaction {
void (*sa_handler)();
sigset_t sa_mask;
int sa_flags;
};
struct sigstack {
char *ss_sp;
int ss_onstack;
};
struct sigcontext {
int sc_onstack;
int sc_mask;
int sc_pc;
int sc_regs[32];
int sc_mdlo;
int sc_mdhi;
int sc_ownedfp;
int sc_fpregs[32];
int sc_fpc_csr;
int sc_fpc_eir;
int sc_cause;
int sc_badvaddr;
int sc_badpaddr;
};
extern void (*signal(int __sig, void(*__func)(int)))(int);
int raise( int __sig );
int kill( pid_t __pid, int __sig );
int sigemptyset( sigset_t *__set );
int sigfillset( sigset_t *__set );
int sigaddset( sigset_t *__set, int __signo );
int sigdelset( sigset_t *__set, int __signo );
int sigismember( const sigset_t *__set, int __signo );
int sigaction( int __sig, const struct sigaction *__act,
struct sigaction *__oact );
int sigprocmask( int __how, const sigset_t *__set, sigset_t *__oset );
int sigpending( sigset_t *__set );
int sigsuspend( const sigset_t *__sigmask );
# 250 "/usr/include/sys/param.h" 2 3
# 1 "/usr/include/sys/smp_lock.h" 1 3
# 1 "/usr/include/ansi_compat.h" 1 3
# 116 "/usr/include/ansi_compat.h" 3
# 126 "/usr/include/sys/smp_lock.h" 2 3
struct __lock_t {
volatile unsigned int
l_call:8,
l_hierpos:8,
l_ipl:8,
l_type:7,
l_lock:1;
struct __lock_t *l_plock;
char * l_pc;
unsigned long l_lost;
unsigned long l_spin;
unsigned long l_won;
unsigned short l_wanted;
};
struct lock_trace {
long tr_pid;
caddr_t tr_pc;
long tr_psl;
struct __lock_t *tr_lock;
};
struct debug_entry {
unsigned int spinct;
caddr_t calling_pc;
caddr_t holding_pc;
};
struct debug_lock_trace {
struct __lock_t *traced_lock;
int current_lock_trace;
int debug_lock_entries;
struct debug_entry element[200 ];
};
extern struct debug_lock_trace *debug_lock_trace;
struct lock_data {
char l_hierpos;
char l_type;
char l_ipl;
};
# 384 "/usr/include/sys/smp_lock.h" 3
# 313 "/usr/include/sys/param.h" 2 3
# 9 "../include/getpagesize.h" 2 3
# 1182 "malloc.c" 2
static size_t malloc_pagesize = 0;
void* valloc(size_t bytes)
{
if (malloc_pagesize == 0) malloc_pagesize = 4096 * 1 ;
return memalign (malloc_pagesize, bytes);
}
void malloc_stats()
{
}
# 1277 "malloc.c"
Technical Details
Message-ID:
<199209092340.AA09363@ds1.cs.umb.edu>Path:
arc1-ca.pugleaf.net!sparky!uunet!cis.ohio-state.edu!ds1.cs.umb.edu!karlShow Full Headers
Complete Article Headers
Newsgroups: gnu.gcc.bug Path: arc1-ca.pugleaf.net!sparky!uunet!cis.ohio-state.edu!ds1.cs.umb.edu!karl From: karl@ds1.cs.umb.edu (Karl Berry) Subject: ld errors on decstation Message-ID: <199209092340.AA09363@ds1.cs.umb.edu> Sender: gnulists@ai.mit.edu Reply-To: karl@cs.umb.edu Organization: GNUs Not Usenet Distribution: gnu Date: Wed, 9 Sep 1992 15:40:55 GMT Approved: bug-gcc@prep.ai.mit.edu Lines: 3033