slink.c

一个很不错的程序切片工具,希望大家来讨论以下,对测试人员很有帮助

# include <stdio.h>
# include <string.h>
# include <malloc.h>
# include "lif.h"
	static  char    sccsid[] = "@(#)slink.c	1.4  4/26/95";
int		v_opt = 0;

typedef struct local_struct local_rec,*local_ptr;
typedef struct addr_struct addr_rec,*addr_ptr;
typedef struct chain_struct chain_rec,*chain_ptr;
typedef struct field_struct field_rec,*field_ptr;
typedef struct global_struct global_rec,*global_ptr;
typedef struct file_struct file_rec,*file_ptr;
typedef struct proc_struct proc_rec,*proc_ptr;
typedef struct proc_list_struct proc_list_rec,*proc_list;
typedef struct h_struct h_rec,*h_ptr;
typedef struct var_struct var_rec,*var_ptr;

struct h_struct {
	char	*name;
	var_ptr vars;
	int		n_v;
	h_ptr	next;
};

struct var_struct {
	int		id;
	var_ptr	next;
};

struct local_struct {
	int		local,global;
	char	*text;
	char	*flags;
	local_ptr next;
};

struct addr_struct {
	int		addr,pid,id,new_id;
	int		new_addr,new_pid;
};

struct chain_struct {
	int		old,new,id,new_id;
	int		pid;
	int		done;
	field_ptr field;
};

struct field_struct {
	int			chain,fid;
	int			offset;
	char		*flags;
	field_ptr	next;
};

struct global_struct {
	int		new;
	char	*text;
	char	*flags;
	int		is_static;
};

struct proc_list_struct {
	proc_list	next;
	proc_ptr	proc;
};

struct file_struct {
	int			n_procs,n_stmts;
	int			n_globals,n_addrs,n_chains;
	int			n_lines,n_chars;
	char		*name;
	proc_ptr	procs;
	global_ptr	globals;
	chain_ptr	chains;
	addr_ptr	addrs;
};

struct proc_struct {
	int			proc_id,
				new_id,
				exit,
				n_locals,
				entry;
	char		*name;
	char		s_or_x;
	local_ptr	localx;
};

int		last_global,last_proc,last_addr,last_chain;

print_procs(p)
	proc_ptr	p[];
{
	int		i;

	printf ("\n\nP R O C S\n");
	for (i = 1; i <= last_proc; i++){
		printf ("%3d %3d %3d %c %s %d\n",i,p[i]->proc_id,
			p[i]->new_id,
			p[i]->s_or_x,
			p[i]->name,
			p[i]->entry);
	}
}

print_globals(g)
	global_rec	g[];
{
	int		i;

	printf ("\n\nG L O B A L S\n");
	for (i = 1; i <= last_global; i++){
		printf ("%3d %3d %c %s %s\n",i,g[i].new,
			g[i].is_static?'S':' ',
			g[i].text,g[i].flags);
	}
}

int chains_are_equal(a,b)
	chain_ptr	a,b;
{
	field_ptr	af,bf;

	if (!a || !b) return 0;
	if (a->pid) return 0; /* KLUDGE */
	if ((a->new_id != b->new_id) ||
		(a->pid != b->pid)) return 0;
	af = a->field;
	bf = b->field;

	while (af && bf){
		if (af -> fid != bf -> fid) return 0;
		if (af -> offset != bf -> offset) return 0;
		af = af -> next;
		bf = bf -> next;
	}
	if (af || bf) return 0;
	return 1;
}

get_lif_files (n,f,dir)
	int		 n;
	file_rec f[];
	char	*dir;
{
	int		i,j,k,len;
	int		pid = 0,pix;
	int		code,id,chain,fid,offset,addr,scope;
	char	buff[2000],name[2000],flags[2000];
	FILE	*lif_file;
	char	*right,*extern_x;
	field_ptr field,at;
	local_ptr new_local;

	for (i = 0; i < n; i++){
		sprintf (buff,"%s/%sLIF",dir,f[i].name);
		lif_file = fopen (buff,"r");
		if (!lif_file){
			fprintf (stderr,"slink: could not open %s\n",buff);
			exit (1);
		}
		f[i].addrs = (addr_ptr) malloc ((1+f[i].n_addrs)*
			sizeof(addr_rec));
		f[i].chains = (chain_ptr) malloc((1+f[i].n_chains)*
			sizeof(chain_rec));
		for (j = 0; j <= f[i].n_chains; j++){
				f[i].chains[j].old = 0;
				f[i].chains[j].new = 0;
				f[i].chains[j].id = 0;
				f[i].chains[j].pid = 0;
				f[i].chains[j].field = NULL;
				f[i].chains[j].done = 0;
		}
		while (fgets (buff,2000,lif_file)){
			sscanf (buff,"%d",&code);
			switch (code){
			case LIF_CHAIN :
			case LIF_GCHAIN :
				sscanf(buff,"%*d(%d,%d",&chain,&id);
				f[i].chains[chain].old = chain;
				f[i].chains[chain].new = 0;
				f[i].chains[chain].id = id;
				f[i].chains[chain].pid = code == LIF_CHAIN?pid:0;
				f[i].chains[chain].field = NULL;
				break;
			case LIF_FIELD :
				field = (field_ptr) malloc (sizeof(field_rec));
				sscanf (buff,"%*d(%d,%d,%d%[^\n]",
					&chain,&fid,&offset,flags);
				field -> chain = chain;
				field -> offset = offset;
				field -> fid = fid;
				field -> next = NULL;
				field -> flags = malloc (strlen(flags)+1);
				strcpy (field->flags,flags);
				if (f[i].chains[chain].field){
					if (f[i].chains[chain].field->fid > fid){
						field -> next = f[i].chains[chain].field;
						f[i].chains[chain].field = field;
					}
					else {
						at = f[i].chains[chain].field;
						while ((at->next) &&
							(at->fid < fid)) at = at -> next;

						if (at -> fid > fid){
							field -> next = at -> next;
							at -> next = field;
						}
						else {
							field -> next = at ->next;
							at -> next = field;
						}
					}
				}
				else f[i].chains[chain].field = field;
				break;
			case LIF_ADDRESS :
				sscanf (buff,"%*d(%d,%d,%d",&addr,&scope,&id);
				f[i].addrs[addr].addr = addr;
				f[i].addrs[addr].new_addr = 0;
				f[i].addrs[addr].pid = scope;
				f[i].addrs[addr].id = id;
				break;
			case LIF_LOCAL_ID :
				sscanf (buff,"%*d(%d,%[^,)]%[^\n]",&id,name,flags);
				right = strchr (flags,')');
				extern_x = strchr (flags,'X');
				if ((extern_x) &&
					(extern_x - flags <
						right - flags)){
					new_local = (local_ptr) malloc (sizeof(local_rec));
					new_local -> next = f[i].procs[pix].localx;
					f[i].procs[pix].localx = new_local;
					new_local -> local = id;
					new_local -> text = malloc (strlen(name)+1);
					new_local -> flags = malloc (strlen(flags)+1);
					strcpy (new_local->text,name);
					strcpy (new_local->flags,flags);
					new_local -> global = 0;
				}
				break;
			case LIF_GLOBAL_ID :
				sscanf (buff,"%*d(%d,%[^,)]%[^\n]",&id,name,flags);
				f[i].globals[id].text = malloc(strlen(name)+1);
				f[i].globals[id].flags = malloc(strlen(flags)+1);
				strcpy(f[i].globals[id].flags,flags);
				strcpy(f[i].globals[id].text,name);
				break;
			case LIF_PROC_START :
				sscanf (buff,"%*d(%*d,%d",&pid);
				for (pix = 0; pix < f[i].n_procs; pix++)
					if (f[i].procs[pix].proc_id == pid) break;
				break;
			case LIF_PROC_END :
				pid = 0;
				break;
			case LIF_FORMAL_ID :
			case LIF_FILE :
			case LIF_REF :
			case LIF_DEF :
			case LIF_GREF :
			case LIF_GDEF :
			case LIF_CALL_START :
			case LIF_ACTUAL_SEP :
			case LIF_CALL_END :
			case LIF_RETURN :
			case LIF_GOTO :
			case LIF_SUCC :
			case LIF_REQUIRES :
			case LIF_SOURCE_MAP :
			case LIF_CREF :
			case LIF_CDEF :
			case LIF_AREF :
			default :
				break;
			}
		}
		fclose(lif_file);
	}
}

get_t_files (sys,n,f,dir)
	FILE	 *sys;
	int		 n;
	file_rec f[];
	char	*dir;
{
	int		i,j,k,len,nr;
	char	buff[2000];
	FILE	*t_file;
	int		t_globals = 0;
	int		warning = 1;

	fscanf (sys,"%s",buff);
	for (i = 0; i < n; i++){
		fscanf (sys,"%s",buff);
		f[i].name = malloc (1 + strlen(buff));
		strcpy (f[i].name,buff);
		len = strlen(buff);
		if (len > 2)
			f[i].name[len - 1] = '\0';
	}
	/*
	k = printf ("FILES : ");
	for (i = 0; i < n; i++){
		if (k == 0) printf ("\t");
		k += printf ("%s ",f[i].name);
		if (k > 30){
			printf ("\n");
			k = 0;
		}
	}
	if (k) printf ("\n");
	*/

	fclose (sys);
	/*
	fprintf(t_file,"%d\n",n_procs);
	p = procs;
	while (p){
		fprintf (t_file,"%3d %4d %4d %4d %c %s\n",
			p->proc_id,p->entry_node,
			p->exit_node,p->n_locals,
			p->static_or_extern,p->proc->text);
		p = p -> next;
	}
	*/
	for (i = 0; i < n; i++){
		sprintf (buff,"%s/%sT",dir,f[i].name);
		t_file = fopen (buff,"r");
		warning = 1;
		if (!t_file){
			fprintf (stderr,"slink: couldn't open %s\n",buff);
			exit(1);
		}
		else {
			fscanf (t_file,"%d %d",&f[i].n_procs,&f[i].n_stmts);
			f[i].procs = (proc_ptr)
				malloc (f[i].n_procs*sizeof(proc_rec));
			for (j = 0; j < f[i].n_procs; j++){
				nr = fscanf (t_file,"%d %d %d %d %c %s",
					&f[i].procs[j].proc_id,
					&f[i].procs[j].entry,
					&f[i].procs[j].exit,
					&f[i].procs[j].n_locals,
					&f[i].procs[j].s_or_x,
					buff);
				if ((nr != 6) && warning) {
					warning = 0;
					fprintf (stderr,"Warning (slink): %sT corrupt\n",
						f[i].name);
				}
				f[i].procs[j].name = malloc (strlen(buff) + 1);
				strcpy (f[i].procs[j].name,buff);
				f[i].procs[j].localx = NULL;
			}
			nr = fscanf (t_file,"%d%d%d %d %*d %d",&f[i].n_globals,
				&f[i].n_chains,&f[i].n_addrs,
				&f[i].n_lines,&f[i].n_chars);
			if ((nr != 5) && warning) {
				warning = 0;
				fprintf (stderr,
			"Warning (slink): %sT corrupt (counts from wc missing)\n",
					f[i].name);
				}
			fclose(t_file);
			f[i].globals = (global_ptr) malloc((1+f[i].n_globals)*
				sizeof(global_rec));
			for (j = 0; j < (1+f[i].n_globals); j++){
				f[i].globals[j].new = 0;
			}
			t_globals += f[i].n_globals;
		}
	}
}

int scan_system(sys,target)
	FILE	*sys;
	char	*target;
{
	char	buff[2000],name[2000];
	int		n = 0;

	while (fgets (buff,2000,sys)){
		if (buff[0] == 'M'){
			sscanf(buff,"MAIN %s %d",name,&n);
			if (strcmp (name,target) == 0) return n;
		}
	}
	return 0;
}

print_files(n,f)
	int		 n;
	file_rec f[];
{
	int		i,j;
	int		k;
	field_ptr field;
	local_ptr localx;

	for (i = 0; i < n; i++){
		printf ("\nFile: %s  globals %d addrs %d chains %d procs %d\n",
			f[i].name,f[i].n_globals,f[i].n_addrs,f[i].n_chains,
			f[i].n_procs);
		printf("Globals:\n");
		for (j = 0; j < f[i].n_globals; j++){
			if (f[i].globals[j+1].text){
				printf ("%3d => %3d %s <%s>\n", j+1,
					f[i].globals[j+1].new,
					f[i].globals[j+1].text,
					f[i].globals[j+1].flags);
			}
		}
		printf ("Chains:\n");
		for (j = 1; j <= f[i].n_chains; j++){
			if (j != f[i].chains[j].old) printf ("Chain skipped\n");
			else {
				printf ("chain %3d -> %3d pid %3d id %3d (%d) fields: ",
					f[i].chains[j].old,
					f[i].chains[j].new,
					f[i].chains[j].pid,
					f[i].chains[j].id,
					f[i].chains[j].new_id);
				field = f[i].chains[j].field;
				while (field){
					printf (" (%d,%d)" ,field->fid,field->offset);
					field = field -> next;
				}
				printf ("\n");
			}
		}
		printf("Addrs:\n");
		for (j = 1; j <= f[i].n_addrs; j++){
			printf ("%3d => %3d %4d %4d\n",
				f[i].addrs[j].addr,
				f[i].addrs[j].new_addr,
				f[i].addrs[j].pid,
				f[i].addrs[j].id);
		}
		printf("Procs:\n");
		for (j = 0; j < f[i].n_procs; j++){
			printf ("%3d => %3d %c %4d %s\n",
			f[i].procs[j].proc_id,
			f[i].procs[j].new_id,
			f[i].procs[j].s_or_x,
			f[i].procs[j].entry,
			f[i].procs[j].name);
			localx = f[i].procs[j].localx;
			if (localx){
				k = printf ("\tLocal externs: ");
				while(localx){
					k += printf ("(%d => %d %s %s) ",
						localx->local,localx->global,
						localx->text,localx->flags);
					if (k > 50) {printf ("\n"); k = 0;}
					localx = localx -> next;
				}
				if (k)printf("\n");
			}
		}
	}
}

int pid_to_index (n,f,i,pid)
	int		pid,n,i;
	file_rec f[];
{
	int		pix;

	for (pix = 0; pix < f[i].n_procs; pix++)
		if (f[i].procs[pix].proc_id == pid) return pix;
	return -1;
}

int find_proc (np,procs,name)
	int		np;
	proc_ptr *procs;
	char	*name;
{
	int		i;
	for (i = 1; i <= np; i++){
		if (strcmp (name,procs[i]->name) == 0)
			if (procs[i]->s_or_x == 'X') return i;
	}
	return 0;
}

int	find_global (ng,g,name)
	int			ng;
	global_rec	g[];
	char		*name;
{
	int			i;
	int			k;

	for (i = 0,k = 1; i < ng; i++,k++){
		if (strcmp (name,g[k].text) == 0)
			if (!g[k].is_static) return k;
	}
	return 0;
}

proc_ptr *assign_procs(n_files,f)
	int			n_files;
	file_rec	f[];
{
	int			total = 0;
	int			i,j,k,last,at;
	proc_ptr	*procs;

	last = 0;
	for (i = 0; i < n_files; i++) total += f[i].n_procs;
	procs = (proc_ptr *) malloc (sizeof(proc_ptr)*(++total));
	for (i = 0; i < total; i++) procs[i] = NULL;
	for (j = 0; j < f[0].n_procs; j++){
		procs[f[0].procs[j].proc_id] = &f[0].procs[j];
		f[0].procs[j].new_id = f[0].procs[j].proc_id;
		if (f[0].procs[j].proc_id > last) 
			last = f[0].procs[j].proc_id;
	}
	for (i = 1; i < n_files; i++){
		for (j = 0; j < f[i].n_procs; j++){
			if (f[i].procs[j].s_or_x == 'S') at = 0;
			else at = find_proc (last,procs,f[i].procs[j].name);
			if (at) {
				f[i].procs[j].new_id = at;
				if (f[i].procs[j].entry != -1)
					procs[at] = &f[i].procs[j];
			}
			else {
				last++;
				procs[last] = &f[i].procs[j];
				f[i].procs[j].new_id = last;
			}
		}
	}
	last_proc = last;
	return procs;
}

int otn_globals(f,fid,old)
	file_rec    f[];
	int			fid,old;
{
	return f[fid].globals[old].new;
}

int find_global_addr(n,a,var)
	int		n,var;
	addr_ptr *a;
{
	int		i;
	int		gvar;

	for (i = 1; i <= n; i++){
		gvar = a[i]->new_id;
		if ((a[i]->pid == 0) && (gvar == var)) return i;
	}
	return 0;
}

addr_ptr *assign_addrs(n_files,f)
	int			n_files;
	file_rec	f[];
{
	int			total = 0;
	addr_ptr	*addrs;
	int			i,j,last = 0,at;
	int			pix,real_pid,real_id;
	int			addr_found;
	local_ptr	lx;

	for (i = 0; i < n_files; i++) total += f[i].n_addrs;
	addrs = (addr_ptr *) malloc (sizeof(addr_ptr)*(++total));
	/*
	for (j = 1; j <= f[0].n_addrs; j++){
		addrs[j] = &f[0].addrs[j];
		addrs[j]->new_addr = j;
	}
	*/
	last = 0;
	for (i = 0; i < n_files; i++){
		for (j = 1; j <= f[i].n_addrs; j++){
			real_id = 0;
			if (f[i].addrs[j].pid){