VariableSymbol *build_initialized_variable(
SuifEnv *env,
const LString &name,
DataType *type,
ValueBlock *vb,
bool make_static) {
TypeBuilder *tb = (TypeBuilder *)
env->get_object_factory(TypeBuilder::get_class_name());
FileSetBlock *fsb = env->get_file_set_block();
suif_assert_message(fsb->get_file_block_count() == 1,("File is ambiguous"));
FileBlock *fb = fsb->get_file_block(0);
BasicSymbolTable *symtab = to<BasicSymbolTable>(fb->get_symbol_table());
DefinitionBlock *def = fb->get_definition_block ();
QualifiedType *q_type = tb->get_qualified_type(type);
VariableSymbol *var = create_variable_symbol(
env,q_type, name, false );
symtab->append_symbol_table_object(var);
VariableDefinition *vardef =
create_variable_definition(env,var,type->get_bit_alignment(),
vb,make_static);
def->append_variable_definition(vardef);
return var;
}
/*--------------------------------------------------------------------
* add_std_fse_menu
*
*/
void
add_std_fse_menu(vmenu* root_menu, char* parent_menu)
{
/* file set entry submenu */
FileSetBlock *fsb = suif_env->get_file_set_block();
if (!fsb) return;
for (int i = 0; i < fsb->get_file_block_count(); ++i) {
FileBlock *file = fsb->get_file_block(i);
binding *b = new binding((bfun) &do_show_fse, file);
const char* name = file->get_source_file_name().c_str();
root_menu->add_command(b, parent_menu, name ? name : "<no name>" );
}
}
ProcedureDefinition *CreateSuifComplexInputPass::build_main( const char *main_file ) {
DefinitionBlock* file_def_block = create_definition_block( _suif_env );
SymbolTable *file_symbol_table = create_basic_symbol_table( _suif_env );
FileSetBlock* fsb = _suif_env -> get_file_set_block();
// SymbolTable* ext_table = fsb->get_file_set_symbol_table();
FileBlock * the_file_block =
create_file_block( _suif_env, main_file,
file_symbol_table,
file_def_block);
fsb->append_file_block(the_file_block);
ProcedureSymbol *main_symbol =
create_procedure_symbol( _suif_env,_main_type, "main", true );
fsb -> get_external_symbol_table() -> add_symbol(main_symbol);
StatementList *main_body = create_statement_list( _suif_env );
BasicSymbolTable* main_symbol_table =
create_basic_symbol_table( _suif_env, file_symbol_table );
DefinitionBlock* main_def_block = create_definition_block( _suif_env );
ProcedureDefinition *main_definition =
create_procedure_definition( _suif_env, main_symbol, main_body,main_symbol_table,main_def_block);
ParameterSymbol *argc_symbol = create_parameter_symbol( _suif_env, _q_argc_type, "argc", false );
main_definition->get_symbol_table()->add_symbol(argc_symbol);
main_definition->append_formal_parameter(argc_symbol);
ParameterSymbol *argv_symbol =
create_parameter_symbol( _suif_env, _q_argv_type, "argv", false );
main_definition->get_symbol_table()->add_symbol(argv_symbol);
main_definition->append_formal_parameter(argv_symbol);
the_file_block->get_definition_block()->
append_procedure_definition(main_definition);
return main_definition;
}
list<ProcedureSymbol*> *
get_procedure_list(FileSetBlock *file_set,
bool flag_exported,
bool flag_static,
bool flag_nested,
bool flag_def_only)
{
list<ProcedureSymbol*> *procs = new list<ProcedureSymbol*>;
FileSetBlock *fsb = file_set;
// no file_set_block sepcified
if (!fsb) return procs;
// =============== exported procedures ================
if (flag_exported)
add_to_procedure_list(procs,
fsb->get_external_symbol_table(), flag_def_only);
// =============== static procedures ==================
if (flag_static) {
// add the symbols in the static fileset symbol table
add_to_procedure_list(procs,
fsb->get_file_set_symbol_table(), flag_def_only);
// iterate over the files and add their symbol tables
for (int i = 0; i < fsb->get_file_block_count(); ++i) {
FileBlock *file_block = fsb->get_file_block(i);
add_to_procedure_list(procs,
file_block->get_symbol_table(), flag_def_only);
}
}
// =============== nested procedures ==================
if ( flag_nested ) {
// iterate over the files
for (int i=0; i < fsb->get_file_block_count(); ++i) {
FileBlock *file_block = fsb->get_file_block(i);
DefinitionBlock * def_block = file_block->get_definition_block();
// iterate over the procedures
s_count_t count = def_block->get_procedure_definition_count();
for (s_count_t proc_counter=0; proc_counter < count; ++proc_counter) {
ProcedureDefinition *proc = def_block->get_procedure_definition(i);
add_to_procedure_list(procs, proc, flag_def_only );
}
}
}
return procs;
}
/*--------------------------------------------------------------------
* info_viewer::view
*
*/
void info_viewer::view(vnode* vn)
{
if ( !vn ) return;
text->clear();
text->tag_begin( vn );
fstream& fout = text->fout();
char *tag = vn->get_tag();
text->tag_style(BOLD_BEGIN);
fout << "Object: 0x" << (void*)vn->get_object() << '(' << tag << ")\n";
text->tag_style(BOLD_END);
/* properties */
text->tag_style( BOLD_BEGIN );
fout << "Properties:\n";
text->tag_style( BOLD_END );
list<vprop *> *plist = vn->get_prop_list();
if ( !plist || plist->empty() ) {
fout << "<No properties defined>\n";
} else {
for ( s_count_t i = 0; i < plist->size(); i++ ) {
vprop* p = (*plist)[i];
if ( p->name() ) {
char* desc = p->description();
fout << '[' << p->name() << "]: " << (desc ? desc : "") << endl;
}
}
}
fout << endl;
SuifObject* obj;
if ( tag == tag_suif_object ) {
obj = (SuifObject*) vn->get_object();
} else if ( tag == tag_code_fragment ) {
code_fragment* f = (code_fragment*) vn->get_object();
obj = (SuifObject*) f->node();
} else {
suif_assert_message(false, ("Unknown tag"));
}
text->tag_style( BOLD_BEGIN );
const MetaClass *m = obj->get_meta_class();
fout << "Suif object type: " << m->get_class_name().c_str() << "\n\n";
text->tag_style( BOLD_END );
// if obj is a file_set_block => print the whole file_set_block
// in all other cases just print the obj
formater f(suif_env, text, -1 ); //is_file_set_block( obj ) ? -1 : 1 );
if ( is_kind_of<FileSetBlock>( obj ) ) {
// print only the annotes
FileSetBlock *fb = to<FileSetBlock>(obj);
Iter<Annote*> annote_iter = fb->get_annote_iterator();
for ( int i = 0; i < (int)fb->get_annote_count(); i++ ) {
Annote* ann = annote_iter.current();
annote_iter.next();
vn = create_vnode( ann );
text->tag_begin( vn );
f.print_zot( ann, fout );
text->tag_end( vn );
fout << endl;
}
} else {
f.print_zot( obj, fout );
fout << endl;
}
text->tag_end( vn );
text->update();
}
void GCSymbolTablePass::execute(void)
{
// Let's try a little optimization.
// we'll do GC like the trash_it routine.
// walk through all of the owned objects in the program.
// for the non-symbols, walk through their sub-objects and
// find any referenced symbols
// throw away any that are not needed.
FileSetBlock *fsb = get_suif_env()->get_file_set_block();
if (fsb == NULL) return;
static LString k_trash = "trash";
// remove the trash annote. we'll replace it later
Annote *trash_annote = fsb->take_annote(k_trash);
suif_hash_map<SymbolTableObject*,bool> referenced_map;
suif_list<SymbolTableObject*> live_symbols;
// Now we have a map of Object->parent object
// We need another one for object -> referenced
for (Iter<SuifObject> all_iter1 = object_iterator<SuifObject>(fsb);
all_iter1.is_valid(); all_iter1.next()) {
SuifObject *obj = &all_iter1.current();
// for the ownership links of symbols:
if (is_kind_of<SymbolTable>(obj)) continue;
if (is_kind_of<SymbolTableObject>(obj)) {
SymbolTableObject *sym = to<SymbolTableObject>(obj);
//sym->print_to_default();
if (referenced_map.find(sym) == referenced_map.end()) {
//fprintf(stderr, "Found unreferenced Symbol:");
// referenced_map[sym] = false;
referenced_map.enter_value(sym, false);
}
// we will check these later.
continue;
}
for (Iter<SymbolTableObject> ref_iter =
suif_object_ref_iterator<SymbolTableObject>(obj,
SuifObject::get_class_name());
ref_iter.is_valid(); ref_iter.next()) {
SymbolTableObject *sym_ref = &ref_iter.current();
suif_hash_map<SymbolTableObject*,bool>::iterator find =
referenced_map.find(sym_ref);
if (find == referenced_map.end()
|| (*find).second == false) {
//fprintf(stderr, "Found Symbol Reference:");
//sym_ref->print_to_default();
//referenced_map[sym_ref] = true;
referenced_map.enter_value(sym_ref, true);
live_symbols.push_back(sym_ref);
}
}
}
// Now we have to do a worklist algorithm with the live symbols.
// any symbol they own or reference must also be live
while (!live_symbols.empty()) {
SymbolTableObject *obj = live_symbols.back();
live_symbols.pop_back();
// Implicit assumption:
// it will NEVER OWN another symbol.
// If it did, we just need to use the object_instance_iterator
// to add these.
// Everything it references is live.
for (Iter<SymbolTableObject> ref_iter =
suif_object_ref_iterator<SymbolTableObject>(obj,
SuifObject::get_class_name());
ref_iter.is_valid(); ref_iter.next()) {
SymbolTableObject *sym_ref = &ref_iter.current();
suif_hash_map<SymbolTableObject*,bool>::iterator find =
referenced_map.find(sym_ref);
if (find == referenced_map.end()
|| (*find).second == false) {
//fprintf(stderr, "Found Symbol reference:");
//sym_ref->print_to_default();
// referenced_map[sym_ref] = true;
referenced_map.enter_value(sym_ref, true);
live_symbols.push_back(sym_ref);
}
}
}
if (trash_annote != NULL)
fsb->append_annote(trash_annote);
// walk over all of the reference
// and delete or put back
for (suif_hash_map<SymbolTableObject*, bool>::iterator obj_iter =
referenced_map.begin();
obj_iter != referenced_map.end(); obj_iter++) {
bool is_referenced = (*obj_iter).second;
if (!is_referenced) {
SymbolTableObject *sym = (*obj_iter).first;
//fprintf(stderr, "Trashing unused symbol:");
//sym->print_to_default();
SymbolTable *st = sym->get_symbol_table();
if (st != NULL) {
if (sym->get_name() != emptyLString) {
st->remove_all_from_lookup_table(sym);
}
st->remove_symbol_table_object(sym);
}
remove_suif_object(sym);
trash_it(_suif_env, sym);
// delete sym;
}
}
// SuifGC::collect(_suif_env->get_file_set_block());
}
