Logo Search packages:      
Sourcecode: tendra version File versions  Download package

hppadiags.c

/*
             Crown Copyright (c) 1997
    
    This TenDRA(r) Computer Program is subject to Copyright
    owned by the United Kingdom Secretary of State for Defence
    acting through the Defence Evaluation and Research Agency
    (DERA).  It is made available to Recipients with a
    royalty-free licence for its use, reproduction, transfer
    to other parties and amendment for any purpose not excluding
    product development provided that any such use et cetera
    shall be deemed to be acceptance of the following conditions:-
    
      (1) Its Recipients shall ensure that this Notice is
      reproduced upon any copies or amended versions of it;
    
      (2) Any amended version of it shall be clearly marked to
      show both the nature of and the organisation responsible
      for the relevant amendment or amendments;
    
      (3) Its onward transfer from a recipient to another
      party shall be deemed to be that party's acceptance of
      these conditions;
    
      (4) DERA gives no warranty or assurance as to its
      quality or suitability for any purpose and DERA accepts
      no liability whatsoever in relation to any use to which
      it may be put.
*/


/*
                      VERSION INFORMATION
                      ===================

--------------------------------------------------------------------------
$Header: /u/g/release/CVSROOT/Source/src/installers/hppa/common/hppadiags.c,v 1.1.1.1 1998/01/17 15:56:02 release Exp $
--------------------------------------------------------------------------
$Log: hppadiags.c,v $
 * Revision 1.1.1.1  1998/01/17  15:56:02  release
 * First version to be checked into rolling release.
 *
 * Revision 1.4  1996/08/06  10:50:06  wfs
 * bug fixes to pic code, enum diagnostics enabled.
 *
 * Revision 1.3  1996/03/28  10:53:09  wfs
 * Bug fixes to scan(), peephole optimisations in proc.c, and enum diagnostics.
 *
 * Revision 1.2  1995/12/18  13:11:30  wfs
 * Put hppatrans uder cvs control. Major Changes made since last release
 * include:
 * (i) PIC code generation.
 * (ii) Profiling.
 * (iii) Dynamic Initialization.
 * (iv) Debugging of Exception Handling and Diagnostics.
 *
 * Revision 5.11  1995/11/08  10:23:50  wfs
 * Minor changes for compatability with original "hpux_symtab.h" file +
 * extra warning messages.
 *
 * Revision 5.10  1995/11/03  13:24:28  wfs
 * Reset "typeno" after each call of " pos_of_dnttpos_of_dnttpointer". Cosmetic
 * changes.
 *
 * Revision 5.9  1995/10/30  12:58:57  wfs
 * Standardized the format of the warning messages.
 *
 * Revision 5.8  1995/10/25  14:30:42  wfs
 * Incorrect identifier for proc name was being output (in stab_proc()).
 *
 * Revision 5.7  1995/10/24  15:17:57  wfs
 * Fixed a bug in "pos_of_dnttpointer()".
 *
 * Revision 5.6  1995/10/20  13:53:51  wfs
 * Changes for gcc compilation.
 *
 * Revision 5.5  1995/10/09  13:13:46  wfs
 * Added an "SLT_EXIT" entry when closing functions - without this XDB
 * cannot properly trace return's. Cosmetic changes.
 *
 * Revision 5.4  1995/09/26  12:44:52  wfs
 * Moved "SLT_EXIT" in a case statement.
 *
 * Revision 5.3  1995/09/26  08:17:49  wfs
 * Added missing "#ifdef _SYMTAB_INCLUDED"'s.
 *
 * Revision 5.2  1995/09/25  11:46:04  wfs
 *    Added "#ifdef _SYMTAB_INCLUDED" provisios around any code which refers
 * to "hpux-symtab.h". We cannot legally distribute this header file.
 *    Added a procedure which will calculate where in the DNTT table a
 * struct typedef is to be entered without actually emitting the entry.
 * This is required whenever we have a struct typedef with a field being
 * a pointer to a struct of the type in question.
 *
 * Revision 5.1  1995/09/15  12:25:21  wfs
 * Numerous minor changes made to stop gcc complaining.
 *
 * Revision 5.0  1995/08/25  13:42:58  wfs
 * Preperation for August 25 Glue release
 *
 * Revision 3.4  1995/08/25  09:32:55  wfs
 * A major revision. XDB stuff added.
 *
 * Revision 3.4  1995/08/25  09:32:55  wfs
 * A major revision. XDB stuff added.
 *
 * Revision 3.1  95/04/10  16:26:44  16:26:44  wfs (William Simmonds)
 * Apr95 tape version.
 * 
 * Revision 3.0  95/03/30  11:17:22  11:17:22  wfs (William Simmonds)
 * Mar95 tape version with CRCR95_178 bug fix.
 * 
 * Revision 2.0  95/03/15  15:27:08  15:27:08  wfs (William Simmonds)
 * spec 3.1 changes implemented, tests outstanding.
 * 
 * Revision 1.7  1995/01/11  16:40:35  john
 * Fixed bug in diagnostics (for change request CR95_40)
 *
 * Revision 1.6  1995/01/11  09:59:32  john
 * Fixed bug in diagnostics (for change request CR94_224)
 *
 * Revision 1.5  1994/07/07  16:11:33  djch
 * Jul94 tape
 *
 * Revision 1.4  1994/07/04  08:29:06  djch
 * added extra parameter to stab_scope_open

d (section number). -ve values used to control
 * not putting out stabd (sometimes) in solaris; line #s go in the stabs.
 * added assert(0) to catch uninitialized items.
 *
 * Revision 1.3  1994/06/22  09:48:33  djch
 * Changes for solaris - line #s in functions are relative to start of fns,
 * global decls have line # in the stabs, and no stabn, and local labels are .LL,
 * not LL
 *
 * Revision 1.2  1994/05/13  13:08:39  djch
 * Incorporates improvements from expt version
 * changed format strings to remove longs..
 *
 * Revision 1.1  1994/05/03  14:49:53  djch
 * Initial revision
 *
 * Revision 1.6  93/09/27  14:55:15  14:55:15  ra (Robert Andrews)
 * Only whitespace.
 * 
 * Revision 1.5  93/08/27  11:37:55  11:37:55  ra (Robert Andrews)
 * A couple of lint-like changes.
 * 
 * Revision 1.4  93/08/13  14:45:51  14:45:51  ra (Robert Andrews)
 * Allow the stabs for long double to vary depending on DOUBLE_SZ.
 * 
 * Revision 1.3  93/07/05  18:26:29  18:26:29  ra (Robert Andrews)
 * A couple of minor corrections.  Introduced stab_ptrs to avoid duplication
 * of basic pointer types.
 * 
 * Revision 1.2  93/06/29  14:32:54  14:32:54  ra (Robert Andrews)
 * Fairly major rewrite and reformat.  There were a number of errors which
 * meant that the diagnostics were not previously working.
 * 
 * Revision 1.1  93/06/24  14:59:22  14:59:22  ra (Robert Andrews)
 * Initial revision
 * 
--------------------------------------------------------------------------
*/


#define HPPATRANS_CODE
#include "config.h"
#if FS_STDARG
#include <stdarg.h>
#else
#include <varargs.h>
#endif
#include "addrtypes.h"
#include "frames.h"
#include "exptypes.h"
#include "shapemacs.h"
#include "expmacs.h"
#include "codetypes.h"
#include "installtypes.h"
#include "toktypes.h"
#include "exp.h"
#include "exptypes.h"
#include "proctypes.h"
#include "procrec.h"
#include "tags.h"
#include "bitsmacs.h"
#include "diagtypes.h"
#include "xalloc.h"
#include "diag_fns.h"
#include "locate.h"
#include "diagglob.h"
#include "mark_scope.h"
#include "xalloc.h"
#include "comment.h"
#include "myassert.h"
#include "translat.h"
#include "machine.h"
#include "szs_als.h"
#include "install_fns.h"
#include "installglob.h"
#include "externs.h"
#include "out.h"
#include "hppadiags.h"

#ifdef _SYMTAB_INCLUDED
#undef _SYMTAB_INCLUDED
#include "hpux-symtab.h"
#endif



extern bool last_param PROTO_S ( ( exp ) ) ;


/*
    FORWARD DECLARATIONS
*/

static void stab_scope_open PROTO_S ( ( long ) ) ;
static void stab_scope_close PROTO_S ( ( long ) ) ;

#ifdef _SYMTAB_INCLUDED
static int last_lno = 0;
#endif

/*
    ARRAY OF DIAGNOSTIC SCOPES
*/

#define MAX_LEX_LEVEL 256
static long bracket_level = 1 ;
static long BB_id = 0;
static long BE_id = 0;
static int last_LBRAC_stab = 0;

/*
    DIAGNOSTICS FILE
*/

static FILE *dg_file;
static char dg_file_name[L_tmpnam];


/*
    BASIC TYPE NUMBERS
*/

#define STAB_SCHAR      4
#define STAB_UCHAR      6
#define STAB_SSHRT      2
#define STAB_USHRT      3
#define STAB_SLONG      1
#define STAB_ULONG      8
#define STAB_FLOAT      10
#define STAB_DBL  11
#define STAB_LDBL 12
#define STAB_VOID 13
#define NO_STABS  14


/*
    BASIC POINTERS
*/

static long stab_ptrs [ NO_STABS ] = {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
} ;


/*
    CURRENT TYPE NUMBER
*/

static long typeno = NO_STABS ;


/*
    SIZE OF LAST STAB TYPE OUTPUT
*/

static long last_type_sz = 0 ;


/*
    CURRENT LINE NUMBER AND FILE NUMBER
*/

long currentlno = -1 ;
long currentfile = -1 ;

#ifndef _SYMTAB_INCLUDED

typedef int DNTTPOINTER;

#endif

static DNTTPOINTER NIL;

/*
    ARRAY OF TYPE SIZES
*/


/* Information about previously defined types. */

typedef struct { int sz; DNTTPOINTER p; } type_info_t; 

static type_info_t *type_info ;
static int no_type_info = 0 ;


/*
    SETTING AND GETTING TYPE SIZES
*/

#define set_stab_size( i )    type_info [ ( i ) ].sz = last_type_sz
#define get_stab_size( i )    ( type_info [ ( i ) ].sz )


/*
    GET THE NEXT TYPE NUMBER
*/

static long next_typen 
    PROTO_Z ()
{
    if ( typeno >= no_type_info ) {
      int i, n = no_type_info, m = n + 100 ;
      type_info = ( type_info_t* ) xrealloc ( type_info, m * sizeof ( type_info_t ) ) ;
      for ( i = n ; i < m ; i++ ) type_info [i].sz = 0 ;
      no_type_info = m ;
    }
    return ( typeno++ ) ;
}


/*
    ARRAY OF FILE DESCRIPTORS
*/

static filename *fds = null ;
static int szfds = 0 ;
static int nofds = 0 ;


/* tdfstring -> nul terminated C string (char *) */
#define CSTRING(tdfstring)    ((tdfstring).ints.chars)

/* tdf exp -> C int */
#define EXPINT(exp)           (assert(name(exp) == val_tag) , no(exp))

/* tdf nat -> C int */
#define NATINT(n)       ((n).nat_val.small_nat)



#ifdef _SYMTAB_INCLUDED
/******************************   XDB stuff  *********************************/

static FILE *VT_,*SLT_,*LNTT_,*GNTT_ ;

static char   VT_name[L_tmpnam],  SLT_name[L_tmpnam],
            LNTT_name[L_tmpnam], GNTT_name[L_tmpnam] ;

static DNTTPOINTER DNTT_BEGIN_entry[1024];

static int level_of_DNTT_BEGINs = -1;

#define last_DNTT_BEGIN_entry()  DNTT_BEGIN_entry[level_of_DNTT_BEGINs]
#define LNTT 1
#define GNTT 0

static DNTTPOINTER lntt_next;
static DNTTPOINTER gntt_next;
static SLTPOINTER  slt_next = 0;
static VTPOINTER   vt_next = VTNIL;

struct vt_entry_t { long findex;
                VTPOINTER vtp;
                struct vt_entry_t *prev; }; 

typedef struct vt_entry_t *vt_entry;

vt_entry last_vt_entry = (vt_entry)0;

VTPOINTER is_vt_entry
    PROTO_N ( ( findex ) )
    PROTO_T ( long findex )
{
   vt_entry current = last_vt_entry;
   while ( current != (vt_entry)0 )
   {
      if ( current->findex == findex )
       return current->vtp;
      else
       current = current->prev;
   }   
   return VTNIL;
}    

#define EXTENSION_BIT( p ) ( (p)&(1<<31) )

void output_LNTT
    PROTO_N ( ( e ) )
    PROTO_T ( union dnttentry e )
{
   KINDTYPE kind = e.dfunc.kind;
   if (kind==K_SVAR)
   {
      fprintf(LNTT_,"\t.WORD\t%lu,%lu,%s",e.dgeneric.word[0], e.dgeneric.word[1], (char*)e.dgeneric.word[2]);
   }
   else
   {
      fprintf(LNTT_,"\t.WORD\t%lu,%lu,%lu",e.dgeneric.word[0], e.dgeneric.word[1], e.dgeneric.word[2]);
   }

   switch ( kind )
   {
      case K_MODULE:
      case K_WITH: 
      case K_FPARAM:
      case K_SVAR:
      case K_DVAR:
      case K_CONST:
      case K_MEMENUM:
      case K_SUBRANGE:
      case K_ARRAY:
      case K_STRUCT:
      case K_FIELD:
      case K_VARIANT:
      case K_FILE:
      case K_FUNCTYPE:
      {
       if ( EXTENSION_BIT(e.dgeneric.word[3])==0 )
       {
          fprintf(stderr,"hppatrans warning: trans made an error whilst compiling XDB diagnostics tables (extension bit not set)\n");
       }
       else
       {
          fprintf(LNTT_,",%lu,%lu,%lu",e.dgeneric.word[3],e.dgeneric.word[4], e.dgeneric.word[5]);
       }
       break;
      }
      case K_FUNCTION:
      case K_ENTRY:
      case K_BLOCKDATA:
      case K_COBSTRUCT:
      {
       if ( EXTENSION_BIT(e.dgeneric.word[3])==0 )
       {
          fprintf(stderr,"hppatrans warning: trans made an error whilst compiling XDB diagnostics tables (extension bit not set)\n");
          break;
       }
       else
       {
          fprintf(LNTT_,",%lu,%lu,%s",e.dgeneric.word[3],e.dgeneric.word[4], (char*)e.dgeneric.word[5]);
       }
       if ( EXTENSION_BIT(e.dgeneric.word[6])==0 )
       {
          fprintf(stderr,"hppatrans warning: trans made an error whilst compiling XDB diagnostics tables (extension bit not set)\n");
       }
       else
       {
          fprintf(LNTT_,",%lu,%s,%s",e.dgeneric.word[6], (char*)e.dgeneric.word[7],(char*)e.dgeneric.word[8]);         
       }
      }
      default:
      break;
   }
   fprintf(LNTT_,"\n");
}


void output_GNTT
    PROTO_N ( ( e ) )
    PROTO_T ( union dnttentry e )
{
   KINDTYPE kind = e.dfunc.kind;
   if (kind==K_SVAR)
   {
      fprintf(GNTT_,"\t.WORD\t%lu,%lu,%s",e.dgeneric.word[0], e.dgeneric.word[1], (char*)e.dgeneric.word[2]);
      if ( EXTENSION_BIT(e.dgeneric.word[3])==0 )
      {
       fprintf(stderr,"hppatrans warning: trans made an error whilst compiling XDB diagnostics tables (extension bit not set)\n");
      }
      else
      {
       fprintf(GNTT_,",%lu,%lu,%lu",e.dgeneric.word[3],e.dgeneric.word[4], e.dgeneric.word[5]);
      }
   }
   else
   {
      fprintf(GNTT_,"\t.WORD\t%lu,%lu,%lu",e.dgeneric.word[0], e.dgeneric.word[1], e.dgeneric.word[2]);
   }
   if (e.dgeneric.word[6]&(1<<31))
   {
      fprintf(GNTT_,",%lu,%lu,%lu",e.dgeneric.word[6],e.dgeneric.word[7], e.dgeneric.word[8]);
   }
   fprintf(GNTT_,"\n");
}


DNTTPOINTER make_DNTTP_IMMEDIATE
    PROTO_V ( ( BASETYPE type, ... ) )
{
   DNTTPOINTER p;
   va_list ap;
#if FS_STDARG
   va_start(ap,type);
#else
   BASETYPE type;
   va_start(ap);
   type = va_arg(ap, BASETYPE);
#endif
   p.dntti.extension = 1;
   p.dntti.immediate = 1;
   p.dntti.global = 0;
   p.dntti.type = type;
   switch( type )
     {
     case T_UNDEFINED:
       {
        p.dntti.bitlength = 32;
        break;
       } 
     case T_BOOLEAN:
       {
        p.dntti.bitlength = 1;
        break;
       } 
     case T_CHAR:
     case T_INT:
     case T_UNS_INT:
     case T_LONG:
     case T_UNS_LONG:
     case T_REAL:
     case T_COMPLEX:
       {
        p.dntti.bitlength = va_arg(ap,BITS);
        break;
       } 
     }
   return p;
}


void make_vtentry
    PROTO_T ( ( e X record X findex ) )
    PROTO_T ( char *e X int record X long findex )
{
   int len = 0;
   fprintf(VT_,"\t.STRINGZ\t\"");
   while (e[len++])
   {
      fprintf(VT_,"%c",e[len-1]);
   }
   if ( record )
   {
      vt_entry next = (vt_entry) malloc(sizeof(struct vt_entry_t));
      if ( last_vt_entry == (vt_entry)0 )
      {
       last_vt_entry = next;
       last_vt_entry->prev = (vt_entry)0;
      }
      else
      {
       next->prev = last_vt_entry;
       last_vt_entry = next;
      }
      next->findex = findex;
      next->vtp = vt_next;
   }
   vt_next+=len;
   fprintf(VT_,"\"\n");
}


void make_sltentry
    PROTO_V ( ( SLTTYPE sltdesc, ... ) )
{
   va_list ap;
   union sltentry e;
#if FS_STDARG
   va_start(ap,sltdesc);
#else
   SLTTYPE sltdesc;
   va_start(ap);
   sltdesc = va_arg(ap, SLTTYPE);
#endif
   e.sgeneric.word[0] = 0;
   e.sgeneric.word[1] = 0;
   switch(sltdesc)
   {
   case SLT_SRCFILE:
   case SLT_MODULE:
   case SLT_FUNCTION:
   case SLT_ENTRY:
   case SLT_BEGIN:
   case SLT_END:
   case SLT_WITH:
   case SLT_MARKER:
     {
      /*  A "special" entry  */
      e.sspec.sltdesc = sltdesc;
      e.sspec.line = va_arg(ap,BITS);
      e.sspec.backptr = va_arg(ap,DNTTPOINTER);
      fprintf(SLT_,"\t.WORD\t%lu,%lu\n",e.sgeneric.word[0], e.sgeneric.word[1]);
      break;
     }
   case SLT_EXIT:
   case SLT_NORMAL:
     {
      /*  A "normal" entry  */
      e.snorm.sltdesc = SLT_NORMAL;
      e.snorm.line = va_arg(ap,BITS);
      e.snorm.address = va_arg(ap,ADDRESS);
      fprintf(SLT_,"\t.WORD\t%lu,%s\n",e.sgeneric.word[0], (char*)e.sgeneric.word[1]);
      break;
     }
   case SLT_ASSIST:
     {
      /*  An "assist" entry  */
      e.sasst.sltdesc = SLT_ASSIST;
      e.sasst.unused = 0;
      e.sasst.address = va_arg(ap,ADDRESS);
      fprintf(SLT_,"\t.WORD\t%lu,%lu\n",e.sgeneric.word[0], e.sgeneric.word[1]);
      break;
     }
   }
   slt_next++; 
}


DNTTPOINTER make_dnttentry
    PROTO_V ( ( KINDTYPE kind, ... ) )
{
   va_list ap;
   union dnttentry e;
   DNTTPOINTER dnttpointer;
#if FS_STDARG
   va_start(ap,kind);
#else
   KINDTYPE kind;
   va_start(ap);
   kind = va_arg(ap, KINDTYPE);
#endif
   e.dsfile.extension = 0;
   e.dsfile.kind = K_SRCFILE;
   e.dsfile.language = 0;
   dnttpointer = lntt_next;
   switch(kind)
   {
   case K_SRCFILE:
     {
      e.dsfile.extension = 0;
      e.dsfile.kind = K_SRCFILE;
      e.dsfile.language = va_arg(ap,LANGTYPE);
      e.dsfile.unused = 0;
      e.dsfile.name = va_arg(ap,VTPOINTER);
      e.dsfile.address = va_arg(ap,SLTPOINTER);
      output_LNTT(e);
      lntt_next.word++;
      break;
     }
   case K_MODULE:
     {
      DNTT_BEGIN_entry[++level_of_DNTT_BEGINs] = lntt_next;
      e.dmodule.extension = 0;
      e.dmodule.kind = K_MODULE;
      e.dmodule.unused = 0;
      e.dmodule.name = va_arg(ap,VTPOINTER);
      e.dmodule.alias = va_arg(ap,VTPOINTER);
      e.dmodule.dummy = NIL;
      e.dmodule.address = va_arg(ap,SLTPOINTER);
      e.dgeneric.word[5] = 0;
      output_LNTT(e);
      lntt_next.word+=2;
      break;
     }
   case K_FUNCTION:
   case K_ENTRY:
   case K_BLOCKDATA:
     {
      if (kind==K_FUNCTION)
         DNTT_BEGIN_entry[++level_of_DNTT_BEGINs] = lntt_next;
      e.dfunc.extension = 0;
      e.dfunc.kind = kind;
      e.dfunc.public = va_arg(ap,BITS);
      e.dfunc.language = va_arg(ap,LANGTYPE);
      e.dfunc.level = va_arg(ap,BITS);
      e.dfunc.optimize = va_arg(ap,BITS);
      e.dfunc.varargs = va_arg(ap,BITS);
      e.dfunc.info = va_arg(ap,BITS);
      e.dfunc.unused = 0;
      e.dfunc.name = va_arg(ap,VTPOINTER);
      e.dfunc.alias = va_arg(ap,VTPOINTER);
      e.dfunc.firstparam = va_arg(ap,DNTTPOINTER);
      e.dfunc.address = va_arg(ap,SLTPOINTER);
      e.dfunc.entryaddr = va_arg(ap,ADDRESS);
      e.dfunc.retval = va_arg(ap,DNTTPOINTER);
      e.dfunc.lowaddr = va_arg(ap,ADDRESS);
      e.dfunc.hiaddr = va_arg(ap,ADDRESS);
      output_LNTT(e);
      lntt_next.word+=3;
      break;
     }
   case K_BEGIN:
     {
      DNTT_BEGIN_entry[++level_of_DNTT_BEGINs] = lntt_next;
      e.dbegin.extension = 0;
      e.dbegin.kind = K_BEGIN;
      e.dbegin.unused = 0;
      e.dbegin.address = va_arg(ap,SLTPOINTER);
      e.dgeneric.word[2] = 0;
      output_LNTT(e);
      lntt_next.word++;
      break;
     }
   case K_END:
     {
      e.dend.extension = 0;
      e.dend.kind = K_END;
      e.dend.endkind = va_arg(ap,KINDTYPE);
      e.dend.unused = 0;
      e.dend.address = va_arg(ap,SLTPOINTER);
      e.dend.beginscope = va_arg(ap,DNTTPOINTER);
      output_LNTT(e);
      lntt_next.word++;
      level_of_DNTT_BEGINs--;
      break;
     }
   case K_IMPORT:
     {
      e.dimport.extension = 0;
      e.dimport.kind = K_IMPORT;
      e.dimport.explicit = va_arg(ap,BITS);
      e.dimport.unused = 0;
      e.dimport.module = va_arg(ap,VTPOINTER);
      e.dimport.item = va_arg(ap,VTPOINTER);
      output_LNTT(e);
      lntt_next.word++;
      break;
     }
   case K_LABEL:
     {
      e.dlabel.extension = 0;
      e.dlabel.kind = K_LABEL;
      e.dlabel.unused = 0;
      e.dlabel.name = va_arg(ap,VTPOINTER);
      e.dlabel.address = va_arg(ap,SLTPOINTER);
      output_LNTT(e);
      lntt_next.word++;
      break;
     }
   case K_WITH:
     {
      e.dwith.extension = 0;
      e.dwith.kind = K_WITH;
      e.dwith.addrtype = va_arg(ap,BITS);
      e.dwith.indirect = va_arg(ap,BITS);
      e.dwith.longaddr = va_arg(ap,BITS);
      e.dwith.nestlevel = va_arg(ap,BITS);
      e.dwith.unused = 0;
      e.dwith.location = va_arg(ap,long);
      e.dwith.address = va_arg(ap,SLTPOINTER);
      e.dwith.type = va_arg(ap,DNTTPOINTER);
      e.dwith.name = va_arg(ap,VTPOINTER);
      e.dwith.offset = va_arg(ap,unsigned long);
      output_LNTT(e);
      lntt_next.word+=2;
      break;
     }
   case K_COMMON:
     {
      e.dcommon.extension = 0;
      e.dcommon.kind = K_COMMON;
      e.dcommon.unused = 0;
      e.dcommon.name = va_arg(ap,VTPOINTER);
      e.dcommon.alias = va_arg(ap,VTPOINTER);
      output_LNTT(e);
      lntt_next.word++;
      break;
     }
   case K_FPARAM:
     {
      e.dfparam.extension = 0;
      e.dfparam.kind = K_FPARAM;
      e.dfparam.regparam = va_arg(ap,BITS);
      e.dfparam.indirect = va_arg(ap,BITS);
      e.dfparam.longaddr = va_arg(ap,BITS);
      e.dfparam.copyparam = va_arg(ap,BITS);
      e.dfparam.unused = 0;
      e.dfparam.name = va_arg(ap,VTPOINTER);
      e.dfparam.location = va_arg(ap,DYNTYPE);
      e.dfparam.type = va_arg(ap,DNTTPOINTER);
      e.dfparam.nextparam = va_arg(ap,DNTTPOINTER);
      e.dfparam.misc = 0;
      output_LNTT(e);
      lntt_next.word+=2;
      break;
     }
   case K_SVAR:
     {
      int which_table;
      e.dsvar.extension = 0;
      e.dsvar.kind = K_SVAR;
      e.dsvar.public = va_arg(ap,BITS);
      e.dsvar.indirect = va_arg(ap,BITS);
      e.dsvar.longaddr = va_arg(ap,BITS);
      e.dsvar.unused = 0;
      e.dsvar.name = va_arg(ap,VTPOINTER);
      e.dsvar.location = va_arg(ap,STATTYPE);
      e.dsvar.type = va_arg(ap,DNTTPOINTER);
      e.dsvar.offset = va_arg(ap,unsigned long);
      e.dsvar.displacement = va_arg(ap,unsigned long);
      which_table = va_arg(ap,int);
      if (which_table==LNTT)
      {
         output_LNTT(e);
         lntt_next.word+=2;
      }
      else
      {
         dnttpointer = gntt_next;
         output_GNTT(e);
         gntt_next.word+=2;
      }
      break;
     }
   case K_DVAR:
     {
      e.ddvar.extension = 0;
      e.ddvar.kind = K_DVAR;
      e.ddvar.public = va_arg(ap,BITS);
      e.ddvar.indirect = va_arg(ap,BITS);
      e.ddvar.regvar = va_arg(ap,BITS);
      e.ddvar.unused = 0;
      e.ddvar.name = va_arg(ap,VTPOINTER);
      e.ddvar.location = va_arg(ap,DYNTYPE);
      e.ddvar.type = va_arg(ap,DNTTPOINTER);
      e.ddvar.offset = 0;
      e.dgeneric.word[5] = 0;
      output_LNTT(e);
      lntt_next.word+=2;
      break;
     }
   case K_CONST:
     {
      e.dconst.extension = 0;
      e.dconst.kind = K_CONST;
      e.dconst.public = va_arg(ap,BITS);
      e.dconst.indirect = va_arg(ap,BITS);
      e.dconst.locdesc = va_arg(ap,LOCDESCTYPE);
      e.dconst.unused = 0;
      e.dconst.name = va_arg(ap,VTPOINTER);
      e.dconst.location = va_arg(ap,STATTYPE);
      e.dconst.type = va_arg(ap,DNTTPOINTER);
      e.dconst.offset = va_arg(ap,unsigned long);
      e.dconst.displacement = va_arg(ap,unsigned long);
      output_LNTT(e);
      lntt_next.word+=2;
      break;
     }
   case K_TYPEDEF:
   case K_TAGDEF:
     {
      e.dtype.extension = 0;
      e.dtype.kind = kind;
      e.dtype.public = va_arg(ap,BITS);
      e.dtype.typeinfo = va_arg(ap,BITS);
      e.dtype.unused = 0;
      e.dtype.name = va_arg(ap,VTPOINTER);
      e.dtype.type = va_arg(ap,DNTTPOINTER);
      output_LNTT(e);
      lntt_next.word++;
      break;
     }
   case K_POINTER:
     {
      e.dptr.extension = 0;
      e.dptr.kind = kind;
      e.dptr.unused = 0;
      e.dptr.pointsto = va_arg(ap,DNTTPOINTER);
      e.dptr.bitlength = va_arg(ap,unsigned long);
      output_LNTT(e);
      lntt_next.word++;
      break;
     }
   case K_ENUM:
     {
      e.denum.extension = 0;
      e.denum.kind = K_ENUM;
      e.denum.unused = 0;
      e.denum.firstmem = va_arg(ap,DNTTPOINTER);
      e.denum.bitlength = va_arg(ap,unsigned long);
      output_LNTT(e);
      lntt_next.word++;
      break;
     }
   case K_MEMENUM:
     {
      e.dmember.extension = 0;
      e.dmember.kind = K_MEMENUM;  
      e.dmember.unused = 0;
      e.dmember.name = va_arg(ap,VTPOINTER);
      e.dmember.value = va_arg(ap,unsigned long);
      e.dmember.nextmem = va_arg(ap,DNTTPOINTER);
      e.dgeneric.word[4] = 0;
      e.dgeneric.word[5] = 0;
      output_LNTT(e);
      lntt_next.word+=2;
      break;
     }
   case K_SET:
     {
      e.dset.extension = 0;
      e.dset.kind = K_SET;  
      e.dset.declaration = va_arg(ap,BITS);
      e.dset.unused = 0;
      e.dset.subtype = va_arg(ap,DNTTPOINTER);
      e.dset.bitlength = va_arg(ap,unsigned long);
      output_LNTT(e);
      lntt_next.word++;
      break;
     }
   case K_SUBRANGE:
     {
      e.dsubr.extension = 0;
      e.dsubr.kind = K_SUBRANGE;  
      e.dsubr.dyn_low = va_arg(ap,BITS);
      e.dsubr.dyn_high = va_arg(ap,BITS);
      e.dsubr.unused = 0;
      e.dsubr.lowbound = va_arg(ap,long);
      e.dsubr.highbound = va_arg(ap,long);
      e.dsubr.subtype = va_arg(ap,DNTTPOINTER);
      e.dsubr.bitlength = va_arg(ap,unsigned long);
      e.dgeneric.word[5] = 0;
      output_LNTT(e);
      lntt_next.word+=2;
      break;
     }
   case K_ARRAY:
     {
      e.darray.extension = 0;
      e.darray.kind = K_ARRAY;  
      e.darray.declaration = va_arg(ap,BITS);
      e.darray.dyn_low = va_arg(ap,BITS);
      e.darray.dyn_high = va_arg(ap,BITS);
      e.darray.arrayisbytes = va_arg(ap,BITS);
      e.darray.elemisbytes = va_arg(ap,BITS);
      e.darray.elemorder = va_arg(ap,BITS);
      e.darray.justified = va_arg(ap,BITS);
      e.darray.unused = 0;
      e.darray.arraylength = va_arg(ap,unsigned long);
      e.darray.indextype = va_arg(ap,DNTTPOINTER);
      e.darray.elemtype = va_arg(ap,DNTTPOINTER);
      e.darray.elemlength = va_arg(ap,unsigned long);
      e.dgeneric.word[5] = 0;
      output_LNTT(e);
      lntt_next.word+=2;
      break;
     }
   case K_STRUCT:
     {
      e.dstruct.extension = 0;
      e.dstruct.kind = K_STRUCT;  
      e.dstruct.declaration = va_arg(ap,BITS);
      e.dstruct.unused = 0;
      e.dstruct.firstfield = va_arg(ap,DNTTPOINTER);
      e.dstruct.vartagfield = va_arg(ap,DNTTPOINTER);
      e.dstruct.varlist = va_arg(ap,DNTTPOINTER);
      e.dstruct.bitlength = va_arg(ap,unsigned long);
      e.dgeneric.word[5] = 0;
      output_LNTT(e);
      lntt_next.word+=2;
      break;
     }
   case K_UNION:
     {
      e.dunion.extension = 0;
      e.dunion.kind = K_UNION;  
      e.dunion.unused = 0;
      e.dunion.firstfield = va_arg(ap,DNTTPOINTER);
      e.dunion.bitlength = va_arg(ap,unsigned long);
      output_LNTT(e);
      lntt_next.word++;
      break;
     }
   case K_FIELD:
     {
      e.dfield.extension = 0;
      e.dfield.kind = K_FIELD;  
      e.dfield.unused = 0;
      e.dfield.name = va_arg(ap,VTPOINTER);
      e.dfield.bitoffset = va_arg(ap,unsigned long);
      e.dfield.type = va_arg(ap,DNTTPOINTER);
      e.dfield.bitlength = va_arg(ap,unsigned long);
      e.dfield.nextfield = va_arg(ap,DNTTPOINTER);
      output_LNTT(e);
      lntt_next.word+=2;
      break;
     }
   case K_VARIANT:
     {
      e.dvariant.extension = 0;
      e.dvariant.kind = K_VARIANT;  
      e.dvariant.unused = 0;
      e.dvariant.lowvarvalue = va_arg(ap,long);
      e.dvariant.hivarvalue = va_arg(ap,long);
      e.dvariant.varstruct = va_arg(ap,DNTTPOINTER);
      e.dvariant.bitoffset = va_arg(ap,unsigned long);
      e.dvariant.nextvar = va_arg(ap,DNTTPOINTER);
      output_LNTT(e);
      lntt_next.word+=2;
      break;
     }
   case K_FILE:
     {
      e.dfile.extension = 0;
      e.dfile.kind = K_FILE;  
      e.dfile.ispacked = va_arg(ap,BITS);
      e.dfile.unused = 0;
      e.dfile.bitlength = va_arg(ap,unsigned long);
      e.dfile.bitoffset = va_arg(ap,unsigned long);
      e.dfile.elemtype = va_arg(ap,DNTTPOINTER);
      e.dgeneric.word[4] = 0;
      e.dgeneric.word[5] = 0;
      output_LNTT(e);
      lntt_next.word+=2;
      break;
     }
   case K_FUNCTYPE:
     {
      e.dfunctype.extension = 0;
      e.dfunctype.kind = K_FUNCTYPE;  
      e.dfunctype.varargs = va_arg(ap,BITS);
      e.dfunctype.info = va_arg(ap,BITS);
      e.dfunctype.unused = 0;
      e.dfunctype.bitlength = va_arg(ap,unsigned long);
      e.dfunctype.firstparam = va_arg(ap,DNTTPOINTER);
      e.dfunctype.retval = va_arg(ap,DNTTPOINTER);
      e.dgeneric.word[4] = 0;
      e.dgeneric.word[5] = 0;
      output_LNTT(e);
      lntt_next.word+=2;
      break;
     }
   case K_COBSTRUCT:
     {
      e.dcobstruct.extension = 0;
      e.dcobstruct.kind = K_COBSTRUCT;  
      e.dcobstruct.hasoccurs = va_arg(ap,BITS);
      e.dcobstruct.istable = va_arg(ap,BITS);
      e.dcobstruct.unused = 0;
      e.dcobstruct.parent = va_arg(ap,DNTTPOINTER);
      e.dcobstruct.child = va_arg(ap,DNTTPOINTER);
      e.dcobstruct.sibling = va_arg(ap,DNTTPOINTER);
      e.dcobstruct.synonym = va_arg(ap,DNTTPOINTER);
      e.dcobstruct.catusage = va_arg(ap,BITS);
      e.dcobstruct.unused2 = 0;
      e.dcobstruct.table = va_arg(ap,DNTTPOINTER);
      e.dcobstruct.editpgm = va_arg(ap,VTPOINTER);
      e.dcobstruct.bitlength = va_arg(ap,unsigned long);
      output_LNTT(e);
      lntt_next.word+=3;
      break;
     }
   case K_SA:
     {
      e.dsa.extension = 0;
      e.dsa.kind = K_SA;
      e.dsa.base_kind = va_arg(ap,KINDTYPE);
      e.dsa.unused = 0;
      e.dsa.name = va_arg(ap,VTPOINTER);
      e.dsa.extra = 0;
      output_LNTT(e);
      lntt_next.word++;
      break;
     }
   case K_XREF:
     {
      e.dxref.extension = 0;
      e.dxref.kind = K_XREF;
      e.dxref.language = va_arg(ap,LANGTYPE);
      e.dxref.unused = 0;
      e.dxref.xreflist = va_arg(ap,XREFPOINTER);
      e.dxref.extra = 0;
      output_LNTT(e);
      lntt_next.word++;
      break;
     }
   }
   return dnttpointer;
}
  

void output_DEBUG
    PROTO_Z ()
{
    int c ;
    FILE *f ;
    SLTPOINTER slt_prev = slt_next;
    make_sltentry(SLT_END, currentlno, lntt_next);
    make_dnttentry(K_END, K_MODULE, slt_prev, last_DNTT_BEGIN_entry());
    fclose( VT_ );
    fclose( SLT_ );
    fclose( LNTT_ );
    fclose( GNTT_ );
    f = fopen( VT_name, "r" ) ;
    if ( f == NULL ) {
      fail ( "Can't open temporary diagnostics file" ) ;
      exit ( EXIT_FAILURE ) ;
    }
    while( c = fgetc ( f ), c != EOF )  outc ( c );
    outnl();
    fclose( VT_ );
    remove( VT_name );
    f = fopen( SLT_name, "r" ) ;
    if ( f == NULL ) {
      fail ( "Can't open temporary diagnostics file" ) ;
      exit ( EXIT_FAILURE ) ;
    }
    while( c = fgetc ( f ), c != EOF )  outc ( c );
    outnl();
    fclose( SLT_ );
    remove( SLT_name );
    f = fopen( LNTT_name, "r" ) ;
    if ( f == NULL ) {
      fail ( "Can't open temporary diagnostics file" ) ;
      exit ( EXIT_FAILURE ) ;
    }
    while ( c = fgetc ( f ), c != EOF )  outc ( c );
    outnl();
    fclose( LNTT_ );
    remove( LNTT_name );
    f = fopen( GNTT_name, "r" ) ;
    if ( f == NULL ) {
      fail ( "Can't open temporary diagnostics file" ) ;
      exit ( EXIT_FAILURE ) ;
    }
    while( c = fgetc ( f ), c != EOF )  outc ( c );
    fclose( GNTT_ );
    remove( GNTT_name );

    fprintf(outf,"\n\t.SPACE\t$DEBUG$\n");
    fprintf(outf,"\t.SUBSPA\t$HEADER$\n");
#if USE_XT
    fprintf(outf,"\t.WORD\t%ld\n",(gntt_next.word * DNTTBLOCKSIZE) |
                         extension_header);     /* MSB indicates XT */
#else
    fprintf(outf,"\t.WORD\t%ld\n",(gntt_next.word * DNTTBLOCKSIZE) | 0 );
                                                /* MSB indicates XT */
#endif
    fprintf(outf,"\t.WORD\t%ld\n",lntt_next.word * DNTTBLOCKSIZE);
    fprintf(outf,"\t.WORD\t%ld\n",slt_next * SLTBLOCKSIZE);
    fprintf(outf,"\t.WORD\t%ld\n",vt_next);
#if USE_XT
    fprintf(outf,"\t.WORD\t%ld\n",xt_next * XTBLOCKSIZE);
#endif
    return ;
}

/*****************************************************************************/
#endif

/*
    ADD A NEW FILE TO THE ARRAY OF FILE DESCRIPTORS
*/

void stab_collect_files 
    PROTO_N ( ( f ) )
    PROTO_T ( filename f )
{
    if ( fds == null ) {
      szfds += 10 ;
      fds = ( filename * ) xmalloc ( szfds * sizeof ( filename ) ) ;
    } else if ( nofds >= szfds ) {
      szfds += 10 ;
      fds = ( filename * ) xrealloc ( fds, szfds * sizeof ( filename ) ) ;
    }
    fds [ nofds++ ] = f ;
    return ;
}


/*
    FIND THE FILE DESCRIPTOR CORRESPONDING TO A FILE NAME
*/

static long find_file 
    PROTO_N ( ( f ) )
    PROTO_T ( char * f )
{
    long i ;
    for ( i = 0 ; i < nofds ; i++ ) {
      if ( strcmp ( f, fds [i]->file.ints.chars ) == 0 ) return ( i ) ;
    }
    return ( 0 ) ;
}


static char *last_proc_lab = "<<No Proc>>";

/*
    OUTPUT A FILE POSITION CONSTRUCT
*/

#define N_SLINE  0x44
#define N_DSLINE 0x46
#define N_BSLINE 0x48
#define N_LBRAC  0xc0
#define N_RBRAC  0xe0

void stabd 
    PROTO_N ( ( findex, lno, seg ) )
    PROTO_T ( long findex X long lno X int seg )
{
   long i ;
   if ( findex == currentfile && lno == currentlno ) return ;
   stab_file ( findex, 1 ) ;
   if (seg != 0)        /* 0 suppresses always */
   {
      if (seg > 0)            /* -ve line nos are put out in the stabs */
      {
      i = next_lab();
      if (xdb)
      {
#ifdef _SYMTAB_INCLUDED
         char address[128];
         sprintf(address,"L$M%ld-%s",i,last_proc_lab);
         make_sltentry(SLT_NORMAL, lno, (ADDRESS)address);
         last_lno = lno;
#endif
      }
      else  /*  gdb  */
      {
         fprintf(dg_file,"\t.stabn\t0x%x,0,%ld,L$M%ld-%s\n",seg,
               lno,i,last_proc_lab) ;
      }
      fprintf(dg_file,"L$M%ld\n",i) ;
      }
   }
   currentlno = lno ;
   return ;
}


/*
    OUTPUT INITIAL DIAGNOSTICS FOR A DIAGNOSE_TAG
*/

/* ARGSUSED */ void stab_begin 
    PROTO_N ( ( d, proc_no, e ) )
    PROTO_T ( diag_info * d X int proc_no X exp e )
{
    exp x ;

    if ( d->key == DIAG_INFO_SOURCE ) {
      sourcemark *s = &d->data.source.beg ;
      long f = find_file ( s->file->file.ints.chars ) ;
      stabd ( f, ( long ) s->line_no.nat_val.small_nat ,N_SLINE) ;
      return ;
    }

    if ( d->key != DIAG_INFO_ID ) {
      /* not implemented */
      return ;
    }
  
    x = d->data.id_scope.access ;
    /* MIPS */
    if ( isglob ( son ( x ) ) || no ( son ( x ) ) == 1 ) return;

    mark_scope ( e ) ;

    if ( props ( e ) & 0x80 ) {
      stab_scope_open ( currentfile ) ;
      stabd ( currentfile, ( long ) ( currentlno + 1 ), N_SLINE ) ;
    }

    stab_local ( d->data.id_scope.nme.ints.chars, d->data.id_scope.typ,
             x, 0, currentfile ) ;

    if ( last_param ( son ( x ) ) ) {
      stabd ( currentfile, ( long ) ( currentlno + 1 ),N_SLINE) ;
    }
    return ;
}


/*
    OUTPUT FINAL DIAGNOSTICS FOR A DIAGNOSE_TAG
*/

void stab_end 
    PROTO_N ( ( d, e ) )
    PROTO_T ( diag_info * d X exp e )
{
    if ( d->key == DIAG_INFO_SOURCE ) {
      sourcemark *s = &d->data.source.end ;
      long f = find_file ( s->file->file.ints.chars ) ;
      long lno = s->line_no.nat_val.small_nat ;
      stabd (f,lno,N_SLINE) ;
      return ;
    }
    if ( d->key == DIAG_INFO_ID && props ( e ) & 0x80 ) {
      stab_scope_close ( currentfile ) ;
      return ;
    }
    return ;
}


/*
    INITIALISE DIAGNOSTICS
*/

void init_stab 
    PROTO_Z ()
{
    tmpnam ( dg_file_name ) ;
    dg_file = fopen ( dg_file_name, "w+" ) ;
    if ( dg_file == NULL ) {
      fail ( "Can't open temporary diagnostics file" ) ;
      exit ( EXIT_FAILURE ) ;
    }
#ifdef _SYMTAB_INCLUDED
    NIL.word = -1;
#else
    NIL = 0;
#endif
    if (xdb)
    {
#ifdef _SYMTAB_INCLUDED
       stab_types();
       tmpnam( VT_name ) ;
       VT_ = fopen ( VT_name, "w+" ) ;
       if ( VT_ == NULL ) 
       {
        fail ( "Can't open temporary diagnostics file" ) ;
        exit ( EXIT_FAILURE ) ;
       }
       tmpnam( SLT_name ) ;
       SLT_ = fopen ( SLT_name, "w+" ) ;
       if ( SLT_ == NULL ) 
       {
        fail ( "Can't open temporary diagnostics file" ) ;
        exit ( EXIT_FAILURE ) ;
       }
       tmpnam( LNTT_name ) ;
       LNTT_ = fopen ( LNTT_name, "w+" ) ;
       if ( LNTT_ == NULL ) 
       {
        fail ( "Can't open temporary diagnostics file" ) ;
        exit ( EXIT_FAILURE ) ;
       }
       tmpnam( GNTT_name ) ;
       GNTT_ = fopen ( GNTT_name, "w+" ) ;
       if ( GNTT_ == NULL ) 
       {
        fail ( "Can't open temporary diagnostics file" ) ;
        exit ( EXIT_FAILURE ) ;
       }
       fprintf(VT_,"\t.SPACE\t$DEBUG$\n");
       fprintf(VT_,"\t.SUBSPA\t$VT$\n");
       fprintf(SLT_,"\t.SPACE\t$DEBUG$\n");
       fprintf(SLT_,"\t.SUBSPA\t$SLT$\n");
       fprintf(LNTT_,"\t.SPACE\t$DEBUG$\n");
       fprintf(LNTT_,"\t.SUBSPA\t$LNTT$\n");
       fprintf(GNTT_,"\t.SPACE\t$DEBUG$\n");
       fprintf(GNTT_,"\t.SUBSPA\t$GNTT$\n");
       make_vtentry("",0,0);
       lntt_next.word = 1<<31;  /* initialise .word field */
       gntt_next.word = 1<<31;  /* initialise .word field */
       NIL.word = -1;
#endif
    }
    return ;
}


/*
    INITIALIZE DIAGNOSTICS
*/

void init_stab_aux 
    PROTO_Z ()
{
    int c ;
    FILE *f ;
    int i, j = 0 ;
    for ( i = 0 ; i < nofds ; i++ ) {
      char *s = fds [i]->file.ints.chars ;
      int n = ( int ) strlen ( s ) ;
      if ( n && s [ n - 1 ] != 'h' ) j = i ;
    }
    fclose ( dg_file ) ;
    dg_file = outf ;
    stab_file ( ( long ) j, 0 ) ;
    if (gdb)
    {
       stab_types();
    }
    f = fopen ( dg_file_name, "r" ) ;
    if ( f == NULL ) {
      fail ( "Can't open temporary diagnostics file" ) ;
      exit ( EXIT_FAILURE ) ;
    }
    while ( c = fgetc ( f ), c != EOF ) outc ( c ) ;
    fclose ( f ) ;
    remove ( dg_file_name ) ;
    return ;
}


/*
    FIND THE DIAGNOSTICS CORRESPONDING TO THE CURRENT DECLARATION
*/

/* ARGSUSED */ static diag_descriptor *find_dd 
    PROTO_N ( ( e ) )
    PROTO_T ( exp e )
{
    if ( diag_def == NULL ) return ( NULL ) ;
    return ( diag_def->dec_u.dec_val.diag_info ) ;
}


/*
    OUTPUT DIAGNOSTICS DIRECTIVE FOR A FILE
*/

void stab_file 
    PROTO_N ( ( findex, internal ) )
    PROTO_T ( long findex X bool internal )
{
    static long i = 0 ;
    if ( findex == currentfile || findex < 0 || findex >= szfds ) {
      return ;
    }

    if (gdb)
       fprintf(dg_file,"\t.file\t\"%s\"\n",fds[ findex ]->file.ints.chars);
    if (internal)
    {
       /* included file */
       if (xdb)
       {
#ifdef _SYMTAB_INCLUDED
        SLTPOINTER slt_prev = slt_next;
        VTPOINTER entry = is_vt_entry( findex );
        make_sltentry(SLT_SRCFILE, currentlno, lntt_next); 
        make_dnttentry(K_SRCFILE, LANG_C, ( entry==VTNIL ? vt_next : entry ), slt_prev); 
        if ( entry==VTNIL )
           make_vtentry(fds[ findex ]->file.ints.chars,1,findex);
#endif
       }
       else
        fprintf ( dg_file,"\t.stabs\t\"%s\",0x84,0,0,L$M%ld\n",
                 fds[ findex ]->file.ints.chars, i ) ;
    }
    else
    {
       /* source file */
       i = next_lab () ;
       if (xdb)
       {
#ifdef _SYMTAB_INCLUDED
        SLTPOINTER slt_prev = slt_next;
        VTPOINTER entry = is_vt_entry(findex);
        make_sltentry(SLT_SRCFILE, currentlno, lntt_next); 
        make_dnttentry(K_SRCFILE, LANG_C, ( entry==VTNIL ? vt_next : entry ), slt_prev); 
        slt_prev =  slt_next;
        make_sltentry(SLT_MODULE, 1, lntt_next); 
        make_dnttentry(K_MODULE, VTNIL, VTNIL, slt_prev); 
        if ( entry==VTNIL )
           make_vtentry(fds[ findex ]->file.ints.chars,1,findex);
#endif
       }
       else  /*  gdb  */
       {
        fprintf ( dg_file, "\t.stabs\t\"%s\",0x64,0,0,L$M%ld\n",
                 fds[ findex ]->file.ints.chars, i ) ;
       }
       fprintf ( dg_file, "L$M%ld\n", i ) ;
    }
    currentfile = findex ;
    return ;
}


/*********************  START OF A DIAGNOSTICS SCOPE  ************************/

static void stab_scope_open 
    PROTO_N ( ( findex ) )
    PROTO_T ( long findex )
{
   stab_file(findex,1);
   /* nb. don't need to output bracket level */
   if (xdb)
   {
#ifdef _SYMTAB_INCLUDED
      SLTPOINTER slt_prev = slt_next;
      make_sltentry(SLT_BEGIN, (BITS)currentlno, lntt_next);
      make_dnttentry(K_BEGIN, slt_prev);
#endif
   }
   else  /*  gdb  */
   {
      if (last_LBRAC_stab==BB_id-1)
      {
       fprintf(dg_file,"\t.stabn\t0x%x,0,0,L$BB%ld-%s\n",N_LBRAC,BB_id,
             last_proc_lab);
       last_LBRAC_stab=BB_id;
      }
      BB_id++;
      fprintf(dg_file,"L$BB%ld\n",BB_id);
   }
   bracket_level++;
}


/**********************  END OF A DIAGNOSTICS SCOPE  *************************/

static void stab_scope_close 
    PROTO_N ( ( findex ) )
    PROTO_T ( long findex )
{
   bracket_level--;
   if (bracket_level>MAX_LEX_LEVEL)
      return;
   /* nb. don't need to output bracket level */
   if (xdb) 
   {
#ifdef _SYMTAB_INCLUDED
      SLTPOINTER slt_prev = slt_next;
      make_sltentry(SLT_END, currentlno, lntt_next);
      make_dnttentry(K_END, K_BEGIN, slt_prev, last_DNTT_BEGIN_entry());
#endif
   }
   else  /*  gdb  */
   {
      if (last_LBRAC_stab==BB_id-1)
      {
       fprintf(dg_file,"\t.stabn\t0x%x,0,0,L$BB%ld-%s\n",N_LBRAC,BB_id,
            last_proc_lab);
       last_LBRAC_stab = BB_id;
      } 
      BE_id++;
      fprintf(dg_file,"\t.stabn\t0x%x,0,0,L$BE%ld-%s\n",N_RBRAC,BE_id,
                last_proc_lab);
      fprintf(dg_file,"L$BE%ld\n",BE_id);
   }
   return;
}


/*
    DEPTH COUNT FOR STAB TYPES
*/

/* static int max_depth = 64 ; */
static int depth_now = 0 ;


/***************  OUTPUT THE DIAGNOSTICS FOR A SIMPLE SHAPE  *****************/

static long out_sh_type 
    PROTO_N ( ( s ) )
    PROTO_T ( shape s )
{
    last_type_sz = shape_size ( s ) ;
    switch ( name(s) )
      {
      case scharhd : return ( STAB_SCHAR ) ;
      case ucharhd : return ( STAB_UCHAR ) ;
      case swordhd : return ( STAB_SSHRT ) ;
      case uwordhd : return ( STAB_USHRT ) ;
      case slonghd : return ( STAB_SLONG ) ;
      case ulonghd : return ( STAB_ULONG ) ;
      case shrealhd : return ( STAB_FLOAT ) ;
      case realhd : return ( STAB_DBL ) ;
      case doublehd : return ( STAB_LDBL ) ;
      }
    return ( STAB_VOID ) ;
}


/***********************  OUTPUT A DIAGNOSTICS TYPE  *************************/


#ifdef _SYMTAB_INCLUDED


struct outed_t { diag_type dt; struct outed_t *prev; }; 
typedef struct outed_t *outed;

static outed uo;
static DNTTPOINTER pos;


void undo_outed 
    PROTO_N ( ( dt ) )
    PROTO_T ( diag_type dt )
{
   outed p = (outed) malloc( sizeof( struct outed_t ) );
   uo->prev = p;
   p->dt = dt;
   p->prev = (struct outed_t*) 0;
   uo = p;
}


static DNTTPOINTER traverse_diag_type 
    PROTO_N ( ( dt ) )
    PROTO_T ( diag_type dt )
{
    if ( dt->been_outed ) 
    {
       last_type_sz = get_stab_size( dt->been_outed );
       return pos;
    }
  
#if 0
    if ( depth_now >= max_depth )
    {
       return NIL ;
    }
    depth_now++ ;
#endif
  
    switch( dt->key )
      {
      case DIAG_TYPE_PTR:
      {
         long non;
         diag_type pdt = dt->data.ptr.object ;
         if ( pdt->key == DIAG_TYPE_VARIETY )
         {
            long pn = out_sh_type( f_integer( pdt->data.var) );
            non = stab_ptrs[pn];
            if ( non==0 )
            {
             non = next_typen();
             stab_ptrs[pn] = -non;
             pos.word++;
            }
         }
         else
         {
            non = next_typen();
            traverse_diag_type( pdt );
            pos.word++;
         }
         dt->been_outed = non;
         undo_outed( dt );
         last_type_sz = 32;
         set_stab_size(non);
         return pos;
      }
  
      case DIAG_TYPE_ARRAY:
      {
         long lwb = no( dt->data.array.lower_b );
         long upb = no( dt->data.array.upper_b );
         diag_type index_type = dt->data.array.index_type ;
         diag_type element_type = dt->data.array.element_type ;
         long non = next_typen();
         dt->been_outed = non ;
         undo_outed( dt );
         traverse_diag_type( index_type );
         pos.word+=2;
         traverse_diag_type( element_type );
         pos.word+=2;
         last_type_sz *= ( upb-lwb+1 );
         set_stab_size(non);
         return pos;
         break ;
      }

      case DIAG_TYPE_STRUCT:
      case DIAG_TYPE_UNION:
      {
         int i;
         shape s;
         long non = next_typen();
         diag_field_list fields;
         dt->been_outed = non;
         undo_outed( dt );
         if ( dt->key == DIAG_TYPE_STRUCT )
         {
            fields = dt->data.t_struct.fields;
            s = dt->data.t_struct.tdf_shape;
         } 
         else
         {
            fields = dt->data.t_union.fields;
            s = dt->data.t_union.tdf_shape;
         }
         for(i=0;i<fields->lastused;i++)
         {
            diag_field f = (fields->array)[i];
            traverse_diag_type( f->field_type );
            pos.word+=2;
         }
         if ( dt->key == DIAG_TYPE_STRUCT )
         {
            pos.word+=2;
         }
         else
         {
            pos.word++;
         }
         last_type_sz = shape_size(s);
         set_stab_size(non);
         return pos;
      }
  
      case DIAG_TYPE_FLOAT:
      case DIAG_TYPE_VARIETY:
        {
           shape sha;
           if ( dt->key==DIAG_TYPE_VARIETY )
           {
            sha = f_integer(dt->data.var);
           }
           else
           {
            sha = f_floating(dt->data.f_var);
           }
           dt->been_outed = out_sh_type( sha );
           return pos;
        }
  
      case DIAG_TYPE_PROC:
        {
           diag_type result_type = dt->data.proc.result_type ;
           long non1 = next_typen();
           long non2 = next_typen();
           dt->been_outed = non1;
           undo_outed( dt );
           pos.word++;
           traverse_diag_type ( result_type ) ;
           last_type_sz = 32 ;
           set_stab_size ( non1 ) ;
           set_stab_size ( non2 ) ;
           return pos;
        }
  
      case DIAG_TYPE_LOC:
        {
           return traverse_diag_type ( dt->data.loc.object ) ;
        }
  
      case DIAG_TYPE_NULL:
        {
           last_type_sz = 0;
           return pos;
        }
  
      case DIAG_TYPE_BITFIELD:
        {
           long sz = dt->data.bitfield.no_of_bits.nat_val.small_nat ;
           last_type_sz = sz;
           return pos;
        }

      case DIAG_TYPE_ENUM:
      {
         traverse_diag_type( dt->data.t_enum.base_type );
         return pos;
      }

      default:
      {
         last_type_sz = 0 ;
         return pos;
      }
    }
}


DNTTPOINTER pos_of_dnttpointer 
    PROTO_N ( ( dt ) )
    PROTO_T ( diag_type dt )
{
   outed p,f;
   int s;
   int t = typeno;
   pos = lntt_next;
   uo = (struct outed_t*) malloc( sizeof( struct outed_t ) );
   uo->prev = (struct outed_t*) 0; 
   f = uo;
   traverse_diag_type( dt );
   while ( f->prev )
   {
      p = f->prev;
      free( f );  
      p->dt->been_outed = 0;
      f = p;
   }
   free( f );
   for(s=0;s<NO_STABS;s++)
      if ( stab_ptrs[s]<0 )
       stab_ptrs[s] = 0;
   typeno = t;
   return pos;
}


#endif


#define OUT_DT_SHAPE( dt )    out_dt_shape ( ( depth_now = 0, dt ) )

static DNTTPOINTER out_dt_shape 
    PROTO_N ( ( dt ) )
    PROTO_T ( diag_type dt )
{
    if ( dt->been_outed ) 
    {
       last_type_sz = get_stab_size( dt->been_outed );
       if (xdb)
       {
#ifdef _SYMTAB_INCLUDED
        return type_info[dt->been_outed].p; 
#endif
       }
       else
       {
        fprintf(dg_file,"%d",(int) dt->been_outed);
       }
       return NIL ;
    }
  
#if 0
    if ( depth_now >= max_depth )
    {
       if (gdb)
        fprintf( dg_file, "%d", STAB_SLONG ) ;
       return NIL ;
    }
    depth_now++ ;
#endif
  
    switch( dt->key )
      {
      case DIAG_TYPE_PTR:
      {
         DNTTPOINTER p = NIL;
         long non;
         diag_type pdt = dt->data.ptr.object ;
         if ( pdt->key == DIAG_TYPE_VARIETY )
         {
            long pn = out_sh_type( f_integer( pdt->data.var) );
            non = stab_ptrs[pn];
            if ( non==0 )
            {
             non = next_typen();
             stab_ptrs[pn] = non;
             if (xdb)
             {
#ifdef _SYMTAB_INCLUDED
                p = make_dnttentry(K_POINTER, type_info[pn].p, 32);
#endif
             }
             else
             {
                fprintf(dg_file,"%ld=*%ld",non,pn);
             }
            }
            else
            {
             if (xdb)
             {
#ifdef _SYMTAB_INCLUDED
                p = type_info[non].p;  
#endif
             }
             else
             {
                fprintf(dg_file,"%ld",non);
             }
            }
         }
         else
         {
            non = next_typen();
            if (xdb)
            {
#ifdef _SYMTAB_INCLUDED
             p = make_dnttentry(K_POINTER, out_dt_shape( dt->data.ptr.object ), 32);
#endif
            }
            else
            {
             fprintf(dg_file,"%ld=*",non);
             out_dt_shape( dt->data.ptr.object );
            }
         }
         dt->been_outed = non;
#ifdef _SYMTAB_INCLUDED
         type_info[non].p = p;
#endif
         last_type_sz = 32;
         set_stab_size(non);
         return p;
      }
  
      case DIAG_TYPE_ARRAY:
      {
         DNTTPOINTER indextype,elemtype,p=NIL;
#if 0
         long str = no( dt->data.array.stride );
#endif
         long lwb = no( dt->data.array.lower_b );
         long upb = no( dt->data.array.upper_b );
         diag_type index_type = dt->data.array.index_type ;
         diag_type element_type = dt->data.array.element_type ;
         long non = next_typen();
         dt->been_outed = non ;
         if (gdb)
         {
            fprintf(dg_file,"%ld=ar",non);
            out_dt_shape( index_type );
            fprintf (dg_file,";%ld;%ld;",lwb,upb);
         }
         else
         {
#ifdef _SYMTAB_INCLUDED
            indextype = make_dnttentry(K_SUBRANGE, 0, 0, lwb, upb, out_dt_shape( index_type ),
                                 last_type_sz);
#endif
         }
         elemtype = out_dt_shape( element_type );
         if (xdb)
         {
#ifdef _SYMTAB_INCLUDED
            unsigned long arraylength = (upb-lwb+1)<<2;
            unsigned long elemlength = last_type_sz>>3;
            p = make_dnttentry(K_ARRAY, 0, 0, 0, 1, 1, 0, 0, arraylength, indextype, elemtype, elemlength);
            type_info[non].p = p; 
#endif
         }
         last_type_sz *= ( upb-lwb+1 );
         set_stab_size(non);
         return p;
         break ;
      }

      case DIAG_TYPE_STRUCT:
      case DIAG_TYPE_UNION:
      {
         DNTTPOINTER p = NIL;
         int i;
         char su;
         shape s;
         long non = next_typen();
         diag_field_list fields;
#ifdef _SYMTAB_INCLUDED
         if (xdb)
            p = pos_of_dnttpointer( dt );
#endif           
         dt->been_outed = non;
         if ( dt->key == DIAG_TYPE_STRUCT )
         {
            fields = dt->data.t_struct.fields;
            s = dt->data.t_struct.tdf_shape;
            su = 's';
#ifdef _SYMTAB_INCLUDED
            p.word-=2;
#endif           
         } 
         else
         {
            fields = dt->data.t_union.fields;
            s = dt->data.t_union.tdf_shape;
            su = 'u';
#ifdef _SYMTAB_INCLUDED
            p.word--;
#endif           
         }
         if (xdb)
         {
#ifdef _SYMTAB_INCLUDED
            DNTTPOINTER lastfield = NIL;
            type_info[non].p = p; 
            for(i=0;i<fields->lastused;i++)
            {
             diag_field f = (fields->array)[i];
             unsigned long bitoffset = no( f->where );
             DNTTPOINTER type = out_dt_shape( f->field_type );
             lastfield = make_dnttentry(K_FIELD, vt_next, bitoffset, type, last_type_sz, lastfield);
             make_vtentry(f->field_name.ints.chars,0,0);
            }

            if ( lntt_next.word != p.word )
            {
             fprintf(stderr,"hppatrans warning: trans made an error whilst compiling XDB diagnostics tables\n");
            }

            if ( dt->key == DIAG_TYPE_STRUCT )
            {
             make_dnttentry(K_STRUCT, 0, lastfield, NIL, NIL, shape_size(s));
            }
            else
            {
             make_dnttentry(K_UNION, lastfield, shape_size(s));
            }
#endif
         }
         else
         {
            fprintf(dg_file,"%ld=%c%d",non,su,shape_size(s)/8);
            for(i=fields->lastused-1;i>=0;i--)
            {
             diag_field sf = (fields->array)[i];
             unsigned long offset = no( sf->where );
#if 0
                     if ( depth_now >= max_depth )
               return NIL;
             depth_now++;
#endif
             fprintf(dg_file,"%s:",sf->field_name.ints.chars);
             out_dt_shape( sf->field_type );
             fprintf(dg_file,",%ld,%ld;",offset,last_type_sz);
            }
            fprintf(dg_file,";");
         }
         last_type_sz = shape_size(s);
         set_stab_size(non);
         return p ;
      }
  
      case DIAG_TYPE_FLOAT:
      case DIAG_TYPE_VARIETY:
        {
           shape sha;
           if ( dt->key==DIAG_TYPE_VARIETY )
           {
            sha = f_integer(dt->data.var);
           }
           else
           {
            sha = f_floating(dt->data.f_var);
           }
           dt->been_outed = out_sh_type( sha );
           if (xdb)
           {
#ifdef _SYMTAB_INCLUDED
            return type_info[dt->been_outed].p;
#endif
           }
           else
           {
            fprintf (dg_file,"%ld",dt->been_outed);
           }
           return NIL;
        }
  
      case DIAG_TYPE_PROC:
        {
           diag_type result_type = dt->data.proc.result_type ;
           long non1 = next_typen();
           long non2 = next_typen();
           DNTTPOINTER p = NIL;
           dt->been_outed = non1;
           if (xdb)
           {
#ifdef _SYMTAB_INCLUDED
            p = make_dnttentry(K_POINTER, make_DNTTP_IMMEDIATE( T_FLABEL ), 32);
            type_info[non1].p = p;
#endif
           }
           else
           {
              fprintf ( dg_file, "%ld=*%ld=f", non1, non2 ) ;
           }
           out_dt_shape ( result_type ) ;
           last_type_sz = 32 ;
           set_stab_size ( non1 ) ;
           set_stab_size ( non2 ) ;
           return p;
        }
  
      case DIAG_TYPE_LOC:
        {
           /* +++ use qualifier which gives "const"/"volatile" */
           return out_dt_shape ( dt->data.loc.object ) ;
        }
  
      case DIAG_TYPE_NULL:
        {
           if (gdb)
            fprintf(dg_file,"%d",STAB_VOID);
           last_type_sz = 0;
           return NIL;
        }
  
      case DIAG_TYPE_BITFIELD:
        {
           long sz = dt->data.bitfield.no_of_bits.nat_val.small_nat ;
           last_type_sz = sz;
           if (xdb)
           {
#ifdef _SYMTAB_INCLUDED

            return type_info[STAB_SLONG].p;
#endif
           }
           else
           {
            fprintf (dg_file,"%d",STAB_SLONG);
           }
           return NIL;
        }

      case DIAG_TYPE_ENUM:
      {
#if 1
         /*  Currently tdfc (August 95) does not generate DIAG_TYPE_ENUM.
             Enable and test this when DIAG_TYPE_ENUM is generated.  */      

      /*
       * TypeDef: e EnumList ;            "Enumerated type (default size, 32 bits)"
       * EnumList:      Enum | EnumList Enum
       * Enum:          NAME : OrdValue , "Enumerated scalar description"
       * OrdValue:      INTEGER                 "Associated numeric value"
       */
         enum_values_list enumvals = dt->data.t_enum.values;
         enum_values *enumarr = (enumvals->array);
         int nvals = enumvals->len;
         char *nm = dt->data.t_enum.nme.ints.chars;
         int i;
         DNTTPOINTER p = NIL;
         long non;
         if (xdb)
         {
#ifdef _SYMTAB_INCLUDED
            DNTTPOINTER firstmem;
            if (nvals>0)
            {
             firstmem = lntt_next;
             firstmem.word+=2;
            }
            else
            {
             firstmem = NIL;
            }
            make_dnttentry(K_TAGDEF,(BITS)1,(BITS)1,vt_next,lntt_next);
            make_vtentry(nm,0,0);
            p = make_dnttentry(K_ENUM, firstmem, 32);
            for(i=0;i<nvals;i++)
            {
             DNTTPOINTER nextmem;
             if (i==nvals-1)
             {
                nextmem = NIL;
             }
             else
             {
                nextmem = lntt_next;
                nextmem.word+=2;
             }
             make_dnttentry(K_MEMENUM, vt_next, EXPINT(enumarr[i]->val), nextmem);
             make_vtentry(CSTRING(enumarr[i]->nme),0,0);
            }
#endif
         } 
         else
         {
            fprintf(dg_file,"e");
            for(i=0;i<nvals;i++)
            {
             fprintf(dg_file,"%s:%d,",CSTRING(enumarr[i]->nme), EXPINT(enumarr[i]->val));
            }
            fprintf(dg_file,";");
         }
         non = next_typen();
         dt->been_outed = non;
         type_info[non].p = p;
         last_type_sz = 32;
         set_stab_size(non);
         return p;
#else
         /* For now, simply output the base integer type */
         out_dt_shape(dt->data.t_enum.base_type);
         last_type_sz = 32;
#endif
         break;
      }

      default:
      {
         if (gdb)
            fprintf(dg_file,"%d",STAB_VOID);
         last_type_sz = 0 ;
         return NIL;
      }
    }
    return NIL ;
}


/*
    OUTPUT DIAGNOSTICS FOR A GLOBAL VARIABLE
*/

void stab_global 
    PROTO_N ( ( global, id, ext ) )
    PROTO_T ( exp global X char * id X bool ext )
{
  char *nm;
  diag_descriptor *dd = find_dd ( global ) ;

  if ( dd==NULL )
     return;
  nm = dd->data.id.nme.ints.chars;
  stabd ( find_file ( dd->data.id.whence.file->file.ints.chars ),
       ( long ) dd->data.id.whence.line_no.nat_val.small_nat
       , -N_DSLINE ) ;
  if (xdb)
  {
#ifdef _SYMTAB_INCLUDED
     if (ext)
      make_dnttentry(K_SVAR, 1, 0, 0, vt_next, (STATTYPE)nm, OUT_DT_SHAPE( dd->data.id.new_type ), 0, 0, GNTT);
      else
       make_dnttentry(K_SVAR, 0, 0, 0, vt_next, (STATTYPE)id, OUT_DT_SHAPE( dd->data.id.new_type ), 0, 0, LNTT);
      make_vtentry(nm,0,0);
#endif
  }
  else
  {
     fprintf(dg_file,"\t.stabs\t\"%s:%c", nm, ( ext ? 'G' : 'S' ) ) ;
     OUT_DT_SHAPE ( dd->data.id.new_type ) ;
     fprintf(dg_file,"\",%#x,0,%d,%s\n",( ext ? 0x24 : ((no(global)!=0)?0x26:0x28) ),
         dd->data.id.whence.line_no.nat_val.small_nat /*0*/,
         id
         ) ;
  }
  return ;
}


/*
    OUTPUT DIAGNOSTICS FOR A PROCEDURE
*/

void stab_proc 
    PROTO_N ( ( proc, id, public ) )
    PROTO_T ( exp proc X char * id X bool public )
{
   char *nm;
   diag_descriptor *dd = find_dd ( proc ) ;
   if ( dd == NULL )
      return ;
   stabd ( find_file ( dd->data.id.whence.file->file.ints.chars ) ,
       ( long ) dd->data.id.whence.line_no.nat_val.small_nat 
       ,0) ;
   nm = id;
   if (gdb)
      fprintf ( dg_file, "\t.stabs\t\"%s:%c",nm, ( public ? 'F' : 'f' ) ) ;
   OUT_DT_SHAPE ( dd->data.id.new_type->data.proc.result_type ) ;

   if (gdb)
      fprintf ( dg_file,"\",0x24,0,%ld,%s\n",currentlno,id);

   last_proc_lab = id;        /* id is passed from translate_capsule, 
                         so stays in scope while needed */
   if (xdb)
   {
#ifdef _SYMTAB_INCLUDED
      DNTTPOINTER retval;
      SLTPOINTER slt_prev;
      BITS varargs;
      VTPOINTER entry = is_vt_entry( currentfile );
      slt_prev = slt_next;
      make_sltentry(SLT_SRCFILE, 1, lntt_next); 
      make_dnttentry(K_SRCFILE, LANG_C, ( entry==VTNIL ? vt_next : entry ), slt_prev); 
      if ( entry==VTNIL )
       make_vtentry(fds[ currentfile ]->file.ints.chars,1,currentfile);

      slt_prev = slt_next;
      make_sltentry(SLT_FUNCTION, currentlno, lntt_next); 
      retval = make_DNTTP_IMMEDIATE(T_INT);
      varargs = (BITS) dd->data.id.new_type->data.proc.opt_args;
      if (strcmp(nm,"main")==0)
      {
       make_dnttentry(K_FUNCTION, (BITS)public, LANG_C, (BITS)0, (BITS)0,
                  varargs, (BITS)0, vt_next, vt_next+5, NIL, slt_prev,
                  (ADDRESS)"main", retval, (ADDRESS)"main",
                  (ADDRESS)"_main_end_");
       make_vtentry( "main",0,0 );
       make_vtentry( "_MAIN_",0,0 );
      }
      else
      {
       char *address = nm, *lowaddr = nm, hiaddr[128];
       sprintf(hiaddr,"_%s_end_",address);
       make_dnttentry(K_FUNCTION, (BITS)public, LANG_C, (BITS)0, (BITS)0,
                  varargs, (BITS)0, vt_next, VTNIL, NIL, slt_prev,
                  (ADDRESS)address, retval, (ADDRESS)lowaddr,
                  (ADDRESS)hiaddr);
       make_vtentry( nm,0,0 );
      }

      slt_prev = slt_next;
      make_sltentry(SLT_BEGIN, (BITS)currentlno, lntt_next);
      make_dnttentry(K_BEGIN, slt_prev);
#endif
   }

   return ;
}

#ifdef _SYMTAB_INCLUDED
void close_function_scope
    PROTO_N ( ( res_label ) )
    PROTO_T ( int res_label )
{
   SLTPOINTER slt_prev = slt_next;
   char address[128];
   sprintf(address,"L$$%d-%s",res_label,last_proc_lab);
   make_sltentry(SLT_EXIT, last_lno, (ADDRESS)address);
   make_sltentry(SLT_END, last_lno, lntt_next);
   make_dnttentry(K_END, K_BEGIN, slt_prev, last_DNTT_BEGIN_entry());
   slt_prev = slt_next;
   make_sltentry(SLT_END, last_lno, lntt_next);
   make_dnttentry(K_END, K_FUNCTION, slt_prev, last_DNTT_BEGIN_entry());
}
#endif

/*
    OUTPUT DIAGNOSTICS FOR A LOCAL VARIABLE
*/

/* ARGSUSED */ void stab_local
    PROTO_N ( ( nm, dt, ldid, disp, findex ) )
    PROTO_T ( char *nm X diag_type dt X exp ldid X long disp X long findex )
{
    exp id = son (ldid) ;
    disp += boff(id).offset ;
    again:
    if ( name(id) == ident_tag ) 
    {
       if ( ( props(id) & defer_bit ) == 0 )
       {
        /* +++ add assembler comment to say which reg is being used */
        if ( isparam(id) )
        {
           if (xdb)
           {
#ifdef _SYMTAB_INCLUDED
            /* Seems as if parameters are treated like locals by xdb  */
#if 0
            make_dnttentry(K_FPARAM, 0, 0, 0, 0, vt_next, disp, OUT_DT_SHAPE( dt ), NIL);
#endif
            make_dnttentry(K_DVAR, 0, 0, 0, vt_next, disp, OUT_DT_SHAPE( dt ), 0);
            make_vtentry(nm,0,0);
#endif
           }
           else
           {
            fprintf( dg_file, "\t.stabs\t\"%s:p", nm ) ;
            OUT_DT_SHAPE ( dt ) ;  
            fprintf( dg_file, "\",0xa0,0,%d,%ld\n",
#if 0
                   shape_size ( sh ( son ( id ) ) ) / 8,
#else
                   0,
#endif
                   disp+(frame_sz>>3) ) ;
           }
           return ;
        }
        else
        {
           if (xdb)
           {
#ifdef _SYMTAB_INCLUDED
            make_dnttentry(K_DVAR, 0, 0, 0, vt_next, disp, 
                         OUT_DT_SHAPE( dt ),                           
                         0);
            make_vtentry(nm,0,0);
#endif
           }
           else
           {
            fprintf ( dg_file, "\t.stabs\t\"%s:", nm ) ;
            OUT_DT_SHAPE ( dt ) ;
            fprintf (dg_file,"\",0x80,0,%ld,%ld\n",currentlno,disp+(frame_sz>>3)) ;
           }
           return ;
        }
       }
       else
       {
        exp sn = son(id) ;
        long d = disp ;
        while ( sn != nilexp )
        {
           switch ( name(sn) )
           {
            case name_tag:
            {
               disp = d + no(sn) ;
               id = son(sn) ;
               if ( isvar(id) )
                  dt = dt->data.ptr.object ;
               goto again ;
            }
            case reff_tag:
            {
               d += no(sn) ;
               sn = son(sn) ;
               break ;
            }
            case cont_tag: 
            {
               sn = son(sn) ;
               break ;
            }
            default:
            {
               return ;
            }
           }
        }
       }
    }
    return ;
}


/*
    DEAL WITH BASIC TYPES
*/

void stab_types 
    PROTO_Z ()
{
    no_type_info = NO_STABS ;
    type_info = ( type_info_t * ) xmalloc ( NO_STABS * sizeof ( type_info_t ) ) ;
    if (xdb)
    {
#ifdef _SYMTAB_INCLUDED
       type_info[STAB_SCHAR].p = make_DNTTP_IMMEDIATE( T_CHAR, 8 ) ;
       type_info[STAB_UCHAR].p = make_DNTTP_IMMEDIATE( T_UNS_INT, 8 ) ;
       type_info[STAB_SSHRT].p = make_DNTTP_IMMEDIATE( T_INT, 16 ) ;
       type_info[STAB_USHRT].p = make_DNTTP_IMMEDIATE( T_UNS_INT, 16 ) ;
       type_info[STAB_SLONG].p = make_DNTTP_IMMEDIATE( T_LONG, 32 ) ;
       type_info[STAB_ULONG].p = make_DNTTP_IMMEDIATE( T_UNS_LONG, 32 ) ;
       type_info[STAB_FLOAT].p = make_DNTTP_IMMEDIATE( T_REAL, 32 ) ;
       type_info[STAB_DBL].p   = make_DNTTP_IMMEDIATE( T_REAL, 64 ) ;
       type_info[STAB_LDBL].p  = make_DNTTP_IMMEDIATE( T_REAL, 128 ) ;
#endif
    }
    else
    {
       fputs ( "\t.stabs\t\"int:t1=r1;-2147483648;2147483647;\",0x80,0,0,0\n",
          dg_file ) ;
       fputs ( "\t.stabs\t\"short int:t2=r1;-32768;32767;\",0x80,0,0,0\n",
          dg_file ) ;
       fputs ( "\t.stabs\t\"short unsigned int:t3=r1;0;65535;\",0x80,0,0,0\n",
          dg_file ) ;
       fputs ( "\t.stabs\t\"char:t4=r4;0;127;\",0x80,0,0,0\n",
          dg_file ) ;
       fputs ( "\t.stabs\t\"signed char:t5=r1;-128;127;\",0x80,0,0,0\n",
          dg_file ) ;
       fputs ( "\t.stabs\t\"unsigned char:t6=r1;0;255;\",0x80,0,0,0\n",
          dg_file ) ;
       fputs ( "\t.stabs\t\"long int:t7=r1;-2147483648;2147483647;\",0x80,0,0,0\n",
          dg_file ) ;
       fputs ( "\t.stabs\t\"unsigned int:t8=r1;0;-1;\",0x80,0,0,0\n",
          dg_file ) ;
       fputs ( "\t.stabs\t\"long unsigned int:t9=r1;0;-1;\",0x80,0,0,0\n",
          dg_file ) ;
       fputs ( "\t.stabs\t\"float:t10=r1;4;0;\",0x80,0,0,0\n",
          dg_file ) ;
       fputs ( "\t.stabs\t\"double:t11=r1;8;0;\",0x80,0,0,0\n",
          dg_file ) ;
       fprintf ( dg_file,"\t.stabs\t\"long double:t12=r1;8;0;\",0x80,0,0,0\n");
       fputs ( "\t.stabs\t\"void:t13=13\",0x80,0,0,0\n",
          dg_file ) ;
    }
    type_info [0].sz = 0 ;
    type_info [1].sz = 32 ;
    type_info [2].sz = 16 ;
    type_info [3].sz = 16 ;
    type_info [4].sz = 8 ;
    type_info [5].sz = 8 ;
    type_info [6].sz = 8 ;
    type_info [7].sz = 32 ;
    type_info [8].sz = 32 ;
    type_info [9].sz = 32 ;
    type_info [10].sz = 32 ;
    type_info [11].sz = 64 ;
    type_info [12].sz = DOUBLE_SZ ;
    type_info [13].sz = 0 ;
    return ;
}


/*
    DEAL WITH STRUCTURE AND UNION TAGS
*/

void stab_tagdefs 
    PROTO_Z ()
{
    diag_tagdef **di = unit_ind_diagtags ;
    unsigned int n = unit_no_of_diagtags ;
    int i;

    for ( i = 0 ; i < n ; i++ )
    {
      diag_type d = di [i]->d_type ;
      switch ( d->key )
      {
          case DIAG_TYPE_STRUCT :
          case DIAG_TYPE_UNION :
          {
            char *nme ;
            if ( d->key == DIAG_TYPE_STRUCT ) {
                nme = d->data.t_struct.nme.ints.chars ;
            } else {
                nme = d->data.t_union.nme.ints.chars ;
            }

            if ( nme && *nme )
            {
                if (gdb)
                   fprintf ( dg_file, "\t.stabs\t\"%s:", nme ) ;
            }
            else
            if ( d->key == DIAG_TYPE_STRUCT )
            {
/*             static int s_count = 0 ; gcc complains */
               if (gdb)
                  fprintf ( dg_file, "\t.stabs\t\"s:") ;
            }
            else
            {
/*             static int u_count = 0 ; gcc complains */
               if (gdb)
                  fprintf ( dg_file, "\t.stabs\t\"u:") ;
            }
            if ( d->been_outed && 0 )
            {
               if (gdb)
                  fprintf ( dg_file, "%d", (int)d->been_outed ) ;
            }
            else
            {
               if (gdb)
                  fprintf ( dg_file, "T" ) ;
               OUT_DT_SHAPE ( d ) ;
            }
            if (gdb)
               fprintf ( dg_file, "\",0x80,0,0,0\n" ) ;
            break ;
          }
          case DIAG_TYPE_UNINIT:
          case DIAG_TYPE_INITED:
            assert(0);
          default:
            break;
      }
    }
    return ;
}


/*
    DEAL WITH TYPEDEFS
*/

void stab_typedefs 
    PROTO_Z ()
{
    diag_descriptor *di = unit_diagvar_tab.array ;
    int i, n = unit_diagvar_tab.lastused ;
    for ( i = 0 ; i < n ; i++ ) {
      if ( di [i].key == DIAG_TYPEDEF_KEY )
      {
          long non = next_typen () ;
          if (gdb)
             fprintf ( dg_file, "\t.stabs\t\"%s:t%ld=",
                  di [i].data.typ.nme.ints.chars, non ) ;
          OUT_DT_SHAPE ( di [i].data.typ.new_type ) ;
          if (gdb)
             fprintf ( dg_file, "\",0x80,0,0,0\n" ) ;
      }
    }
    return ;
}

Generated by  Doxygen 1.6.0   Back to index