slice-load.c

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

	int		i,j,off;
	char	*at,*dot;

	if (offset > n_vars){
		fprintf (stderr,"offset > n_vars (%d > %d)\n",offset,n_vars);
		abort();
	}
/*
*********************************************************************
*                                                                   *
G L O B A L S
  1   1   alph               alph is structure with offset 5
  2   2   alph.aaa
  3   3   alph.b1            need to find alph.b1 (offset 3)
  4   4   alph.b1.bbb
  5   5   alph.b1.g1         and alph.b1.g1 (offset 1)
  6   6   alph.b1.g1.ggg
*                                                                   *
*********************************************************************
*/
	at = strrchr (vars[id+1].name,'.'); /* find rightmost . */
	if (!at) return;
	for (i = 2; i <= offset; i++){
		dot = strrchr (vars[id+i].name,'.');
		/* test for new level of members by asking if
		   position of rightmost dot has changed */
		if ((dot - vars[id+i].name) != (at - vars[id+1].name)){
			j = i + 1;
			if (j <= offset)dot = strrchr (vars[id+j].name,'.');
			while ((j <= offset) &&
				(dot - vars[id+j].name) != (at - vars[id+1].name)){
				j++;
				if (j <= offset) dot = strrchr (vars[id+j].name,'.');
			}
			off = j - i;  /* j marks extent of change i.e. offset */
			mark_sub_structs (vars,n_vars,id+i-1,off);
			vars[id+i-1].offset = off;
			i = j-1;
		}
	}

}

/*
pr_structs()
{
	int		i;
	int		proc;
	id_ptr	locals;

	for (proc = 1; proc <= n_procs; proc++){
		locals = procs[proc].locals;
		for (i = 1; i <= procs[proc].n_locals;i++){
			printf ("%-10s %3d %5d %3d %s\n",
				procs[proc].proc_name?procs[proc].proc_name:"<NIL>"
				,proc,i,locals[i].offset,
				locals[i].name?locals[i].name:"<NIL>");
			fflush(stdout);
		}
	}
	for (i = 1; i <= n_globals; i++){
		printf ("%-10s %3d %5d %3d %s\n",
			"global var",0,i,globals[i].offset,
			globals[i].name?globals[i].name:"<NIL>");
	}
}
*/

close_gdefs()
{
	int	more,result,proc;
	call_ptr	call;
	int		pass = 0;
	int		var,chain;
	set_ptr	objs;
	id_set_ptr non_local_defs;
	int		aix;
	int		id,pid,addr;
	int		old;
	/* int		v_opt = 1; */

	for (proc = 1; proc <= n_procs; proc++){
		more = 1;
		if(v_opt)printf ("proc %s\n",procs[proc].proc_name);
		if(!is_lib_proc(proc))while (more){
			more = 0;
			if (procs[proc].cdefs){
				chain = -1;
				while ((chain = get_next_member(
					procs[proc].cdefs,chain)) >= 0){
					chain_resolve_set (chain,proc);
					while (chain_resolve_get (&id,&pid)){
						if(v_opt)printf ("got %s\n",var_name(pid,id));fflush(stdout);
						if(c_opt)printf (
							"chain %d resolves to (%d,%d) %s %c\n",
							chain,pid,id,var_name(pid,id),
							(pid?procs[pid].locals[id].is_pointer:
							globals[id].is_pointer)?'P':'S');
						if(offset_check(pid,id,0)){
						if (pid){
							if (pid != proc)
								more += 
									add_to_id_set (
										&procs[proc].other_defs,pid,id);
						}
						else {
							if (!procs[proc].global_defs)
								procs[proc].global_defs =
									create_bit_set (n_globals+1);
							if (!is_bit_on(procs[proc].global_defs,id)){
								bit_on(procs[proc].global_defs,id);
								more++;
							}
						}
						}
						else {
							if(v_opt)printf ("id range error\n");
						}
					}
				}
			}
			if (procs[proc].global_idefs){
				var = -1;
				while ((var = get_next_member(
					procs[proc].global_idefs,var)) >= 0){
					objs = var_points_to (0,var);
					while (objs){
						aix = objs->id;
						if (addrs[aix].pid == 0){
							if (!procs[proc].global_defs)
								procs[proc].global_defs =
									create_bit_set (n_globals+1);
							if (!is_bit_on(procs[proc].global_defs,
								addrs[aix].id)){
								bit_on(procs[proc].global_idefs,
									addrs[aix].id);
								bit_on(procs[proc].global_defs,
									addrs[aix].id);
								more++;
							}
						}
						else {
							old = more;
							more += 
								add_to_id_set (&procs[proc].other_defs,
								addrs[aix].pid,addrs[aix].id);
						}
						objs = objs -> next;
					}
				}
			}
			if (procs[proc].local_idefs){
				var = -1;
				while ((var = get_next_member(
					procs[proc].local_idefs,var)) >= 0){
					objs = var_points_to (proc,var);
					while (objs){
						aix = objs->id;
						if (addrs[aix].pid == 0){
							if (!procs[proc].global_idefs)
								procs[proc].global_idefs = create_bit_set 
									(n_globals+1);
							if (!is_bit_on(procs[proc].global_idefs,
								addrs[aix].id)){
							if (!procs[proc].global_defs)
								procs[proc].global_defs = create_bit_set 
									(n_globals+1);
								bit_on(procs[proc].global_defs,
									addrs[aix].id);
								bit_on(procs[proc].global_idefs,
									addrs[aix].id);
								more++;
							}
							else {
								if (addrs[aix].pid == proc)
									bit_on(procs[proc].local_idefs,
										addrs[aix].id);
							}
						}
						else {
							old = more;
							more += 
								add_to_id_set (&procs[proc].other_defs,
								addrs[aix].pid,addrs[aix].id);
						}
						objs = objs -> next;
					}
				}
			}
			if (procs[proc].lib_arefs){
				addr = -1;
				while ((addr = get_next_member (procs[proc].lib_arefs,
					addr)) >= 0){
					if (addrs[addr].pid == 0){
						bit_on (procs[proc].global_defs,addrs[addr].id);
					}
				}
			}
			if(v_opt)printf ("closing %s %d changes\n",procs[proc].proc_name,
				more);
		}
	}
	more = 1;
	while (more){
		more = 0;
		for (proc = 1; proc <= n_procs; proc++){
			if (!is_lib_proc (proc)){
				call = procs[proc].called_by;
				while (call){
					if (procs[proc].global_defs){
						if (!procs[call->pid].global_defs)
								procs[call->pid].global_defs =
									create_bit_set (n_globals+1);
						result = cunion_bit_set (
							procs[call->pid].global_defs,
							procs[proc].global_defs);
						more += result;
						non_local_defs = procs[proc].other_defs;
						while (non_local_defs){
							if (non_local_defs->pid != call->pid)
								more += add_to_id_set (
									&procs[call->pid].other_defs,
									non_local_defs->pid,
									non_local_defs->id);
							non_local_defs = non_local_defs -> next;
						}
					}
					call = call -> next;
				}
			}
		}
	}
}

/*
*********************************************************************
* scan ids for structures, then call mark_sub_structs to mark       *
* structures declared within other structures                       *
*********************************************************************
*/
scan_structs()
{
	int		i;
	int		proc;
	id_ptr	locals;

	for (i = 1; i <= n_globals; i += 1 + globals[i].offset){
		if (globals[i].offset){
			mark_sub_structs (globals,n_globals,i,globals[i].offset);
		}
	}

	for (proc = 1; proc <= n_procs; proc++){
		locals = procs[proc].locals;
		for (i = 1; i <= procs[proc].n_locals;
				i += 1 + locals[i].offset){
			if (locals[i].offset){
				mark_sub_structs (locals,procs[proc].n_locals,i,
					locals[i].offset);
			}
		}
	}
}

/*
*********************************************************************
*                                                                   *
*  Read the LINK file with the LIF codes for all source files       *
*  merged together by slink.                                        *
*                                                                   *
*********************************************************************
*/
int read_link_file (name)
	char	*name;
{
	char	l_file_name[2000];
	FILE	*l_file;
	int		code,id,pid,fid,stmt,level,file_id,chain;
	int		cur_proc = 0,cur_file = 0,i,n,addr;
	int		fl,fc,tl,tc,field_seq,offset,from,to;
	char	id_name[2000],buff[2000],flags[2000];
	id_ptr	cur_id;
	var_ptr	var,*add_to;
	field_ptr at_field,field;
	call_ptr call_stack[200],call;
	actual_ptr actual;
	int		top_call = 0,sep_stack[200];
	set_ptr		new_return;

	sprintf (l_file_name,"%sLINK",name);
	l_file = fopen (l_file_name,"r");
	if (!l_file) return 1;
	while (fgets (buff,2000,l_file)){
		sscanf (buff,"%d",&code);
		switch (code){
		case LIF_PROC_START:
			sscanf (buff,"%*d(%*d,%d",&cur_proc);
			procs[cur_proc].file_id = cur_file;
			for (i = procs[cur_proc].entry; i<= procs[cur_proc].exit;
				i++){
				files[cur_file].stmts[i].active_local =
					create_bit_set (procs[cur_proc].n_locals+1);
			}
			break;
		case LIF_PROC_END:
			cur_proc = 0;
			break;
		case LIF_FORMAL_ID:
			procs[cur_proc].n_formals++;
		case LIF_LOCAL_ID:
		case LIF_GLOBAL_ID:
			sscanf (buff,"%*d(%d,%[^,)]%s",&id,id_name,flags);
			if (code == LIF_GLOBAL_ID) cur_id = globals;
			else cur_id = procs[cur_proc].locals;
			cur_id[id].name = call_malloc (strlen(id_name)+1,
				"space for id name");
			strcpy (cur_id[id].name,id_name);
			if (code == LIF_FORMAL_ID) cur_id[id].is_formal = 1;
			else cur_id[id].is_formal = 0;
			if (strchr(flags,'P')) cur_id[id].is_pointer = 1;
			else cur_id[id].is_pointer = 0;
			if (strchr(flags,'A')) cur_id[id].is_array = 1;
			else cur_id[id].is_array = 0;
			break;
		case LIF_STRUCT:
			sscanf (buff,"%*d(%d,%d,%d",&pid,&id,&offset);
			if (pid)
				procs[pid].locals[id].offset = offset;
			else globals[id].offset = offset;
			break;
		case LIF_FILE:
			sscanf (buff,"%*d(%d",&cur_file);
			break;
		case LIF_REF:
		case LIF_DEF:
		case LIF_GREF:
		case LIF_GDEF:
		case LIF_CREF:
		case LIF_CDEF:
		case LIF_AREF:
			n = sscanf (buff,"%*d(%d,%d,%d",&stmt,&id,&level);
			if (n == 2) level = 0;
			if (top_call){
				if (!call->actuals){
					actual = (actual_ptr) call_malloc (
						sizeof(actual_rec),"actual");
					actual->next = NULL;
					actual->actuals = NULL;
					call->actuals = actual;
					actual->actual_number = 1;
				}
				else actual = call->actuals;
				actual -> actuals = add_to_var_set (actual->actuals,
					id,level,code);
				if ((code == LIF_AREF) && is_lib_proc(call->pid)){
					if (procs[cur_proc].lib_arefs == NULL)
						procs[cur_proc].lib_arefs = create_bit_set (
							n_addrs+1);
					bit_on (procs[cur_proc].lib_arefs,id);
				}
			}
			else {
				if (code == LIF_GDEF){
					if (procs[cur_proc].global_defs == NULL)
						procs[cur_proc].global_defs = create_bit_set (
							n_globals+1);
					if(level){
						if (procs[cur_proc].global_idefs == NULL)
							procs[cur_proc].global_idefs =
								create_bit_set (n_globals+1);
						bit_on (procs[cur_proc].global_idefs,id);
					}
					else bit_on (procs[cur_proc].global_defs,id);
				}
				else if (code == LIF_DEF){
					if (level){
						if (procs[cur_proc].local_idefs == NULL)
							procs[cur_proc].local_idefs =
								create_bit_set (
									procs[cur_proc].n_locals+1);
						bit_on (procs[cur_proc].local_idefs,id);
					}
				}
				else if (code == LIF_CDEF){
					if (procs[cur_proc].cdefs == NULL)
						procs[cur_proc].cdefs = create_bit_set (
							n_chains+1);
					bit_on (procs[cur_proc].cdefs,id);
				}
				if ( (code == LIF_DEF) ||
					 (code == LIF_GDEF) ||
					 (code == LIF_CDEF) ) add_to =
						&files[cur_file].stmts[stmt].defs;
				else add_to = &files[cur_file].stmts[stmt].refs;
				*add_to = add_to_var_set (*add_to,id,level,code);
			}
			break;
		case LIF_SOURCE_MAP:
			sscanf (buff,"%*d(%d,%d,%d,%d,%d",&stmt,&fl,&fc,&tl,&tc);
			files[cur_file].stmts[stmt].froml = fl;
			files[cur_file].stmts[stmt].fromc = fc;
			files[cur_file].stmts[stmt].tol = tl;
			files[cur_file].stmts[stmt].toc = tc;
			break;
		case LIF_CHAIN:
		case LIF_GCHAIN:
			sscanf (buff,"%*d(%d,%d",&chain,&id);
			chains[chain].id = id;
			chains[chain].pid = LIF_GCHAIN == code? 0:cur_proc;
			break;
		case LIF_ADDRESS:
			sscanf (buff,"%*d(%d,%d,%d",&addr,&pid,&id);
			addrs[addr].id = id;
			addrs[addr].pid = pid;
			break;
		case LIF_FIELD:
			sscanf (buff,"%*d(%d,%d,%d,%[^)]",&chain,&field_seq,&offset,
				id_name);
			field = (field_ptr) call_malloc (sizeof(field_rec),
				"allocating field");
			field->next = chains[chain].fields;
			if (chains[chain].fields && 
				(chains[chain].fields->fid < field_seq)){
				at_field = chains[chain].fields;
				while (at_field -> next &&
						(at_field->next->fid < field_seq))
							at_field = at_field -> next;
				field->next = at_field->next;
				at_field->next = field;
			}
			else {
				field -> next = chains[chain].fields;
				chains[chain].fields = field;
			}
			field -> offset = offset;
			field -> fid = field_seq;
			field -> name = call_malloc (strlen(id_name)+1,
				"field name");
			strcpy (field->name,id_name);
			break;
		case LIF_SUCC:
			sscanf (buff,"%*d(%d,%d",&stmt,&id);
			files[cur_file].stmts[stmt].joins++;
			files[cur_file].stmts[stmt].succ = add_to_set (
				files[cur_file].stmts[stmt].succ,id);
			break;
		case LIF_REQUIRES:
			n = sscanf (buff,"%*d(%d,%d,%d",&stmt,&from,&to);
			if (n == 2) to = from;
			for (i = from; i <= to; i++){
				files[cur_file].stmts[i].requires = add_to_set (
				files[cur_file].stmts[i].requires,stmt);
			}
			break;
		case LIF_CALL_START:
			sscanf (buff,"%*d(%d,%d",&stmt,&pid);
			top_call++;
			sep_stack[top_call] = 1;
			call_stack[top_call] = call = (call_ptr) call_malloc (
				sizeof(call_rec),"call site");
			call -> next = procs[cur_proc].calls;
			procs[cur_proc].calls = call;
			call -> actuals = NULL;
			call -> stmt = stmt;
			call -> pid = pid;
			call -> next_this_stmt = files[cur_file].stmts[stmt].calls;