From: pardo@cs.washington.edu (David Keppel)
Subject: GCC 2.1 sparc -g fatal 11
Organization: Computer Science & Engineering, U. of Washington, Seattle
Distribution: gnu
Date: Fri, 25 Sep 1992 19:48:44 GMT

Running GCC 2.1 on the buggy .c file at the end of this message causes
GCC to fail with an internal error if the -g flag is used.

Repeat by:

% gcc -v -g -c junky.c
Reading specs from /usr/local/gcc-2.1/lib/gcc-lib/sparc-sun-sunos4.1/2.1/specs
gcc version 2.1
 /usr/local/gcc-2.1/lib/gcc-lib/sparc-sun-sunos4.1/2.1/cpp -lang-c -v -undef -D__GNUC__=2 -Dsparc -Dsun -Dunix -D__sparc__ -D__sun__ -D__unix__ -D__sparc -D__sun -D__unix -g junky.c /usr/tmp/cca16808.i
GNU CPP version 2.1 (sparc)
 /usr/local/gcc-2.1/lib/gcc-lib/sparc-sun-sunos4.1/2.1/cc1 /usr/tmp/cca16808.i -quiet -dumpbase junky.c -g -version -o /usr/tmp/cca16808.s
GNU C version 2.1 (sparc) compiled by GNU C version 2.1.
!
! proper error messages deleted
!
gcc: Internal compiler error: program cc1 got fatal signal 11

		;-D on  ( The fatalist )  Pardo


# 1 "code.c"
char code_rcsid[] = "$Header: /tmp_mnt/homes/gws/pardo/local/resch/rtcg/slow/slow/rtcg2.d/RCS/code.c,v 1.5 1992/09/17 16:00:44 pardo Exp $";

# 1 "../includes.d/assert.h" 1 3
 








void __eprintf (char const *fmt, ...);	 











# 32 "../includes.d/assert.h" 3



# 3 "code.c" 2

# 1 "../includes.d/stdio.h" 1 3
 




extern	struct	_iobuf {
	int	_cnt;
	unsigned char *_ptr;
	unsigned char *_base;
	int	_bufsiz;
	short	_flag;
	char	_file;		 
} _iob[];








































extern struct _iobuf 	*fopen (char const *filename, char const *type);
extern struct _iobuf 	*fdopen (int fd, char const *type);
extern struct _iobuf 	*freopen (char const *filename, char const *type, struct _iobuf  *fp);
extern struct _iobuf 	*popen (char const *cmd, char const *type);
extern struct _iobuf 	*tmpfile (void);
extern long	ftell (struct _iobuf  const *);
extern char	*fgets (char *dst, struct _iobuf  *stream);
extern char	*gets (char *dst);
extern char	*sprintf (char *buf, char const *fmt, ...);
extern char	*ctermid (char *buf);
extern char	*cuserid (char *buf);
extern char	*tempnam (char *dir, char *pfx);
extern char	*tmpnam (char *buf);






# 4 "code.c" 2


# 1 "../utils.d/alloc.h" 1 3
 





  
# 1 "../utils.d/decl.h" 1



 









  





   
  










  


typedef enum bool {
  NO=0,
  YES
} bool;

 

typedef enum trinary {
  LESS_THAN = -1,
  EQUAL = 0,
  GREATER_THAN = 1
} trinary;

typedef void (f_t)(void);

extern int _flsbuf(unsigned char c, void   *fp);
extern void abort (void);
extern int atoi (char const *a);
extern void exit (int status);
extern char *mktemp (char *buf);
extern void perror (char const *msg);
extern int system (char const *cmd);

  


  extern int fclose (void   *fp);
  extern int fputs (char const *str, void   *out);
  extern int fprintf (void   *out, char const *fmt, ...);
  extern int printf (char const *fmt, ...);
  extern int vfprintf (void   *ouit, char const *fmt, void const *args);


extern void qsort (void *base, int nel, int width,
  int (*compar)(void const *r1, void const *r2));
extern long random (void);
extern void srandom (int seed);


# 7 "../utils.d/alloc.h" 2 3



typedef void *(alloc_alloc_t)(void *state, unsigned size);
typedef void *(alloc_realloc_t)(void *state, void *sto, unsigned size);
typedef void (alloc_free_t)(void *state, void *sto);

typedef struct alloc_t alloc_t;

 











  extern alloc_t *
alloc_create (void *state, alloc_alloc_t *malloc,
	      alloc_realloc_t *realloc, alloc_free_t *free,
	      alloc_free_t *free_since);


 




  extern void *
alloc_delete (alloc_t *al);


 




  extern bool
alloc_debugging (bool on);


  extern void *
alloc (alloc_t *al, unsigned size);

  extern void *
alloc_re (alloc_t *al, void *sto, unsigned newsize);

  extern void
alloc_free (alloc_t *al, void *sto);


 




  extern void
alloc_free_since (alloc_t *al, void *sto);


# 6 "code.c" 2


# 1 "../timer.d/timer.h" 1 3



 





















  




 
typedef unsigned timer_name_t;

 




  extern void
timer_init (unsigned initas, unsigned nphases, char const * const *names);

  extern void
timer_done (void);

  extern void
timer_name_keep (char const *fname);

  extern unsigned
timer_pop (unsigned assert_phase);

  extern void
timer_push (unsigned phase);











# 73 "../timer.d/timer.h" 3

  
  








  



# 8 "code.c" 2


# 1 "code.h" 1




   
  
# 1 "./ir.h" 1 3

 









   

  
# 1 "./type.h" 1

 




typedef enum rtcg2_type_tag_t {
  RTCG2_TYPE_TAG_ERR,		 
  RTCG2_TYPE_TAG_CHAR,	 
  RTCG2_TYPE_TAG_UCHAR,	 
  RTCG2_TYPE_TAG_SHORT,	 
  RTCG2_TYPE_TAG_USHORT,
  RTCG2_TYPE_TAG_INT,
  RTCG2_TYPE_TAG_UINT,
  RTCG2_TYPE_TAG_LONG,
  RTCG2_TYPE_TAG_ULONG,
  RTCG2_TYPE_TAG_FLOAT,
  RTCG2_TYPE_TAG_DOUBLE,
  RTCG2_TYPE_TAG_VOID,
  RTCG2_TYPE_TAG_PTR,
  RTCG2_TYPE_TAG_STRUCT,

  RTCG2_TYPE_TAG_LIST,	 
  RTCG2_TYPE_TAG_FUNC,	 
  RTCG2_TYPE_TAG_N
} rtcg2_type_tag_t;

typedef struct rtcg2_type_t rtcg2_type_t;


  extern alloc_t *
rtcg2_type_allocator (alloc_t *newallocator);


  extern rtcg2_type_t *
rtcg2_type_copy_recursive (rtcg2_type_t const *t);


  extern rtcg2_type_t *
rtcg2_type_func (rtcg2_type_t *rettype, rtcg2_type_t *args_list);


 

  extern rtcg2_type_t *
rtcg2_type_prim (rtcg2_type_tag_t tag);


 

  extern rtcg2_type_t *
rtcg2_type_ptr (rtcg2_type_t *ptr_to);


  extern rtcg2_type_t *
rtcg2_type_list (rtcg2_type_t *type, rtcg2_type_t *args);


  extern void
rtcg2_type_delete (rtcg2_type_t *t);



# 14 "./ir.h" 2 3




typedef enum rtcg2_ir_tag_t {
  RTCG2_IR_TAG_ERR,

   
   
  RTCG2_IR_TAG_ADD,
  RTCG2_IR_TAG_SUB,
  RTCG2_IR_TAG_MUL,
  RTCG2_IR_TAG_DIV,
  RTCG2_IR_TAG_MOD,
  RTCG2_IR_TAG_BITAND,
  RTCG2_IR_TAG_BITOR,
  RTCG2_IR_TAG_BITNOT,
  RTCG2_IR_TAG_BITXOR,
  RTCG2_IR_TAG_LOGAND,	 
  RTCG2_IR_TAG_LOGOR,		 
  RTCG2_IR_TAG_LOGXOR,	 
  RTCG2_IR_TAG_LOGNOT,	 
  RTCG2_IR_TAG_EQ,		 
  RTCG2_IR_TAG_NEQ,		 
  RTCG2_IR_TAG_GE,		 
  RTCG2_IR_TAG_GT,		 

   
  RTCG2_IR_TAG_CAST,		 
  RTCG2_IR_TAG_CAST_TYPE,	 

   
  RTCG2_IR_TAG_FCALL,		 

   
  RTCG2_IR_TAG_SPLAT,		 

   
  RTCG2_IR_TAG_BLOCK,		 
  RTCG2_IR_TAG_STMT,		 
  RTCG2_IR_TAG_ASSIGN,		 
  RTCG2_IR_TAG_DOWHILE,		 
  RTCG2_IR_TAG_IF,		 
  RTCG2_IR_TAG_PCALL,		 
  RTCG2_IR_TAG_SWITCH,		 
  RTCG2_IR_TAG_SWITCH_CASE1,	 

  RTCG2_IR_TAG_SWITCH_CASE2,	 
  RTCG2_IR_TAG_THEN_ELSE,	 
  RTCG2_IR_TAG_RETURN,		 
  RTCG2_IR_TAG_WHILE,		 

   
  RTCG2_IR_TAG_ARGS,		 
  RTCG2_IR_TAG_DECL,		 
  RTCG2_IR_TAG_LITERAL,		 
  RTCG2_IR_TAG_FUNC,		 
  RTCG2_IR_TAG_GLOBAL,		 
  RTCG2_IR_TAG_ARGS_BODY,	 
  RTCG2_IR_TAG_VAR,		 
  RTCG2_IR_TAG_VAR_REF,		 

  RTCG2_IR_TAG_ROOT,		 


   
  RTCG2_IR_TAG_TOP,		 
  RTCG2_IR_TAG_TOPPED,		 
  RTCG2_IR_TAG_TOP2,		 

   
  RTCG2_IR_TAG_HOLE_UNINIT,	 
  RTCG2_IR_TAG_HOLE_EMPTY,	 
  RTCG2_IR_TAG_HOLE_FULL,	 
  RTCG2_IR_TAG_HOLE_FIXED,	 

  RTCG2_IR_TAG_N
} rtcg2_ir_tag_t;


 





typedef struct node_t rtcg2_ir_t;


 




typedef struct rtcg2_hole_mapping_t {
  int pn;
  int cn;
} rtcg2_hole_mapping_t;


 

  extern alloc_t *
rtcg2_ir_allocator (alloc_t *newallocator);


 

  extern rtcg2_ir_t *
rtcg2_ir_assign (rtcg2_ir_t *lval, rtcg2_ir_t *rval);


 





  extern rtcg2_ir_t *
rtcg2_ir_args (rtcg2_ir_t *argref, rtcg2_ir_t *otherargs);


 




  extern rtcg2_ir_t *
rtcg2_ir_block (rtcg2_ir_t *decls, rtcg2_ir_t *stmts);


 

  extern rtcg2_ir_t *
rtcg2_ir_bop (rtcg2_ir_tag_t tag, rtcg2_ir_t *lexpr, rtcg2_ir_t *rexpr);


 






  extern rtcg2_ir_t *
rtcg2_ir_cast (rtcg2_type_t *t, rtcg2_ir_t *expr);


 






  extern rtcg2_ir_t *
rtcg2_ir_copy (rtcg2_ir_t const *src);

  extern rtcg2_ir_t *
rtcg2_ir_copy_top (rtcg2_ir_t const *src, int n);


 





  extern rtcg2_ir_t *
rtcg2_ir_decl (rtcg2_ir_t *var, rtcg2_ir_t *decls);


 

  extern void
rtcg2_ir_delete (rtcg2_ir_t *ir);

  extern void
rtcg2_ir_delete_tree (rtcg2_ir_t *ir);


 

  extern rtcg2_ir_t *
rtcg2_ir_fcall (rtcg2_ir_t *func, rtcg2_ir_t *args);


 

  extern char const *
ir_fname_is (rtcg2_ir_t const *ir);


 


  extern rtcg2_ir_t *
rtcg2_ir_func (rtcg2_type_t *rettype, rtcg2_ir_t *args, rtcg2_ir_t *body);


 







  extern rtcg2_ir_t *
rtcg2_ir_global (char const *name, rtcg2_type_t *type);


 

  extern rtcg2_ir_t *
rtcg2_ir_if (rtcg2_ir_t *bexpr, rtcg2_ir_t *then_block, rtcg2_ir_t *else_block);


 

  extern rtcg2_ir_t *
rtcg2_ir_literal (rtcg2_type_t *type, char const *name);


 
  extern rtcg2_ir_t *
rtcg2_ir_loop (rtcg2_ir_tag_t tag,
	       rtcg2_ir_t *cond,
	       rtcg2_ir_t *body);


 

  extern rtcg2_ir_t *
rtcg2_ir_pcall (rtcg2_ir_t *func, rtcg2_ir_t *args);


 


  extern rtcg2_ir_t *
rtcg2_ir_return (rtcg2_ir_t *expr);


 




  extern rtcg2_ir_t *
rtcg2_ir_stmt (rtcg2_ir_t *lstat, rtcg2_ir_t *rstat);


 


  extern rtcg2_ir_t *
rtcg2_ir_switch (rtcg2_ir_t *expr, rtcg2_ir_t **cases, int ncases,
		 rtcg2_ir_t *default_case);


 


  extern rtcg2_ir_t *
rtcg2_ir_switch_case (rtcg2_ir_t *tag, rtcg2_ir_t *stmts);


 

  extern rtcg2_ir_t *
rtcg2_ir_uop (rtcg2_ir_tag_t tag, rtcg2_ir_t *expr);


 



  extern rtcg2_ir_t *
rtcg2_ir_var (rtcg2_type_t *type);

 



  extern rtcg2_ir_t *
rtcg2_ir_var_ref (rtcg2_ir_t *var);

 

 

  extern rtcg2_ir_t *
rtcg2_ir_hole (void);


 





  extern void
rtcg2_ir_holes_fix (rtcg2_ir_t *child, int choles);

 

  extern void
rtcg2_ir_holes_fix_undo (rtcg2_ir_t *child, int choles);


 

  extern rtcg2_ir_t *
rtcg2_ir_hole_top (int n, rtcg2_ir_t *tree);


 


  extern void
rtcg2_ir_hole_set (rtcg2_ir_t *top, int n, rtcg2_ir_t *hole);


 






 



  extern rtcg2_ir_t *
rtcg2_ir_hole_fill (rtcg2_ir_t *top, int n, rtcg2_ir_t *tree, int choles,
		    int const *map);


 


  extern rtcg2_ir_t *
rtcg2_ir_hole_fill_many (rtcg2_ir_t *top,
			 int lo,
			 int n,
			 rtcg2_ir_t **tree,
			 rtcg2_hole_mapping_t *map)


 



  extern void
rtcg2_ir_hole_narrow (rtcg2_ir_t *top, int newholes, int oldholes);


 

  void
ir_print_fdecl (rtcg2_ir_t const *f);

  void
ir_print_topf (rtcg2_ir_t const *top);


# 6 "code.h" 2



typedef enum rtcg2_code_quality_t {
  RTCG2_CODE_QUALITY_ERR,
  RTCG2_CODE_QUALITY_SLOW,
  RTCG2_CODE_QUALITY_N
} rtcg2_code_quality_t;

typedef struct rtcg2_code_t rtcg2_code_t;

typedef void (rtcg2_code_f_t)(void);

  extern alloc_t *
rtcg2_code_allocator (alloc_t *alloc);

  extern rtcg2_code_t *
rtcg2_code_of_ir (rtcg2_ir_t *ir, rtcg2_code_quality_t cq);

  extern rtcg2_code_f_t *
rtcg2_code_f (rtcg2_code_t *cd);

  extern void
rtcg2_code_delete (rtcg2_code_t *cd);


# 10 "code.c" 2

# 1 "codei.h" 1








  
# 1 "codeinit.h" 1




   
  








typedef alloc_t *(code_allocator_t)(alloc_t *al);
typedef void (code_init_t)(char const *argv0);
typedef void (code_done_t)(void);
typedef void (code_of_ir_t)(void **state,
			    rtcg2_code_f_t **f,
			    rtcg2_ir_t const *ir);
typedef void (code_delete_t)(void *state);

  extern void
codeinit (void);


# 9 "codei.h" 2



  extern void
code_allocator (alloc_t *al);

  extern void
code_init (char const *argv0);

  extern void
code_init_state (rtcg2_code_quality_t cq,
		 code_allocator_t *set_the_allocator,
		 code_init_t *init,
		 code_done_t *done,
		 code_of_ir_t *of_ir,
		 code_delete_t *delete);

  extern void
code_done (void);


# 11 "code.c" 2


# 1 "defines.h" 1









  
  
  



# 13 "code.c" 2



typedef struct code_state_t {
  bool inited;
  code_allocator_t *allocator;
  code_init_t *init;
  code_done_t *done;
  code_of_ir_t *of_ir;
  code_delete_t *delete;
} code_state_t;

struct rtcg2_code_t {
  rtcg2_code_quality_t cq;	 
  rtcg2_code_f_t *f;		 
  void *state;			 
};

static alloc_t *code_g_al;
static code_state_t code_g_state[RTCG2_CODE_QUALITY_N];
static char const *code_g_argv0;
static bool code_g_init_called = NO;


  alloc_t *
rtcg2_code_allocator (alloc_t *alloc)
{
  rtcg2_code_quality_t i;
  alloc_t *old;

  do { ; } while (0) ;
  do { do { (void)  (((code_g_init_called)) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(code_g_init_called)",  44,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;

  old = code_g_al;
  code_g_al = alloc;

  for (i=RTCG2_CODE_QUALITY_ERR+1; i<RTCG2_CODE_QUALITY_N; ++i) {
    if (code_g_state[i].inited) {
      alloc_t *this_old_alloc; 

      do { this_old_alloc = (*(code_g_state[i].allocator))(alloc) ; } while (0) ;
      do { do { (void)  (((this_old_alloc == old)) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(this_old_alloc == old)",  54,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;
    }
  }
  return (old);
}


  void
code_init (char const *argv0)
{
  rtcg2_code_quality_t i;

  do { ; } while (0) ;
  do { do { (void)  (((!code_g_init_called)) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(!code_g_init_called)",  67,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;

  code_g_argv0 = argv0;

  for (i=RTCG2_CODE_QUALITY_ERR+1; i<RTCG2_CODE_QUALITY_N; ++i) {
    code_g_state[i].inited = NO;
    code_g_state[i].allocator = 0 ;	 
    code_g_state[i].init = 0 ;	 
    code_g_state[i].done = 0 ;	 
    code_g_state[i].of_ir = 0 ;	 
    code_g_state[i].delete = 0 ;	 
  }
  codeinit();			 
  code_g_init_called = YES;
}

  void
code_init_state (rtcg2_code_quality_t cq,
		 code_allocator_t *set_the_allocator,
		 code_init_t *init,
		 code_done_t *done,
		 code_of_ir_t *of_ir,
		 code_delete_t *delete)
{
  do { ; } while (0) ;

  do { do { (void)  (((cq > RTCG2_CODE_QUALITY_ERR && cq < RTCG2_CODE_QUALITY_N)) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(cq > RTCG2_CODE_QUALITY_ERR && cq < RTCG2_CODE_QUALITY_N)",  93,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;

  do { do { (void)  (((code_g_state[cq].allocator == 0 )) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(code_g_state[cq].allocator == 0)",  95,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;
  code_g_state[cq].allocator = set_the_allocator;
  do { do { (void)  (((code_g_state[cq].init == 0 )) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(code_g_state[cq].init == 0)",  97,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;
  code_g_state[cq].init = init;
  do { do { (void)  (((code_g_state[cq].done == 0 )) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(code_g_state[cq].done == 0)",  99,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;
  code_g_state[cq].done = done;
  do { do { (void)  (((code_g_state[cq].of_ir == 0 )) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(code_g_state[cq].of_ir == 0)",  101,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;
  code_g_state[cq].of_ir = of_ir;
  do { do { (void)  (((code_g_state[cq].delete == 0 )) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(code_g_state[cq].delete == 0)",  103,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;
  code_g_state[cq].delete = delete;
}


  void
code_done (void)
{
  rtcg2_code_quality_t i;

  do { ; } while (0) ;
  do { do { (void)  (((code_g_init_called)) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(code_g_init_called)",  114,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;

  for (i=RTCG2_CODE_QUALITY_ERR+1; i<RTCG2_CODE_QUALITY_N; ++i) {
    if (code_g_state[i].inited) {
      alloc_t *old;

      code_g_state[i].inited = NO;
      (*(code_g_state[i].done))();
      old = (*(code_g_state[i].allocator))(0 );
      do { do { (void)  (((old == code_g_al)) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(old == code_g_al)",  123,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;
    }
  }
  code_g_init_called = NO;
}


  rtcg2_code_t *
rtcg2_code_of_ir (rtcg2_ir_t *ir, rtcg2_code_quality_t cq)
{
  rtcg2_code_t *code;

  do { ; } while (0) ;

  do { do { (void)  (((ir)) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(ir)",  137,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;
  do { do { (void)  (((cq > RTCG2_CODE_QUALITY_ERR && cq < RTCG2_CODE_QUALITY_N)) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(cq > RTCG2_CODE_QUALITY_ERR && cq < RTCG2_CODE_QUALITY_N)",  138,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;
  do { do { (void)  (((code_g_init_called)) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(code_g_init_called)",  139,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;

  if (!(code_g_state[cq].inited)) {
    alloc_t *old;

    old = (*(code_g_state[cq].allocator))(code_g_al);
    do { do { (void)  (((old == 0 )) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(old == 0)",  145,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;
    (*(code_g_state[cq].init))(code_g_argv0);
    code_g_state[cq].inited = YES;
  }

  code = alloc (code_g_al, sizeof(rtcg2_code_t));
  (*(code_g_state[cq].of_ir))(&code->state, &code->f, ir);
  code->cq = cq;
  return (code);
}

  rtcg2_code_f_t *
rtcg2_code_f (rtcg2_code_t *cd)
{
  do { ; } while (0) ;
  do { do { (void)  (((cd)) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(cd)",  160,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;

  return (cd->f);
}


  extern void
rtcg2_code_delete (rtcg2_code_t *cd)
{
  rtcg2_code_quality_t cq;

  do { ; } while (0) ;
  do { do { (void)  (((cd)) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(cd)",  172,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;
  cq = cd->cq;
  do { do { (void)  (((code_g_state[cq].inited)) ? 0 : ((__eprintf ("Failed assertion `%s' at line %d of `%s'.\n",	"(code_g_state[cq].inited)",  174,  "code.c"),	abort ()) , 0)) ; } while (0)  ; } while (0) ;
  (*(code_g_state[cq].delete))(cd->state);
}


Newsgroups: gnu.gcc.help