pss.c

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

							if (a_pid)printf ("%s",
								procs[a_pid].locals[a_id].name);
							else printf ("%s",globals[a_id].name);
						}
						printf ("\n");
							*/
						count += add_aref_to_var (r,id);
					}
					break;
				case LIF_GDEF:
					if (globals[var_defed].is_pointer){
						id = globals[var_defed].ptr_id;
						/*
						printf ("assign to %d addr of %d: ",
							d->id,r->id);
						if (id){
							printf (" %s = &",
								globals[var_defed].name);
							if (a_pid)printf ("%s",
								procs[a_pid].locals[a_id].name);
							else printf ("%s",globals[a_id].name);
						}
						printf ("\n");
						*/
						count += add_aref_to_var (r,id);
					}
					break;
				case LIF_CDEF:
					/*
					printf ("cdef %d (%d,%d)\n",var_defed,
						chains[var_defed].id,
						chains[var_defed].pid);
					*/
					get_cdefs(var_defed);
					ptr = -1;
					/*
					printf ("update ptrs (%d):",id);
					*/
					while ((ptr = get_next_member (ptrs_out,ptr)) >= 0){
					/*
						printf (" %d",ptr);
					*/
						count += add_aref_to_var (r,ptr);
					}
					/*
					printf ("\n");
					*/
					break;
				default:
					break;
				}
				d = d -> next;
			}
		}
		r = r -> next;
	}
	return count;
}

int prop_call (pid,fid,sid)
	int		pid,fid,sid;
{
	var_ptr	r,d;
	int		rp,var_refed,rix,var_defed,id;
	int		count = 0,ptr;
	int		called_pid;
	call_ptr c;
	set_ptr	ret_addrs,old;

	/* printf ("%5d %5d %5d\n",pid,fid,sid); */
	d = files[fid].stmts[sid].defs;
	if (!d && !files[fid].stmts[sid].is_return) return 0;
	if (!files[fid].stmts[sid].calls) return 0;
	c = files[fid].stmts[sid].calls;
	while (c){
		called_pid = c->pid;
		if (proc_ret_ptrs[called_pid]){
			if (procs[pid].returns_xpr &&
				files[fid].stmts[sid].is_return){
					old = proc_ret_ptrs[pid];
					ret_addrs = proc_ret_ptrs[called_pid];
					while (ret_addrs){
						proc_ret_ptrs[pid] = add_to_set (
							proc_ret_ptrs[pid],ret_addrs->id);
						ret_addrs = ret_addrs->next;
					}
					count += (old != proc_ret_ptrs[pid]);
			}
			d = files[fid].stmts[sid].defs;
			while (d && (d->level == 0)){
				var_defed = d->id;
				id = 0;
				switch (d->code){
				case LIF_DEF:
					if (procs[pid].locals[var_defed].is_pointer){
						id = procs[pid].locals[var_defed].ptr_id;
					}
					break;
				case LIF_GDEF:
					if (globals[var_defed].is_pointer){
						id = globals[var_defed].ptr_id;
					}
					break;
				case LIF_CDEF:
					get_cdefs(var_defed);
					id = 0;
					break;
				default:
					break;
				}
				/* count += pointer_assign (id,rp); */
				if (id){
					count += call_assign (id,called_pid);
				}
				else {
					ptr = -1;
					while ((ptr = get_next_member (ptrs_out,ptr)) >= 0){
						/*
						if(rp)count += pointer_assign (ptr,rp);
						*/
					}
				}
				d = d -> next;
			}
		}
		c = c -> next;
	}
	return count;
}

int prop_stmt (pid,fid,sid)
	int		pid,fid,sid;
{
	var_ptr	r,d;
	int		rp,var_refed,rix,var_defed,id;
	int		count = 0,ptr;

	/* printf ("%5d %5d %5d\n",pid,fid,sid); */
	r = files[fid].stmts[sid].refs;
	while (r){
		/*
		printf ("rcode %s\n",
			r->code == LIF_AREF?"AREF":(r->code == LIF_CREF?
				"chain ref":(r->code == LIF_REF?"local ref":
				"global ref")));
		*/
		if (r -> code != LIF_AREF){
			if (r -> code != LIF_CREF){
				var_refed = r->id;
				if (r->code == LIF_REF){
					rp = procs[pid].locals[var_refed].ptr_id;
				}
				else {
					rp = globals[var_refed].ptr_id;
				}
				if ((rp == 0) && (r -> code != LIF_CREF))
					{r = r->next; continue;}
				rix = ptrs[rp].id;
				/*
				printf ("ptr id %d addr %d, idx %d var_refed %d %s\n",
					rp,ptrs[rp].addrs,
					rix,var_refed,r->code==LIF_REF?"local":"global");
				*/
			}
			else {
				get_crefs (r->id);
				rp = 0;
			}
			if (procs[pid].returns_xpr &&
				files[fid].stmts[sid].is_return){
					count += ret_assign (pid,rp);
			}
			d = files[fid].stmts[sid].defs;
			while (d && (d->level == 0)){
				var_defed = d->id;
				/*
				printf ("def code %d\n",d->code);
				*/
				switch (d->code){
				case LIF_DEF:
					if (procs[pid].locals[var_defed].is_pointer){
						id = procs[pid].locals[var_defed].ptr_id;
						/*
						printf ("assign to ptr %d contents of ptr %d: ",
							id,rp);
						if (id){
							printf (" %s = ",
								procs[pid].locals[var_defed].name);
							printf ("%s", ids[rix]->name);
						}
						printf ("\n");
						*/
						if(rp)count += pointer_assign (id,rp);
						else {
							rp = -1;
							/*
							printf ("update ptrs (%d):",rp);
							*/
							while ((rp = get_next_member
									(ptrs_refed,rp)) >= 0){
								count += pointer_assign (id,rp);
							}
						}
					}
					break;
				case LIF_GDEF:
					if (globals[var_defed].is_pointer){
						id = globals[var_defed].ptr_id;
						/*
						printf ("assign to %d contents of %d: ",
							id,rp);
						if (id){
							printf (" %s = ",
								globals[var_defed].name);
							printf ("%s", ids[rix]->name);
						}
						printf ("\n");
							*/
						if(rp)count += pointer_assign (id,rp);
						else {
							rp = -1;
							/*
							printf ("update ptrs (%d):",rp);
							*/
							while ((rp = get_next_member
									(ptrs_refed,rp)) >= 0){
								count += pointer_assign (id,rp);
							}
						}
					}
					break;
				case LIF_CDEF:
					/*
					printf ("cdef %d (%d,%d)\n",var_defed,
						chains[var_defed].id,
						chains[var_defed].pid);
					*/
					get_cdefs(var_defed);
					ptr = -1;
					/*
					printf ("update ptrs (%d):",rp);
					*/
					while ((ptr = get_next_member (ptrs_out,ptr)) >= 0){
						/*
						printf (" %d",ptr);
						WHAT ABOUT RP == 0 ??????
						*/
						if(rp)count += pointer_assign (ptr,rp);
						else {
							rp = -1;
							while ((rp = get_next_member
									(ptrs_refed,rp)) >= 0){
								count += pointer_assign (ptr,rp);
							}
							rp = 0;
						}
					}
					/*
					printf ("\n");
					*/
					break;
				default:
					break;
				}
				d = d -> next;
			}
		}
		r = r -> next;
	}
	return count;
}

int do_a_call(pid,fid,call)
	int		pid,fid;
	call_ptr call;
{
	int		change = 0,called_pid,fp;
	int		rix,a_id,a_pid,fpx;
	id_ptr	formals;
	actual_ptr act;
	var_ptr	a_list;

	called_pid = call->pid;
	if (is_lib_proc(called_pid)) return 0;
	formals = procs[called_pid].locals;
	/*
	printf ("call %s (%d formals)",procs[called_pid].proc_name,
		procs[called_pid].n_formals);
		*/
	for (fp = 1; fp <= procs[called_pid].n_formals; fp++){
		/*
		printf ("  %s (%d)",formals[fp].name,fp);
		*/
		if (formals[fp].is_pointer){
			/*
			printf("*");
			*/
			fpx = formals[fp].ptr_id;
			act = call->actuals;
			while (act && act->actual_number != fp)
				act = act->next;
			if (act){
				a_list = act->actuals;
				while(a_list){
					/*
					printf ("actual code %d\n",a_list->code);
					*/
					if (a_list->code == LIF_AREF){
						change += add_aref_to_var (a_list,fpx);
						a_pid = addrs[a_list->id].pid;
						a_id = addrs[a_list->id].id;
						/*
						printf ("==>&%s",a_pid?
							procs[a_pid].locals[a_id].name:
							globals[a_id].name);
						*/
					}
					else {
						if (a_list->code == LIF_REF){
							rix = procs[pid].locals[a_list->id].ptr_id;
						}
						else if (a_list->code == LIF_GREF){
							rix = globals[a_list->id].ptr_id;
						}
						else rix = 0;
						if(rix){
							change += pointer_assign (fpx,rix);
						}
						else if(a_list->code == LIF_CREF){
							get_cdefs (a_list->id);
							rix = -1;
							/*
							printf ("update call ptrs (%d):",rix);
							*/
							while ((rix =
								get_next_member (ptrs_out,rix)) >= 0){
								change += pointer_assign (fpx,rix);
							}
							/*
							printf ("\n");
							*/
						}
					}
					a_list = a_list->next;
				}
			}
		}
	}
	/*
	printf ("\n");
	*/
	return change;
}

int direct_assigns()
{
	int		pid,fid,sid;
	int		change = 0;

	/*
	printf ("get direct assigns\n");
	*/
	for (pid = 1; pid <= n_procs; pid++){
		if (procs[pid].entry != -1){
			fid = procs[pid].file_id;
			for (sid = procs[pid].entry; sid <= procs[pid].exit; sid++){
				change += capture_assigns(pid,fid,sid);
			}
		}
	}
	return change;
}

int propagate()
{
	int		pid,fid,sid;
	int		change = 0;

	/*
	printf ("propagate\n");
	*/
	for (pid = 1; pid <= n_procs; pid++){
		if (procs[pid].entry != -1){
			/*
			printf ("prop %s (%d)\n",procs[pid].proc_name,pid);
			*/
			fid = procs[pid].file_id;
			for (sid = procs[pid].entry; sid <= procs[pid].exit; sid++){
				change += prop_call(pid,fid,sid);
				change += prop_stmt(pid,fid,sid);
			}
		}
	}
	return change;
}

int do_calls()
{
	int		pid,fid,sid;
	int		change = 0;
	call_ptr call_list;

	/*
	printf ("do_calls\n");
	*/
	for (pid = 1; pid <= n_procs; pid++){
		if (procs[pid].entry != -1){
			fid = procs[pid].file_id;
			call_list = procs[pid].calls;
			while(call_list){
				change += do_a_call(pid,fid,call_list);
				call_list = call_list->next;
			}
		}
	}
	return change;
}

flow()
{
	int		change;

	ptrs_in = create_bit_set (n_ptrs+1);
	ptrs_out = create_bit_set (n_ptrs+1);
	ptrs_refed = create_bit_set (n_ptrs+1);
	change = 1;
	while (change){
		change = 0;
		change += direct_assigns();
		change += do_calls();
		change += propagate();
		if(v_opt)printf ("%d changes\n",change);
	}
	if(v_opt)print_pvs();
}