VariableSymbol *build_string_constant_variable(SuifEnv *env,const char *string) { TypeBuilder *tb = (TypeBuilder *) env->get_object_factory(TypeBuilder::get_class_name()); IntegerType *char_type = tb->get_integer_type(sizeof(char)*BITSPERBYTE, sizeof(char)*BITSPERBYTE,true); size_t len = 0; while (string[len]) len ++; QualifiedType *q_char_type = tb->get_qualified_type(char_type); ArrayType *string_literal_type = tb->get_array_type(q_char_type,0,len + 1); MultiValueBlock *string_literal_initialization = create_multi_value_block(env,string_literal_type); for (size_t char_num = 0; char_num <= len; ++char_num) { string_literal_initialization->add_sub_block( char_num, create_expression_value_block( env, create_int_constant( env,char_type,string[char_num]))); } return build_initialized_variable(env,emptyLString,string_literal_type, string_literal_initialization,true); }
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; }
Walker::ApplyStatus NonConstBoundArrayTypeWalker::operator () (SuifObject *x) { ArrayTypeProxy type(to<DataType>(x)); if (!type.has_non_const_bounds()) return Walker::Continue; Type *rep_type = _type_builder->get_array_type(_type_builder->get_qualified_type(type.get_element_type()),0,1); set_address(rep_type); to<BasicSymbolTable>(x->get_parent())->remove_symbol_table_object( to<SymbolTableObject>(x)); return Walker::Replaced; }
Walker::ApplyStatus sctis_multi_way_branch_statement_walker::operator () (SuifObject *x) { SuifEnv *env = get_env(); MultiWayBranchStatement *multi_way_stmt = to<MultiWayBranchStatement>(x); ProcedureDefinition *proc_def = get_procedure_definition(multi_way_stmt); TypeBuilder *tb = get_type_builder(env); BrickAnnote *end_label_annote = to<BrickAnnote>(multi_way_stmt->lookup_annote_by_name("end_label")); SuifObjectBrick *sob = to<SuifObjectBrick>(end_label_annote->get_brick(0)); CodeLabelSymbol *end_label_sym = to<CodeLabelSymbol>(sob->get_object()); Expression *decision_expr = multi_way_stmt->get_decision_operand(); CodeLabelSymbol *default_label_sym = multi_way_stmt->get_default_target(); Statement *replacement = get_statement_block_btw_labels(proc_def, default_label_sym, end_label_sym); cout << "ADDED " << print_statement(replacement); for(Iter<indexed_list<IInteger, CodeLabelSymbol*>::pair> iter = multi_way_stmt->get_case_iterator(); iter.is_valid(); iter.next()) { indexed_list<IInteger, CodeLabelSymbol*>::pair case_pair = iter.current(); Expression *condition_expr = create_binary_expression(env, tb->get_boolean_type(), String("is_equal_to"), to<Expression>(deep_suif_clone(decision_expr)), create_int_constant(env, decision_expr->get_result_type(), case_pair.first)); Statement *then_stmt = get_statement_block_btw_labels(proc_def, case_pair.second, end_label_sym); print_statement(then_stmt); replacement = create_if_statement(env, condition_expr, then_stmt, replacement); } Statement *next_stmt = get_next_statement(multi_way_stmt); bool is_removal_complete = 0; while(!is_removal_complete && next_stmt != NULL) { if(is_a<LabelLocationStatement>(next_stmt)) { if((to<LabelLocationStatement>(next_stmt))->get_defined_label() == end_label_sym) is_removal_complete = 1; } remove_statement(next_stmt); next_stmt = get_next_statement(multi_way_stmt); } multi_way_stmt->get_parent()->replace(multi_way_stmt, replacement); set_address(replacement); return Walker::Replaced; }
IntConstant* build_vtbl_slot_count_int_constant( SuifEnv* env, ClassType* owning_class ) { TypeBuilder* tb = get_type_builder( env ); IntConstant* icnst = ::create_int_constant( env, tb->get_integer_type( true ), // result_type IInteger() // value: inserted later ); attach_vtbl_slot_count_annote( env, icnst, owning_class ); return icnst; }
IntConstant* build_vtbl_slot_int_constant( SuifEnv* env, InstanceMethodSymbol* msym ) { TypeBuilder* tb = get_type_builder( env ); IntConstant* icnst = ::create_int_constant( env, tb->get_integer_type( true ), // result_type IInteger() // value: inserted later ); attach_vtbl_slot_annote( env, icnst, msym ); return icnst; }
TypePtr Type::newType(const std::wstring& name, Category category, const TypeDeclarationPtr& reference, const TypePtr& parentType, const std::vector<TypePtr>& protocols, const GenericDefinitionPtr& generic) { assert(!name.empty()); TypeBuilder* ret = new TypeBuilder(category); ret->name = name; ret->reference = reference; ret->parentType = parentType; ret->protocols = protocols; ret->genericDefinition = generic; if(parentType) ret->addParentTypesFrom(parentType); for(const TypePtr& t : protocols) { ret->addParentTypesFrom(t); } if(parentType) ret->inheritantDepth = parentType->inheritantDepth + 1; return TypePtr(ret); }
ITypeBuilder* TypeBuilder::create( TypeKind kind, INamespace* ns, const std::string& name ) { TypeBuilder* tb = NULL; switch( kind ) { case TK_ENUM: tb = new EnumBuilder; break; case TK_EXCEPTION: tb = new ExceptionTypeBuilder; break; case TK_STRUCT: tb = new StructBuilder; break; case TK_NATIVECLASS: tb = new NativeClassBuilder; break; case TK_INTERFACE: tb = new InterfaceBuilder; break; case TK_COMPONENT: tb = new ComponentBuilder; break; default: assert( false ); } assert( tb ); tb->initialize( ns, name ); return tb; }
static Expression *build_empty_expression(DataType *t) { SuifEnv *s = t->get_suif_env(); suif_assert_message(!is_kind_of<GroupType>(t), ("build_empty_expression:: can not handle GroupType")); if (is_kind_of<VoidType>(t)) return(NULL); if (is_kind_of<IntegerType>(t)) { IntConstant *c = create_int_constant(s, t, IInteger(0)); return c; } // This works for Int, Float, Enum, pointers TypeBuilder *tb = get_type_builder(s); IntegerType *it = tb->get_integer_type(); IntConstant *c = create_int_constant(s, it, IInteger(0)); Expression *cvt = create_unary_expression(s, t, k_convert, c); return(cvt); }
Walker::ApplyStatus dste_call_statement_walker2::operator () (SuifObject *x) { SuifEnv *env = get_env(); CallStatement *call_stmt = to<CallStatement>(x); SymbolAddressExpression *callee_address = to<SymbolAddressExpression>(call_stmt->get_callee_address()); ProcedureSymbol *proc_symbol = to<ProcedureSymbol>(callee_address->get_addressed_symbol()); String called_proc_name = proc_symbol->get_name(); if(called_proc_name == String("ROCCC_lookup_in_state_table")){ Expression *argument_expr = call_stmt->get_argument(0); if(is_a<UnaryExpression>(argument_expr)) argument_expr = (to<UnaryExpression>(argument_expr))->get_source(); int st_id = (to<IntConstant>(argument_expr))->get_value().c_int(); suif_map<int, ST*>::iterator iter = state_table_defs->find(st_id); if(iter == state_table_defs->end()) return Walker::Continue; ST* state_table_def = (*iter).second; int pattern_length = state_table_def->get_length(); int state_count = state_table_def->get_state_count(); int alphabet_count = state_table_def->get_alphabet_count(); int start_state = state_table_def->get_start_state(); int error_state = state_table_def->get_error_state(); int final_state = state_table_def->get_final_state(); VariableSymbol *char_set_array_sym = state_table_def->get_char_set_sym(); DataType *stream_data_type = get_array_element_type(char_set_array_sym); QualifiedType *qualed_stream_data_type = retrieve_qualified_type(stream_data_type); VariableSymbol *state_table_sym = state_table_def->get_state_table_sym(); DataType *dfa_state_data_type = get_array_element_type(state_table_sym); QualifiedType *qualed_dfa_state_type = retrieve_qualified_type(dfa_state_data_type); StatementList *replacement = create_statement_list(env); argument_expr = call_stmt->get_argument(1); argument_expr->set_parent(0); if(is_a<UnaryExpression>(argument_expr)) argument_expr = (to<UnaryExpression>(argument_expr))->get_source(); VariableSymbol* input_char_sym = new_anonymous_variable(env, proc_def_body, qualed_stream_data_type); name_variable(input_char_sym, "ic"); StoreVariableStatement *store_var_stmt = create_store_variable_statement(env, input_char_sym, argument_expr); replacement->append_statement(store_var_stmt); TypeBuilder *tb = get_type_builder(env); SymbolTable *external_symbol_table = get_external_symbol_table(get_procedure_definition(call_stmt)); list<QualifiedType*> cam_proc_argument_types; for(int j = 0; j < alphabet_count+1; j++) cam_proc_argument_types.push_back(qualed_stream_data_type); DataType *cam_return_type; int cam_return_bit_size = get_unsigned_bit_size(alphabet_count); cam_return_type = tb->get_integer_type(cam_return_bit_size, cam_return_bit_size, 0); cam_return_type->set_name(String("ROCCC_int") + String(cam_return_bit_size)); CProcedureType *cam_proc_type = tb->get_c_procedure_type(cam_return_type, cam_proc_argument_types); ProcedureSymbol *cam_proc_sym = create_procedure_symbol(env, cam_proc_type, String("ROCCC_cam") + String(alphabet_count)); external_symbol_table->add_symbol(cam_proc_sym); VariableSymbol* alphabet_index_sym = new_anonymous_variable(env, proc_def_body, retrieve_qualified_type(cam_return_type)); name_variable(alphabet_index_sym, "ais"); SymbolAddressExpression *cam_proc_sym_expr = create_symbol_address_expression(env, tb->get_pointer_type(cam_proc_type), cam_proc_sym); CallStatement *cam_macro_stmt = create_call_statement(env, alphabet_index_sym, cam_proc_sym_expr); for(int j = 0; j < alphabet_count; j++){ Expression *cam_argument_expr = create_symbol_address_expression(env, char_set_array_sym->get_type()->get_base_type(), char_set_array_sym); cam_argument_expr = create_array_reference_expression(env, stream_data_type, cam_argument_expr, create_int_constant(env, tb->get_integer_type(), IInteger(j))); cam_argument_expr = create_load_expression(env, stream_data_type, cam_argument_expr); cam_macro_stmt->append_argument(cam_argument_expr); } cam_macro_stmt->append_argument(create_load_variable_expression(env, stream_data_type, input_char_sym)); replacement->append_statement(cam_macro_stmt); suif_vector<VariableSymbol*>* state_column_vars = new suif_vector<VariableSymbol*>; for(int i = 0; i < state_count; i++){ VariableSymbol* state_column_sym = new_anonymous_variable(env, proc_def_body, qualed_dfa_state_type); name_variable(state_column_sym, "st"); state_column_vars->push_back(state_column_sym); } list<QualifiedType*> mux_proc_argument_types; for(int j = 0; j < alphabet_count; j++) mux_proc_argument_types.push_back(qualed_dfa_state_type); mux_proc_argument_types.push_back(retrieve_qualified_type(cam_return_type)); CProcedureType *mux_proc_type = tb->get_c_procedure_type(dfa_state_data_type, mux_proc_argument_types); ProcedureSymbol *mux_proc_sym = create_procedure_symbol(env, mux_proc_type, String("ROCCC_mux") + String(alphabet_count)); external_symbol_table->add_symbol(mux_proc_sym); ArrayType *state_table_array_type = to<ArrayType>(state_table_sym->get_type()->get_base_type()); for(int i = 0; i < state_count; i++){ if(i == error_state){ StoreVariableStatement *state_column_var_init_stmt = create_store_variable_statement(env, state_column_vars->at(i), create_int_constant(env, tb->get_integer_type(), IInteger(i))); replacement->append_statement(state_column_var_init_stmt); continue; } SymbolAddressExpression *mux_proc_sym_expr = create_symbol_address_expression(env, tb->get_pointer_type(mux_proc_type), mux_proc_sym); CallStatement *mux_macro_stmt = create_call_statement(env, state_column_vars->at(i), mux_proc_sym_expr); for(int j = 0; j < alphabet_count; j++){ Expression *mux_argument_expr = create_symbol_address_expression(env, state_table_array_type, state_table_sym); mux_argument_expr = create_array_reference_expression(env, state_table_array_type->get_element_type()->get_base_type(), mux_argument_expr, create_int_constant(env, tb->get_integer_type(), IInteger(i))); mux_argument_expr = create_array_reference_expression(env, dfa_state_data_type, mux_argument_expr, create_int_constant(env, tb->get_integer_type(), IInteger(j))); mux_argument_expr = create_load_expression(env, dfa_state_data_type, mux_argument_expr); mux_macro_stmt->append_argument(mux_argument_expr); } mux_macro_stmt->append_argument(create_load_variable_expression(env, cam_return_type, alphabet_index_sym)); replacement->append_statement(mux_macro_stmt); } suif_vector<VariableSymbol*>* current_state_vars = new suif_vector<VariableSymbol*>; suif_vector<VariableSymbol*>* next_state_vars = new suif_vector<VariableSymbol*>; StatementList *var_init_stmt_list = create_statement_list(env); for(int i = 0; i < pattern_length; i++){ VariableSymbol* current_state_sym = new_anonymous_variable(env, proc_def_body, qualed_dfa_state_type); name_variable(current_state_sym, "cs"); BrickAnnote *feedback_level_annote = create_brick_annote(env, "feedback_level"); current_state_sym->append_annote(feedback_level_annote); feedback_level_annote->insert_brick(0, create_integer_brick(env, IInteger(0))); current_state_vars->push_back(current_state_sym); StoreVariableStatement *init_var_stmt = create_store_variable_statement(env, current_state_sym, create_int_constant(env, dfa_state_data_type, IInteger(start_state))); var_init_stmt_list->append_statement(init_var_stmt); VariableSymbol* next_state_sym = new_anonymous_variable(env, proc_def_body, qualed_dfa_state_type); name_variable(next_state_sym, "ns"); next_state_vars->push_back(next_state_sym); } insert_statement_before(get_enclosing_c_for_stmt(call_stmt), var_init_stmt_list); mux_proc_argument_types.empty(); for(int j = 0; j < state_count+1; j++) mux_proc_argument_types.push_back(qualed_dfa_state_type); mux_proc_type = tb->get_c_procedure_type(dfa_state_data_type, mux_proc_argument_types); mux_proc_sym = create_procedure_symbol(env, mux_proc_type, String("ROCCC_mux") + String(state_count)); external_symbol_table->add_symbol(mux_proc_sym); for(int i = 0; i < pattern_length; i++){ SymbolAddressExpression *mux_proc_sym_expr = create_symbol_address_expression(env, tb->get_pointer_type(mux_proc_type), mux_proc_sym); CallStatement *mux_macro_stmt = create_call_statement(env, next_state_vars->at(i), mux_proc_sym_expr); for(int k = 0; k < state_count; k++) mux_macro_stmt->append_argument(create_load_variable_expression(env, dfa_state_data_type, state_column_vars->at(k))); mux_macro_stmt->append_argument(create_load_variable_expression(env, dfa_state_data_type, current_state_vars->at(i))); replacement->append_statement(mux_macro_stmt); } Expression *equality_check_expr = create_binary_expression(env, tb->get_boolean_type(), String("is_equal_to"), create_load_variable_expression(env, dfa_state_data_type, next_state_vars->at(0)), create_int_constant(env, dfa_state_data_type, IInteger(final_state))); VariableSymbol *destination_sym = call_stmt->get_destination(); StoreVariableStatement *result_stmt = create_store_variable_statement(env, destination_sym, equality_check_expr); replacement->append_statement(result_stmt); for(int i = 1; i < pattern_length; i++){ equality_check_expr = create_binary_expression(env, tb->get_boolean_type(), String("is_equal_to"), create_load_variable_expression(env, dfa_state_data_type, next_state_vars->at(i)), create_int_constant(env, dfa_state_data_type, IInteger(final_state))); Expression *result_expr = create_binary_expression(env, tb->get_boolean_type(), String("logical_or"), create_load_variable_expression(env, tb->get_boolean_type(), destination_sym), equality_check_expr); result_stmt = create_store_variable_statement(env, destination_sym, result_expr); replacement->append_statement(result_stmt); } for(int i = 0; i < pattern_length-1; i++){ StoreVariableStatement *store_var_stmt = create_store_variable_statement(env, current_state_vars->at(i+1), create_load_variable_expression(env, dfa_state_data_type, next_state_vars->at(i))); replacement->append_statement(store_var_stmt); } call_stmt->get_parent()->replace(call_stmt, replacement); return Walker::Truncate; } return Walker::Continue; }
void DismantleStructuredReturns::do_file_set_block( FileSetBlock* file_set_block ) { suif_map<CProcedureType *,QualifiedType *> type_map; list<ArrayReferenceExpression*> ref_exprs; SuifEnv *env = 0; TypeBuilder *tb = 0; VoidType *vt = 0; for (Iter<ProcedureSymbol> iter = object_iterator<ProcedureSymbol>(file_set_block); iter.is_valid(); iter.next()) { ProcedureSymbol *sym = &iter.current(); Type *type = sym->get_type(); if (!is_kind_of<CProcedureType>(type)) continue; CProcedureType *cp_type = to<CProcedureType>(type); type = cp_type->get_result_type(); if (!env) { env = type->get_suif_env(); tb = (TypeBuilder*) env->get_object_factory(TypeBuilder::get_class_name()); vt = tb->get_void_type(); } suif_map<CProcedureType *,QualifiedType *>::iterator t_iter = type_map.find(cp_type); QualifiedType *qtype; if (t_iter == type_map.end()) { if (!is_kind_of<GroupType>(type) && !is_kind_of<ArrayType>(type)) continue; qtype = tb->get_qualified_type( tb->get_pointer_type(to<DataType>(type))); cp_type->set_result_type(vt); cp_type->insert_argument(0,qtype); type_map.enter_value(cp_type,qtype); } else { qtype = (*t_iter).second; } ProcedureDefinition *def = sym->get_definition(); if (!def) continue; ParameterSymbol *par = create_parameter_symbol(env,qtype); def->get_symbol_table()->append_symbol_table_object(par); def->insert_formal_parameter(0,par); // Convert all returns into assigned and returns for (Iter<ReturnStatement> ret_iter = object_iterator<ReturnStatement>(def->get_body()); ret_iter.is_valid(); ret_iter.next()) { ReturnStatement *ret = &ret_iter.current(); Expression *retval = ret->get_return_value(); ret->set_return_value(0); retval->set_parent(0); insert_statement_before(ret, create_store_statement(env,retval,create_var_use(par))); } } // Change all calls to the new form for (Iter<CallStatement> cs_iter = object_iterator<CallStatement>(file_set_block); cs_iter.is_valid(); cs_iter.next()) { CallStatement *call = &cs_iter.current(); Type *type = call->get_callee_address()->get_result_type(); Type *p_type = tb->unqualify_type(to<PointerType>(type)->get_reference_type()); if (!is_kind_of<PointerType>(p_type)) continue; p_type = tb->unqualify_type(to<PointerType>(p_type)->get_reference_type()); if (!is_kind_of<CProcedureType>(p_type)) continue; CProcedureType *cp_type = to<CProcedureType>(p_type); suif_map<CProcedureType *,QualifiedType *>::iterator t_iter = type_map.find(cp_type); if (t_iter == type_map.end()) continue; QualifiedType *qtype = (*t_iter).second; DataType *var_type = to<DataType>(tb->unqualify_type(to<PointerType>(qtype->get_base_type()) ->get_reference_type())); VariableSymbol *var = new_anonymous_variable(env,call,tb->get_qualified_type(var_type)); Expression *exp = create_symbol_address_expression( env, tb->get_pointer_type(var_type), var); call->insert_argument(0,exp); call->set_destination(0); } for (Iter<CallExpression> ce_iter = object_iterator<CallExpression>(file_set_block); ce_iter.is_valid(); ce_iter.next()) { CallExpression *call = &ce_iter.current(); Type *type = call->get_callee_address()->get_result_type(); Type *p_type = tb->unqualify_type(to<PointerType>(type)->get_reference_type()); if (!is_kind_of<PointerType>(p_type)) continue; p_type = tb->unqualify_type(to<PointerType>(p_type)->get_reference_type()); if (!is_kind_of<CProcedureType>(p_type)) continue; CProcedureType *cp_type = to<CProcedureType>(p_type); ; suif_map<CProcedureType *,QualifiedType *>::iterator t_iter = type_map.find(cp_type); if (t_iter == type_map.end()) continue; QualifiedType *qtype = (*t_iter).second; DataType *var_type = to<DataType>(tb->unqualify_type(to<PointerType>(qtype->get_base_type()) ->get_reference_type())); VariableSymbol *var = new_anonymous_variable(env,call,tb->get_qualified_type(var_type)); Expression *exp = create_symbol_address_expression( env, tb->get_pointer_type(var_type), var); call->insert_argument(0,exp); Statement *loc = get_expression_owner(call); call->get_parent()->replace(call,create_var_use(var)); call->set_parent(0); suif_assert(vt != 0); call->set_result_type(vt); EvalStatement *es = create_eval_statement(env); insert_statement_before(loc,es); // Would be better to turn this into a call statement es->append_expression(call); } }
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")); } } } } }
void One2MultiArrayExpressionPass::do_procedure_definition(ProcedureDefinition* proc_def) { bool kill_all = !(_preserve_one_dim->is_set()); // access all array type declarations and create corresponding multi array types SuifEnv* suif_env = proc_def->get_suif_env(); TypeBuilder* tb = (TypeBuilder*)suif_env-> get_object_factory(TypeBuilder::get_class_name()); (void) tb; // avoid warning #ifdef CONVERT_TYPES for (Iter<ArrayType> at_iter = object_iterator<ArrayType>(proc_def); at_iter.is_valid();at_iter.next()) { MultiDimArrayType* multi_type = converter->array_type2multi_array_type(&at_iter.current()); } #endif //CONVERT_TYPES // collect tops of array access chains into this list list<ArrayReferenceExpression*> ref_exprs; for (Iter<ArrayReferenceExpression> are_iter = object_iterator<ArrayReferenceExpression>(proc_def); are_iter.is_valid(); are_iter.next()) { // itself an array and parent is *not* an array ArrayReferenceExpression* are = &are_iter.current(); if((kill_all || is_kind_of<ArrayReferenceExpression>(are->get_base_array_address())) && !is_kind_of<ArrayReferenceExpression>(are->get_parent())) { //printf("%p \t", are);are->print_to_default(); ref_exprs.push_back(are); } } // for top all expressions, convert them to multi-exprs for(list<ArrayReferenceExpression*>::iterator ref_iter = ref_exprs.begin(); ref_iter != ref_exprs.end(); ref_iter++) { ArrayReferenceExpression* top_array = *ref_iter; converter->convert_array_expr2multi_array_expr(top_array); } #ifdef CONVERT_TYPES // replace the types of all array variables for (Iter<VariableSymbol> iter = object_iterator<VariableSymbol>(proc_def); iter.is_valid();iter.next()) { VariableSymbol* vd = &iter.current(); DataType *vtype = tb->unqualify_data_type(vd->get_type()); if (is_kind_of<ArrayType>(vtype)) { MultiDimArrayType* multi_type = converter->array_type2multi_array_type(to<ArrayType>(vtype)); vd->replace(vd->get_type(), tb->get_qualified_type(multi_type)); } } // remove the remaining one-dim array types converter->remove_all_one_dim_array_types(); #endif //CONVERT_TYPES // make sure no traces of single-dim arrays are left if(kill_all){ {for(Iter<ArrayReferenceExpression> iter = object_iterator<ArrayReferenceExpression>(proc_def); iter.is_valid(); iter.next()) { // ArrayReferenceExpression* are = &iter.current(); //are->print_to_default(); printf("at %p \t", are); suif_assert_message(false, ("ARE not eliminated")); } } #ifdef CONVERT_TYPES {for(Iter<ArrayType> iter = object_iterator<ArrayType>(proc_def); iter.is_valid(); iter.next()) {suif_assert_message(false, ("ArrayType not eliminated"));}} #endif } }