C-Breeze C Compiler Infrastructure [ Project home page]

memoryblock.h Go to the documentation of this file. // $Id: memoryblock.h,v 1.30 2003/08/08 15:16:29 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_MEMORYBLOCK_H #define CBZ_MEMORYBLOCK_H #include "pointeroptions.h" #include "location.h" #include "memoryaccess.h" #include "proceduredb.h" #include "unification.h" #include <set> // ------------------------------------------------------------ // Memory block // Each object in memory that may be a pointer, or pointed to is // represented by a memoryBlock. class memoryBlock; typedef list< memoryBlock * > memoryblock_list; typedef memoryblock_list::iterator memoryblock_list_p; typedef map< int, memoryBlock *, less< int > > component_map; typedef component_map::iterator component_map_p; typedef component_map::const_iterator component_map_cp; typedef vector< memoryBlock * > memoryblock_vector; typedef memoryblock_vector::iterator memoryblock_vector_p; // -- Keep track of the reaching objects that are combined at a // context-insensitive procedure call (the self-assignments generated when // this object is an external input). typedef map< stmtLocation *, memoryblock_set > callsite_objects_map; typedef callsite_objects_map::iterator callsite_objects_map_p; typedef callsite_objects_map::const_iterator callsite_objects_map_cp; typedef map< procNode *, callsite_objects_map > parameter_assign_map; typedef parameter_assign_map::iterator parameter_assign_map_p; class enumPropertyAnn; class memoryBlock : public PerClassHeap< PointersHeap > { public: typedef enum { Control_flow, Parameter_pass, Weak_update, Additive } DestructiveKind; typedef map< Location *, DestructiveKind > destructive_assignment_map; typedef destructive_assignment_map::iterator destructive_assignment_map_p; typedef destructive_assignment_map::const_iterator destructive_assignment_map_cp; typedef map< Location *, memoryblock_set > complicit_assignment_map; typedef complicit_assignment_map::iterator complicit_assignment_map_p; typedef complicit_assignment_map::const_iterator complicit_assignment_map_cp; static int memoryblock_count; static void stats(); private: REF memoryBlock * _container; TREE orderedDefs Defs; TREE orderedUses Uses; parameter_assign_map _parameter_assignments; REF memoryUse * _current_use; REF memoryDef * _current_def; component_map _components; declNode * _decl; int _synthetic_decl:1; int _write_protected:1; int _is_array:1; int _is_array_element:1; int _is_indexed:1; int _is_allocation_object:1; int _flow_sensitive:1; // TB_unify int _unify:1; int _single_assignment:1; int _is_return_value:1; procNode * _local_to; // string _name; stmtLocation * _allocation_site; // memoryDef * _initializer_def; memoryBlock * _allocation_object; // memoryDef * _only_def; // memoryUse * _only_use; procedureinfo_set _input_to; destructive_assignment_map _destructive_assignments; complicit_assignment_map _complicit_assignments; UnifyType *_unifytype; // TB_unify public: // --- These two members are just for Broadway enumPropertyAnn * property; memoryblock_vector property_blocks; private: friend class memoryModel; memoryBlock(declNode * decl, bool synthetic, memoryBlock * container, procNode * local_to); ~memoryBlock(); public: void clear(); // --- Data members declNode * decl() const { return _decl; } procNode * local_to() const { return _local_to; } bool is_synthetic_decl() const { return _synthetic_decl; } bool write_protected() const { return _write_protected; } void set_write_protected() { _write_protected = true; } bool is_indexed() const { return _is_indexed; } void set_indexed() { _is_indexed = true; } // void set_name(const string & new_name) { _name = new_name; } stmtLocation * allocation_site() const { return _allocation_site; } bool is_heap_object() const { return _allocation_site != 0; } void set_heap_object(stmtLocation * alloc_site) { _allocation_site = alloc_site; } bool is_allocation_object() const { return _is_allocation_object; } memoryUse * current_use() const { return _current_use; } memoryDef * current_def() const { return _current_def; } void reset_current_def_use(Location * unused); void set_current_def_use(Location * where); inline memoryBlock * container() const { return _container; } inline bool is_flow_sensitive() const { return _flow_sensitive; } inline void set_flow_sensitive() { _flow_sensitive = true; // cout << "SETFS: (0x" << this << ") " << name() << endl; } inline void set_flow_insensitive() { _flow_sensitive = false; } inline bool is_unify() const { return _unify; } inline void set_unify(bool flag) { _unify = flag; } inline UnifyType *unifyType() const { return _unifytype; } inline void unifyType(UnifyType *t) { _unifytype=t; } inline bool is_single_assignment() const { return _single_assignment; } inline bool is_return_value() const { return _is_return_value; } inline bool set_return_value() { _is_return_value = true; } // inline memoryDef * only_def() const { return _only_def; } // inline memoryUse * only_use() const { return _only_use; } inline procedureinfo_set & input_to() { return _input_to; } // --- Manage uses and defs memoryDef * def_at(Location * where, bool & is_new); memoryDef * nearest_def_at(Location * where); /* memoryDef * nearest_def_at(Location * where, const procedurecall_stack & callstack); */ memoryUse * use_at(Location * where); memoryDef * last_def_at(basicblockLocation * block); memoryDef * find_def_at(Location * where); memoryUse * find_use_at(Location * where); void find_uses_at(Location * where, memoryuse_set & uses); inline const memorydef_list & defs() const { return Defs.def_list(); } void add_parameter_assignment(procNode * proc, stmtLocation * callsite, memoryBlock * block); void add_parameter_assignment(procNode * proc, stmtLocation * callsite, memoryblock_set & blocks); const callsite_objects_map & parameter_assignments(procNode * proc) { return _parameter_assignments[proc]; } void apply_weak_update(Location * current, memoryDef * previous_def, memoryuse_set & uses); void setup_merge_uses_at(basicblockLocation * merge_location, memoryDef * reaching_def, basicblock_set & predecessors); void merge_uses_at(basicblockLocation * where, memoryuse_list & uses, cfg_edge_set & active_edges, memoryDef * dominating_def, bool computePointers); void reachable_blocks(Location * where, bool has_use_here, memoryblock_list & worklist, memoryblock_set & already_seen, memoryBlock * null); memoryBlock * get_allocation_object(memoryModel & Memory); memoryBlock * allocation_object(); Multiplicity at_allocation(Location * current, memoryDef * reaching_def, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes); Multiplicity at_deallocation(Location * current, memoryDef * reaching_def, memoryblock_set & defs, memoryuse_set & uses, memoryblock_set & changes); void add_destructive_assignment(Location * where, DestructiveKind cause); void add_complicit_assignment(Location * where, memoryblock_set & objects); void add_complicit_assignment(Location * where, memoryBlock * object); const destructive_assignment_map & destructive_assignments() const { return _destructive_assignments; } const complicit_assignment_map & complicit_assignments() const { return _complicit_assignments; } void add_to_flow_sensitive_list(flow_sensitive_set & flow_sensitive_objects); bool is_in_flow_sensitive_list(flow_sensitive_set & flow_sensitive_objects); void set_flow_sensitivity(flow_sensitive_set & flow_sensitive_objects); void add_to_non_unify_list(UnifyTypes & non_unify_types); void set_unification(UnifyTypes & unify_types); memoryBlock * top_most_container(); // TB_unify /* @brief Get all parents. */ memoryblock_set containers() const; memoryblock_set top_most_containers(); static void print_multiplicity(Multiplicity m, ostream & out); void def_uses(memoryDef * def, memoryuse_list & uses); // --- Prune out unneeded uses and defs void prune_defs_uses(); // --- Manage structure fields void dot(const string & field_name, declNode * field_decl, memoryModel & Memory, memoryblock_set & results); // --- Handle special array objects bool is_array() const { return _is_array; } bool is_array_element() const { return _is_array_element; } void set_array_element(memoryBlock * element); memoryBlock * get_array_element(); memoryDef * setup_array_def(); // --- Scoping bool in_scope(basicblockLocation * where) const; // --- Output friend ostream& operator<<(ostream & o, const memoryBlock & mb) { // mb.print(o, Path::always()); return o; } // --- Pass after = true to see the points-to information after the // given statement has been executed. typedef enum { NAME_ONLY, CURRENT_VALUE, AFTER_ASSIGNMENT, ALL_VALUES } Output_mode; void print(ostream & o, Location * path, Output_mode mode = CURRENT_VALUE) const; string name() const; string generate_su_field_name(const string & field) const; void print_def_use(ostream & o) const; // --- Update the def-use chains (only performed once at the end of // analysis by the memoryModel). void update_def_use_chains(); // --- Statistics void stats(ostream & out, bool header, long int & global_defs, long int & global_merge_defs, long int & global_weak_defs, long int & global_uses, long int & global_merge_uses); private: // Structure field-name database // Since the number of possible field names is small, we keep them in // a database and then refer to them by number in the memoryBlock class. class FieldNameDB { private: typedef map< string, int, less< string > > field_name_map; typedef field_name_map::iterator field_name_map_p; field_name_map _fields; int _count; public: static int ArrayField; FieldNameDB() : _fields(), _count(0) {} // --- Get the index for a field name, create if needed int get_field(const string & name); // --- Reverse search: find the name for a particular index string field_name(int index); void stats() { cout << " Field names: " << _count << endl; } }; static FieldNameDB FieldNames; // TB_unify helper functionn. memoryblock_set top_most_containers(memoryblock_set &visited); }; #endif // CBZ_MEMORYBLOCK_H

Generated on August 27, 2003
Back to the C-Breeze home page