This is the mail archive of the
gcc-bugs@gcc.gnu.org
mailing list for the GCC project.
ICE on valid code gcc-4.1-20051001
- From: Jean-Marc Valin <Jean-Marc dot Valin at USherbrooke dot ca>
- To: gcc-bugs at gcc dot gnu dot org
- Date: Thu, 06 Oct 2005 17:11:15 +1000
- Subject: ICE on valid code gcc-4.1-20051001
Hi,
I'm getting an ICE with gcc-4.1-20051001 on the code in attachment. When
compiling with:
% gcc -O2 -march=pentium3 -ftree-vectorize -c cb_search_pre.c
the result is:
cb_search.c: In function 'split_cb_search_shape_sign':
cb_search.c:268: internal compiler error: Segmentation fault
Please submit a full bug report,
with preprocessed source if appropriate.
See <URL:http://gcc.gnu.org/bugs.html> for instructions.
If I remove any of the three optimization switches, the ICE goes away
(anything older than pentium3 is also OK for -march). In case it's of
any interest, this file is part of the Speex codec.
Jean-Marc
# 1 "cb_search.c"
# 0 "<interne>"
# 1 "<ligne de commande>"
# 1 "cb_search.c"
# 33 "cb_search.c"
# 1 "../config.h" 1
# 34 "cb_search.c" 2
# 1 "cb_search.h" 1
# 38 "cb_search.h"
# 1 "../include/speex/speex_bits.h" 1
# 44 "../include/speex/speex_bits.h"
typedef struct SpeexBits {
char *chars;
int nbBits;
int charPtr;
int bitPtr;
int owner;
int overflow;
int buf_size;
int reserved1;
void *reserved2;
} SpeexBits;
void speex_bits_init(SpeexBits *bits);
void speex_bits_init_buffer(SpeexBits *bits, void *buff, int buf_size);
void speex_bits_destroy(SpeexBits *bits);
void speex_bits_reset(SpeexBits *bits);
void speex_bits_rewind(SpeexBits *bits);
void speex_bits_read_from(SpeexBits *bits, char *bytes, int len);
void speex_bits_read_whole_bytes(SpeexBits *bits, char *bytes, int len);
int speex_bits_write(SpeexBits *bits, char *bytes, int max_len);
int speex_bits_write_whole_bytes(SpeexBits *bits, char *bytes, int max_len);
void speex_bits_pack(SpeexBits *bits, int data, int nbBits);
int speex_bits_unpack_signed(SpeexBits *bits, int nbBits);
unsigned int speex_bits_unpack_unsigned(SpeexBits *bits, int nbBits);
int speex_bits_nbytes(SpeexBits *bits);
unsigned int speex_bits_peek_unsigned(SpeexBits *bits, int nbBits);
int speex_bits_peek(SpeexBits *bits);
void speex_bits_advance(SpeexBits *bits, int n);
int speex_bits_remaining(SpeexBits *bits);
void speex_bits_insert_terminator(SpeexBits *bits);
# 39 "cb_search.h" 2
# 1 "misc.h" 1
# 46 "misc.h"
# 1 "arch.h" 1
# 38 "arch.h"
# 1 "../include/speex/speex_types.h" 1
# 120 "../include/speex/speex_types.h"
# 1 "../include/speex/speex_config_types.h" 1
typedef short spx_int16_t;
typedef unsigned short spx_uint16_t;
typedef int spx_int32_t;
typedef unsigned int spx_uint32_t;
# 121 "../include/speex/speex_types.h" 2
# 39 "arch.h" 2
# 98 "arch.h"
typedef float spx_mem_t;
typedef float spx_coef_t;
typedef float spx_lsp_t;
typedef float spx_sig_t;
typedef float spx_word16_t;
typedef float spx_word32_t;
typedef float spx_word64_t;
# 47 "misc.h" 2
void print_vec(float *vec, int len, char *name);
spx_uint32_t be_int(spx_uint32_t i);
spx_uint32_t le_int(spx_uint32_t i);
void *speex_alloc (int size);
void *speex_alloc_scratch (int size);
void *speex_realloc (void *ptr, int size);
void speex_free (void *ptr);
void speex_free_scratch (void *ptr);
void *speex_move (void *dest, void *src, int n);
void speex_memcpy_bytes(char *dst, char *src, int nbytes);
void speex_memset_bytes(char *dst, char src, int nbytes);
void speex_error(const char *str);
void speex_warning(const char *str);
void speex_warning_int(const char *str, int val);
void speex_rand_vec(float std, spx_sig_t *data, int len);
spx_word32_t speex_rand(spx_word16_t std, spx_int32_t *seed);
void _speex_putc(int ch, void *file);
# 40 "cb_search.h" 2
typedef struct split_cb_params {
int subvect_size;
int nb_subvect;
const signed char *shape_cb;
int shape_bits;
int have_sign;
} split_cb_params;
void split_cb_search_shape_sign(
spx_sig_t target[],
spx_coef_t ak[],
spx_coef_t awk1[],
spx_coef_t awk2[],
const void *par,
int p,
int nsf,
spx_sig_t *exc,
spx_word16_t *r,
SpeexBits *bits,
char *stack,
int complexity,
int update_target
);
void split_cb_shape_sign_unquant(
spx_sig_t *exc,
const void *par,
int nsf,
SpeexBits *bits,
char *stack
);
void noise_codebook_quant(
spx_sig_t target[],
spx_coef_t ak[],
spx_coef_t awk1[],
spx_coef_t awk2[],
const void *par,
int p,
int nsf,
spx_sig_t *exc,
spx_word16_t *r,
SpeexBits *bits,
char *stack,
int complexity,
int update_target
);
void noise_codebook_unquant(
spx_sig_t *exc,
const void *par,
int nsf,
SpeexBits *bits,
char *stack
);
# 37 "cb_search.c" 2
# 1 "filters.h" 1
# 40 "filters.h"
spx_word16_t compute_rms(const spx_sig_t *x, int len);
void signal_mul(const spx_sig_t *x, spx_sig_t *y, spx_word32_t scale, int len);
void signal_div(const spx_sig_t *x, spx_sig_t *y, spx_word32_t scale, int len);
# 51 "filters.h"
typedef struct {
int last_pitch;
spx_word16_t last_pitch_gain[3];
spx_word16_t smooth_gain;
} CombFilterMem;
void qmf_decomp(const spx_word16_t *xx, const spx_word16_t *aa, spx_sig_t *, spx_sig_t *y2, int N, int M, spx_word16_t *mem, char *stack);
void fir_mem_up(const spx_sig_t *x, const spx_word16_t *a, spx_sig_t *y, int N, int M, spx_word32_t *mem, char *stack);
void filter_mem2(const spx_sig_t *x, const spx_coef_t *num, const spx_coef_t *den, spx_sig_t *y, int N, int ord, spx_mem_t *mem);
void fir_mem2(const spx_sig_t *x, const spx_coef_t *num, spx_sig_t *y, int N, int ord, spx_mem_t *mem);
void iir_mem2(const spx_sig_t *x, const spx_coef_t *den, spx_sig_t *y, int N, int ord, spx_mem_t *mem);
void bw_lpc(spx_word16_t , const spx_coef_t *lpc_in, spx_coef_t *lpc_out, int order);
void syn_percep_zero(const spx_sig_t *x, const spx_coef_t *ak, const spx_coef_t *awk1, const spx_coef_t *awk2, spx_sig_t *y, int N, int ord, char *stack);
void residue_percep_zero(const spx_sig_t *xx, const spx_coef_t *ak, const spx_coef_t *awk1, const spx_coef_t *awk2, spx_sig_t *y, int N, int ord, char *stack);
void compute_impulse_response(const spx_coef_t *ak, const spx_coef_t *awk1, const spx_coef_t *awk2, spx_word16_t *y, int N, int ord, char *stack);
void comb_filter_mem_init (CombFilterMem *mem);
void comb_filter(
spx_sig_t *exc,
spx_sig_t *new_exc,
spx_coef_t *ak,
int p,
int nsf,
int pitch,
spx_word16_t *pitch_gain,
spx_word16_t comb_gain,
CombFilterMem *mem
);
# 38 "cb_search.c" 2
# 1 "stack_alloc.h" 1
# 39 "cb_search.c" 2
# 1 "vq.h" 1
# 40 "vq.h"
int scal_quant(spx_word16_t in, const spx_word16_t *boundary, int entries);
int scal_quant32(spx_word32_t in, const spx_word32_t *boundary, int entries);
int vq_index(float *in, const float *codebook, int len, int entries);
void vq_nbest(spx_word16_t *in, const spx_word16_t *codebook, int len, int entries, spx_word32_t *E, int N, int *nbest, spx_word32_t *best_dist, char *stack);
void vq_nbest_sign(spx_word16_t *in, const spx_word16_t *codebook, int len, int entries, spx_word32_t *E, int N, int *nbest, spx_word32_t *best_dist, char *stack);
# 40 "cb_search.c" 2
# 51 "cb_search.c"
static void compute_weighted_codebook(const signed char *shape_cb, const spx_word16_t *r, spx_word16_t *resp, spx_word16_t *resp2, spx_word32_t *E, int shape_cb_size, int subvect_size, char *stack)
{
int i, j, k;
;
spx_word16_t shape[subvect_size];
for (i=0;i<shape_cb_size;i++)
{
spx_word16_t *res;
res = resp+i*subvect_size;
for (k=0;k<subvect_size;k++)
shape[k] = (spx_word16_t)shape_cb[i*subvect_size+k];
E[i]=0;
for(j=0;j<subvect_size;j++)
{
spx_word32_t resj=0;
spx_word16_t res16;
for (k=0;k<=j;k++)
resj = ((resj)+(spx_word32_t)(shape[k])*(spx_word32_t)(r[j-k]));
res16 = 0.03125f*resj;
E[i]=((E[i])+(spx_word32_t)(res16)*(spx_word32_t)(res16));
res[j] = res16;
}
}
}
static inline void target_update(spx_word16_t *t, spx_word16_t g, spx_word16_t *r, int len)
{
int n;
int q=0;
for (n=0;n<len;n++,q++)
t[n] = ((t[n])-(((g)*(r[q]))));
}
static void split_cb_search_shape_sign_N1(
spx_sig_t target[],
spx_coef_t ak[],
spx_coef_t awk1[],
spx_coef_t awk2[],
const void *par,
int p,
int nsf,
spx_sig_t *exc,
spx_word16_t *r,
SpeexBits *bits,
char *stack,
int complexity,
int update_target
)
{
int i,j,m,q;
int n;
;
spx_word16_t *resp2;
;
;
;
const signed char *shape_cb;
int shape_cb_size, subvect_size, nb_subvect;
const split_cb_params *params;
int N=2;
int best_index;
spx_word32_t best_dist;
int have_sign;
N=complexity;
if (N>10)
N=10;
if (N<1)
N=1;
params = (const split_cb_params *) par;
subvect_size = params->subvect_size;
nb_subvect = params->nb_subvect;
shape_cb_size = 1<<params->shape_bits;
shape_cb = params->shape_cb;
have_sign = params->have_sign;
spx_word16_t resp[shape_cb_size*subvect_size];
resp2 = resp;
spx_word32_t E[shape_cb_size];
spx_word16_t t[nsf];
spx_sig_t e[nsf];
for (i=0;i<nsf;i++)
t[i]=((target[i]));
compute_weighted_codebook(shape_cb, r, resp, resp2, E, shape_cb_size, subvect_size, stack);
for (i=0;i<nb_subvect;i++)
{
spx_word16_t *x=t+subvect_size*i;
if (have_sign)
vq_nbest_sign(x, resp2, subvect_size, shape_cb_size, E, 1, &best_index, &best_dist, stack);
else
vq_nbest(x, resp2, subvect_size, shape_cb_size, E, 1, &best_index, &best_dist, stack);
speex_bits_pack(bits,best_index,params->shape_bits+have_sign);
{
int rind;
spx_word16_t *res;
spx_word16_t sign=1;
rind = best_index;
if (rind>=shape_cb_size)
{
sign=-1;
rind-=shape_cb_size;
}
res = resp+rind*subvect_size;
if (sign>0)
for (m=0;m<subvect_size;m++)
t[subvect_size*i+m] = ((t[subvect_size*i+m])-(res[m]));
else
for (m=0;m<subvect_size;m++)
t[subvect_size*i+m] = ((t[subvect_size*i+m])+(res[m]));
# 204 "cb_search.c"
for (j=0;j<subvect_size;j++)
e[subvect_size*i+j]=sign*0.03125*shape_cb[rind*subvect_size+j];
}
for (m=0;m<subvect_size;m++)
{
spx_word16_t g;
int rind;
spx_word16_t sign=1;
rind = best_index;
if (rind>=shape_cb_size)
{
sign=-1;
rind-=shape_cb_size;
}
q=subvect_size-m;
g=sign*0.03125*shape_cb[rind*subvect_size+m];
for (n=subvect_size*(i+1);n<nsf;n++,q++)
t[n] = ((t[n])-(g*r[q]));
}
}
for (j=0;j<nsf;j++)
exc[j]=((exc[j])+(e[j]));
if (update_target)
{
;
spx_sig_t r2[nsf];
syn_percep_zero(e, ak, awk1, awk2, r2, nsf,p, stack);
for (j=0;j<nsf;j++)
target[j]=((target[j])-(r2[j]));
}
}
void split_cb_search_shape_sign(
spx_sig_t target[],
spx_coef_t ak[],
spx_coef_t awk1[],
spx_coef_t awk2[],
const void *par,
int p,
int nsf,
spx_sig_t *exc,
spx_word16_t *r,
SpeexBits *bits,
char *stack,
int complexity,
int update_target
)
{
int i,j,k,m,n,q;
;
spx_word16_t *resp2;
;
;
;
;
;
;
;
;
;
;
spx_word16_t **ot, **nt;
;
;
;
const signed char *shape_cb;
int shape_cb_size, subvect_size, nb_subvect;
const split_cb_params *params;
int N=2;
;
;
;
;
int have_sign;
N=complexity;
if (N>10)
N=10;
if (N<1)
N=1;
if (N==1)
{
split_cb_search_shape_sign_N1(target,ak,awk1,awk2,par,p,nsf,exc,r,bits,stack,complexity,update_target);
return;
}
spx_word16_t* ot2[N];
spx_word16_t* nt2[N];
int* oind[N];
int* nind[N];
params = (const split_cb_params *) par;
subvect_size = params->subvect_size;
nb_subvect = params->nb_subvect;
shape_cb_size = 1<<params->shape_bits;
shape_cb = params->shape_cb;
have_sign = params->have_sign;
spx_word16_t resp[shape_cb_size*subvect_size];
resp2 = resp;
spx_word32_t E[shape_cb_size];
spx_word16_t t[nsf];
spx_sig_t e[nsf];
spx_sig_t r2[nsf];
int ind[nb_subvect];
spx_word16_t tmp[2*N*nsf];
for (i=0;i<N;i++)
{
ot2[i]=tmp+2*i*nsf;
nt2[i]=tmp+(2*i+1)*nsf;
}
ot=ot2;
nt=nt2;
int best_index[N];
spx_word32_t best_dist[N];
int best_nind[N];
int best_ntarget[N];
spx_word32_t ndist[N];
spx_word32_t odist[N];
int itmp[2*N*nb_subvect];
for (i=0;i<N;i++)
{
nind[i]=itmp+2*i*nb_subvect;
oind[i]=itmp+(2*i+1)*nb_subvect;
}
for (i=0;i<nsf;i++)
t[i]=((target[i]));
for (j=0;j<N;j++)
speex_move(&ot[j][0], t, nsf*sizeof(spx_word16_t));
compute_weighted_codebook(shape_cb, r, resp, resp2, E, shape_cb_size, subvect_size, stack);
for (j=0;j<N;j++)
odist[j]=0;
for (i=0;i<nb_subvect;i++)
{
for (j=0;j<N;j++)
ndist[j]=1e15f;
for (j=0;j<N;j++)
{
spx_word16_t *x=ot[j]+subvect_size*i;
spx_word32_t tener = 0;
for (m=0;m<subvect_size;m++)
tener = ((tener)+(spx_word32_t)(x[m])*(spx_word32_t)(x[m]));
tener *= .5;
if (have_sign)
vq_nbest_sign(x, resp2, subvect_size, shape_cb_size, E, N, best_index, best_dist, stack);
else
vq_nbest(x, resp2, subvect_size, shape_cb_size, E, N, best_index, best_dist, stack);
for (k=0;k<N;k++)
{
spx_word32_t err = ((((odist[j])+(best_dist[k])))+(tener));
if (err<ndist[N-1])
{
for (m=0;m<N;m++)
{
if (err < ndist[m])
{
for (n=N-1;n>m;n--)
{
ndist[n] = ndist[n-1];
best_nind[n] = best_nind[n-1];
best_ntarget[n] = best_ntarget[n-1];
}
ndist[m] = err;
best_nind[n] = best_index[k];
best_ntarget[n] = j;
break;
}
}
}
}
if (i==0)
break;
}
for (j=0;j<N;j++)
{
for (m=(i+1)*subvect_size;m<nsf;m++)
nt[j][m]=ot[best_ntarget[j]][m];
for (m=0;m<subvect_size;m++)
{
spx_word16_t g;
int rind;
spx_word16_t sign=1;
rind = best_nind[j];
if (rind>=shape_cb_size)
{
sign=-1;
rind-=shape_cb_size;
}
q=subvect_size-m;
g=sign*0.03125*shape_cb[rind*subvect_size+m];
for (n=subvect_size*(i+1);n<nsf;n++,q++)
nt[j][n] = ((nt[j][n])-(g*r[q]));
}
for (q=0;q<nb_subvect;q++)
nind[j][q]=oind[best_ntarget[j]][q];
nind[j][i]=best_nind[j];
}
{
spx_word16_t **tmp2;
tmp2=ot;
ot=nt;
nt=tmp2;
}
for (j=0;j<N;j++)
for (m=0;m<nb_subvect;m++)
oind[j][m]=nind[j][m];
for (j=0;j<N;j++)
odist[j]=ndist[j];
}
for (i=0;i<nb_subvect;i++)
{
ind[i]=nind[0][i];
speex_bits_pack(bits,ind[i],params->shape_bits+have_sign);
}
for (i=0;i<nb_subvect;i++)
{
int rind;
spx_word16_t sign=1;
rind = ind[i];
if (rind>=shape_cb_size)
{
sign=-1;
rind-=shape_cb_size;
}
# 506 "cb_search.c"
for (j=0;j<subvect_size;j++)
e[subvect_size*i+j]=sign*0.03125*shape_cb[rind*subvect_size+j];
}
for (j=0;j<nsf;j++)
exc[j]=((exc[j])+(e[j]));
if (update_target)
{
syn_percep_zero(e, ak, awk1, awk2, r2, nsf,p, stack);
for (j=0;j<nsf;j++)
target[j]=((target[j])-(r2[j]));
}
}
void split_cb_shape_sign_unquant(
spx_sig_t *exc,
const void *par,
int nsf,
SpeexBits *bits,
char *stack
)
{
int i,j;
;
;
const signed char *shape_cb;
int shape_cb_size, subvect_size, nb_subvect;
const split_cb_params *params;
int have_sign;
params = (const split_cb_params *) par;
subvect_size = params->subvect_size;
nb_subvect = params->nb_subvect;
shape_cb_size = 1<<params->shape_bits;
shape_cb = params->shape_cb;
have_sign = params->have_sign;
int ind[nb_subvect];
int signs[nb_subvect];
for (i=0;i<nb_subvect;i++)
{
if (have_sign)
signs[i] = speex_bits_unpack_unsigned(bits, 1);
else
signs[i] = 0;
ind[i] = speex_bits_unpack_unsigned(bits, params->shape_bits);
}
for (i=0;i<nb_subvect;i++)
{
spx_word16_t s=1;
if (signs[i])
s=-1;
# 575 "cb_search.c"
for (j=0;j<subvect_size;j++)
exc[subvect_size*i+j]+=s*0.03125*shape_cb[ind[i]*subvect_size+j];
}
}
void noise_codebook_quant(
spx_sig_t target[],
spx_coef_t ak[],
spx_coef_t awk1[],
spx_coef_t awk2[],
const void *par,
int p,
int nsf,
spx_sig_t *exc,
spx_word16_t *r,
SpeexBits *bits,
char *stack,
int complexity,
int update_target
)
{
int i;
;
spx_sig_t tmp[nsf];
residue_percep_zero(target, ak, awk1, awk2, tmp, nsf, p, stack);
for (i=0;i<nsf;i++)
exc[i]+=tmp[i];
for (i=0;i<nsf;i++)
target[i]=0;
}
void noise_codebook_unquant(
spx_sig_t *exc,
const void *par,
int nsf,
SpeexBits *bits,
char *stack
)
{
speex_rand_vec(1, exc, nsf);
}