---

ipanalysis.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_IPANALYSIS_H
#define CBZ_IPANALYSIS_H

#include "pointers_common.h"
#include "proceduredb.h"

class analysisVal
{
public:
  virtual ~analysisVal() {}
  virtual analysisVal * clone() const =0;
//  virtual analysisVal * clone() const = 0;
};


class pointerValue;

typedef list< pointerValue > pointervalue_list;
// typedef pointervalue_list::iterator pointervalue_list_p;



class analysisProblem
{
protected:

  Direction _direction;

public:

  analysisProblem(Direction direction)
    : _direction(direction)
  {}

  Direction direction() const { return _direction; }

  virtual string name() =0;


  // -- Non-pointer expressions

  virtual void at_id(stmtLocation * current, idNode * id,
                     pointerValue & result,
                     bool result_is_a_use)
  {}

  virtual void at_unary(stmtLocation * current,
                        unaryNode * unary,
                        pointerValue & operand,
                        pointerValue & result,
                        bool result_is_a_use)
  {}

  virtual void at_binary(stmtLocation * current,
                         binaryNode * binary,
                         pointerValue & left,
                         pointerValue & right,
                         pointerValue & result,
                         bool result_is_a_use)
  {}

  virtual void at_cast(stmtLocation * current, castNode * cast,
                       pointerValue & operand,
                       pointerValue & result,
                       bool result_is_a_use)
  {}

  virtual void at_const(stmtLocation * current, constNode * cons,
                        pointerValue & result,
                        bool result_is_a_use)
  {}

  // -- Procedure calls

  virtual void at_call(stmtLocation * current, callNode * call,
                       pointerValue & call_target,
                       procNode * callee,
                       pointervalue_list & arguments,
                       pointerValue & return_val)
  {}

  // -- Pointer expressions

  virtual void at_field_access(stmtLocation * current,
                               binaryNode * binary,
                               pointerValue & operand,
                               idNode * field,
                               pointerValue & result,
                               bool result_is_a_use)
  {}

  virtual void at_dereference(stmtLocation * current,
                              unaryNode * unary,
                              pointerValue & operand,
                              pointerValue & result,
                              bool result_is_a_use)
  {}

  virtual void at_address(stmtLocation * current,
                          unaryNode * unary,
                          pointerValue & operand,
                          pointerValue & result,
                          bool result_is_a_use)
  {}

  virtual void at_index(stmtLocation * current,
                        binaryNode * binary,
                        pointerValue & left,
                        pointerValue & right,
                        pointerValue & result,
                        bool result_is_a_use)
  {}

  // -- Assignments

  virtual void at_assignment(stmtLocation * current,
                             binaryNode * binary,
                             pointerValue & left,
                             pointerValue & right,
                             pointerValue & result,
                             bool result_is_a_use,
                             memoryblock_set & changes)
  {}

  virtual void at_parameter_pass(Location * current,
                                 pointerValue & left,
                                 pointerValue & right,
                                 pointerValue & result,
                                 memoryblock_set & changes)
  {}

  // -- Statement types

  virtual void at_return(stmtLocation * stmt,
                         returnNode * ret,
                         pointerValue & result,
                         pointerValue & return_val)
  {}

  virtual void at_exprstmt(stmtLocation * stmt,
                           exprstmtNode * es,
                           pointerValue & result)
  {}

  virtual void at_if(stmtLocation * stmt,
                     ifNode * ifnode,
                     pointerValue & result)
  {}

  // -- Process a merge point

  virtual void at_merge(basicblockLocation * where,
                        memoryBlock * block,
                        memoryuse_list & phi_uses,
                        pointerValue & result,
                        memoryblock_set & changes)
  {}

  // -- Control-flow options

  virtual void at_basicblock_entry(basicblockLocation * block,
                                   procedureInfo * info,
                                   pointerValue & initial)
  {}

  virtual void at_stmt_entry(stmtLocation * stmt,
                             pointerValue & result)
  {}

  virtual void at_stmt_exit(stmtLocation * stmt,
                            pointerValue & result)
  {}

  virtual void at_basicblock_exit(basicblockLocation * block,
                                  procedureInfo * info,
                                  pointerValue & final)
  {}

  // -- Procedure boundaries

  virtual void at_conservative_procedure_call(stmtLocation * current,
                                              callNode * call,
                                              pointerValue & call_target,
                                              pointervalue_list & arguments,
                                              memoryblock_set & reachable_blocks,
                                              pointerValue & return_val,
                                              memoryblock_set & changes)
  {}

  virtual void at_procedure_entry(procLocation * proc,
                                  procedureInfo * info,
                                  pointerValue & return_val)
  {}

  virtual void at_procedure_exit(procLocation * proc,
                                 procedureInfo * info,
                                 pointerValue & return_val)
  {}


};

#endif // CBZ_IPANALYSIS_H

---