vms-dbg.c

早期freebsd实现

	  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 = sp->sy_next) {
		/*
		 *	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 = s1->sy_next; symbolP1 != s2; symbolP1 = symbolP1->sy_next) {
		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 = symbolP->sy_next; symbolP1; symbolP1 = symbolP1->sy_next) {
		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);
}