path: root/gas/config/vms/vms-dbg.c

#include <stdio.h>
#include "as.h"
#include "struc-symbol.h"
#include "symbols.h"
#include "objrecdef.h"
#include <stab.h>

/* This file contains many of the routines needed to output debugging info into
 * the object file that the VMS debugger needs to understand symbols.  These
 * routines are called very late in the assembly process, and thus we can be
 * fairly lax about changing things, since the GSD and the TIR sections have
 * already been output.
 */

/* We need this info to cross correlate between the stabs def for a symbol and
 * the actual symbol def.  The actual symbol def contains the psect number and
 * offset, which is needed to declare a variable to the debugger for global
 * and static variables
 */
struct VMS_Symbol {
	struct VMS_Symbol *Next;
	struct symbol *Symbol;
	int Size;
	int Psect_Index;
	int Psect_Offset;
	};
extern struct VMS_Symbol *VMS_Symbols;

enum advanced_type {BASIC,POINTER,ARRAY,ENUM,STRUCT,UNION,FUNCTION,VOID,UNKNOWN};

/* this structure contains the information from the stabs directives, and the
 * information is filled in by VMS_typedef_parse.  Everything that is needed
 * to generate the debugging record for a given symbol is present here.
 * This could be done more efficiently, using nested struct/unions, but for now
 * I am happy that it works.
 */
struct VMS_DBG_Symbol{
	struct VMS_DBG_Symbol * next;
	enum advanced_type advanced;	/* description of what this is */
	int dbx_type;	/* this record is for this type */
	int type2;	/* For advanced types this is the type referred to.
				i.e. the type a pointer points to, or the type
				of object that makes up an array */
	int VMS_type;	/* Use this type when generating a variable def */
	int index_min;	/* used for arrays - this will be present for all */
	int index_max;	/* entries, but will be meaningless for non-arrays */
	int data_size;	/* size in bytes of the data type.  For an array, this
			   is the size of one element in the array */
	int struc_numb; /* Number of the structure/union/enum - used for ref */
};

struct VMS_DBG_Symbol *VMS_Symbol_type_list={(struct VMS_DBG_Symbol*) NULL};

/* we need this structure to keep track of forward references to
 * struct/union/enum that have not been defined yet.  When they are ultimately
 * defined, then we can go back and generate the TIR commands to make a back
 * reference.
 */

struct forward_ref{
	struct forward_ref * next;
	int dbx_type;
	int struc_numb;
	char resolved;
	};

struct forward_ref * f_ref_root={(struct forward_ref*) NULL};

static char * symbol_name;
static structure_count=0;

/* this routine converts a number string into an integer, and stops when it
 * sees an invalid character the return value is the address of the character 
 * just past the last character read.  No error is generated.
 */
static char * cvt_integer(char* str,int * rtn){
	int ival, neg;
		neg = *str == '-' ? ++str, -1 : 1;
		ival=0;	/* first get the number of the type for dbx */
		while((*str <= '9') && (*str >= '0'))
			ival = 10*ival + *str++ -'0';
	*rtn = neg*ival;
	return str;
}

/* this routine fixes the names that are generated by C++, ".this" is a good
 * example.  The period does not work for the debugger, since it looks like
 * the syntax for a structure element, and thus it gets mightily confused
 */
static fix_name(char* pnt){
	for( ;*pnt != 0; pnt++){
	if(*pnt == '.') *pnt = '$';
	};
}

/* this routine is used to compare the names of certain types to various
 * fixed types that are known by the debugger.
 */
#define type_check(x)  !strcmp( symbol_name , x )

/* When defining a structure, this routine is called to find the name of
 * the actual structure.  It is assumed that str points to the equal sign
 * in the definition, and it moves backward until it finds the start of the
 * name.  If it finds a 0, then it knows that this structure def is in the
 * outermost level, and thus symbol_name points to the symbol name.
 */
static char* get_struct_name(char* str){
	char* pnt;
	pnt=str;
	while((*pnt != ':') && (*pnt != '\0')) pnt--;
	if(*pnt == '\0') return symbol_name;
	*pnt-- = '\0';
	while((*pnt != ';') && (*pnt != '=')) pnt--;
	if(*pnt == ';') return pnt+1;
	while((*pnt < '0') || (*pnt > '9')) pnt++;
	while((*pnt >= '0') && (*pnt <= '9')) pnt++;
	return pnt;
}	
/* search symbol list for type number dbx_type.  Return a pointer to struct */
static struct VMS_DBG_Symbol* find_symbol(int dbx_type){
	struct VMS_DBG_Symbol* spnt;
	spnt=VMS_Symbol_type_list;
	while (spnt!=(struct VMS_DBG_Symbol*) NULL){
		if(spnt->dbx_type==dbx_type) break;
		spnt=spnt->next;};
	if(spnt==(struct VMS_DBG_Symbol*) NULL) return 0;/*Dunno what this is*/
	return spnt;
}


/* Many good programmers cringe when they see a fixed size array - since I am
 * using this to generate the various descriptors for the data types present,
 * you might argue that the descriptor could overflow the array for a
 * complicated variable, and then I am in deep doo-doo.  My answer to this is
 * that the debugger records that we write have all sorts of length bytes
 * stored in them all over the place, and if we exceed 127 bytes (since the top
 * bit indicates data, rather than a command), we are dead anyhow.  So I figure
 * why not do this the easy way.  Besides, to get 128 bytes, you need something
 * like an array with 10 indicies, or something like
 *       char **************************************** var; 
 * Lets get real.  If some idiot writes programs like that he/she gets what
 * they deserve.  (It is possible to overflow the record with a somewhat
 * simpler example, like: int (*(*(*(*(*(* sarr6)[1])[1])[2])[3])[4])[5];
 * but still...).  And if someone in the peanut gallery wants to know "What
 * does VAX-C do with something like this?", I will tell you.  It crashes.
 * At least this code has the good sense to convert it to *void.
 * In practice, I do not think that this presents too much of a problem, since
 * struct/union/enum all use defined types, which sort of terminate the
 * definition.  It occurs to me that we could possibly do the same thing with
 * arrays and pointers, but I don't know quite how it would be coded.
 *
 * And now back to the regularly scheduled program...
 */
#define MAX_DEBUG_RECORD 128
static char Local[MAX_DEBUG_RECORD]; /* buffer for variable descriptor */
static int Lpnt;		/* index into Local */
static char Asuffix[MAX_DEBUG_RECORD]; /* buffer for array descriptor */
static int Apoint;	/* index into Asuffix */
static char overflow;	/* flag to indicate we have written too much*/
static int total_len;	/* used to calculate the total length of variable
			descriptor plus array descriptor - used for len byte*/
static int struct_number;	/* counter used to assign indexes to struct
					unions and enums */

/* this routine puts info into either Local or Asuffix, depending on the sign
 * of size.  The reason is that it is easier to build the variable descriptor
 * backwards, while the array descriptor is best built forwards.  In the end
 * they get put together, if there is not a struct/union/enum along the way
 */
push(int value, int size){
	char * pnt;
	int i;
	int size1;
	long int val;
	val=value;
	pnt=(char*) &val;
	size1 = size;
	if (size < 0) {size1 = -size; pnt += size1-1;};
	if(size < 0)
	for(i=0;i<size1;i++) {
		Local[Lpnt--] = *pnt--;
		if(Lpnt < 0) {overflow = 1; Lpnt = 1;};}
	else for(i=0;i<size1;i++){
		 Asuffix[Apoint++] = *pnt++;
		 if(Apoint >= MAX_DEBUG_RECORD) 
			{overflow = 1; Apoint =MAX_DEBUG_RECORD-1;};}
}

/* this routine generates the array descriptor for a given array */
static array_suffix(struct VMS_DBG_Symbol* spnt2){
	struct VMS_DBG_Symbol * spnt;
	struct VMS_DBG_Symbol * spnt1;
	int rank;
	int total_size;
	int i;
	rank=0;
	spnt=spnt2;
	while(spnt->advanced != ARRAY) {
		spnt=find_symbol(spnt->type2);
		if(spnt == (struct VMS_DBG_Symbol *) NULL) return;};
	spnt1=spnt;
	spnt1=spnt;
	total_size= 1;
	while(spnt1->advanced == ARRAY) {rank++;
		total_size *= (spnt1->index_max - spnt1->index_min +1);
		spnt1=find_symbol(spnt1->type2);};
	total_size = total_size * spnt1->data_size;
	push(spnt1->data_size,2);
	if(spnt1->VMS_type == 0xa3) push(0,1);
			else push(spnt1->VMS_type,1);
	push(4,1);
	for(i=0;i<6;i++) push(0,1);
	push(0xc0,1);
	push(rank,1);
	push(total_size,4);
	push(0,4);
	spnt1=spnt;
	while(spnt1->advanced == ARRAY) {
		push(spnt1->index_max - spnt1->index_min+1,4);
		spnt1=find_symbol(spnt1->type2);};
	spnt1=spnt;
	while(spnt1->advanced == ARRAY) {
		push(spnt1->index_min,4);
		push(spnt1->index_max,4);
		spnt1=find_symbol(spnt1->type2);};
}

/* this routine generates the start of a variable descriptor based upon
 * a struct/union/enum that has yet to be defined.  We define this spot as
 * a new location, and save four bytes for the address.  When the struct is
 * finally defined, then we can go back and plug in the correct address
*/
static new_forward_ref(int dbx_type){
	struct forward_ref* fpnt;
	fpnt = (struct forward_ref*) malloc(sizeof(struct forward_ref));
	fpnt->next = f_ref_root;
	f_ref_root = fpnt;
	fpnt->dbx_type = dbx_type;
	fpnt->struc_numb = ++structure_count;
	fpnt->resolved = 'N';
	push(3,-1);
	total_len = 5;
	push(total_len,-2);
	struct_number = - fpnt->struc_numb;
}

/* this routine generates the variable descriptor used to describe non-basic
 * variables.  It calls itself recursively until it gets to the bottom of it
 * all, and then builds the descriptor backwards.  It is easiest to do it this
 *way since we must periodically write length bytes, and it is easiest if we know
 *the value when it is time to write it.
 */
static int gen1(struct VMS_DBG_Symbol * spnt,int array_suffix_len){
	struct VMS_DBG_Symbol * spnt1;
	int i;
	switch(spnt->advanced){
	case VOID:
		push(DBG$C_VOID,-1);
		total_len += 1;
		push(total_len,-2);
		return 0;
	case BASIC:
	case FUNCTION:
		if(array_suffix_len == 0) {
				push(spnt->VMS_type,-1);
				push(DBG$C_BASIC,-1);		
				total_len = 2;
				push(total_len,-2);
				return 1;};
		push(0,-4);
		push(0xfa02,-2);		
		total_len = -2;
		return 1;
	case STRUCT:
	case UNION:
	case ENUM:
		struct_number=spnt->struc_numb;
		if(struct_number < 0) {
			new_forward_ref(spnt->dbx_type);
			return 1;
		}
		push(DBG$C_STRUCT,-1);
		total_len = 5;
		push(total_len,-2);
		return 1;
	case POINTER:
		spnt1=find_symbol(spnt->type2);
		i=1;
		if(spnt1 == (struct VMS_DBG_Symbol *) NULL)	
			new_forward_ref(spnt->type2);
		else  i=gen1(spnt1,0);
		if(i){ /* (*void) is a special case, do not put pointer suffix*/
		  push(DBG$C_POINTER,-1);
		  total_len += 3;
		  push(total_len,-2);
		};
		return 1;
	case ARRAY:
		spnt1=spnt;
		while(spnt1->advanced == ARRAY)
			{spnt1 = find_symbol(spnt1->type2);
			if(spnt1 == (struct VMS_DBG_Symbol *) NULL) {
			    printf("gcc-as warning(debugger output):");
			    printf("Forward reference error, dbx type %d\n",
					spnt->type2);
			    return;}
			};
/* It is too late to generate forward references, so the user gets a message.
 * This should only happen on a compiler error */
		i=gen1(spnt1,1);
		i=Apoint;
		array_suffix(spnt);
		array_suffix_len = Apoint - i;
		switch(spnt1->advanced){
		case BASIC:
		case FUNCTION:
			break;
		default:
			push(0,-2);
			total_len += 2;
			push(total_len,-2);
			push(0xfa,-1);
			push(0x0101,-2);
			push(DBG$C_COMPLEX_ARRAY,-1);
		};
		total_len += array_suffix_len + 8;
		push(total_len,-2);			
	};
}

/* this generates a suffix for a variable.  If it is not a defined type yet,
 * then dbx_type contains the type we are expecting so we can generate a
 * forward reference.  This calls gen1 to build most of the descriptor, and
 * then it puts the icing on at the end.  It then dumps whatever is needed
 * to get a complete descriptor (i.e. struct reference, array suffix ).
 */
static generate_suffix(struct VMS_DBG_Symbol * spnt,int dbx_type){
	int ilen;
	int i;
	char pvoid[6] = {5,0xaf,0,1,0,5};
	struct VMS_DBG_Symbol * spnt1;
	Apoint=0;
	Lpnt =MAX_DEBUG_RECORD-1;
	total_len=0;
	struct_number = 0;
	overflow = 0;
	if(spnt == (struct VMS_DBG_Symbol*) NULL)
		new_forward_ref(dbx_type);
	else{
		if(spnt->VMS_type != 0xa3) return 0; /* no suffix needed */
		gen1(spnt,0);
	};
	push(0x00af,-2);
	total_len += 4;
	push(total_len,-1);
/* if the variable descriptor overflows the record, output a descriptor for
 * a pointer to void.
 */
	if((total_len >= MAX_DEBUG_RECORD) || overflow) {
		 printf(" Variable descriptor %d too complicated. Defined as *void ",spnt->dbx_type);
		 VMS_Store_Immediate_Data(pvoid, 6, OBJ$C_DBG);
		  return;
		};		
	i=0;
	while(Lpnt < MAX_DEBUG_RECORD-1) Local[i++] = Local[++Lpnt];
	Lpnt = i; 
/* we use this for a reference to a structure that has already been defined */
	if(struct_number > 0){
		 VMS_Store_Immediate_Data(Local, Lpnt, OBJ$C_DBG);Lpnt=0;
		 VMS_Store_Struct(struct_number);}; 
/* we use this for a forward reference to a structure that has yet to be
*defined.  We store four bytes of zero to make room for the actual address once
* it is known
*/
	if(struct_number < 0){
		 struct_number = -struct_number;
		  VMS_Store_Immediate_Data(Local, Lpnt,OBJ$C_DBG);Lpnt=0;
		  VMS_Def_Struct(struct_number);
		 for(i=0;i<4;i++) Local[Lpnt++] = 0;
		 VMS_Store_Immediate_Data(Local, Lpnt, OBJ$C_DBG);Lpnt=0;
		  };
	i=0;
	while(i<Apoint) Local[Lpnt++] = Asuffix[i++];
	if(Lpnt != 0)
	VMS_Store_Immediate_Data(Local, Lpnt, OBJ$C_DBG);
	Lpnt=0;
 }

/* This routine generates a symbol definition for a C sybmol for the debugger.
 * It takes a psect and offset for global symbols - if psect < 0, then this is
 * a local variable and the offset is relative to FP.  In this case it can
 * be either a variable (Offset < 0) or a parameter (Offset > 0).
 */
VMS_DBG_record(struct VMS_DBG_Symbol* spnt,int Psect,int  Offset, char* Name)
{
	char* pnt;
	int j;
	int maxlen;
	int i=0;
	if(Psect < 0) {	/* this is a local variable, referenced to SP */
	  maxlen=7+strlen(Name);
	  Local[i++] = maxlen;
	  Local[i++]=spnt->VMS_type;
	  if(Offset > 0) Local[i++] = DBG$C_FUNCTION_PARAMETER;
		else Local[i++] = DBG$C_LOCAL_SYM;
	  pnt=(char*) &Offset;
	  for(j=0;j<4;j++) Local[i++]=*pnt++; /* copy the offset */
	} else {
	  maxlen=7+strlen(Name); /* symbols fixed in memory */
	  Local[i++]=7+strlen(Name);
	  Local[i++]=spnt->VMS_type;
	  Local[i++]=1;
	  VMS_Store_Immediate_Data(Local, i, OBJ$C_DBG); i=0;
	  VMS_Set_Data(Psect,Offset,OBJ$C_DBG,0);
	}
	Local[i++]=strlen(Name);
	pnt=Name;
	fix_name(pnt);	/* if there are bad characters in name, convert them */
	while(*pnt!='\0') Local[i++]=*pnt++;
	VMS_Store_Immediate_Data(Local, i, OBJ$C_DBG);
	if(spnt->VMS_type == DBG$C_ADVANCED_TYPE) generate_suffix(spnt,0);
}


/* This routine parses the stabs entries in order to make the definition
 * for the debugger of local symbols and function parameters
 */
int VMS_local_stab_Parse(symbolS * sp){
	char *pnt;
	char *pnt1;
	char *str;
	struct VMS_DBG_Symbol* spnt;
   	struct VMS_Symbol *	vsp;
	int dbx_type;
	int VMS_type;
	dbx_type=0;
	str=sp->sy_nlist.n_un.n_name;
	pnt=(char*) strchr(str,':');
	if(pnt==(char*) NULL) return;	/* no colon present */
	pnt1=pnt++;	/* save this for later, and skip colon */
	if(*pnt == 'c') return 0;	/* ignore static constants */
/* there is one little catch that we must be aware of.  Sometimes function
 * parameters are optimized into registers, and the compiler, in its infiite
 * wisdom outputs stabs records for *both*.  In general we want to use the
 * register if it is present, so we must search the rest of the symbols for 
 * this function to see if this parameter is assigned to a register.
 */
	{
	char *str1;
	char *pnt2;
	symbolS * sp1;
	if(*pnt == 'p'){
	  for(sp1 = symbol_next(sp); sp1; sp1 = symbol_next(sp1)) {
	    if ((sp1->sy_nlist.n_type & N_STAB) == 0) continue;
	    if((unsigned char)sp1->sy_nlist.n_type == N_FUN) break;
	    if((unsigned char)sp1->sy_nlist.n_type != N_RSYM) continue;
	    str1=sp1->sy_nlist.n_un.n_name;	/* and get the name */
	    pnt2=str;
	    while(*pnt2 != ':') {
		if(*pnt2 != *str1) break;
		pnt2++; str1++;};
	    if((*str1 != ':') || (*pnt2 != ':') ) continue;
	    return;	/* they are the same!  lets skip this one */
	  }; /* for */
/* first find the dbx symbol type from list, and then find VMS type */
	  pnt++;	/* skip p in case no register */
	};/* if */ }; /* p block */
	pnt = cvt_integer( pnt, &dbx_type);
	spnt = find_symbol(dbx_type);
	if(spnt==(struct VMS_DBG_Symbol*) NULL) return 0;/*Dunno what this is*/
	*pnt1='\0';
	VMS_DBG_record(spnt,-1,sp->sy_nlist.n_value,str);
	*pnt1=':';	/* and restore the string */
	return 1;
}

/* this routine parses a stabs entry to find the information required to define
 * a variable.  It is used for global and static variables. 
 * Basically we need to know the address of the symbol.  With older versions
 * of the compiler, const symbols are
 * treated differently, in that if they are global they are written into the
 * text psect.  The global symbol entry for such a const is actually written
 * as a program entry point (Yuk!!), so if we cannot find a symbol in the list
 * of psects, we must search the entry points as well.  static consts are even
 * harder, since they are never assigned a memory address.  The compiler passes
 * a stab to tell us the value, but I am not sure what to do with it.
 */
static gave_compiler_message = 0;

static int VMS_stab_parse(symbolS * sp,char expected_type,
	int type1,int type2,int Text_Psect){
	char *pnt;
	char *pnt1;
	char *str;
	symbolS * sp1;
	struct VMS_DBG_Symbol* spnt;
   	struct VMS_Symbol *	vsp;
	int dbx_type;
	int VMS_type;
	dbx_type=0;
	str=sp->sy_nlist.n_un.n_name;
	pnt=(char*) strchr(str,':');
	if(pnt==(char*) NULL) return;	/* no colon present */
	pnt1=pnt;	/* save this for later*/
	pnt++;
	if(*pnt==expected_type){
		pnt = cvt_integer(pnt+1,&dbx_type);
		spnt = find_symbol(dbx_type);
		if(spnt==(struct VMS_DBG_Symbol*) NULL) return 0;/*Dunno what this is*/
/* now we need to search the symbol table to find the psect and offset for
 * this variable.
 */
	*pnt1='\0';
	vsp=VMS_Symbols;
	while(vsp != (struct VMS_Symbol*) NULL) 
	  {pnt=vsp->Symbol->sy_nlist.n_un.n_name;
	   if(pnt!=(char*) NULL)  if(*pnt++ == '_') 
/* make sure name is the same, and make sure correct symbol type */
	   if((strlen(pnt) == strlen(str)) && (strcmp(pnt,str)==0) 
		&& ((vsp->Symbol->sy_type == type1) ||
		(vsp->Symbol->sy_type == type2))) break;
			vsp=vsp->Next;};
		if(vsp != (struct VMS_Symbol*) NULL){
	    VMS_DBG_record(spnt,vsp->Psect_Index,vsp->Psect_Offset,str);
		*pnt1=':';	/* and restore the string */
		return 1;};
/* the symbol was not in the symbol list, but it may be an "entry point"
   if it was a constant */
	   for(sp1 = symbol_rootP; sp1; sp1 = symbol_next(sp1)) {
		  /*
		   *	Dispatch on STAB type
		   */
		  if(sp1->sy_type != (N_TEXT | N_EXT) && sp1->sy_type!=N_TEXT)
		      continue;
		  pnt = sp1->sy_nlist.n_un.n_name;
		  if(*pnt == '_') pnt++;
		  if(strcmp(pnt,str) == 0){
			if(!gave_compiler_message && expected_type=='G'){
printf("***Warning - the assembly code generated by the compiler has placed\n");
printf("global constant(s) in the text psect.  These will not be available to\n");
printf("other modules, since this is not the correct way to handle this. You\n");
printf("have two options: 1) get a patched compiler that does not put global\n");
printf("constants in the text psect, or 2) remove the 'const' keyword from\n");
printf("definitions of global variables in your source module(s).  Don't say\n");
printf("I didn't warn you!");
gave_compiler_message = 1;};
				VMS_DBG_record(spnt,
	 			Text_Psect,
	 			sp1->sy_nlist.n_value,
	 			str);
	 		*pnt1=':';
	 		*(sp1->sy_nlist.n_un.n_name) = 'L';
					/* fool assembler to not output this
					 * as a routine in the TBT */
			return 1;};
	    };
	};
	*pnt1=':';	/* and restore the string */
	return 0;
}


VMS_GSYM_Parse(symbolS * sp,int Text_Psect){ /* Global variables */
	VMS_stab_parse(sp,'G',(N_UNDF | N_EXT),(N_DATA | N_EXT),Text_Psect);
}


VMS_LCSYM_Parse(symbolS * sp,int Text_Psect){/* Static symbols - uninitialized */
	VMS_stab_parse(sp,'S',N_BSS,-1,Text_Psect);
}

VMS_STSYM_Parse(symbolS * sp,int Text_Psect){ /*Static symbols - initialized */
	VMS_stab_parse(sp,'S',N_DATA,-1,Text_Psect);
}


/* for register symbols, we must figure out what range of addresses within the
 * psect are valid. We will use the brackets in the stab directives to give us
 * guidance as to the PC range that this variable is in scope.  I am still not
 * completely comfortable with this but as I learn more, I seem to get a better
 * handle on what is going on.
 * Caveat Emptor.
 */
VMS_RSYM_Parse(symbolS * sp,symbolS * Current_Routine,int Text_Psect){
	char* pnt;
	char* pnt1;
	char* str;
	int dbx_type;
	struct VMS_DBG_Symbol* spnt;
	int j;
	int maxlen;
	int i=0;
	int bcnt=0;
	int Min_Offset=-1;	/* min PC of validity */
	int Max_Offset=0; /* max PC of validity */
	symbolS * symbolP;
	   for(symbolP = sp; symbolP; symbolP = symbol_next(symbolP)) {
		  /*
		   *	Dispatch on STAB type
		   */
		  switch((unsigned char)symbolP->sy_type) {
		     case N_LBRAC:
				if(bcnt++==0) Min_Offset = symbolP->sy_nlist.n_value;
				break;
		     case N_RBRAC:
				if(--bcnt==0) Max_Offset = 
					symbolP->sy_nlist.n_value-1;
				break;
 		  }
	   if((Min_Offset != -1) && (bcnt == 0)) break;
	   if((unsigned char)symbolP->sy_type == N_FUN) break;
 	   }
/* check to see that the addresses were defined.  If not, then there were no
 * brackets in the function, and we must try to search for the next function
 * Since functions can be in any order, we should search all of the symbol list
 * to find the correct ending address. */
	if(Min_Offset == -1){
	  int Max_Source_Offset;
	  int This_Offset;
	  Min_Offset = sp->sy_nlist.n_value;
	   for(symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
		  /*
		   *	Dispatch on STAB type
		   */
		  This_Offset = symbolP->sy_nlist.n_value;
		  switch(symbolP->sy_type) {
 		     case N_TEXT | N_EXT:
			if((This_Offset > Min_Offset) && (This_Offset < Max_Offset))
					Max_Offset = This_Offset;
				break;
		     case N_SLINE:
			if(This_Offset > Max_Source_Offset)
				Max_Source_Offset=This_Offset;
 		  }
 	   }
/* if this is the last routine, then we use the PC of the last source line
 * as a marker of the max PC for which this reg is valid */
	  if(Max_Offset == 0x7fffffff) Max_Offset = Max_Source_Offset;
	};
	dbx_type=0;
	str=sp->sy_nlist.n_un.n_name;
	pnt=(char*) strchr(str,':');
	if(pnt==(char*) NULL) return;	/* no colon present */
	pnt1=pnt;	/* save this for later*/
	pnt++;
	if(*pnt!='r') return 0;
	pnt = cvt_integer( pnt+1, &dbx_type);
	spnt = find_symbol(dbx_type);
	if(spnt==(struct VMS_DBG_Symbol*) NULL) return 0;/*Dunno what this is yet*/
	*pnt1='\0';
	maxlen=25+strlen(sp->sy_nlist.n_un.n_name);
	Local[i++]=maxlen;
	Local[i++]=spnt->VMS_type;
	Local[i++]=0xfb;
	Local[i++]=strlen(sp->sy_nlist.n_un.n_name)+1;
	Local[i++]=0x00;
	Local[i++]=0x00;
	Local[i++]=0x00;
	Local[i++]=strlen(sp->sy_nlist.n_un.n_name);
	pnt=sp->sy_nlist.n_un.n_name;
	fix_name(pnt);	/* if there are bad characters in name, convert them */
	while(*pnt!='\0') Local[i++]=*pnt++;
	Local[i++]=0xfd;
	Local[i++]=0x0f;
	Local[i++]=0x00;
	Local[i++]=0x03;
	Local[i++]=0x01;
	VMS_Store_Immediate_Data(Local, i, OBJ$C_DBG); i=0;
	VMS_Set_Data(Text_Psect,Min_Offset,OBJ$C_DBG,1);
	VMS_Set_Data(Text_Psect,Max_Offset,OBJ$C_DBG,1);
	Local[i++]=0x03;
	Local[i++]=sp->sy_nlist.n_value;
	Local[i++]=0x00;
	Local[i++]=0x00;
	Local[i++]=0x00;
	VMS_Store_Immediate_Data(Local, i, OBJ$C_DBG);
	*pnt1=':';
	if(spnt->VMS_type == DBG$C_ADVANCED_TYPE) generate_suffix(spnt,0);
}

/* this function examines a structure definition, checking all of the elements
 * to make sure that all of them are fully defined.  The only thing that we
 * kick out are arrays of undefined structs, since we do not know how big
 * they are.  All others we can handle with a normal forward reference.
 */
static int forward_reference(char* pnt){
	int i;
	struct VMS_DBG_Symbol * spnt;
	struct VMS_DBG_Symbol * spnt1;
	pnt = cvt_integer(pnt+1,&i);
	if(*pnt == ';') return 0; /* no forward references */
	do{
	  pnt=(char*) strchr(pnt,':');
	  pnt = cvt_integer(pnt+1,&i);
	  spnt = find_symbol(i);
	  if(spnt == (struct VMS_DBG_Symbol*) NULL) return 0;
	  while((spnt->advanced == POINTER) || (spnt->advanced == ARRAY)){
		  i=spnt->type2;
		  spnt1 = find_symbol(spnt->type2);
		  if((spnt->advanced == ARRAY) &&
			(spnt1 == (struct VMS_DBG_Symbol*) NULL))return 1;
		  if(spnt1 == (struct VMS_DBG_Symbol*) NULL) break;
		  spnt=spnt1;
	  };
	  pnt = cvt_integer(pnt+1,&i);
	  pnt = cvt_integer(pnt+1,&i);
	}while(*++pnt != ';');
	return 0;	/* no forward refences found */
}

/* This routine parses the stabs directives to find any definitions of dbx type
 * numbers.  It makes a note of all of them, creating a structure element
 * of VMS_DBG_Symbol that describes it.  This also generates the info for the
 * debugger that describes the struct/union/enum, so that further references
 * to these data types will be by number
 * 	We have to process pointers right away, since there can be references
 * to them later in the same stabs directive.  We cannot have forward
 * references to pointers, (but we can have a forward reference to a pointer to
 * a structure/enum/union) and this is why we process them immediately.
 * After we process the pointer, then we search for defs that are nested even
 * deeper.
 */
static int VMS_typedef_parse(char* str){
	char* pnt;
	char* pnt1;
	char* pnt2;
	int i;
	int dtype;
	struct forward_ref * fpnt;
	int i1,i2,i3;
	int convert_integer;
	struct VMS_DBG_Symbol* spnt;
	struct VMS_DBG_Symbol* spnt1;
/* check for any nested def's */
	pnt=(char*)strchr(str+1,'=');
	if((pnt != (char*) NULL) && (*(str+1) != '*')) 
		if(VMS_typedef_parse(pnt) == 1 ) return 1;
/* now find dbx_type of entry */
	pnt=str-1;
	if(*pnt == 'c'){	/* check for static constants */
		*str = '\0';	/* for now we ignore them */
		return 0;};
	while((*pnt <= '9')&& (*pnt >= '0')) pnt--;
	pnt++;	/* and get back to the number */
	cvt_integer(pnt,&i1);
	spnt = find_symbol(i1);
/* first we see if this has been defined already, due to a forward reference*/
	if(spnt == (struct VMS_DBG_Symbol*) NULL) {
	  if(VMS_Symbol_type_list==(struct VMS_DBG_Symbol*) NULL)
	    {spnt=(struct VMS_DBG_Symbol*) malloc(sizeof(struct VMS_DBG_Symbol));
	     spnt->next = (struct VMS_DBG_Symbol*) NULL;
	    VMS_Symbol_type_list=spnt;}
	  else
	    {spnt=(struct VMS_DBG_Symbol*) malloc(sizeof(struct VMS_DBG_Symbol));
	    spnt->next=VMS_Symbol_type_list;
	    VMS_Symbol_type_list = spnt;};
	  spnt->dbx_type = i1;	/* and save the type */
	};
/* for structs and unions, do a partial parse, otherwise we sometimes get
 * circular definitions that are impossible to resolve. We read enough info
 * so that any reference to this type has enough info to be resolved 
 */
	pnt=str + 1;	/* point to character past equal sign */
	if((*pnt == 'u') || (*pnt == 's')){
	};
	if((*pnt <= '9') && (*pnt >= '0')){
	   if(type_check("void")){ /* this is the void symbol */
		*str='\0';
		spnt->advanced = VOID;
		return 0;};
	   printf("gcc-as warning(debugger output):");
	   printf(" %d is an unknown untyped variable.\n",spnt->dbx_type);
	   return 1;	/* do not know what this is */
	};
/* now define this module*/
	pnt=str + 1;	/* point to character past equal sign */
	switch (*pnt){
	    case 'r':
		spnt->advanced= BASIC;
		if(type_check("int")) {
			spnt->VMS_type=DBG$C_SLINT; spnt->data_size=4;}
		else if(type_check("long int")) {
			spnt->VMS_type=DBG$C_SLINT; spnt->data_size=4;}
		else if(type_check("unsigned int")) {
			spnt->VMS_type=DBG$C_ULINT; spnt->data_size = 4;}
		else if(type_check("long unsigned int")) {
			spnt->VMS_type=DBG$C_ULINT; spnt->data_size = 4;}
		else if(type_check("short int")) {
			spnt->VMS_type=DBG$C_SSINT; spnt->data_size = 2;}
		else if(type_check("short unsigned int")) {
			spnt->VMS_type=DBG$C_USINT; spnt->data_size = 2;}
		else if(type_check("char")) {
			spnt->VMS_type=DBG$C_SCHAR; spnt->data_size = 1;}
		else if(type_check("signed char")) {
			spnt->VMS_type=DBG$C_SCHAR; spnt->data_size = 1;}
		else if(type_check("unsigned char")) {
			spnt->VMS_type=DBG$C_UCHAR; spnt->data_size = 1;}
		else if(type_check("float")) {
			spnt->VMS_type=DBG$C_REAL4; spnt->data_size = 4;}
		else if(type_check("double")) {
			spnt->VMS_type=DBG$C_REAL8; spnt->data_size = 8;}
		pnt1=(char*) strchr(str,';')+1;
		break;
	    case 's':
	    case 'u':
		if(*pnt == 's') spnt->advanced= STRUCT;
				else spnt->advanced= UNION;
		spnt->VMS_type = DBG$C_ADVANCED_TYPE;
		pnt1 = cvt_integer(pnt+1,&spnt->data_size);
		if(forward_reference(pnt)) {
			spnt->struc_numb = -1;
			return 1;
		}
		spnt->struc_numb = ++structure_count;
		pnt1--;
		pnt=get_struct_name(str);
		VMS_Def_Struct(spnt->struc_numb);
		fpnt = f_ref_root;
		while(fpnt != (struct forward_ref*) NULL){
			if(fpnt->dbx_type == spnt->dbx_type) {
				fpnt->resolved = 'Y';
				VMS_Set_Struct(fpnt->struc_numb);
				VMS_Store_Struct(spnt->struc_numb);};
			fpnt = fpnt->next;};
		VMS_Set_Struct(spnt->struc_numb);
		i=0;
		Local[i++] = 11+strlen(pnt);
		Local[i++] = DBG$C_STRUCT_START;
		Local[i++] = 0x80;
		for(i1=0;i1<4;i1++) Local[i++] = 0x00;
		Local[i++] = strlen(pnt);
		pnt2=pnt;
		while(*pnt2 != '\0') Local[i++] = *pnt2++;
		i2=spnt->data_size * 8;		/* number of bits */
		pnt2=(char*) &i2;
		for(i1=0;i1<4;i1++) Local[i++] = *pnt2++;
		VMS_Store_Immediate_Data(Local, i, OBJ$C_DBG); i=0;
		if(pnt != symbol_name) {
			pnt += strlen(pnt);
			*pnt=':';};	/* replace colon for later */
		while(*++pnt1 != ';'){
		  pnt=(char*) strchr(pnt1,':');
		  *pnt='\0';
		  pnt2=pnt1;
		  pnt1 = cvt_integer(pnt+1,&dtype);
		  pnt1 = cvt_integer(pnt1+1,&i2);
		  pnt1 = cvt_integer(pnt1+1,&i3);
		  if((dtype == 1) && (i3 != 32)) { /* bitfield */
		    Apoint = 0;
		    push(19+strlen(pnt2),1);
		    push(0xfa22,2);
		    push(1+strlen(pnt2),4);
		    push(strlen(pnt2),1);
		    while(*pnt2 != '\0') push(*pnt2++,1);
		    push(i3,2);	/* size of bitfield */
		    push(0x0d22,2);
		    push(0x00,4);
		    push(i2,4);	/* start position */
		    VMS_Store_Immediate_Data(Asuffix,Apoint,OBJ$C_DBG);
		    Apoint=0;
		  }else{
		    Local[i++] = 7+strlen(pnt2);
		    spnt1 = find_symbol(dtype);
		/* check if this is a forward reference */
		    if(spnt1 != (struct VMS_DBG_Symbol*) NULL)
				 Local[i++] = spnt1->VMS_type;
			else
				 Local[i++] = DBG$C_ADVANCED_TYPE;
		    Local[i++] = DBG$C_STRUCT_ITEM;
		    pnt=(char*) &i2;		
		    for(i1=0;i1<4;i1++) Local[i++] = *pnt++;
		    Local[i++] = strlen(pnt2);
		    while(*pnt2 != '\0') Local[i++] = *pnt2++;
		    VMS_Store_Immediate_Data(Local, i, OBJ$C_DBG); i=0;
		    if(spnt1 == (struct VMS_DBG_Symbol*) NULL)
				generate_suffix(spnt1,dtype);
		    else if(spnt1->VMS_type == DBG$C_ADVANCED_TYPE)
				generate_suffix(spnt1,0);
		};
		};
		pnt1++;
		Local[i++] = 0x01;	/* length byte */
		Local[i++] = DBG$C_STRUCT_END;
		VMS_Store_Immediate_Data(Local, i, OBJ$C_DBG); i=0;
		break;
	    case 'e':
		spnt->advanced= ENUM;
		spnt->VMS_type = DBG$C_ADVANCED_TYPE;
		spnt->struc_numb = ++structure_count;
		spnt->data_size=4;
		VMS_Def_Struct(spnt->struc_numb);
		fpnt = f_ref_root;
		while(fpnt != (struct forward_ref*) NULL){
			if(fpnt->dbx_type == spnt->dbx_type) {
				fpnt->resolved = 'Y';
				VMS_Set_Struct(fpnt->struc_numb);
				VMS_Store_Struct(spnt->struc_numb);};
			fpnt = fpnt->next;};
		VMS_Set_Struct(spnt->struc_numb);
		i=0;
		Local[i++] = 3+strlen(symbol_name);
		Local[i++] = DBG$C_ENUM_START;
		Local[i++] = 0x20;
		Local[i++] = strlen(symbol_name);
		pnt2=symbol_name;
		while(*pnt2 != '\0') Local[i++] = *pnt2++;
		VMS_Store_Immediate_Data(Local, i, OBJ$C_DBG); i=0;
		while(*++pnt != ';') {
		  pnt1=(char*) strchr(pnt,':');
		  *pnt1++='\0';
		  pnt1 = cvt_integer(pnt1,&i1);
		  Local[i++] = 7+strlen(pnt);
		  Local[i++] = DBG$C_ENUM_ITEM;
		  Local[i++] = 0x00;
		  pnt2=(char*) &i1;
		  for(i2=0;i2<4;i2++) Local[i++] = *pnt2++;
		  Local[i++] = strlen(pnt);
		  pnt2=pnt;
		  while(*pnt != '\0') Local[i++] = *pnt++;
		  VMS_Store_Immediate_Data(Local, i, OBJ$C_DBG); i=0;
		  pnt= pnt1;	/* Skip final semicolon */
		};
		Local[i++] = 0x01; /* len byte */
		Local[i++] = DBG$C_ENUM_END;
		VMS_Store_Immediate_Data(Local, i, OBJ$C_DBG); i=0;
		pnt1=pnt + 1;
		break;
	    case 'a':
		spnt->advanced= ARRAY;
		spnt->VMS_type = DBG$C_ADVANCED_TYPE;
		pnt=(char*)strchr(pnt,';');  if (pnt == (char*) NULL) return 1;
		pnt1 = cvt_integer(pnt+1,&spnt->index_min);
		pnt1 = cvt_integer(pnt1+1,&spnt->index_max);
		pnt1 = cvt_integer(pnt1+1,&spnt->type2);
		break;
	    case 'f':
		spnt->advanced= FUNCTION;
		spnt->VMS_type = DBG$C_FUNCTION_ADDR;
			/* this masquerades as a basic type*/
		spnt->data_size=4;
		pnt1 = cvt_integer(pnt+1,&spnt->type2);
		break;
	    case '*':
		spnt->advanced= POINTER;
		spnt->VMS_type = DBG$C_ADVANCED_TYPE;
		spnt->data_size=4;
		pnt1 = cvt_integer(pnt+1,&spnt->type2);
		pnt=(char*)strchr(str+1,'=');
		if((pnt != (char*) NULL)) 
			if(VMS_typedef_parse(pnt) == 1 ) return 1;
		break;
	    default:
		spnt->advanced= UNKNOWN;
		spnt->VMS_type = 0;
		printf("gcc-as warning(debugger output):");
	   	printf(" %d is an unknown type of variable.\n",spnt->dbx_type);
		return 1; /* unable to decipher */
	};
/* this removes the evidence of the definition so that the outer levels of 
parsing do not have to worry about it */
	pnt=str;
	while (*pnt1 != '\0') *pnt++ = *pnt1++;
	*pnt = '\0';
	return 0;
}


/* 
 * This is the root routine that parses the stabs entries for definitions.
 * it calls VMS_typedef_parse, which can in turn call itself.
 * We need to be careful, since sometimes there are forward references to
 * other symbol types, and these cannot be resolved until we have completed
 * the parse.
 */
int VMS_LSYM_Parse(){
	char *pnt;
	char *pnt1;
	char *pnt2;
	char *str;
	char fixit[10];
	int incomplete,i,pass,incom1;
	struct VMS_DBG_Symbol* spnt;
   	struct VMS_Symbol *	vsp;
	struct forward_ref * fpnt;
	symbolS * sp;
	pass=0;
	incomplete = 0;
	   do{
	   incom1=incomplete;
	   incomplete = 0;
	   for(sp = symbol_rootP; sp; sp = symbol_next(sp)) {
		/*
		 *	Deal with STAB symbols
		 */
		if ((sp->sy_nlist.n_type & N_STAB) != 0) {
		  /*
		   *	Dispatch on STAB type
		   */
		  switch((unsigned char)sp->sy_nlist.n_type) {
			case N_GSYM:
			case N_LCSYM:
			case N_STSYM:
 			case N_PSYM:
 			case N_RSYM:
			case N_LSYM:
			case N_FUN:	/*sometimes these contain typedefs*/
				str=sp->sy_nlist.n_un.n_name;
				symbol_name = str;
				pnt=(char*)strchr(str,':');
				if(pnt== (char*) NULL) break;
				*pnt='\0';
				pnt1=pnt+1;
				pnt2=(char*)strchr(pnt1,'=');
				if(pnt2 == (char*) NULL){
						*pnt=':';	/* replace colon */
						break;};	/* no symbol here */
				incomplete += VMS_typedef_parse(pnt2);
				*pnt=':';    /* put back colon so variable def code finds dbx_type*/
				break;
		  }	/*switch*/
		}	/* if */
	   }		/*for*/
	pass++;
	} while((incomplete != 0) && (incomplete != incom1 ));
			/* repeat until all refs resolved if possible */
/*	if(pass > 1) printf(" Required %d passes\n",pass);*/
	if(incomplete != 0){	
		printf("gcc-as warning(debugger output):");
		printf("Unable to resolve %d circular references.\n",incomplete);
		};
	fpnt = f_ref_root;
	symbol_name="\0";
	while(fpnt != (struct forward_ref*) NULL){
		if(fpnt->resolved != 'Y') {
		  if( find_symbol(fpnt->dbx_type) != 
			(struct VMS_DBG_Symbol*) NULL){
			    printf("gcc-as warning(debugger output):");
			    printf("Forward reference error, dbx type %d\n",
					fpnt->dbx_type);
			    break;};
		  fixit[0]=0;
		  sprintf(&fixit[1],"%d=s4;",fpnt->dbx_type);
		  pnt2=(char*)strchr(&fixit[1],'=');
		  VMS_typedef_parse(pnt2);
		  };
		fpnt = fpnt->next;};
}

static symbolS* Current_Routine;
static int Text_Psect;

static Define_Local_Symbols(symbolS* s1,symbolS* s2){
	symbolS * symbolP1;
	for(symbolP1 = symbol_next(s1); symbolP1 != s2; symbolP1 = symbol_next(symbolP1)) {
		if (symbolP1 == (symbolS *)NULL) return;
		if (symbolP1->sy_nlist.n_type == N_FUN) return;
		/*
		 *	Deal with STAB symbols
		 */
		if ((symbolP1->sy_nlist.n_type & N_STAB) != 0) {
		  /*
		   *	Dispatch on STAB type
		   */
		  switch((unsigned char)symbolP1->sy_nlist.n_type) {
 			case N_LSYM:
 			case N_PSYM:
 			   VMS_local_stab_Parse(symbolP1);
 			   break;
 			case N_RSYM:
 			   VMS_RSYM_Parse(symbolP1,Current_Routine,Text_Psect);
 				break;
		  }	/*switch*/
		}	/* if */
	   }		/* for */
}

static symbolS* Define_Routine(symbolS* symbolP,int Level){
	symbolS * sstart;
	symbolS * symbolP1;
	char	str[10];
	char * pnt;
	int rcount = 0;
	int Offset;
	sstart = symbolP;
	for(symbolP1 = symbol_next(symbolP); symbolP1; symbolP1 = symbol_next(symbolP1)) {
		if (symbolP1->sy_nlist.n_type == N_FUN) break;
		/*
		 *	Deal with STAB symbols
		 */
		if ((symbolP1->sy_nlist.n_type & N_STAB) != 0) {
		  /*
		   *	Dispatch on STAB type
		   */
		  if((unsigned char)symbolP1->sy_nlist.n_type == N_FUN) break;
		  switch((unsigned char)symbolP1->sy_nlist.n_type) {
			case N_LBRAC:
				if(Level != 0) {
				   pnt = str +sprintf(str,"$%d",rcount++);
				   *pnt = '\0';
				   VMS_TBT_Block_Begin(symbolP1,Text_Psect,str);
				};
				Offset = symbolP1->sy_nlist.n_value;
				Define_Local_Symbols(sstart,symbolP1);
				symbolP1 = 
				    Define_Routine(symbolP1,Level+1);
				if(Level != 0)
				  VMS_TBT_Block_End(symbolP1->sy_nlist.n_value -
					   Offset);
				sstart=symbolP1;
				break;
			case N_RBRAC:
				return symbolP1;
		  }	/*switch*/
		}	/* if */
	   }		/* for */
	/* we end up here if there were no brackets in this function. Define
everything */
	Define_Local_Symbols(sstart,(symbolS *) 0);
}

VMS_DBG_Define_Routine(symbolS* symbolP,symbolS* Curr_Routine,int Txt_Psect){
	Current_Routine = Curr_Routine;
	Text_Psect = Txt_Psect;
	Define_Routine(symbolP,0);
}