ICE on valid code gcc-4.1-20051001

[Jean-Marc Valin]

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);
}