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