void Pass::execute() {
FileSetBlock *fsb = _suif_env->get_file_set_block();
if (fsb == NULL)
suif_warning("%s: Pass execution attempted without a file set block\n",
get_module_name().c_str());
else
do_file_set_block( fsb );
}
void SuifCFGraphPass::do_procedure_definition(ProcedureDefinition *proc_def )
{
CFGraphQuery q(get_suif_env(), proc_def);
// bool verbose = _verbose_output->is_set();
bool dot_output = _dot_output->is_set();
if (dot_output) {
const char *fname =
(String(proc_def->get_procedure_symbol()->get_name()) + ".dot").c_str();
FILE *fp = fopen(fname, "w");
if (!fp) {
suif_warning("Could not open file '%s'\n", fname);
} else {
file_ion the_ion(fp);
q.print_dot(&the_ion);
fclose(fp);
}
}
}
/*
#define NO_IMMED_DOM ((size_t)-1)
array_tos<SGraphNode> *build_immediate_dominators(
const SGraph *reachable,
const SGraph *domination,
tos<SGraphNode> *rev_postord_list,
SGraphNode root,
bool do_forward) {
*/
void build_immediate_dominators(SGraph *immed_doms,
const SGraph *reachable,
const SGraph *domination,
SGraphNodeList *rev_postord_list,
SGraphNode root,
bool do_forward) {
//unsigned num = reachable->max_num_nodes();
// unsigned root = (forward ? entry_node()->number() : exit_node()->number());
// Bit_set *d = (forward ? doms : pdoms);
/*
array_tos<SGraphNode> *immed_doms =
new array_tos<SGraphNode>;
for (unsigned i = 0; i < num; i++) {
// cfgraph_node **im = new cfgraph_node*[num];
immed_doms->set_elem(i, NO_IMMED_DOM);
// im[root] = NULL;
}
*/
// Iterate over all of the nodes
for (SNodeIter iter(domination->get_node_iterator());
!iter.done(); iter.increment()) {
// for (unsigned n = 0; n < num; n++) {
SGraphNode current_node = iter.get();
/* the root node has no dominators */
if (current_node == root) continue;
/* remove self for comparison */
// domination->remove_edge(n, n);
// d[n].remove(n);
/* check nodes in dominator set */
bool found = false;
// iterate over all of the possible predecessors
for (SNodeIter iter2(domination->get_node_iterator());
!iter2.done(); iter2.increment()) {
// bit_set_iter diter(&d[n]);
// while (!diter.is_empty()) {
SGraphNode check_node = iter2.get();
if (check_node == current_node) continue;
// Now iterate over the successors of current_node and check_node
// at the same time. Ignore self.
SNodeIter current_iter(domination->get_node_successor_iterator(current_node, do_forward));
SNodeIter check_iter(domination->get_node_successor_iterator(check_node, do_forward));
bool not_found = false;
// The easier way:
// get the first, remove it
// then compare.
for (; !current_iter.done() && !check_iter.done();
current_iter.increment(), check_iter.increment()) {
// while (!current_iter.done() &&
// !check_iter.done()) {
// SGraphNode current_edge = current_iter.get();
if (current_node == current_iter.get()) {
current_iter.increment();
if (current_iter.done()) break;
}
// SGraphNode check_edge = check_iter.get();
if (current_iter.get() != check_iter.get()) {
not_found = true;
break;
}
}
if (!not_found &&
!current_iter.done() &&
check_iter.done()) {
if (current_iter.get() == current_node) {
current_iter.increment();
}
}
if (!not_found &&
current_iter.done() &&
check_iter.done()) {
found = true;
immed_doms->add_edge(SGraphEdge(current_node,check_node));
break;
}
}
if (!found) {
suif_warning("can't find idom of node %u", current_node);
}
}
}
void EliminateArrayConvertsPass::do_procedure_definition(ProcedureDefinition* proc_def){
suif_hash_map<ParameterSymbol*, Type*> params;
TypeBuilder *tb = (TypeBuilder*)
get_suif_env()->get_object_factory(TypeBuilder::get_class_name());
// collect all procedure parameters of pointer type into params list
for(Iter<ParameterSymbol*> iter = proc_def->get_formal_parameter_iterator();
iter.is_valid(); iter.next())
{
ParameterSymbol* par_sym = iter.current();
Type* par_type = tb->unqualify_type(par_sym->get_type());
if(is_kind_of<PointerType>(par_type)){
// put NULLs into the map at first,
// they will later be overwritten
params[par_sym] = NULL;
}
}
if(params.size()==0) return; // nothing to do
// walk thru all AREs and look for arrays that are in the param list
{for(Iter<ArrayReferenceExpression> iter =
object_iterator<ArrayReferenceExpression>(proc_def);
iter.is_valid(); iter.next())
{
ArrayReferenceExpression* are = &iter.current();
if(is_kind_of<UnaryExpression>(are->get_base_array_address())){
UnaryExpression* ue = to<UnaryExpression>(are->get_base_array_address());
if(ue->get_opcode() == k_convert){
if(is_kind_of<LoadVariableExpression>(ue->get_source())){
LoadVariableExpression* lve =
to<LoadVariableExpression>(ue->get_source());
VariableSymbol* array = lve->get_source();
for(suif_hash_map<ParameterSymbol*, Type*>::iterator iter = params.begin();
iter!=params.end();iter++)
{
ParameterSymbol* par_sym = (*iter).first;
if(par_sym == array){
// match!
Type* array_type;
suif_hash_map<ParameterSymbol*, Type*>::iterator iter =
params.find(par_sym);
if(iter==params.end() || (*iter).second==NULL){
//array_type = to<PointerType>(ue->get_result_type())->get_reference_type();
array_type = tb->get_qualified_type(ue->get_result_type());
params[par_sym] = array_type;
//printf("%s has type ",par_sym->get_name().c_str());
//array_type->print_to_default();
}else{
array_type = params[par_sym].second;
suif_assert(is_kind_of<QualifiedType>(array_type));
}
array->replace(array->get_type(), array_type);
remove_suif_object(ue);
remove_suif_object(lve);
lve->replace(lve->get_result_type(), tb->unqualify_type(array_type));
// put the LoadVar directly under ARE
are->set_base_array_address(lve);
//are->print_to_default();
}
}
} else {
suif_warning(ue->get_source(),
("Expecting a LoadVariableExpression here"));
}
} else {
suif_warning(ue, ("Disallow converts in AREs for "
"things other than procedure parameters"));
}
}
}
}
}
