C-Breeze C Compiler Infrastructure [ Project home page]

pointers.h Go to the documentation of this file. // $Id: pointers.h,v 1.37 2003/09/29 13:01:33 toktb Exp $ // ---------------------------------------------------------------------- // // C-Breeze // C Compiler Framework // // Copyright (c) 2000 University of Texas at Austin // // Samuel Z. Guyer // Daniel A. Jimenez // Calvin Lin // // Permission is hereby granted, free of charge, to any person // obtaining a copy of this software and associated documentation // files (the "Software"), to deal in the Software without // restriction, including without limitation the rights to use, copy, // modify, merge, publish, distribute, sublicense, and/or sell copies // of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be // included in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // NONINFRINGEMENT. IN NO EVENT SHALL THE UNIVERSITY OF TEXAS AT // AUSTIN BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER // IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF // OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. // // We acknowledge the C-to-C Translator from MIT Laboratory for // Computer Science for inspiring parts of the C-Breeze design. // // ---------------------------------------------------------------------- #ifndef CBZ_POINTERS_H #define CBZ_POINTERS_H #include "pointeroptions.h" #include "location.h" #include "memorymodel.h" #include "memoryblock.h" #include "proceduredb.h" #include "linker.h" #include "ipanalysis.h" #include "pointervalue.h" #include "constants.h" #include "unification.h" // TB_unify typedef map< stmtNode *, declNode *> heap_map; typedef heap_map::iterator heap_map_p; typedef list< memoryblock_set > memoryblock_set_list; typedef memoryblock_set_list::iterator memoryblock_set_list_p; class Pointers { public: typedef set< string > string_set; typedef string_set::iterator string_set_p; typedef pair< int, double > count_accuracy_pair; typedef map< stmtLocation *, count_accuracy_pair > accuracy_map; typedef accuracy_map::iterator accuracy_map_p; protected: memoryModel Memory; heap_map HeapMap; procNode * Root; procLocation * root_location; Linker & linker; procedureDB Procedures; constantAnalyzer _constants; analysisProblem * Problem; bool computePointers; Direction _direction; int _procedureCount; int _skipCount; bool _show_progress; bool _use_multiplicity; string_set _unknown_procedures; accuracy_map _def_accuracy; accuracy_map _star_accuracy; UnificationBasedPtr *_unification_based; public: Pointers(procNode * root, Linker & l, unitNode * unit); virtual ~Pointers(); inline Linker & getLinker() const { return linker; } virtual void run_unification(); inline UnificationBasedPtr *unification_analyzer() const { return _unification_based; } inline void use_unification_analyzer(UnificationBasedPtr *u) { Memory.unification(_unification_based = u); } void analyze(); void analyze(analysisProblem * problem); virtual void initialize() {} inline constantAnalyzer & get_constants() { return _constants; } void clear(); void show_progress() { _show_progress = true; } void hide_progress() { _show_progress = false; } void turn_on_multiplicity() { _use_multiplicity = true; } void turn_off_multiplicity() { _use_multiplicity = false; } void analyze_procedure(procLocation * current, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes); virtual void procedure_call(procedureInfo * caller, stmtLocation * current, operandNode * call, operand_list & args, pointerValue & call_target, memoryBlock * target_mb, pointervalue_list & arguments, memoryblock_set & external_defs, memoryuse_set & external_uses, memoryblock_set & external_changes, pointerValue & return_val, bool & never_returns); void analyze_procedure_at(procedureInfo * callee, stmtLocation * callsite, pointervalue_list & arguments, memoryblock_set & external_defs, memoryuse_set & external_uses, memoryblock_set & external_changes, pointerValue & return_val); void pass_parameters(procedureInfo * info, stmtLocation * callsite, pointervalue_list & arguments, memoryblock_set & parameters, memoryblock_set & changed_inputs); void pass_return_value(procedureInfo * info, stmtLocation * current_callsite, pointerValue & return_val, memoryblock_set & changes); void process_merge_point(procedureInfo * info, basicblockLocation * current_block, pointerValue & result, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes); void process_local_changes(procedureInfo * info, basicblockLocation * current_block, memoryblock_set & local_changes, memoryblock_set & changes); void pass_external_inputs(procedureInfo * info, stmtLocation * current_callsite, memoryuse_set & external_uses, memoryblock_set & changed_inputs); void pass_one_external_input(procedureInfo * callee, procedureInfo * caller, stmtLocation * current_callsite, memoryBlock * block_to_pass, memoryblock_set & changed_inputs); void pass_external_outputs(procedureInfo * info, stmtLocation * current_callsite); void pass_one_external_output(procedureInfo * info, stmtLocation * current_callsite, memoryBlock * block_to_pass, bool is_return_val); void record_external_inputs_and_outputs(procedureInfo * callee, procLocation * current, pointervalue_list & arguments, //TB memoryblock_set & parameters, memoryblock_set & defs, memoryblock_set & external_defs, memoryuse_set & uses, memoryuse_set & external_uses, memoryblock_set & changes, memoryblock_set & external_changes); virtual void conservative_procedure_call(procedureInfo * info, stmtLocation * current, pointervalue_list & arguments, memoryblock_set & reachable, memoryblock_set & external_defs, memoryuse_set & external_uses, memoryblock_set & external_changes, pointerValue & return_val); void eval(procedureInfo * info, stmtLocation * current, exprNode * E, stmtNode *cur_stmt, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes, pointerValue & result, bool & never_returns); // TB: new. void eval(procedureInfo * info, stmtLocation * current, threeAddrNode *threeAddr, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes, pointerValue & result, bool & never_returns); void star_operator(procedureInfo * info, Location * current, pointerValue & operand, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes, pointerValue & result); void dot_operator(Location * current, const string & field_name, declNode * field_decl, pointerValue & operand, memoryuse_set & uses, pointerValue & result); void struct_union_assignment(procedureInfo * info, stmtLocation * current, threeAddrNode *threeaddr, sueNode * suetype, pointerValue & left_hand_side, pointerValue & right_hand_side, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes); virtual void assignment_operator(procedureInfo * info, Location * current, stmtLocation * parameter_callsite, pointerValue & left_hand_side, pointerValue & right_hand_side, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes); void merge_operator(procedureInfo * info, Location * current, memoryBlock * block_to_merge, memoryuse_list & phi_uses, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes); void self_assignment(Location * from, Location * to, memoryBlock * block, memoryblock_set & changes); void call_operator(procedureInfo * caller, stmtLocation * current, operandNode * call, operand_list & args, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes, pointerValue & result, pointerValue & call_targets, bool & never_returns); void determine_call_targets(procedureInfo * caller, stmtLocation * current, operandNode * call, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes, pointerValue & targets); void generate_uses(procedureInfo * info, Location * where, memoryuse_set & uses, pointerValue & pointer); memoryDef * nearest_def_at(procedureInfo * info, memoryBlock * block, Location * where); void reachable_blocks(Location * where, memoryblock_list & worklist, memoryblock_set & already_seen); procedureInfo * lookup_procedure(procNode * proc); bool is_pointer_expression(operandNode * operand); void stats(ostream & out); void uses_and_defs(); void show_accuracy(); protected: // -- Manage the heap memoryBlock * at_allocation(const string & name, procedureInfo * info, stmtLocation * current, stmtNode * allocation_stmt, declNode * decl, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes, pointerValue & result); void at_deallocation(procedureInfo * info, Location * current, pointerValue & to_deallocate, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes); Multiplicity current_multiplicity(procedureInfo * info, Location * current, memoryBlock * block, memoryuse_set & uses); // memoryBlock * lookup_heap_object(stmtLocation * current); static bool is_allocation(pointerValue & call_targets); static bool is_deallocation(pointerValue & call_targets); static bool is_reallocation(pointerValue & call_targets); void mark_as_indexed(memoryblock_set & blocks); void setup_va_list_variables(procedureInfo * info, procLocation * callee_path, stmtLocation * parameter_callsite, procNode * callee, memoryBlock * ellipsis); static bool is_va_list(declNode * decl); static bool is_va_list(exprNode * expr); static bool is_va_arg(pointerValue & call_targets); static bool is_va_start(pointerValue & call_targets); static bool is_va_end(pointerValue & call_targets); static bool is_exit(pointerValue & call_targets); public: static void merge(const memoryblock_set & source, memoryblock_set & dest); static void print_memoryblock_set(const string & label, const memoryblock_set & the_set, ostream & o); static void print_memoryblock_def_set(const string & label, const memoryblock_set & the_set, ostream & o); static void print_memorydef_set(const string & label, const memorydef_set & the_set, ostream & o); void progress_meter(procedureInfo * info, bool skipped); static long int call_counter; double compute_accuracy(accuracy_map & accuracy_data); inline proc_info_map procedures() const { return Procedures.procedures(); } }; #endif // CBZ_POINTERS_H

Generated on February 1, 2006
Back to the C-Breeze home page