Path: utzoo!telly!ddsw1!mcdchg!rutgers!tut.cis.ohio-state.edu!BAYES.ARC.NASA.GOV!self
From: self@BAYES.ARC.NASA.GOV (Matthew Self)
Newsgroups: gnu.gcc.bug
Subject: gcc 1.29 gets fatal signal 11 with -g flag under SunOS 4.0
Message-ID: <8810120627.AA00898@bayes.arc.nasa.gov>
Date: 12 Oct 88 06:27:33 GMT
Sender: daemon@tut.cis.ohio-state.edu
Distribution: gnu
Organization: GNUs Not Usenet
Lines: 542


gcc version 1.29 (with corrected patch of 11 Oct 88) gets fatal
error (when debugging only) on a Sun 3 running 4.0

Specifics:

gcc -v => gcc version 1.29
gcc -c -g => gcc: Program cc1 got fatal signal 11.
(note that gcc -c and gcc -c -O produce working code.)

config.h => config-sun4.h
tm.h => tm-sun3.h
md => m68k.md
aux-output.c => output-m68k.c

P.S. I tried installing gdb 2.8 today (same machine) with no luck.
I made patches to core.c replacing references to c_fpstatus and
c_fparegs with c_fpu.f_pstatus and c_fpu.f_fparegs to come into line
with the new <sys/core.h>.  Compilation was successful, but gdb dumps
core when it tries to load symbol table info.  Has anyone made this
work under 4.0 yet?

=========================exmaple code=============================

extern	struct	_iobuf {
	int	_cnt;
	unsigned char *_ptr;
	unsigned char *_base;
	int	_bufsiz;
	short	_flag;
	char	_file;		 
} _iob[];
extern struct _iobuf 	*fopen();
extern struct _iobuf 	*fdopen();
extern struct _iobuf 	*freopen();
extern struct _iobuf 	*popen();
extern struct _iobuf 	*tmpfile();
extern long	ftell();
extern char	*fgets();
extern char	*gets();
extern char	*ctermid();
extern char	*cuserid();
extern char	*tempnam();
extern char	*tmpnam();
enum fp_direction_type 		 
	{
	fp_nearest	= 0,
	fp_tozero	= 1,
	fp_negative	= 2,
	fp_positive	= 3
	} ;
enum fp_precision_type		 
	{
	fp_extended	= 0,
	fp_single	= 1,
	fp_double	= 2,
	fp_precision_3	= 3
	} ;
enum fp_exception_type		 
	{
	fp_inexact	= 0,
	fp_division	= 1,
	fp_underflow	= 2,
	fp_overflow	= 3,
	fp_invalid	= 4
	} ;
enum fp_class_type		 
	{
	fp_zero		= 0,
	fp_subnormal	= 1,
	fp_normal	= 2,
	fp_infinity   	= 3,
	fp_quiet	= 4,
	fp_signaling	= 5
	} ;
typedef float single ;			
typedef unsigned extended[3] ;
typedef unsigned fp_exception_field_type ; 
typedef int sigfpe_code_type ;   
typedef void (* sigfpe_handler_type)() ; 
extern enum fp_direction_type fp_direction ;
extern enum fp_precision_type fp_precision ;
extern sigfpe_handler_type ieee_handlers [5	] ;
extern fp_exception_field_type fp_accrued_exceptions ;	
extern sigfpe_handler_type sigfpe( ) ;
typedef char decimal_string[512	] ;	
typedef struct
	{
	enum fp_class_type fpclass ;
	int	sign ;
	int	exponent ;
	decimal_string ds ;	 
	int	more ;		 
	int 	ndigits ;	 
	}
	decimal_record ;
enum decimal_form
	{
	fixed_form,		 
	floating_form		 
	} ;
typedef struct
	{
	enum fp_direction_type rd ;	
	enum decimal_form df ;	 
	int ndigits ;		 
	}
	decimal_mode ;
enum decimal_string_form
	{			 
	invalid_form,		 
	whitespace_form,	 
	fixed_int_form,		 
	fixed_intdot_form,	 
	fixed_dotfrac_form,	 
	fixed_intdotfrac_form,	 
	floating_int_form,	 	
	floating_intdot_form,	 
	floating_dotfrac_form,	 
	floating_intdotfrac_form, 
	inf_form,		 
	infinity_form,		 
	nan_form,		 
	nanstring_form		 
	} ;
extern void single_to_decimal ( ) ; 
extern void double_to_decimal ( ) ;
extern void extended_to_decimal ( ) ;
extern void decimal_to_single ( ) ;
extern void decimal_to_double ( ) ;
extern void decimal_to_extended ( ) ;
extern char *econvert( ) ;
extern char *fconvert( ) ;
extern char *gconvert( ) ;
extern char *seconvert( ) ;
extern char *sfconvert( ) ;
extern char *sgconvert( ) ;
extern void string_to_decimal( ) ; 
extern void   file_to_decimal( ) ; 
extern void   func_to_decimal( ) ; 
extern double atof();
extern int errno;
extern double strtod ();
extern int    finite();
extern double fabs(), floor(), ceil(), rint();
extern double hypot();
extern double copysign();
extern double sqrt();
extern double modf(), frexp();
extern double asinh(), acosh(), atanh();
extern double erf(), erfc();
extern double exp(), expm1(), log(), log10(), log1p(), pow();
extern double lgamma();
extern double j0(), j1(), jn(), y0(), y1(), yn();
extern double sin(), cos(), tan(), asin(), acos(), atan(), atan2();
extern double sinh(), cosh(), tanh();
extern double cbrt();
enum fp_pi_type { 		 
	fp_pi_infinite	= 0,	 
	fp_pi_66	= 1,	 
	fp_pi_53	= 2	 
	} ;
extern enum fp_pi_type fp_pi ;   
extern enum fp_class_type fp_class() ;
extern int ilogb(), irint(), signbit() ;
extern int isinf(), isnan(), isnormal(), issubnormal(), iszero() ;
extern double nextafter(), remainder() ;
extern double logb(), significand(), scalb(), scalbn();
extern double min_subnormal(), max_subnormal();
extern double min_normal(), max_normal();
extern double infinity(), quiet_nan(), signaling_nan();
extern double log2(), exp10(), exp2(), aint(), anint() ;
extern int nint() ;
extern void   sincos();
extern int ieee_flags ();
extern int ieee_handler ();
extern int    ir_finite_();
extern int  r_fabs_(), r_floor_(), r_ceil_(), r_rint_();
extern int  r_hypot_();
extern int  r_copysign_();
extern int  r_sqrt_();
extern int  r_asinh_(), r_acosh_(), r_atanh_();
extern int  r_erf_(), r_erfc_();
extern int  r_exp_(), r_expm1_(), r_log_(), r_log10_(), r_log1p_();
extern int  r_pow_();
extern int  r_lgamma_();
extern int  r_j0_(), r_j1_(), r_jn_(), r_y0_(), r_y1_(), r_yn_();
extern int  r_sin_(), r_cos_(), r_tan_(), r_asin_(), r_acos_();
extern int  r_atan_(), r_atan2_();
extern int  r_sinh_(), r_cosh_(), r_tanh_();
extern int  r_cbrt_();
extern int ir_ilogb_(), ir_irint_(), ir_signbit_() ;
extern int ir_isinf_(), ir_isnan_(), 
	   ir_issubnormal_(), ir_isnormal_(), ir_iszero_() ;
extern enum fp_class_type ir_fp_class_();
extern int  r_nextafter_(), r_remainder_() ;
extern int  r_log2_(), r_exp10_(), r_exp2_(), r_aint_(), r_anint_() ;
extern int ir_nint_() ;
extern int  r_fmod_();
extern int  r_logb_(), r_significand_(), r_scalb_(), r_scalbn_();
extern int  r_min_subnormal_(), r_max_subnormal_();
extern int  r_min_normal_(), r_max_normal_();
extern int  r_infinity_(), r_quiet_nan_(), r_signaling_nan_();
extern void r_sincos_();
struct exception {
        int type;
        char *name;
        double arg1;
        double arg2;
        double retval;
};
extern int signgam;
extern double fmod();
extern int matherr();
extern double cabs();	 
extern double drem();	 
extern double gamma();	 
extern double ldexp();	 
int output= 1;
int start= 0;
int N= 2,M= 3,T= 10,L= 1;
extern int rand();
extern void srand();
extern int atoi();
void random_states(a,pi,i,N,T)
int N,T;
float a[][N],pi[];
int i[];
{
int t;
i[0]= random_selection(pi,N);
for(t= 1;t<T;t++)
i[t]= random_selection(a[i[t-1]],N);
}
void random_output(b,i,o,M,T)
int M,T;
float b[][M];
int i[],o[];
{
int t;
for(t= 0;t<T;t++)
o[t]= random_selection(b[i[t]],M);
}
float random_float()
{
return((float)rand()/(float)2147483647 );
}
int random_selection(a,N)
int N;
float a[];
{
int i;
float x;
x= random_float();
for(i= 0;i<N;i++){
x-= a[i];
if(x<0.0)
return(i);
}
printf("rounding error?\n");
return(N-1);
}
void random_distribution(a,N)
int N;
float a[];
{
int i;
float sum,factor;
sum= 0.0;
for(i= 0;i<N;i++){
float temp;
temp= random_float();
a[i]= temp;
sum+= temp;
}
factor= 1.0/sum;
for(i= 0;i<N;i++)
a[i]*= factor;
}
void random_transition_matrix(a,N)
int N;
float a[][N];
{
int i;
for(i= 0;i<N;i++)
random_distribution(a[i],N);
}
void random_initial_probabilities(pi,N)
int N;
float pi[];
{
random_distribution(pi,N);
}
void random_output_matrix(b,N,M)
int N,M;
float b[][M];
{
int i;

for(i= 0;i<N;i++)
random_distribution(b[i],M);
} 
float forward_backward(a,b,pi,a_bar,b_bar,pi_bar,o,N,M,T)
int N,M,T;
float a[][N],b[][M],pi[];
float a_bar[][N],b_bar[][M],pi_bar[];
int o[];
{
float alpha[T][N],beta[T][N],gamma_T_minus_1[N];
float sigma[T],eta[N];
int t,i;
float log_likelihood;
log_likelihood= 0.0;
for(t= 0;t<T;t++){
int j;
float factor;
float alpha_sum= 0.0;
for(j= 0;j<N;j++){
float temp;
if(t==0)
temp= pi[j]*b[j][o[0]];
else{
int i;
float sum= 0.0;
for(i= 0;i<N;i++)
sum+= alpha[t-1][i]*a[i][j];
temp= sum*b[j][o[t]];
}
alpha[t][j]= temp;
alpha_sum+= temp;
}
factor= 1.0/alpha_sum;
sigma[t]= factor;
log_likelihood+= log(factor);
for(j= 0;j<N;j++)
alpha[t][j]*= factor;
}
for(i= 0;i<N;i++){
int j,k;
beta[T-1][i]= 1.0;
gamma_T_minus_1[i]= alpha[T-1][i];
for(j= 0;j<N;j++)
a_bar[i][j]= 0.0;
for(k= 0;k<M;k++)
b_bar[i][k]= 0.0;
b_bar[i][o[T-1]]+= gamma_T_minus_1[i];
eta[i]= 0.0;
}
for(t= T-2;t>=0;t--){
int i;
for(i= 0;i<N;i++){
int j;
float gamma_t_i;
float sum= 0.0;
for(j= 0;j<N;j++){
float temp;
temp= a[i][j]*b[j][o[t+1]]*beta[t+1][j];
a_bar[i][j]+= alpha[t][i]*temp*sigma[t+1];
sum+= temp;
}
beta[t][i]= sigma[t+1]*sum;
gamma_t_i= alpha[t][i]*beta[t][i];
b_bar[i][o[t]]+= gamma_t_i;
eta[i]+= gamma_t_i;
if(t==0)
pi_bar[i]= gamma_t_i;
}
}
for(i= 0;i<N;i++){
int j,k;
for(j= 0;j<N;j++)
a_bar[i][j]/= eta[i];
for(k= 0;k<M;k++)
b_bar[i][k]/= eta[i]+gamma_T_minus_1[i];
}
return(log_likelihood);
}
void print_float_array_2(a,N,M,name)
int N,M;
float a[][M];
char name[];
{
int i,j;
printf("%s:",name);
for(i= 0;i<N;i++){
for(j= 0;j<M;j++)
printf("\t%.2f",a[i][j]);
printf("\n");
}
}
void print_int_array_2(a,N,M,name)
int N,M;
int a[][M];
char name[];
{
int i,j;
printf("%s:",name);
for(i= 0;i<N;i++){
for(j= 0;j<M;j++)
printf("\t%d",a[i][j]);
printf("\n");
}
}
void print_float_array_1(a,N,name)
int N;
float a[];
char name[];
{
int i;
printf("%s:",name);
for(i= 0;i<N;i++)
printf("\t%.2f",a[i]);
printf("\n");
}
void print_int_array_1(a,N,name)
int N;
int a[];
char name[];
{
int i;
printf("%s:",name);
for(i= 0;i<N;i++)
printf("\t%d",a[i]);
printf("\n");
}
void parse_command_line(argc,argv)
int argc;
char*argv[];
{
int i;
int seed= 0;
if(argc>1)
for(i= 1;i<argc;i++)
if(argv[i][0]= '-')
switch(argv[i][1]){
case'n':
N= atoi(argv[++i]);
break;
case'm':
M= atoi(argv[++i]);
break;
case't':
T= atoi(argv[++i]);
break;
case'l':
L= atoi(argv[++i]);
break;
case's':
seed= atoi(argv[++i]);
break;
case'o':
output= 0;
break;
case'r':
start= 1;
break;
}
srand(seed);
}
void initialize_data(a,b,pi,i,o,N,M,T)
int N,M,T;
float a[][N],b[][M],pi[];
int i[],o[];
{
random_transition_matrix(a,N);
random_output_matrix(b,N,M);
random_initial_probabilities(pi,N);
random_states(a,pi,i,N,T);
random_output(b,i,o,M,T);
}
void random_starting_point(a,b,pi,N,M,T)
int N,M,T;
float a[][N],b[][M],pi[];
{
random_transition_matrix(a,N);
random_output_matrix(b,N,M);
random_initial_probabilities(pi,N);
}
void print_results(a,b,pi,N,M)
int N,M;
float a[][M],b[][M],pi[];
{
print_float_array_1(pi,N,"pi");
printf("\n");
print_float_array_2(a,N,N,"a");
printf("\n");
print_float_array_2(b,N,M,"b");
}
main(argc,argv)
int argc;
char*argv[];
{
parse_command_line(argc,argv);
{
int l;
float a[N][N],b[N][M],pi[N];
float a_bar[L+1][N][N],b_bar[L+1][N][M],pi_bar[L+1][N];
int i[T],i_star[T],o[T];
float actual_log_likelihood,log_likelihood;
initialize_data(a,b,pi,i,o,N,M,T);
if(output){
printf("\nActual values:\n");
print_results(a,b,pi,N,M);
}
actual_log_likelihood= 
forward_backward(a,b,pi,a_bar[0],b_bar[0],pi_bar[0],
o,N,M,T);
if(output)
printf("Log likelihood = %.2f for actual values.\n\n",
actual_log_likelihood);
if(start==1){
random_starting_point(a_bar[0],b_bar[0],pi_bar[0],N,M,T);
if(output==1){
printf("Beginning iteration 1 at random starting point:\n");
print_results(a_bar[0],b_bar[0],pi_bar[0],N,M);
}
}
else
if(output){
printf("New values:\n");
print_results(a_bar[0],b_bar[0],pi_bar[0],N,M);
}
for(l= 0;l<L;l++){
log_likelihood= 
forward_backward(a_bar[l],b_bar[l],pi_bar[l],
a_bar[l+1],b_bar[l+1],pi_bar[l+1],
o,N,M,T);
if(output){
printf("Log likelihood = %.2f for iteration %d.\n\n",
log_likelihood,l+1);
printf("New values:\n");
print_results(a_bar[l+1],b_bar[l+1],pi_bar[l+1],N,M);
}
}
if(output){
printf("\nActual values:\n");
print_results(a,b,pi,N,M);
printf("Log likelihood = %.2f for actual values.\n\n",
actual_log_likelihood);
}
}
}