C-Breeze C Compiler Infrastructure [ Project home page]

constants.h Go to the documentation of this file. // $Id: constants.h,v 1.17 2003/08/08 15:16:29 toktb Exp $ // ---------------------------------------------------------------------- // // C-Breeze // C Compiler Framework // // Copyright (c) 2003 University of Texas at Austin // // Samuel Z. Guyer // Adam Brown // Teck Bok Tok // Paul Arthur Navratil // 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_CONSTANTS_H #define CBZ_CONSTANTS_H #include "pointeroptions.h" #include "location.h" #include "memoryblock.h" #include "pointervalue.h" class constantAnalyzer { private: typedef set< constant > constant_set; typedef constant_set::iterator constant_set_p; typedef map< exprNode *, const constant * > expr_value_map; typedef expr_value_map::iterator expr_value_map_p; typedef map< stmtNode *, const constant * > stmt_value_map; typedef stmt_value_map::iterator stmt_value_map_p; TREE constant_set _schar_constants; TREE constant_set _uchar_constants; TREE constant_set _sshort_constants; TREE constant_set _ushort_constants; TREE constant_set _sint_constants; TREE constant_set _uint_constants; TREE constant_set _slong_constants; TREE constant_set _ulong_constants; TREE constant_set _float_constants; TREE constant_set _double_constants; REF memoryBlock * _null; const constant * _top; const constant * _bottom; const constant * _non_null; expr_value_map _expr_values; stmt_value_map _stmt_values; public: constantAnalyzer(); ~constantAnalyzer(); void clear(); void set_null_object(memoryBlock * null_object) { _null = null_object; } inline const constant * top() const { return _top; } inline const constant * bottom() const { return _bottom; } inline bool has_value(const constant * val) { return ((val != _top) && (val != _bottom) && (val != _non_null)); } bool has_truth_value(const constant * val, bool & value); const constant * lookup(const constant & value); const constant * lookup_flowvalue(memoryDef * def); bool update_flowvalue(const constant * val, memoryDef * def); const constant * meet(const constant * one, const constant * two); const constant * rebuild_flowvalue(pointerValue & pointer); void record_expression(exprNode * expr, const constant * val); void record_stmt(stmtNode * stmt, const constant * val); const constant * evaluate_points_to(const memoryblock_set & points_to); public: const constant * lookup_expression(exprNode * expr); const constant * lookup_stmt(stmtNode * expr); // --- Transfer functions ----------------------- // -- Non-pointer expressions void at_id(stmtLocation * current, idNode * id, pointerValue & value); void at_unary(stmtLocation * current, stmtNode *t, pointerValue & operand, pointerValue & result); void at_sizeof(stmtLocation * current, threeAddrNode *t, pointerValue & operand, pointerValue & result); void at_binary(stmtLocation * current, stmtNode *s, pointerValue & left, pointerValue & right, pointerValue & result); void at_const(stmtLocation * current, constNode * cons, pointerValue & result); // -- Pointer expressions void at_address(stmtLocation * current, operandNode * operand, pointerValue & result); void at_cast(stmtLocation * current, operandNode *operand, pointerValue & operand_val, pointerValue & result); void at_dereference(stmtLocation * current, operandNode *operand, pointerValue & result); void at_field_access(stmtLocation * current, operandNode *operand, pointerValue & result); void at_index(stmtLocation * current, operandNode *operand, pointerValue & result); // -- Assignments void at_assignment(stmtLocation * current, pointerValue & left, pointerValue & right, pointerValue & result, memoryblock_set & changes); void at_parameter_pass(Location * current, pointerValue & left, pointerValue & right, memoryblock_set & changes); void at_self_assignment(Location * source, Location * target, memoryBlock * block, memoryblock_set & changes); // -- Statement types void at_return(stmtLocation * stmt, returnNode * ret, pointerValue & result, pointerValue & return_val); // -- Process a merge point void at_merge(Location * where, memoryBlock * block, memoryuse_list & phi_uses, pointerValue & result, memoryblock_set & changes); // -- Control-flow options void at_basicblock_entry(basicblockLocation * block, procedureInfo * info, pointerValue & initial); void at_stmt_entry(stmtLocation * stmt, pointerValue & result); // -- Procedure boundaries void at_conservative_procedure_call(stmtLocation * current, operandNode * call, operand_list & args, pointerValue & call_target, pointervalue_list & arguments, memoryblock_set & reachable_blocks, pointerValue & return_val, memoryblock_set & changes); // --- Output --------------------- void print(ostream & o, const constant * val) { if (val == _bottom) o << "(bottom)"; else if (val == _top) o << "(top)"; else { constant temp = *val; o << temp.to_string(); } } string to_string(const constant * val) { if (val == _bottom) return string("(bottom)"); else if (val == _top) return string("(top)"); else if (val == _non_null) return string("(non-null)"); else { constant temp = *val; return temp.to_string(); } } private: void record_change(memoryDef * def); }; class constantsChanger : public Changer { public: static void optimize(unitNode * u, constantAnalyzer * constants, bool simplify) { constantsChanger ipcc(constants, simplify); u->change(ipcc); } private: constantAnalyzer * _constants; bool _simplify; constantsChanger(constantAnalyzer * constants, bool simplify); public: Node * at_id(idNode * id, Order ord); Node * at_threeAddr(threeAddrNode * operand, Order ord); Node * at_conditiongoto(conditiongotoNode * C, Order ord); }; #endif // CBZ_CONSTANTS_H

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