String ErrorSubSystem::get_location(const SuifObject *obj) const {
if (obj == NULL) return emptyString;
LString style = get_default_location_module();
if (style == emptyLString) {
return(obj->getClassName());
}
ModuleSubSystem *ms = get_suif_env()->get_module_subsystem();
Module *module = ms->retrieve_module(style);
LString location_iface = "get_object_location";
if (!module->supports_interface(location_iface))
{
return(obj->getClassName());
}
LocationDispatch pfunc =
(LocationDispatch)module->get_interface(location_iface);
//TODO:
#ifdef MSVC
if((int)pfunc==0x1)pfunc=NULL;
#endif
if (pfunc)
{
return ((*pfunc)(obj).print_to_string());
}
else
{
// cerr << "installed location style"
// << style.c_str() << "has no valid print function" << endl;
return(obj->getClassName());
}
}
String to_cstring(const SuifObject *obj) {
if (obj == NULL) return("(nil)");
SuifEnv* suif_env = obj->get_suif_env();
ModuleSubSystem *ms = suif_env->get_module_subsystem();
CPrintStyleModule* cprint = (CPrintStyleModule*)
ms->retrieve_module("cprint");
suif_assert_message(cprint, ("CPrintStyleModule is not loaded"));
return cprint->print_to_string(obj);
}
extern "C" void init_utils(SuifEnv *s) {
s->require_module("basicnodes");
s->require_module("suifnodes");
s->require_module("typebuilder");
s->require_module("suifcloning");
ModuleSubSystem *ms = s->get_module_subsystem();
if (!ms->is_available("constant_folding_table")) {
ms->register_module(new FoldTable(s));
}
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void SuifPrinterModule::initialize()
{
Module::initialize();
// register as a listener
ModuleSubSystem *ms = get_suif_env()->get_module_subsystem();
ms->register_interface_listener(this, "print_init");
// ms->register_interface_producer(this, "print");
set_interface("print", (Address)SuifPrinterModule::print_dispatch);
init();
}
extern "C" void init_osuiflowering( SuifEnv* suif )
{
initialize_libraries( suif );
ModuleSubSystem *mss = suif->get_module_subsystem();
mss->register_module(new LoweringPass( suif ) );
mss->register_module(new StaticMethodCallStatementLoweringPass( suif ) );
mss->register_module(new StaticMethodCallExpressionLoweringPass( suif ) );
mss->register_module(new DefinitionBlockPass( suif ) );
}
extern "C" void EXPORT init_print_styles(SuifEnv* suif)
{
suif->require_module("basicnodes");
suif->require_module("suifnodes");
ModuleSubSystem* mSubSystem = suif->get_module_subsystem();
if (!mSubSystem->retrieve_module(CPrintStyleModule::get_class_name())) {
Module *m = new CPrintStyleModule(suif);
mSubSystem -> register_module(m);
//suif->get_print_subsystem()->set_default_print_style(m->get_module_name());
}
}
extern "C" void init_s2c(SuifEnv *suif_env) {
suif_env->require_module("suifnodes");
suif_env->require_module("cfenodes");
suif_env->require_module("suifpasses");
ModuleSubSystem* mSubSystem = suif_env->get_module_subsystem();
if (!mSubSystem->retrieve_module("s2c")) {
mSubSystem -> register_module( new S2CPass( suif_env ) );
}
}
extern "C" void
init_ex1(SuifEnv *suif_env)
{
static bool init_done = false;
if (init_done)
return;
init_done = true;
ModuleSubSystem *mSubSystem = suif_env->get_module_subsystem();
mSubSystem->register_module(new Ex1SuifPass(suif_env));
// initialize the libraries required by this OPI pass
init_suifpasses(suif_env);
init_machine(suif_env);
}
extern "C" void
init_m2a(SuifEnv *suif_env)
{
static bool init_done = false;
if (init_done)
return;
init_done = true;
ModuleSubSystem *mSubSystem = suif_env->get_module_subsystem();
mSubSystem->register_module(new M2aSuifPass(suif_env));
init_suifpasses(suif_env);
init_machine(suif_env);
init_suifvm(suif_env);
}
extern "C" void init_porky(SuifEnv *suif_env) {
ModuleSubSystem *ms = suif_env->get_module_subsystem();
/*
static boolean init_done = FALSE;
if (init_done)
return;
init_done = TRUE;
enter_suif(argc, argv);
enter_suifpasses(argc, argv);
*/
/*
ms->register_module(new make_empty_file_set_symbol_table_pass());
*/
ms->register_module(new globalize_class_method_symbols_pass(suif_env,
"osuif_demo_pass"));
/*
ms->register_module(new dismantle_while_statements_pass());
ms->register_module(new dismantle_do_while_statements_pass());
ms->register_module(new dismantle_for_statements_pass());
ms->register_module(new dismantle_scope_statements_pass());
ms->register_module(new dismantle_multi_way_branch_statements_pass());
ms->register_module(new dismantle_select_instructions_pass());
ms->register_module(new dismantle_array_reference_instructions_pass());
ms->register_module(new dismantle_field_access_instructions_pass());
ms->register_module(new dismantle_extract_fields_instructions_pass());
ms->register_module(new dismantle_set_fields_instructions_pass());
ms->register_module(new dismantle_extract_elements_instructions_pass());
ms->register_module(new dismantle_set_elements_instructions_pass());
ms->register_module(new dismantle_bit_size_of_instructions_pass());
ms->register_module(new dismantle_byte_size_of_instructions_pass());
ms->register_module(new dismantle_bit_alignment_of_instructions_pass());
ms->register_module(new dismantle_byte_alignment_of_instructions_pass());
ms->register_module(new dismantle_bit_offset_of_instructions_pass());
ms->register_module(new dismantle_byte_offset_of_instructions_pass());
ms->register_module(new dismantle_sc_and_instructions_pass());
ms->register_module(new dismantle_sc_or_instructions_pass());
ms->register_module(new dismantle_sc_select_instructions_pass());
ms->register_module(new dismantle_load_value_block_instructions_pass());
ms->register_module(new dismantle_multi_way_branch_instructions_pass());
*/
}
int
main(int argc, char* argv[])
{
// initialize the environment
SuifEnv* suif_env = new SuifEnv;
suif_env->init();
init_ex5(suif_env);
// transform the input arguments into a stream of input tokens
TokenStream token_stream(argc, argv);
// execute the Module "ex5"
ModuleSubSystem* mSubSystem = suif_env->get_module_subsystem();
mSubSystem->execute("ex5", &token_stream);
delete suif_env;
return 0;
}
extern "C" void EXPORT init_suif_cfgraph(SuifEnv *suif_env) {
// Initialize libraries
//suif_env->require_module("suif_cfgraphnodes");
suif_env->require_module("bit_vector");
suif_env->require_module("suifnodes");
suif_env->require_module("cfenodes");
suif_env->require_module("typebuilder");
suif_env->require_module("suifcloning");
suif_env->require_module("suifprinter");
init_suif_cfgraphnodes( suif_env );
ModuleSubSystem *ms = suif_env->get_module_subsystem();
SuifCFGraphPass *pass = new SuifCFGraphPass(suif_env);
ms->register_module(pass);
ms->register_module(new SuifCFGraphBuilderModule(suif_env));
ms->register_module(new PrintSuifCFGraphPass(suif_env));
ms->register_module(new PrintDotSuifCFGraphPass(suif_env));
}
extern "C" void init_vtblpass( SuifEnv* suif )
{
initialize_libraries( suif );
ModuleSubSystem *mss = suif->get_module_subsystem();
if ( !mss->retrieve_module("build_single_inheritance_vtbl") ) {
mss->register_module(new VtblPass( suif ) );
mss->register_module(new VtblAnnotePass( suif ) );
mss->register_module(new VtblSlotAnnotePass( suif ) );
mss->register_module(new VtblSlotCountAnnotePass( suif ) );
mss->register_module(new InstanceMethodCallStatementLoweringPass( suif ) );
mss->register_module(new InstanceMethodCallExpressionLoweringPass( suif ) );
}
}
//----------------------------------------------------------------------------
extern "C" void EXPORT init_suifprinter(SuifEnv* suif)
{
suif->require_module("suifpasses");
// These are needed by the cprint style
suif->require_module("basicnodes");
suif->require_module("suifnodes");
ModuleSubSystem* mSubSystem = suif->get_module_subsystem();
if (!mSubSystem->retrieve_module(SuifPrinterModule::ClassName)) {
Module *m = new SuifPrinterModule(suif);
mSubSystem -> register_module(m);
suif->get_print_subsystem()->set_default_print_style(m->get_module_name());
m = new CPrintStyleModule(suif);
mSubSystem -> register_module(m);
init_suifprinter_extras(suif);
m = new IdPrinter(suif);
mSubSystem -> register_module(m);
m = new MCPrintStyleModule(suif);
mSubSystem -> register_module(m);
}
}
extern "C" void init_cpp_transforms(SuifEnv *suif_env) {
ModuleSubSystem *ms = suif_env->get_module_subsystem();
init_typebuilder(suif_env);
ms->register_module(new CombinedPassForCpp(suif_env));
}
extern "C" void init_transforms(SuifEnv *suif_env) {
ModuleSubSystem *ms = suif_env->get_module_subsystem();
suif_env->require_module("typebuilder");
suif_env->require_module("suifnodes");
suif_env->require_module("cfenodes");
suif_env->require_module("suifcloning");
suif_env->require_module("cfeutils");
suif_env->require_module("suifpasses");
suif_env->require_module("suiflocation");
suif_env->require_module("utils");
// init_typebuilder(suif_env);
/*
static boolean init_done = FALSE;
if (init_done)
return;
init_done = TRUE;
enter_suif(argc, argv);
enter_suifpasses(argc, argv);
*/
/*
ms->register_module(new make_empty_file_set_symbol_table_pass());
*/
ms->register_module(new NameAllSymbolsPass(suif_env));
ms->register_module(new AvoidExternCollisions(suif_env));
ms->register_module(new AvoidFileScopeCollisions(suif_env));
ms->register_module(new PaddingPass(suif_env));
ms->register_module(new StructPaddingPass(suif_env));
ms->register_module(new CombinedPass(suif_env));
ms->register_module(new CallExpressionDismantlerPass(suif_env));
ms->register_module(new FieldBuilderPass(suif_env));
ms->register_module(new MultiDimArrayDismantlerPass(suif_env));
ms->register_module(new NonConstBoundDismantlerPass(suif_env));
ms->register_module(new SetAddrTakenPass(suif_env));
ms->register_module(new DismantleEmptyScopeStatements(suif_env));
ms->register_module(new DismantleCallArguments(suif_env));
ms->register_module(new DismantleMultiEntryScopeStatements(suif_env));
/* DEW */
// This is in usefulpasses
//ms->register_module(new UnownedPass(suif_env));
ms->register_module(
new walker_based_module<if_statement_walker>(
suif_env, "dismantle_if_statements",
"Dismantle IfStatements to Branches and Jumps"));
ms->register_module(
new walker_based_module<while_statement_walker>(
suif_env, "dismantle_while_statements",
"Dismantle all WhileStatements to Branches and Jumps"));
ms->register_module(
new walker_based_module<do_while_statement_walker>(
suif_env, "dismantle_do_while_statements",
"Dismantle all DoWhileStatements to Branches and Jumps"));
ms->register_module(
new walker_based_module<for_statement_walker>(
suif_env, "dismantle_for_statements",
"Dismantle all ForStatements to Branches and Jumps"));
ms->register_module(
new walker_based_module<c_for_statement_walker>(
suif_env, "dismantle_c_for_statements",
"Dismantle all CForStatements"));
ms->register_module(
new walker_based_module<scope_statement_walker>(
suif_env, "dismantle_scope_statements",
"Dismantle all ScopeStatements and move their symbols"));
ms->register_module(
new walker_based_module<multi_way_branch_statement_walker>(
suif_env, "dismantle_multi_way_branch_statements",
"Dismantle all MultiWayBranchStatements to Branches and Jumps"));
ms->register_module( new ArrayReferenceDismantlerPass(suif_env));
// A number of the expression dismantlers were not implemented in SUIFX, so they are grouped at
// the end of the list here
ms->register_module(
new walker_based_module<field_access_expression_walker>(
suif_env, "dismantle_field_access_expressions",
"Dismantle all FieldAccessExpressions to pointer arithmetic"));
/*
ms->register_module(
new walker_based_module<call_expression_walker>(
suif_env, "dismantle_call_expressions"));
*/
// A multi-way branch re-organiser
ms->register_module(
new walker_based_module<multi_way_branch_statement_compactor>(
suif_env, "compact_multi_way_branch_statements",
"convert multi-way branches to IfStatements with dense multi-way branches"));
ms->register_module(new AvoidLabelCollisions(suif_env));
ms->register_module(new RepeatValueBlockBuilderPass(suif_env));
// ms->register_module(new walker_based_module<extract_fields_expression_walker>(suif_env, "dismantle_extract_fields_expressions"));
// ms->register_module(new walker_based_module<extract_elements_expression_walker>(suif_env, "dismantle_extract_elements_expressions"));
// ms->register_module(new walker_based_module<byte_size_of_expression_walker>(suif_env, "dismantle_byte_size_of_expressions"));
#if 0
// These are not implemented in SUIFX or the new Suif (yet)
ms->register_module(new walker_based_module<select_expression_walker>(suif_env, "dismantle_sc_select_expressions"));
ms->register_module(new walker_based_module<array_reference_expression_walker>(suif_env, "dismantle_array_reference_expressions"));
ms->register_module(new walker_based_module<set_fields_expression_walker>(suif_env, "dismantle_set_fields_expressions"));
ms->register_module(new walker_based_module<set_elements_expression_walker>(suif_env, "dismantle_set_elements_expressions"));
ms->register_module(new walker_based_module<bit_size_of_expression_walker>(suif_env, "dismantle_bit_size_of_expressions"));
ms->register_module(new walker_based_module<bit_alignment_of_expression_walker>(suif_env, "dismantle_bit_alignment_of_expressions"));
ms->register_module(new walker_based_module<byte_alignment_of_expression_walker>(suif_env, "dismantle_byte_alignment_of_expressions"));
ms->register_module(new walker_based_module<bit_offset_of_expression_walker>(suif_env, "dismantle_bit_offset_of_expressions"));
ms->register_module(new walker_based_module<byte_offset_of_expression_walker>(suif_env, "dismantle_byte_offset_of_expressions"));
ms->register_module(new walker_based_module<sc_and_expression_walker>(suif_env, "dismantle_sc_and_expressions"));
ms->register_module(new walker_based_module<sc_or_expression_walker>(suif_env, "dismantle_sc_or_expressions"));
ms->register_module(new walker_based_module<sc_select_expression_walker>(suif_env, "dismantle_sc_select_expressions"));
ms->register_module(new walker_based_module<load_value_block_expression_walker>(suif_env, "dismantle_load_value_block_expressions"));
ms->register_module(new walker_based_module<multi_way_branch_expression_walker>(suif_env, "dismantle_multi_way_branch_expressions"));
#endif
ms->register_module(new RemoveIfAndLoopPass(suif_env));
ms->register_module(new FlattenStatementListsPass(suif_env));
ms->register_module(new RemoveIfAndLoopPass(suif_env));
ms->register_module(new AddProcedureEndLabelsPass(suif_env));
ms->register_module(new One2MultiArrayExpressionPass(suif_env));
//ms->register_module(new EliminateArrayConvertsPass(suif_env));
ms->register_module(new CFor2ForPass(suif_env));
ms->register_module(new DismantleStructuredReturns(suif_env));
ms->register_module(new NormalizeProcedureReturns(suif_env));
ms->register_module(new RequireProcedureReturns(suif_env));
ms->register_module(new LoadExpressionDismantlerPass(suif_env));
ms->register_module(new FoldStatementsPass(suif_env));
ms->register_module(new DismantleStmtsWithJumpsInside(suif_env));
ms->register_module(new AddStatementListsToProcs(suif_env));
ms->register_module(new AddExplicitLoopLabels(suif_env));
ms->register_module(new FixupExplicitLoopLabels(suif_env));
ms->register_module(new RemoveExplicitLoopLabels(suif_env));
ms->register_module(new IfConditionsToBinaryExprs(suif_env));
ms->register_module(new GuardAllFors(suif_env));
ms->register_module(new MarkGuardedFors(suif_env));
}
