---

pointers.h

Go to the documentation of this file.

// ----------------------------------------------------------------------
//
//  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 "location.h"
#include "memorymodel.h"
#include "memoryblock.h"
#include "proceduredb.h"
#include "linker.h"
#include "ipanalysis.h"
#include "pointervalue.h"

typedef map< Location *, memoryBlock *> 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;
  
protected:

  memoryModel Memory;

  heap_map HeapMap;

  procNode * Root;

  procLocation * root_location;

  Linker linker;

  procedureDB Procedures;

  analysisProblem * Problem;

  bool computePointers;

  Direction _direction;

  int _context_sensitivity_threshold;

  bool _debug;

  int _procedureCount;

  int _skipCount;

  bool _show_progress;

  string_set _unknown_procedures;

public:

  Pointers(procNode * root, unitNode * unit, bool debug = false);

  ~Pointers();

  void analyze();
  void analyze(analysisProblem * problem);

  void reanalyze_at(procedureInfo * info, stmtLocation * callsite);

  void clear();

  void set_context_sensitivity_threshold(int threshold);

  void show_progress() { _show_progress = true; }

  void hide_progress() { _show_progress = false; }

  void analyze_procedure(procLocation * current,
                         memoryblock_set & external_defs,
                         memoryuse_set & external_uses,
                         memoryblock_set & external_changes,
                         pointerValue & return_val);

  virtual void procedure_call(procedureInfo * caller,
                              stmtLocation * current,
                              callNode * call,
                              pointerValue & call_target,
                              pointervalue_list & arguments,
                              memoryblock_set & external_defs,
                              memoryuse_set & external_uses,
                              memoryblock_set & external_changes,
                              pointerValue & return_val);

  void pass_parameters(procedureInfo * info,
                       procedureInfo * caller,
                       procLocation * callee_path,
                       procNode * callee,
                       pointervalue_list & arguments,
                       memoryblock_set & changed_inputs,
                       pointerValue & return_val);

  void process_merge_point(procedureInfo * info,
                           basicblockLocation * current_block,
                           pointerValue & result,
                           memoryblock_set & defs,
                           memoryuse_set & uses,
                           memoryblock_set & changes);

  void process_changes(procedureInfo * info,
                       basicblockLocation * current_block,
                       memoryblock_set & changes,
                       memoryblock_set & external_changes);

  void pass_external_inputs(procedureInfo * info,
                            memoryuse_set & external_uses,
                            memoryblock_set & changed_inputs);

  void pass_external_outputs(procedureInfo * info,
                             memoryblock_set & external_defs,
                             memoryblock_set & external_changes);

  void record_external_inputs_and_outputs(procedureInfo * info,
                                          procLocation * current,
                                          memoryblock_set & defs,
                                          memoryblock_set & external_defs,
                                          memoryuse_set & uses,
                                          memoryuse_set & external_uses);

  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,
            memoryblock_set & defs,
            memoryuse_set & uses,
            memoryblock_set & changes,
            pointerValue & result,
            bool result_is_a_use);

  void star_operator(stmtLocation * current,
                     pointerValue & operand,
                     memoryuse_set & uses,
                     pointerValue & result);

  void dot_operator(stmtLocation * current,
                    const string & field_name,
                    declNode * field_decl,
                    pointerValue & operand,
                    memoryuse_set & uses,
                    pointerValue & result);

  void assignment_operator(procedureInfo * info,
                           Location * current,
                           pointerValue & left_hand_side,
                           pointerValue & right_hand_side,
                           memoryblock_set & defs,
                           memoryuse_set & uses,
                           memoryblock_set & changes,
                           bool additive = false);

  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 call_operator(procedureInfo * caller,
                     stmtLocation * current,
                     callNode * call,
                     memoryblock_set & defs,
                     memoryuse_set & uses,
                     memoryblock_set & changes,
                     pointerValue & result);

  void determine_call_targets(procedureInfo * caller,
                              stmtLocation * current,
                              callNode * 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);

  memoryBlock * lookup_memoryblock(Location * location, declNode * decl);

  procedureInfo * lookup_procedure(procNode * proc);

  bool is_pointer_expression(exprNode * expr);

  void stats(ostream & out);

  void uses_and_defs();

protected:

  memoryBlock * lookup_heap_object(stmtLocation * current);

  static bool is_allocation(pointerValue & call_targets);

  static bool is_deallocation(pointerValue & call_targets);

  memoryBlock * lookup_string_constant(stmtLocation * current,
                                       constant & value);

  void setup_va_list_variables(procedureInfo * info,
                               procLocation * callee_path, 
                               procNode * callee,
                               memoryBlock * ellipsis,
                               pointerValue & return_val);

  static bool is_va_list(declNode * decl);
  static bool is_va_list(exprNode * expr);

  static bool is_va_start(pointerValue & call_targets);

  static bool is_va_end(pointerValue & call_targets);

  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);
};

#endif // CBZ_POINTERS_H

---