slice.c

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

# include <stdio.h>
# include "slice.h"
# include "lif.h"

static  char    sccsid[] = "@(#)slice.c	1.7  8/16/95";
static char *sccs_h_id = SLICE_SCCS_ID;
extern int v_opt;
static bit_set dont_descend;
void	(*slice_hook)() = NULL;
void	(*slice_pass_hook)() = NULL;
void  *QQQ;

int stmt_to_proc (file,stmt)
	int	file,stmt;
{
	int		i;

	for (i = 1; i <= n_procs; i++){
		if (procs[i].file_id == file)
			if ((stmt >= procs[i].entry) &&
				(stmt <= procs[i].exit)) return i;
	}
	return 0; /* no proc found */
}

int is_id_valid (pid,id)
	int		pid,id;
{
	if ((pid < 0) || (pid > n_procs)){
		fprintf (stderr,"proc %d out of range %d\n",
			pid,n_procs); fflush(stderr);
		return 0;
	}
	if (pid){
		if ((id < 0) || (id > procs[pid].n_locals)){
			fprintf (stderr,"local id %d out of range %d\n",
				id,procs[pid].n_locals);
			fflush (stderr);
			return 0;
		}
	}
	else {
		if ((id < 0) || (id > n_globals)){
			fprintf (stderr,"global id %d out of range %d\n",
				id,n_globals);
			fflush (stderr);
			return 0;
		}
	}
	return 1;
	
}

set_criteria (file,stmt_proc,stmt,var_proc,var)
	int		file,stmt,stmt_proc,var_proc,var;
{
	int		var_ix,var_max,var_n;

	if (var_proc){ /* get all members of a structure */
		var_n = procs[var_proc].n_locals;
		var_max = procs[var_proc].locals[var].offset + var;
	}
	else {
		var_n = n_globals;
		var_max = globals[var].offset + var;
	}
	for (; var <= var_max; var++){
		is_id_valid (var_proc,var);
		if (var_proc){
			if (stmt_proc == var_proc)
				bit_on (files[file].stmts[stmt].active_local,var);
			else {
				add_to_id_set (&files[file].stmts[stmt].active_other,
					var_proc,var);
			}
		}
		else bit_on (files[file].stmts[stmt].active_global,var);
	}
}

clear_active_proc(proc)
	int		proc;
{
	int	file,stmt;

	file = procs[proc].file_id;
	for (stmt = procs[proc].entry; stmt <= procs[proc].exit; stmt++){
		clear_bit_set (files[file].stmts[stmt].active_global);
		clear_bit_set (files[file].stmts[stmt].active_local);
		clear_id_set (files[file].stmts[stmt].active_other);
		files[file].stmts[stmt].active_other = NULL;
	}
}

clear_active()
{
	int	file,stmt;

	for (file = 0; file < n_files; file++)
		for (stmt = 1; stmt <= files[file].n_stmts; stmt++){
			clear_bit_set (files[file].stmts[stmt].active_global);
			clear_bit_set (files[file].stmts[stmt].active_local);
			clear_id_set (files[file].stmts[stmt].active_other);
			files[file].stmts[stmt].active_other = NULL;
		}
}

int lib_defs (stmt,id,is_local)
	int		id;
	stmt_ptr stmt;
{
	call_ptr	calls;
	var_ptr		var;
	actual_ptr	act;
	int			cx,ax;

	calls = stmt->calls;
	while (calls){
		cx = calls->pid;
		if(v_opt)printf ("call to %s\n",procs[cx].proc_name);
		act = calls->actuals;
		while (act){
			var = act -> actuals;
			while (var){
				if (var -> code == LIF_AREF){
					ax = var->id;
					if ((addrs[ax].id == id) &&
						((is_local && addrs[ax].pid) ||
						(!is_local && !addrs[ax].pid))) return 1;
				}
				var = var -> next;
			}
			act = act -> next;
		}
		calls = calls->next_this_stmt;
	}
	return 0;
}

int is_var_defed (stmt,id,is_local)
	int		id,is_local;
	stmt_ptr stmt;
{
	var_ptr	defs;
	int		result;

	defs = stmt->defs;
	while (defs){
		if (defs->level == 0)switch (defs->code){
		case LIF_DEF:
			if (!is_local) break;
			if (id == defs->id) return 1;
			break;
		case LIF_GDEF:
			if (is_local) break;
			if (id == defs->id) return 1;
			break;
		default:;
		}
		defs = defs->next;
	}
	result = lib_defs (stmt,id,is_local);
	if(v_opt)printf ("is %d defed %d\n",result);
	return result;
/*
	if (is_local) return is_bit_on (stmt->active_local,id);
	return is_bit_on (stmt->active_global,id);
*/
}

print_addr(addr_set)
	set_ptr	addr_set;
{
	int		addr,id,pid;

	if (addr_set){
		addr = addr_set -> id;
		id = addrs[addr].id;
		pid = addrs[addr].pid;
	}
}

static int base_id,base_pid,base_ptr,base_level,base_done = 1;;
static var_ptr	base;
static set_ptr	base_addrs[200];
static int		base_off[200];
int offset_check(pid,id,off)
    int pid,id,off;
{
    id_ptr  ids;
    int     n,is_new;
    static id_set_ptr   trouble = NULL;
 
    if (pid){
        ids = procs[pid].locals;
        n = procs[pid].n_locals;
    }
    else {
       n = n_globals;
        ids = globals;
    }
    if (id > n){
        if(add_to_id_set (&trouble,pid,id))
            fprintf (stderr,"id %d out of range (%d)\n",
                id,n);
           return 0;
    }
    if ((off > ids[id].offset)||(off+id > n)){
        if(add_to_id_set(&trouble,pid,id))
            fprintf (stderr,"offset on %s is too large %d (%d)\n"
,
            var_name(pid,id),off,ids[id].offset);
            return 0;
    }
    return 1;
}
 


print_field_resolve(ptr,f)
	int		ptr;
	field_ptr f;
{
	set_ptr	addr;
	int		id,pid,p;

	if (!f) return;
	addr = ptr_points_to(ptr);
	while(addr){
		print_addr(addr); printf(" ");
		printf ("field %d %s +%d: ",f->fid,f->name,f->offset);
		id = addrs[addr->id].id;
		pid = addrs[addr->id].pid;
		id += f->offset;
		p = pid?procs[pid].locals[id].ptr_id:globals[id].ptr_id;
		printf ("[[%s]]",pid?procs[pid].locals[id].name:
			globals[id].name);
		printf ("\n");
		print_field_resolve(p,f->next);
		addr = addr -> next;
	}
}

chain_resolve_set (def,proc)
	int		proc;
	int		def;
{
	int		chain_id,head_id,head_pid,ptr;
	int		id,pid;
	set_ptr	addr;
	id_ptr	head;
	field_ptr f;

	if(v_opt) printf ("proc %s\n",procs[proc].proc_name);
	chain_id = def;
	head_id = chains[chain_id].id;
	head_pid = chains[chain_id].pid;
	f = chains[chain_id].fields;
	if(v_opt)printf ("Set chain %d on %s->%s\n",def,
		var_name(head_pid,head_id),f?f->name:"<No field>");
	head = head_pid?procs[head_pid].locals:globals;
	ptr = head[head_id].ptr_id;
	addr = ptr_points_to(ptr);
	base_level = 0;
	base_addrs[base_level] = addr;
	while (f){
		base_off[base_level] = f->offset;
		base_level++;
		if (addr){
			id = addrs[addr->id].id;
			pid = addrs[addr->id].pid;
			if (offset_check(pid,id,f->offset)){
				id += f->offset;
				ptr = pid?procs[pid].locals[id].ptr_id:globals[id].ptr_id;
				addr = ptr_points_to(ptr);
				base_addrs[base_level] = addr;
			}
			else {
				base_addrs[base_level] = NULL;
			}
		}
		else base_addrs[base_level] = NULL;
		f = f -> next;
	}
	if (v_opt){
		printf ("base level %d\n",base_level);
		printf ("base off %d %d %d %d\n",base_off[0],base_off[1],
			base_off[2],base_off[3]);
		printf ("base addrs %d %d %d %d\n",base_addrs[0],base_addrs[1],
			base_addrs[2],base_addrs[3]);
	}
}

int chain_resolve_get (id,pid)
	int		*id,*pid;
{
	int		level,addr;
	int		idx,pidx,ptr;
	set_ptr	objs;

	/*
	level = base_level - 1;
	if (level < 0) return 0;
	printf ("get level %d\n",level); fflush(stdout);
	objs = base_addrs[level];
	while ((!objs) && (level >= 0)){
		if(v_opt)printf ("level %d\n",level);
		if (base_addrs[level]){
			base_addrs[level] = base_addrs[level]->next;
			objs = base_addrs[level];
			if (objs)while ((level >= 0) && (level < (base_level - 1))){
				if(v_opt)printf ("\tlevel %d\n",level);
				if (base_addrs[level]){
					addr = base_addrs[level]->id;
					idx = addrs[addr].id;
					pidx = addrs[addr].pid;
					if (offset_check(pidx,idx,base_off[level])){
						idx += base_off[level];
						ptr = pidx?procs[pidx].locals[idx].ptr_id:
							globals[idx].ptr_id;
						base_addrs[level] = base_addrs[level]->next;
						level++;
						if (ptr) base_addrs[level] = ptr_points_to(ptr);
						else {
							level--;
						}
					}
					else {
							base_addrs[level] = base_addrs[level]->next;
					}
				}
				else {
					level--;
				}
			}
			else {
				level--;
			}
		}
		else level--;
		if (level == (base_level - 1))objs = base_addrs[level];
		else objs = NULL;
	}
*/
	level = base_level - 1;
	if (level < 0) return 0;
	objs = base_addrs[level];
	if (!objs) level--;
	while ((level >= 0) && (level < (base_level - 1))){
		if(v_opt)printf ("level %d\n",level);
		if (base_addrs[level]){
			base_addrs[level] = base_addrs[level]->next;
			objs = base_addrs[level];
			if(v_opt)printf ("\tlevel %d\n",level);
			if (base_addrs[level]){
				addr = base_addrs[level]->id;
				idx = addrs[addr].id;
				pidx = addrs[addr].pid;
				if (offset_check(pidx,idx,base_off[level])){
					idx += base_off[level];
					ptr = pidx?procs[pidx].locals[idx].ptr_id:
						globals[idx].ptr_id;
					level++;
					if (ptr) base_addrs[level] = ptr_points_to(ptr);
					else {
						level--;
					}
				}
				else {
						base_addrs[level] = base_addrs[level]->next;
				}
			}
			else {
				level--;
			}
		}
		else level--;
	}
	if (base_addrs[level] && (level == (base_level - 1))){
		addr = base_addrs[level]->id;
		if (offset_check (addrs[addr].pid,addrs[addr].id,
			base_off[level])){
			*id = addrs[addr].id + base_off[level];
			*pid = addrs[addr].pid;
			base_addrs[level] = base_addrs[level]->next;
			return 1;
		}
	}
	return 0;
}

var_resolve_set (def,proc)
	int		proc;
	var_ptr	def;
{
	int		i,id,pid,ptr,addr;

	base = def;
	base_done = 0;
	base_level = def->level;
	base_id = def->id;
	if ((def->code == LIF_GDEF) ||
		(def->code == LIF_GREF)) base_pid = 0;
	else base_pid = proc;
	base_ptr = base_pid?procs[proc].locals[base_id].ptr_id:
		globals[base_id].ptr_id;
	base_addrs[0] = ptr_points_to(base_ptr);
	for (i = 1; i < base_level; i++){
		if (base_addrs[i-1] != NULL){
			addr = base_addrs[i-1]->id;
			pid = addrs[addr].pid;
			id = addrs[addr].id;
			ptr = pid?procs[pid].locals[id].ptr_id:
				globals[id].ptr_id;
			if (ptr) base_addrs[i] = ptr_points_to(ptr);
			else base_addrs[i] = NULL;
		}
		else base_addrs[i] = NULL;
	}
}
print_base_state()
{
	int		i,top,at;
	int		ptr,addr;
	set_ptr objs;

	printf ("resolve %s at level %d\n",base_pid?
		procs[base_pid].locals[base_id].name:
		globals[base_id].name,base_level);
	for (i = 0; i < base_level; i++){
		if (base_addrs[i]){
			printf ("level %d is:",i);
			objs = base_addrs[i];
			while (objs){
				printf (" %d",objs->id);
				objs = objs->next;
			}
			printf ("\n");
		}
	}
}

/********************************************************************/
/*                                                                  */
/* var_resolve_get does a depth first traversal of the pointer state*/
/*                                                                  */
/********************************************************************/
int var_resolve_get (id,pid)
	int		*id,*pid;
{
	int		i,top,at;
	int		ptr,addr;
	set_ptr objs;

	top = base_level - 1;
	objs = base_addrs[top];
	while ((!objs) && (top >= 0)){
	/*	top--; */
		if (base_addrs[top]){
			base_addrs[top] = base_addrs[top]->next;
			objs = base_addrs[top];
			if (objs)while (((top < (base_level - 1))&&(top >= 0))){
				if (base_addrs[top]){
					int	id,pid; /* D E C L */
					addr = base_addrs[top]->id;
					top++;
					pid = addrs[addr].pid;
					id = addrs[addr].id;
					ptr = pid?procs[pid].locals[id].ptr_id:
						globals[id].ptr_id;
					if (ptr) base_addrs[top] = ptr_points_to(ptr);
					else {
						top--;
						base_addrs[top] = base_addrs[top]->next;
					}
				}
				else {
					top--;
				}
			}
		}
		else top--;

		if (top == (base_level - 1)) objs = base_addrs[top];
		else objs = NULL;
	}
	if (objs){
		base_addrs[top] = base_addrs[top]->next;
		addr = objs->id;
		if ((addr > 0) && (addr <= n_addrs)){
			*id = addrs[addr].id;
			*pid = addrs[addr].pid;
			return 1;
		}
	}
	return 0;
}

chain_resolve_path (f,n,proc)
	int		f,n,proc;
{
	int		i,id,pid,addr;

	if (base_level < 2) return;
	for (i = 0; i < (base_level - 1); i++)
		if (base_addrs[i]){
		addr = base_addrs[i]->id;
		if (offset_check(addrs[addr].pid,
			addrs[addr].id,
			base_off[i])){
			id = addrs[addr].id + base_off[i];
			pid = addrs[addr].pid;
			if ((pid == 0) || (pid == proc)){
				bit_on (pid?files[f].stmts[n].active_local:
					files[f].stmts[n].active_global,id);
			}
			else add_to_id_set (&files[f].stmts[n].active_other,pid,id);
		}

	}
}


var_resolve_path (f,n,proc)
	int		f,n,proc;
{
	int		i,id,pid,addr;

	if (base_level < 2) return;
	for (i = 0; i < (base_level - 1); i++)
		if (base_addrs[i]){
		addr = base_addrs[i]->id;
		id = addrs[addr].id;
		pid = addrs[addr].pid;
		if ((pid == 0) || (pid == proc)){
			bit_on (pid?files[f].stmts[n].active_local:
				files[f].stmts[n].active_global,id);
		}
		else add_to_id_set (&files[f].stmts[n].active_other,pid,id);

	}
}

int is_other_active (set,pid,id)
	id_set_ptr	set;
	int		id,pid;
{
	while (set){
		if ((set->id == id) && (set->pid == pid))
			return 1;
		set = set -> next;
	}
	return 0;
}

int active_defed (f,n,succ,proc)
	int	f,n,succ,proc;
{
	int match = 0;

	if (!files[f].stmts[n].defs) return 0;
	if (files[f].stmts[n].defs->level == 0){
		switch (files[f].stmts[n].defs->code){
		case LIF_DEF: