CFGIRInterface.hpp

Go to the documentation of this file.

#ifndef CFGIRInterface_h
#define CFGIRInterface_h

//-----------------------------------------------------------------------------
// This file contains the abstract base classes for the IR interface.
//
// See the top level README for a description of the IRInterface and
// how to use it.
//-----------------------------------------------------------------------------

#include <iostream>
#include "IRHandles.hpp"
#include <OpenAnalysis/Utils/OA_ptr.hpp>

namespace OA {
  namespace CFG {

enum IRStmtType {
  SIMPLE,                       // Anything not covered below.
  COMPOUND,                     // A block of statements. 
  LOOP,                         // Any type of top-tested, structured loop.
  END_TESTED_LOOP,              // Any type of end-tested, structured loop.
  STRUCT_TWOWAY_CONDITIONAL,    // Structured if-then-else.
  STRUCT_MULTIWAY_CONDITIONAL,  // Structured switch statement.
  USTRUCT_TWOWAY_CONDITIONAL_T, // Unstructured branch (on true).
  USTRUCT_TWOWAY_CONDITIONAL_F, // Unstructured branch (on false).
  USTRUCT_MULTIWAY_CONDITIONAL, // Unstructured multiway branch
                                //  (e.g., computed goto in Fortran or 
                                //  jump tables in low-level/assembly
                                //  languages).
  RETURN,                       // Return statement.
  BREAK,                        // Break statement.
  LOOP_CONTINUE,                // Loop continuation statement.
  ALTERNATE_PROC_ENTRY,         // Alternate entry point (e.g., Fortran)
  UNCONDITIONAL_JUMP,           // GOTO in HLL, or unconditional direct
                                //   jump in low-level/assembly languages.
  UNCONDITIONAL_JUMP_I,         // Assigned GOTO in HLL, or unconditional
                                //   indirect jump in low-level/assembly
                                //   languages.
  NONE
};


//class EdgeInfo;

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------

class CFGIRInterface : public virtual IRHandlesIRInterface {
 public:
  CFGIRInterface() { }
  //virtual ~CFGIRInterface() = 0 ;
  virtual ~CFGIRInterface() {} // changed to get rid of in-charge with whirl, 4/12

  virtual OA_ptr<IRRegionStmtIterator> procBody(ProcHandle h) = 0;
  
  //--------------------------------------------------------
  // Statements: General
  //--------------------------------------------------------

  virtual bool returnStatementsAllowed() = 0;

  virtual IRStmtType getCFGStmtType(StmtHandle h) = 0; 

  virtual StmtLabel getLabel(StmtHandle h) = 0; 

  virtual OA_ptr<IRRegionStmtIterator> getFirstInCompound(StmtHandle h) = 0;  
  
  //--------------------------------------------------------
  // Loops
  //--------------------------------------------------------

  virtual OA_ptr<IRRegionStmtIterator> loopBody(StmtHandle h) = 0; 

  virtual StmtHandle loopHeader(StmtHandle h) = 0; 

  virtual StmtHandle getLoopIncrement(StmtHandle h) = 0; 

  virtual bool loopIterationsDefinedAtEntry(StmtHandle h) = 0; 

  // deprecated
  //OA::ExprHandle getLoopCondition(OA::StmtHandle h); 


  //--------------------------------------------------------
  // Invariant: a two-way conditional or a multi-way conditional MUST provide
  // provide either a target, or a target label
  //--------------------------------------------------------

  //--------------------------------------------------------
  // Structured two-way conditionals
  //
  // Note: An important pre-condition for structured conditionals is
  // that chains of else-ifs must be represented as nested elses.  For
  // example, this Matlab statement:
  //   if (c1)
  //     s1;
  //   elseif (c2)
  //     s2;
  //   else
  //     s3;
  //   end;
  //
  // would need be represented by the underlying IR as:
  //   if (c1)
  //     s1;
  //   else
  //     if (c2)
  //       s2;
  //     else
  //       s3;
  //     end;
  //   end; 
  //--------------------------------------------------------

  virtual OA_ptr<IRRegionStmtIterator> trueBody(StmtHandle h) = 0; 

  virtual OA_ptr<IRRegionStmtIterator> elseBody(StmtHandle h) = 0; 
  
  //--------------------------------------------------------
  // Structured multiway conditionals
  //--------------------------------------------------------

  virtual int numMultiCases(StmtHandle h) = 0; 

  virtual OA_ptr<IRRegionStmtIterator> 
      multiBody(StmtHandle h, int bodyIndex) = 0; 

  virtual bool isBreakImplied(StmtHandle multicond) = 0; 

  virtual bool isCatchAll(StmtHandle h, int bodyIndex) = 0;

  virtual OA_ptr<IRRegionStmtIterator> getMultiCatchall (StmtHandle h) = 0;
  
  virtual ExprHandle getSMultiCondition(StmtHandle h, int bodyIndex) = 0; 

  //--------------------------------------------------------
  // Unstructured two-way conditionals: 
  //--------------------------------------------------------

  virtual StmtLabel  getTargetLabel(StmtHandle h, int n) = 0; 

  //--------------------------------------------------------
  // Unstructured multi-way conditionals
  // FIXME: Review all of the multi-way stuff.
  //--------------------------------------------------------

  virtual int numUMultiTargets(StmtHandle h) = 0; 

  virtual StmtLabel getUMultiTargetLabel(StmtHandle h, int targetIndex) = 0; 

  virtual StmtLabel getUMultiCatchallLabel(StmtHandle h) = 0; 

  // Given an unstructured multi-way branch, return the condition
  // expression corresponding to target 'targetIndex'. The n targets
  // are indexed [0..n-1].
  // multiway target condition 
  virtual ExprHandle getUMultiCondition(StmtHandle h, int targetIndex) = 0; 

  //--------------------------------------------------------
  // Special, for assembly-language level instructions only.
  // These are necessary because there are some intricacies involved
  // in building a CFG for an instruction set which has delayed branches,
  // and in particular, allows branches within branch delay slots. 
  //--------------------------------------------------------

  virtual bool parallelWithSuccessor(StmtHandle h) = 0;

  virtual int numberOfDelaySlots(StmtHandle h) = 0;


  //--------------------------------------------------------
  // Symbol Handles
  //--------------------------------------------------------

  // Currently never used. This might be deprecated in the future.
  // virtual SymHandle getProcSymHandle(ProcHandle h) = 0;
  
};


  } // end of namespace CFG
} // end of namespace OA

#endif // CFGIRInterface_h