sageInterface.h

Go to the documentation of this file.

#ifndef ROSE_SAGE_INTERFACE
#define ROSE_SAGE_INTERFACE

#include "sage3basic.hhh"
#include <stdint.h>
#include <utility>

#if 0   // FMZ(07/07/2010): the argument "nextErrorCode" should be call-by-reference
SgFile* determineFileType ( std::vector<std::string> argv, int nextErrorCode, SgProject* project );
#else
SgFile* determineFileType ( std::vector<std::string> argv, int& nextErrorCode, SgProject* project );
#endif

#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
#include "rewrite.h"
#endif

// DQ (7/20/2008): Added support for unparsing abitrary strings in the unparser.
#include "astUnparseAttribute.h"
#include <set>

#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
#include "LivenessAnalysis.h"
#include "abstract_handle.h"
#include "ClassHierarchyGraph.h"
#endif

// DQ (8/19/2004): Moved from ROSE/src/midend/astRewriteMechanism/rewrite.h
std::string getVariantName (VariantT v);

// DQ (12/9/2004): Qing, Rich and Dan have decided to start this namespace within ROSE
// This namespace is specific to interface functions that operate on the Sage III AST.
// The name was chosen so as not to conflict with other classes within ROSE.
// This will become the future home of many interface functions which operate on
// the AST and which are generally useful to users.  As a namespace multiple files can be used
// to represent the compete interface and different developers may contribute interface
// functions easily.

// Constructor handling: (We have sageBuilder.h now for this purpose, Liao 2/1/2008)
//     We could add simpler layers of support for construction of IR nodes by
// hiding many details in "makeSg***()" functions. Such functions would
// return pointers to the associated Sg*** objects and would be able to hide
// many IR specific details, including:
//      memory handling
//      optional parameter settings not often required
//      use of Sg_File_Info objects (and setting them as transformations)
//
// namespace AST_Interface  (this name is taken already by some of Qing's work :-)

#define TRANS_FILE Sg_File_Info::generateDefaultFileInfoForTransformationNode()

//------------------------------------------------------------------------
namespace SageInterface
{
extern int gensym_counter;

// tps : 28 Oct 2008 - support for finding the main interpretation
 SgAsmInterpretation* getMainInterpretation(SgAsmGenericFile* file);

uint64_t getAsmConstant(SgAsmValueExpression* e);

int64_t getAsmSignedConstant(SgAsmValueExpression *e);

 void addMessageStatement( SgStatement* stmt, std::string message );

  class UniqueNameAttribute : public AstAttribute
  {
    private:
     std::string name;
    public:
     UniqueNameAttribute(std::string n="") {name =n; };
     void set_name (std::string n) {name = n;};
     std::string get_name () {return name;};
  };

// DQ (3/2/2009): Added support for collectiong an merging the referenced symbols in the outlined
// function into the list used to edit the outlined code subtree to fixup references (from symbols
// in the original file to the symbols in the newer separate file).
// typedef rose_hash::unordered_map<SgNode*, SgNode*, hash_nodeptr> ReplacementMapType;
// void supplementReplacementSymbolMap ( const ReplacementMapTraversal::ReplacementMapType & inputReplacementMap );

// CH (4/9/2010): Use boost::hash instead
//#ifdef _MSC_VER
#if 0
inline size_t hash_value(SgNode* t) {return (size_t)t;}
#endif

struct hash_nodeptr
   {
// CH (4/9/2010): Use boost::hash instead
//#ifndef _MSC_VER
#if 0
           //rose_hash::hash<char*> hasher;
#endif
     public:
          size_t operator()(SgNode* node) const
             {
// CH (4/9/2010): Use boost::hash instead
//#ifdef _MSC_VER
 #if 0
                                  return (size_t) hash_value(node);
 #else
                                  return (size_t) node;
 #endif
                   }
    };

  void supplementReplacementSymbolMap ( rose_hash::unordered_map<SgNode*, SgNode*, hash_nodeptr> & inputReplacementMap );

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

   // Liao 1/22/2008, used for get symbols for generating variable reference nodes
   // ! Find a variable symbol in current and ancestor scopes for a given name
   SgVariableSymbol *lookupVariableSymbolInParentScopes (const SgName & name,
                                                         SgScopeStatement *currentScope=NULL);
   SgSymbol *lookupSymbolInParentScopes (const SgName & name,
                                                         SgScopeStatement *currentScope=NULL);

   // DQ (11/24/2007): Functions moved from the Fortran support so that they could be called from within astPostProcessing.
   SgFunctionSymbol *lookupFunctionSymbolInParentScopes (const SgName & functionName,
                                                         SgScopeStatement *currentScope=NULL);

   // Liao, 1/24/2008, find exact match for a function
   SgFunctionSymbol *lookupFunctionSymbolInParentScopes (const SgName &  functionName,
                                                         const SgType* t,
                                                         SgScopeStatement *currentScope=NULL);

// DQ (5/7/2011): Added support for SgClassSymbol (used in name qualification support).
   SgClassSymbol*     lookupClassSymbolInParentScopes    (const SgName & name, SgScopeStatement *currentScope = NULL);
   SgTypedefSymbol*   lookupTypedefSymbolInParentScopes  (const SgName & name, SgScopeStatement *currentScope = NULL);
   SgTemplateSymbol*  lookupTemplateSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
   SgEnumSymbol*      lookupEnumSymbolInParentScopes     (const SgName & name, SgScopeStatement *currentScope = NULL);
   SgNamespaceSymbol* lookupNamespaceSymbolInParentScopes(const SgName & name, SgScopeStatement *currentScope = NULL);

// DQ (7/17/2011): Added function from cxx branch that I need here for the Java support.
// SgClassSymbol* lookupClassSymbolInParentScopes (const SgName &  name, SgScopeStatement *cscope);

   // DQ (12/9/2004): Moved this function (by Alin Jula) from being a member of SgInitializedName
   // to this location where it can be a part of the interface for the Sage III AST.
   int set_name (SgInitializedName * initializedNameNode, SgName new_name);

   void outputGlobalFunctionTypeSymbolTable ();

   // DQ (6/27/2005):
   void outputLocalSymbolTables (SgNode * node);

   class OutputLocalSymbolTables:public AstSimpleProcessing
         {
           public:
     void visit (SgNode * node);
         };
   // DQ (9/28/2005):
   void rebuildSymbolTable (SgScopeStatement * scope);

   void clearUnusedVariableSymbols ();

   // DQ (3/1/2009):
   void fixupReferencesToSymbols( const SgScopeStatement* this_scope,  SgScopeStatement* copy_scope, SgCopyHelp & help );


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

   // DQ (9/21/2005): General function for extracting the name of declarations (when they have names)
     std::string get_name (const SgNode * node);

   // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
     std::string get_name (const SgStatement * stmt);

     std::string get_name (const SgExpression * expr);

   // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
     std::string get_name (const SgDeclarationStatement * declaration);

   // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
     std::string get_name (const SgScopeStatement * scope);

   // DQ (2/11/2007): Added this function to make debugging support more complete (useful for symbol table debugging support).
     std::string get_name (const SgSymbol * symbol);

     std::string get_name (const SgType * type);


     std::string get_name (const SgSupport * node);


     std::string get_name (const SgLocatedNodeSupport * node);

     std::string get_name ( const SgC_PreprocessorDirectiveStatement* directive );

     std::string get_name ( const SgToken* token );


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

   // DQ (6/21/2005): Get the default destructor from the class declaration
   SgMemberFunctionDeclaration *getDefaultDestructor (SgClassDeclaration *
                                                      classDeclaration);

   // DQ (6/22/2005): Get the default constructor from the class declaration
   SgMemberFunctionDeclaration *getDefaultConstructor (SgClassDeclaration *
                                                       classDeclaration);
   // DQ (8/27/2005):
   bool templateDefinitionIsInClass (SgTemplateInstantiationMemberFunctionDecl
                                     * memberFunctionDeclaration);

   // DQ (9/17/2005):
      SgTemplateInstantiationMemberFunctionDecl*
      buildForwardFunctionDeclaration
         (SgTemplateInstantiationMemberFunctionDecl * memberFunctionInstantiation);

   bool isStructDeclaration(SgNode * node);
 #if 0
 // DQ (8/28/2005): This is already a member function of the SgFunctionDeclaration
 // (so that it can handle template functions and member functions)

    // DQ (8/27/2005):
   bool isTemplateMemberFunction (SgTemplateInstantiationMemberFunctionDecl *
                                  memberFunctionDeclaration);
 #endif


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


   bool isOmpStatement(SgNode* );
   // DQ (8/27/2005):
   bool isOverloaded (SgFunctionDeclaration * functionDeclaration);

  void annotateExpressionsWithUniqueNames (SgProject* project);

   bool isMain (const SgNode* node);
   // DQ (6/22/2005):
    std::string generateUniqueName ( const SgNode * node, bool ignoreDifferenceBetweenDefiningAndNondefiningDeclarations);

    std::string generateUniqueVariableName(SgScopeStatement* scope, std::string baseName = "temp");
    
  // DQ (8/10/2010): Added const to first parameter.
  // DQ (3/10/2007):
    std::string declarationPositionString (const SgDeclarationStatement * declaration);

  // DQ (1/20/2007):
    std::string generateProjectName (const SgProject * project, bool supressSuffix = false );

  SgFunctionDeclaration* getDeclarationOfNamedFunction(SgExpression* func);

  SgExpression* forallMaskExpression(SgForAllStatement* stmt);

  void addVarRefExpFromArrayDimInfo(SgNode * astNode, Rose_STL_Container<SgNode *>& NodeList_t);

  // DQ (10/6/2006): Added support for faster mangled name generation (caching avoids recomputation).
  void clearMangledNameCache (SgGlobal * globalScope);
  void resetMangledNameCache (SgGlobal * globalScope);
  std::string getMangledNameFromCache (SgNode * astNode);
  std::string addMangledNameToCache (SgNode * astNode, const std::string & mangledName);

  SgDeclarationStatement * getNonInstantiatonDeclarationForClass (SgTemplateInstantiationMemberFunctionDecl * memberFunctionInstantiation);

  void setBaseTypeDefiningDeclaration(SgVariableDeclaration* var_decl, SgDeclarationStatement *base_decl);

  // DQ (10/14/2006): This function tests the AST to see if for a non-defining declaration, the
  // bool declarationPreceedsDefinition ( SgClassDeclaration* classNonDefiningDeclaration, SgClassDeclaration* classDefiningDeclaration );
  bool declarationPreceedsDefinition (SgDeclarationStatement *nonDefiningDeclaration, SgDeclarationStatement *definingDeclaration);

  // DQ (10/19/2006): Function calls have interesting context dependent rules to determine if
  // they are output with a global qualifier or not.  Were this is true we have to avoid global
  // qualifiers, since the function's scope has not been defined.  This is an example of where
  // qualification of function names in function calls are context dependent; an interesting
  // example of where the C++ language is not friendly to source-to-source processing :-).
  bool functionCallExpressionPreceedsDeclarationWhichAssociatesScope (SgFunctionCallExp * functionCall);

    std::vector < SgNode * >astIntersection (SgNode * original, SgNode * copy, SgCopyHelp * help = NULL);

   SgNode* deepCopyNode (const SgNode* subtree);

   template <typename NodeType>
   NodeType* deepCopy (const NodeType* subtree) {
     return dynamic_cast<NodeType*>(deepCopyNode(subtree));
   }

   SgExpression* copyExpression(SgExpression* e);

   SgStatement* copyStatement(SgStatement* s);

// from VarSym.cc in src/midend/astOutlining/src/ASTtools
  SgVariableSymbol* getFirstVarSym (SgVariableDeclaration* decl);

  SgInitializedName* getFirstInitializedName (SgVariableDeclaration* decl);

void myRemoveStatement(SgStatement* stmt);

bool isConstantTrue(SgExpression* e);
bool isConstantFalse(SgExpression* e);

bool isCallToParticularFunction(SgFunctionDeclaration* decl, SgExpression* e);
bool isCallToParticularFunction(const std::string& qualifiedName, size_t arity, SgExpression* e);

bool isStatic(SgDeclarationStatement* stmt);

void setStatic(SgDeclarationStatement* stmt);

bool isExtern(SgDeclarationStatement* stmt);

void setExtern(SgDeclarationStatement* stmt);

class StatementGenerator {
  public:
  virtual ~StatementGenerator() {};
  virtual SgStatement* generate(SgExpression* where_to_write_answer) = 0;
};

  bool isAssignmentStatement(SgNode* _s, SgExpression** lhs=NULL, SgExpression** rhs=NULL, bool* readlhs=NULL);

SgInitializedName* convertRefToInitializedName(SgNode* current);

SgNode* getSgNodeFromAbstractHandleString(const std::string& input_string);

void dumpInfo(SgNode* node, std::string desc="");

std::vector<SgDeclarationStatement*>
sortSgNodeListBasedOnAppearanceOrderInSource(const std::vector<SgDeclarationStatement*>& nodevec);


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

//  std::string version();  // utility_functions.h, version number
  bool is_C_language ();
  bool is_OpenMP_language ();
  bool is_UPC_language ();
  bool is_UPC_dynamic_threads();
  bool is_C99_language ();
  bool is_Cxx_language ();
  bool is_Java_language ();
  bool is_Fortran_language ();
  bool is_CAF_language ();
  bool is_PHP_language();
  bool is_Python_language();
  bool is_Cuda_language();
  bool is_binary_executable();
  bool is_mixed_C_and_Cxx_language ();
  bool is_mixed_Fortran_and_C_language ();
  bool is_mixed_Fortran_and_Cxx_language ();
  bool is_mixed_Fortran_and_C_and_Cxx_language ();

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

  // DQ (10/5/2006): Added support for faster (non-quadratic) computation of unique
  // labels for scopes in a function (as required for name mangling).
  void resetScopeNumbers (SgFunctionDefinition * functionDeclaration);

  // DQ (10/5/2006): Added support for faster (non-quadratic) computation of unique
  // labels for scopes in a function (as required for name mangling).
  void clearScopeNumbers (SgFunctionDefinition * functionDefinition);


  SgNamespaceDefinitionStatement * enclosingNamespaceScope (SgDeclarationStatement * declaration);
//  SgNamespaceDefinitionStatement * getEnclosingNamespaceScope (SgNode * node);

  bool isPrototypeInScope (SgScopeStatement * scope,
                           SgFunctionDeclaration * functionDeclaration,
                           SgDeclarationStatement * startingAtDeclaration);

  bool isAncestor(SgNode* node1, SgNode* node2);
//------------------------------------------------------------------------


  void dumpPreprocInfo (SgLocatedNode* locatedNode);

PreprocessingInfo* insertHeader(const std::string& filename, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::after, bool isSystemHeader=false, SgScopeStatement* scope=NULL);

void moveUpPreprocessingInfo (SgStatement* stmt_dst, SgStatement* stmt_src, PreprocessingInfo::RelativePositionType src_position=PreprocessingInfo::undef,  PreprocessingInfo::RelativePositionType dst_position=PreprocessingInfo::undef, bool usePrepend= false);

void movePreprocessingInfo (SgStatement* stmt_src, SgStatement* stmt_dst,  PreprocessingInfo::RelativePositionType src_position=PreprocessingInfo::undef,
                             PreprocessingInfo::RelativePositionType dst_position=PreprocessingInfo::undef, bool usePrepend= false);


void cutPreprocessingInfo (SgLocatedNode* src_node, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType& save_buf);

void pastePreprocessingInfo (SgLocatedNode* dst_node, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType& saved_buf);

PreprocessingInfo* attachArbitraryText(SgLocatedNode* target,
                const std::string & text,
               PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before);

void replaceMacroCallsWithExpandedStrings(SgPragmaDeclaration* target);


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


   PreprocessingInfo* attachComment(SgLocatedNode* target, const std::string & content,
               PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before,
               PreprocessingInfo::DirectiveType dtype= PreprocessingInfo::CpreprocessorUnknownDeclaration);

// DQ (11/25/2009): Added matching support for adding comments to SgAsm nodes.
// Build and attach comment
// void attachComment(SgAsmStatement* target, const std::string & content );

// DQ (7/20/2008): I am not clear were I should put this function, candidates include: SgLocatedNode or SgInterface
  void addTextForUnparser ( SgNode* astNode, std::string s, AstUnparseAttribute::RelativePositionType inputlocation );


  // Liao, 1/8/2007, set file info. for a whole subtree as transformation generated
  void setOneSourcePositionForTransformation(SgNode *node);

  void setOneSourcePositionNull(SgNode *node);

  void setSourcePositionForTransformation (SgNode * root);

  void setSourcePositionForTransformation_memoryPool();

  void setSourcePosition (SgLocatedNode * locatedNode);



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

// from src/midend/astInlining/typeTraits.h
// src/midend/astUtil/astInterface/AstInterface.h

SgType* getBoolType(SgNode* n);


bool isStrictIntegerType(SgType* t);
SgType* getFirstVarType(SgVariableDeclaration* decl);

bool isDefaultConstructible(SgType* type);

bool isCopyConstructible(SgType* type);

bool isAssignable(SgType* type);

#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
bool isPureVirtualClass(SgType* type, const ClassHierarchyWrapper& classHierarchy);
#endif

bool hasTrivialDestructor(SgType* t);

bool isNonconstReference(SgType* t);

bool isReferenceType(SgType* t);

bool isPointerType(SgType* t);

bool isPointerToNonConstType(SgType* type);

/* const char* p = "aa"; is not treated as having a const type. It is a pointer to const char.
 * Similarly, neither for const int b[10]; or const int & c =10;
 * The standard says, "A compound type is not cv-qualified by the cv-qualifiers (if any) of
the types from which it is compounded. Any cv-qualifiers applied to an array type affect the array element type, not the array type".
 */
bool isConstType(SgType* t);

SgType* removeConst(SgType* t);

bool isVolatileType(SgType* t);

bool isRestrictType(SgType* t);


bool isScalarType(SgType* t);

bool isStrictIntegerType(SgType* t);

bool isStructType(SgType* t);

std::string mangleType(SgType* type);

  std::string mangleScalarType(SgType* type);

  std::string mangleModifierType(SgModifierType* type);

size_t getArrayElementCount(SgArrayType* t);

int getDimensionCount(SgType* t);

SgType* getArrayElementType(SgType* t);

SgType* getElementType(SgType* t);

bool isArrayReference(SgExpression* ref, SgExpression** arrayNameExp=NULL, std::vector<SgExpression*>** subscripts=NULL);



bool hasUpcSharedType(SgType* t, SgModifierType ** mod_type_out = NULL  );


bool isUpcSharedType(SgType* t, SgModifierType ** mod_type_out = NULL);

bool isUpcSharedModifierType (SgModifierType* mod_type);

bool isUpcSharedArrayType (SgArrayType* array_type);

bool isUpcStrictSharedModifierType(SgModifierType* mode_type);

size_t getUpcSharedBlockSize(SgModifierType* mod_type);

size_t getUpcSharedBlockSize(SgType* t);

bool isUpcPhaseLessSharedType (SgType* t);

bool isUpcPrivateToSharedType(SgType* t);

bool isUpcArrayWithThreads(SgArrayType* t);

SgType* lookupNamedTypeInParentScopes(const std::string& type_name, SgScopeStatement* scope=NULL);


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

// by Jeremiah
void addStepToLoopBody(SgScopeStatement* loopStmt, SgStatement* step);

void moveForStatementIncrementIntoBody(SgForStatement* f);
void convertForToWhile(SgForStatement* f);
void convertAllForsToWhiles(SgNode* top);
void changeContinuesToGotos(SgStatement* stmt, SgLabelStatement* label);

SgInitializedName* getLoopIndexVariable(SgNode* loop);

bool isLoopIndexVariable(SgInitializedName* ivar, SgNode* subtree_root);

SgStatement* getLoopBody(SgScopeStatement* loop);

void setLoopBody(SgScopeStatement* loop, SgStatement* body);

SgStatement* getLoopCondition(SgScopeStatement* loop);

void setLoopCondition(SgScopeStatement* loop, SgStatement* cond);

bool isCanonicalForLoop(SgNode* loop, SgInitializedName** ivar=NULL, SgExpression** lb=NULL, SgExpression** ub=NULL, SgExpression** step=NULL, SgStatement** body=NULL, bool *hasIncrementalIterationSpace = NULL, bool* isInclusiveUpperBound = NULL);

bool isCanonicalDoLoop(SgFortranDo* loop,SgInitializedName** ivar/*=NULL*/, SgExpression** lb/*=NULL*/, SgExpression** ub/*=NULL*/, SgExpression** step/*=NULL*/, SgStatement** body/*=NULL*/, bool *hasIncrementalIterationSpace/*= NULL*/, bool* isInclusiveUpperBound/*=NULL*/);

void setLoopLowerBound(SgNode* loop, SgExpression* lb);

void setLoopUpperBound(SgNode* loop, SgExpression* ub);

void setLoopStride(SgNode* loop, SgExpression* stride);


bool normalizeForLoopInitDeclaration(SgForStatement* loop);

bool forLoopNormalization(SgForStatement* loop);

bool doLoopNormalization(SgFortranDo* loop);

bool loopUnrolling(SgForStatement* loop, size_t unrolling_factor);

bool loopInterchange(SgForStatement* loop, size_t depth, size_t lexicoOrder);

bool loopTiling(SgForStatement* loopNest, size_t targetLevel, size_t tileSize);


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


template <typename NodeType>
std::vector<NodeType*> querySubTree(SgNode* top, VariantT variant = (VariantT)NodeType::static_variant)
{
  Rose_STL_Container<SgNode*> nodes = NodeQuery::querySubTree(top,variant);
  std::vector<NodeType*> result(nodes.size(), NULL);
  int count = 0;
  for (Rose_STL_Container<SgNode*>::const_iterator i = nodes.begin();
       i != nodes.end(); ++i, ++count) {
    NodeType* node = dynamic_cast<NodeType*>(*i);
    ROSE_ASSERT (node);
    result[count] = node;
  }
  return result;
}
    std::vector < SgFile * >generateFileList ();

  SgProject * getProject();

template <typename NodeType>
static std::vector<NodeType*> getSgNodeListFromMemoryPool()
{
  // This function uses a memory pool traversal specific to the SgFile IR nodes
  class MyTraversal : public ROSE_VisitTraversal
  {
    public:
      std::vector<NodeType*> resultlist;
      void visit ( SgNode* node)
      {
        NodeType* result = dynamic_cast<NodeType* > (node);
        ROSE_ASSERT(result!= NULL);
        if (result!= NULL)
        {
          resultlist.push_back(result);
        }
      };
      virtual ~MyTraversal() {}
  };

  MyTraversal my_traversal;
  NodeType::visitRepresentativeNode(my_traversal);
  return my_traversal.resultlist;
}


SgFunctionDeclaration* findMain(SgNode* currentNode);

SgStatement* findLastDeclarationStatement(SgScopeStatement * scope);

          //midend/programTransformation/partialRedundancyElimination/pre.h
std::vector<SgVariableSymbol*> getSymbolsUsedInExpression(SgExpression* expr);


std::vector<SgBreakStmt*> findBreakStmts(SgStatement* code, const std::string& fortranLabel = "");


  std::vector<SgContinueStmt*> findContinueStmts(SgStatement* code, const std::string& fortranLabel = "");
  std::vector<SgGotoStatement*> findGotoStmts(SgStatement* scope, SgLabelStatement* l);
  std::vector<SgStatement*> getSwitchCases(SgSwitchStatement* sw);

  template <typename T>
  T* findDeclarationStatement(SgNode* root, std::string name, SgScopeStatement* scope, bool isDefining)
  {
    if (!root) return 0;
    T* decl = dynamic_cast<T*>(root);
    if (decl!=NULL)
    {
      if (scope)
      {
        if ((decl->get_scope() == scope)&&
            (decl->search_for_symbol_from_symbol_table()->get_name()==name))
          return decl;
      }
      else // Liao 2/9/2010. We should allow NULL scope
      {
        if(decl->search_for_symbol_from_symbol_table()->get_name()==name)
          return decl;
      }
    }

    std::vector<SgNode*> children = root->get_traversalSuccessorContainer();
    for (std::vector<SgNode*>::const_iterator i = children.begin();
            i != children.end(); ++i)
    {
     T* target= findDeclarationStatement<T> (*i,name, scope, isDefining);
     if (target)
       return target;
    }
    return 0;
  }
  SgFunctionDeclaration* findFunctionDeclaration(SgNode* root, std::string name, SgScopeStatement* scope, bool isDefining);

#if 0 //TODO
  // 1. preorder traversal from current SgNode till find next SgNode of type V_SgXXX
  //    until reach the end node
  SgNode* getNextSgNode( const SgNode* astSourceNode, VariantT=V_SgNode, SgNode* astEndNode=NULL);

  // 2. return all nodes of type VariantT following the source node
  std::vector<SgNode*> getAllNextSgNode( const SgNode* astSourceNode, VariantT=V_SgNode, SgNode* astEndNode=NULL);
#endif


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

// remember to put const to all arguments.


template <typename NodeType>
NodeType* getEnclosingNode(const SgNode* astNode, const bool includingSelf=false)
{
  if (NULL==astNode)
    return NULL;
  if ((includingSelf)&&(dynamic_cast<const NodeType*>(astNode)))
    return const_cast<NodeType*>(dynamic_cast<const NodeType*> (astNode));

  SgNode* parent = astNode->get_parent();
  while ((parent!=NULL)&&(!dynamic_cast<const NodeType*>(parent)))
    parent = parent->get_parent();

  return const_cast<NodeType*>(dynamic_cast<const NodeType*> (parent));
}

SgScopeStatement* getScope(const SgNode* astNode);

  SgGlobal* getGlobalScope( const SgNode* astNode);


  SgFunctionDefinition* getEnclosingProcedure(SgNode* n, const bool includingSelf=false);

  SgFunctionDefinition* getEnclosingFunctionDefinition(SgNode* astNode, const bool includingSelf=false);

  SgStatement* getEnclosingStatement(SgNode* n);

  SgSwitchStatement* findEnclosingSwitch(SgStatement* s);

  SgScopeStatement* findEnclosingLoop(SgStatement* s, const std::string& fortranLabel = "", bool stopOnSwitches = false);

  SgFunctionDeclaration * getEnclosingFunctionDeclaration (SgNode * astNode, const bool includingSelf=false);
   //roseSupport/utility_functions.h
  SgFile* getEnclosingFileNode (SgNode* astNode );

  SgInitializer* getInitializerOfExpression(SgExpression* n);

  SgClassDefinition* getEnclosingClassDefinition(SgNode* astnode, const bool includingSelf=false);

// TODO
#if 0
   SgNode * getEnclosingSgNode(SgNode* source,VariantT, SgNode* endNode=NULL);
   std::vector<SgNode *>  getAllEnclosingSgNode(SgNode* source,VariantT, SgNode* endNode=NULL);
   SgVariableDeclaration* findVariableDeclaratin( const string& varname)

   SgClassDeclaration* getEnclosingClassDeclaration( const SgNode* astNode);

   // e.g. for some expression, find its parent statement
   SgStatement* getEnclosingStatement(const SgNode* astNode);

   SgSwitchStatement* getEnclosingSwitch(SgStatement* s);
   SgModuleStatement* getEnclosingModuleStatement( const SgNode* astNode);

  // used to build a variable reference for compiler generated code in current scope
   SgSymbol * findReachingDefinition (SgScopeStatement* startScope, SgName &name);
#endif


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

  // Liao, 1/9/2008
  SgGlobal * getFirstGlobalScope(SgProject *project);

  SgStatement* getLastStatement(SgScopeStatement *scope);

  SgStatement* getFirstStatement(SgScopeStatement *scope,bool includingCompilerGenerated=false);
  SgFunctionDeclaration* findFirstDefiningFunctionDecl(SgScopeStatement* scope);

  SgStatement* getNextStatement(SgStatement * currentStmt);

  SgStatement* getPreviousStatement(SgStatement * currentStmt);
#if 0 //TODO
  // preorder traversal from current SgNode till find next SgNode of type V_SgXXX
  SgNode* getNextSgNode( const SgNode* currentNode, VariantT=V_SgNode);
#endif


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


 bool isEqualToIntConst(SgExpression* e, int value);


 bool isSameFunction(SgFunctionDeclaration* func1, SgFunctionDeclaration* func2);

 bool isLastStatement(SgStatement* stmt);


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

// DQ (2/24/2009): Simple function to delete an AST subtree (used in outlining).
 void deleteAST(SgNode* node);

 void deleteExpressionTreeWithOriginalExpressionSubtrees(SgNode* root);

// DQ (2/25/2009): Added new function to support outliner.
 void moveStatementsBetweenBlocks ( SgBasicBlock* sourceBlock, SgBasicBlock* targetBlock );


void appendStatement(SgStatement *stmt, SgScopeStatement* scope=NULL);

void appendStatementList(const std::vector<SgStatement*>& stmt, SgScopeStatement* scope=NULL);

// DQ (2/6/2009): Added function to support outlining into separate file.
void appendStatementWithDependentDeclaration( SgDeclarationStatement* decl, SgGlobal* scope, SgStatement* original_statement, bool excludeHeaderFiles );

void prependStatement(SgStatement *stmt, SgScopeStatement* scope=NULL);

void prependStatementList(const std::vector<SgStatement*>& stmt, SgScopeStatement* scope=NULL);

bool  hasSimpleChildrenList (SgScopeStatement* scope);

void insertStatement(SgStatement *targetStmt, SgStatement* newStmt, bool insertBefore= true, bool autoMovePreprocessingInfo = true);

//target's scope
void insertStatementList(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmts, bool insertBefore= true);

void insertStatementBefore(SgStatement *targetStmt, SgStatement* newStmt, bool autoMovePreprocessingInfo = true);

void insertStatementListBefore(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmts);

void insertStatementAfter(SgStatement *targetStmt, SgStatement* newStmt, bool autoMovePreprocessingInfo = true);

void insertStatementListAfter(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmt);

void insertStatementAfterLastDeclaration(SgStatement* stmt, SgScopeStatement* scope);

void insertStatementAfterLastDeclaration(std::vector<SgStatement*> stmt_list, SgScopeStatement* scope);

void removeStatement(SgStatement* stmt, bool autoRelocatePreprocessingInfo = true);

void deepDelete(SgNode* root);

void replaceStatement(SgStatement* oldStmt, SgStatement* newStmt, bool movePreprocessinInfo = false);

SgNode* replaceWithPattern (SgNode * anchor, SgNode* new_pattern);

std::pair<SgVariableDeclaration*, SgExpression* > createTempVariableForExpression(SgExpression* expression,
        SgScopeStatement* scope, bool initializeInDeclaration, SgAssignOp** reEvaluate = NULL);


SgVariableSymbol* appendArg(SgFunctionParameterList *, SgInitializedName*);
SgVariableSymbol* prependArg(SgFunctionParameterList *, SgInitializedName*);

void appendExpression(SgExprListExp *, SgExpression*);

void appendExpressionList(SgExprListExp *, const std::vector<SgExpression*>&);

void setParameterList(SgFunctionDeclaration *func,SgFunctionParameterList *paralist);

void setPragma(SgPragmaDeclaration* decl, SgPragma *pragma);

void replaceExpression(SgExpression* oldExp, SgExpression* newExp, bool keepOldExp=false);

void replaceExpressionWithStatement(SgExpression* from,
                                    SageInterface::StatementGenerator* to);
void replaceSubexpressionWithStatement(SgExpression* from,
                                      SageInterface::StatementGenerator* to);

void setOperand(SgExpression* target, SgExpression* operand);

void setLhsOperand(SgExpression* target, SgExpression* lhs);

void setRhsOperand(SgExpression* target, SgExpression* rhs);

void removeAllOriginalExpressionTrees(SgNode* top);

// DQ (1/25/2010): Added support for directories
void moveToSubdirectory ( std::string directoryName, SgFile* file );

SgStatement* findSurroundingStatementFromSameFile(SgStatement* targetStmt, bool & surroundingStatementPreceedsTargetStatement);

   void moveCommentsToNewStatement(SgStatement* sourceStatement, const std::vector<int> & indexList, SgStatement* targetStatement, bool surroundingStatementPreceedsTargetStatement);

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



int fixVariableReferences(SgNode* root);


void fixVariableDeclaration(SgVariableDeclaration* varDecl, SgScopeStatement* scope);

void fixStructDeclaration(SgClassDeclaration* structDecl, SgScopeStatement* scope);
void fixClassDeclaration(SgClassDeclaration* classDecl, SgScopeStatement* scope);

void fixNamespaceDeclaration(SgNamespaceDeclarationStatement* structDecl, SgScopeStatement* scope);


void fixLabelStatement(SgLabelStatement* label_stmt, SgScopeStatement* scope);

void setFortranNumericLabel(SgStatement* stmt, int label_value);

int  suggestNextNumericLabel(SgFunctionDefinition* func_def);

void fixStatement(SgStatement* stmt, SgScopeStatement* scope);


void updateDefiningNondefiningLinks(SgFunctionDeclaration* func, SgScopeStatement* scope);

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


bool
collectReadWriteRefs(SgStatement* stmt, std::vector<SgNode*>& readRefs, std::vector<SgNode*>& writeRefs);

bool collectReadWriteVariables(SgStatement* stmt, std::set<SgInitializedName*>& readVars, std::set<SgInitializedName*>& writeVars);

void collectReadOnlyVariables(SgStatement* stmt, std::set<SgInitializedName*>& readOnlyVars);

void collectReadOnlySymbols(SgStatement* stmt, std::set<SgVariableSymbol*>& readOnlySymbols);

bool isUseByAddressVariableRef(SgVarRefExp* ref);

void collectUseByAddressVariableRefs (const SgStatement* s, std::set<SgVarRefExp* >& varSetB);

#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
LivenessAnalysis * call_liveness_analysis(SgProject* project, bool debug=false);

void getLiveVariables(LivenessAnalysis * liv, SgForStatement* loop, std::set<SgInitializedName*>& liveIns, std::set<SgInitializedName*> & liveOuts);
#endif

void ReductionRecognition(SgForStatement* loop, std::set< std::pair <SgInitializedName*, VariantT> > & results);


void constantFolding(SgNode* r);


int instrumentEndOfFunction(SgFunctionDeclaration * func, SgStatement* s);

void removeJumpsToNextStatement(SgNode*);

void removeUnusedLabels(SgNode* top);

void removeConsecutiveLabels(SgNode* top);


 SgAssignInitializer* splitExpression(SgExpression* from, std::string newName = "");

void splitExpressionIntoBasicBlock(SgExpression* expr);

void removeLabeledGotos(SgNode* top);

void changeBreakStatementsToGotos(SgStatement* loopOrSwitch);

SgBasicBlock* ensureBasicBlockAsBodyOfFor(SgForStatement* fs);

SgBasicBlock* ensureBasicBlockAsBodyOfUpcForAll(SgUpcForAllStatement* fs);

SgBasicBlock* ensureBasicBlockAsBodyOfWhile(SgWhileStmt* ws);
SgBasicBlock* ensureBasicBlockAsBodyOfDoWhile(SgDoWhileStmt* ws);
SgBasicBlock* ensureBasicBlockAsBodyOfSwitch(SgSwitchStatement* ws);
SgBasicBlock* ensureBasicBlockAsTrueBodyOfIf(SgIfStmt* ifs);
SgBasicBlock* ensureBasicBlockAsFalseBodyOfIf(SgIfStmt* ifs);
SgBasicBlock* ensureBasicBlockAsBodyOfCatch(SgCatchOptionStmt* cos);
SgBasicBlock* ensureBasicBlockAsBodyOfOmpBodyStmt(SgOmpBodyStatement* ompbodyStmt);
SgLocatedNode* ensureBasicBlockAsParent(SgStatement* s);

void changeAllLoopBodiesToBlocks(SgNode* top);

unsigned long long getIntegerConstantValue(SgValueExp* expr);

std::vector<SgDeclarationStatement*> getDependentDeclarations (SgStatement* stmt );


SgCommaOpExp *insertBeforeUsingCommaOp (SgExpression* new_exp, SgExpression* anchor_exp);

SgCommaOpExp *insertAfterUsingCommaOp (SgExpression* new_exp, SgExpression* anchor_exp, SgStatement** temp_decl = NULL, SgVarRefExp** temp_ref = NULL);




#if 0

//------------------------AST dump, stringify-----------------------------
//------------------------------------------------------------------------
  std::string buildOperatorString ( SgNode* astNode ); //transformationSupport.h

  // do we need these?
  std::string dump_node(const SgNode* astNode);
  std::string dump_tree(const SgNode* astNode);

  // or a friendly version of  unparseToString(), as a memeber function
  std::string SgNode::toString(bool asSubTree=true); // dump node or subtree

//----------------------------AST comparison------------------------------
//------------------------------------------------------------------------
// How to get generic functions for comparison?
  bool isNodeEqual(SgNode* node1, SgNode* node2); //?
  bool isTreeEqual(SgNode* tree1, SgNode* tree2);

  bool expressionTreeEqual(SgExpression*, SgExpression*);
  bool expressionTreeEqualStar(const SgExpressionPtrList&,
                             const SgExpressionPtrList&);

//----------------------AST verfication/repair----------------------------
//------------------------------------------------------------------------
// sanity check of AST subtree, any suggestions?
//  TODO
    verifySgNode(SgNode* node, bool subTree=true);
  //src/midend/astDiagnostics/AstConsistencyTests.h
  // AstTests::runAllTests(SgProject * )

  //src/midend/astUtil/astInterface/AstInterface.h.C
  //FixSgProject(SgProject &project)
  //FixSgTree(SgNode* r)

  //src/frontend/SageIII/astPostProcessing
  //AstPostProcessing(SgNode * node)

//--------------------------AST modification------------------------------
//------------------------------------------------------------------------
// any operations changing AST tree, including
// insert, copy, delete(remove), replace

  // insert before or after some point, argument list is consistent with LowLevelRewrite
  void insertAst(SgNode* targetPosition, SgNode* newNode, bool insertBefore=true);

  // previous examples
  //void myStatementInsert(SgStatement* target,...)
  // void AstInterfaceBase::InsertStmt(AstNodePtr const & orig, AstNodePtr const &n, bool insertbefore, bool extractfromBasicBlock)

  // copy
  // copy children of one basic block to another basic block
  //void appendStatementCopy (const SgBasicBlock* a, SgBasicBlock* b);
  void copyStatements (const SgBasicBlock* src, SgBasicBlock* dst);

  // delete (remove) a node or a whole subtree
  void removeSgNode(SgNode* targetNode); // need this?
  void removeSgNodeTree(SgNode* subtree); // need this?

  void removeStatement( SgStatement* targetStmt);

  //Move = delete + insert
  void moveAst (SgNode* src, SgNode* target); // need this?
      // similar to
  void moveStatements (SgBasicBlock* src, SgBasicBlock* target);

  // replace= delete old + insert new (via building or copying)

// DQ (1/25/2010): This does not appear to exist as a definition anywhere in ROSE.
// void replaceAst(SgNode* oldNode, SgNode* newNode);

   //void replaceChild(SgNode* parent, SgNode* from, SgNode* to);
   //bool AstInterface::ReplaceAst( const AstNodePtr& orig, const AstNodePtr& n)

//--------------------------AST transformations---------------------------
//------------------------------------------------------------------------
// Advanced AST modifications through basic AST modifications
// Might not be included in AST utitlity list, but listed here for the record.

  // extract statements/content from a scope
  void flattenBlocks(SgNode* n);

  //src/midend/astInlining/inlinerSupport.h
  void renameVariables(SgNode* n);
  void renameLabels(SgNode* n, SgFunctionDefinition* enclosingFunctionDefinition);

  void simpleCopyAndConstantPropagation(SgNode* top);
  void changeAllMembersToPublic(SgNode* n);

  void removeVariableDeclaration(SgInitializedName* initname);

  SgAssignOp* convertInitializerIntoAssignment(SgAssignInitializer* init);

  void pushTestIntoBody(LoopStatement* loopStmt);

  //programTransformation/finiteDifferencing/finiteDifferencing.h
  void moveForDeclaredVariables(SgNode* root);

//------------------------ Is/Has functions ------------------------------
//------------------------------------------------------------------------
// misc. boolean functions
// some of them could moved to SgXXX class as a member function

  bool isOverloaded (SgFunctionDeclaration * functionDeclaration);

  bool isSwitchCond (const SgStatement* s);
  bool isIfCond (const SgStatement* s);
  bool isWhileCond (const SgStatement* s);
  bool isStdNamespace (const SgScopeStatement* scope);
  bool isTemplateInst (const SgDeclarationStatement* decl);


  bool isCtor (const SgFunctionDeclaration* func);
  bool isDtor (const SgFunctionDeclaration* func);

   // src/midend/astInlining/typeTraits.h
  bool hasTrivialDestructor(SgType* t);
  bool isNonconstReference(SgType* t);
  bool isReferenceType(SgType* t);

  //  generic ones, or move to the SgXXX class as a member function

  bool isConst(SgNode* node); // const type, variable, function, etc.
  // .... and more

  bool isConstType (const SgType* type);
  bool isConstFunction (const SgFunctionDeclaration* decl);


  bool isMemberVariable(const SgInitializedName & var);
  //bool isMemberVariable(const SgNode& in);

  bool isPrototypeInScope (SgScopeStatement * scope,
                           SgFunctionDeclaration * functionDeclaration,
                           SgDeclarationStatement * startingAtDeclaration);

  bool MayRedefined(SgExpression* expr, SgNode* root);
  // bool isPotentiallyModified(SgExpression* expr, SgNode* root); // inlinderSupport.h
  bool hasAddressTaken(SgExpression* expr, SgNode* root);

  //src/midend/astInlining/inlinerSupport.C
     // can also classified as topdown search
  bool containsVariableReference(SgNode* root, SgInitializedName* var);

  bool isDeclarationOf(SgVariableDeclaration* decl, SgInitializedName* var);
  bool isPotentiallyModifiedDuringLifeOf(SgBasicBlock* sc,
                                       SgInitializedName* toCheck,
                                       SgInitializedName* lifetime)
  //src/midend/programTransformation/partialRedundancyElimination/pre.h
  bool anyOfListPotentiallyModifiedIn(const std::vector<SgVariableSymbol*>& syms, SgNode* n);

//------------------------ loop handling ---------------------------------
//------------------------------------------------------------------------
  //get and set loop control expressions
  // 0: init expr, 1: condition expr, 2: stride expr

  SgExpression* getForLoopTripleValues(int valuetype,SgForStatement* forstmt );
  int setForLoopTripleValues(int valuetype,SgForStatement* forstmt, SgExpression* exp);

  bool isLoopIndexVarRef(SgForStatement* forstmt, SgVarRefExp *varref);
  SgInitializedName * getLoopIndexVar(SgForStatement* forstmt);

//------------------------expressions-------------------------------------
//------------------------------------------------------------------------
  //src/midend/programTransformation/partialRedundancyElimination/pre.h
  int countComputationsOfExpressionIn(SgExpression* expr, SgNode* root);

        //src/midend/astInlining/replaceExpressionWithStatement.h
  void replaceAssignmentStmtWithStatement(SgExprStatement* from, StatementGenerator* to);

  void replaceSubexpressionWithStatement(SgExpression* from,
                                       StatementGenerator* to);
  SgExpression* getRootOfExpression(SgExpression* n);

//--------------------------preprocessing info. -------------------------
//------------------------------------------------------------------------
  void cutPreprocInfo (SgBasicBlock* b,
                       PreprocessingInfo::RelativePositionType pos,
                       AttachedPreprocessingInfoType& save_buf);
  void pastePreprocInfoFront (AttachedPreprocessingInfoType& save_buf,
                              SgStatement* s);
  void pastePreprocInfoBack (AttachedPreprocessingInfoType& save_buf,
                             SgStatement* s);

  // a generic one for all
  void moveBeforePreprocInfo (SgStatement* src, SgStatement* dest);
  void moveInsidePreprocInfo (SgBasicBlock* src, SgBasicBlock* dest);
  void moveAfterPreprocInfo (SgStatement* src, SgStatement* dest);

//--------------------------------operator--------------------------------
//------------------------------------------------------------------------
  from transformationSupport.h, not sure if they should be included here
  /* return enum code for SAGE operators */
  operatorCodeType classifyOverloadedOperator(); // transformationSupport.h

  std::string stringifyOperator (std::string name);

//--------------------------------macro ----------------------------------
//------------------------------------------------------------------------
  std::string buildMacro ( std::string s ); //transformationSupport.h

//--------------------------------access functions---------------------------
//----------------------------------get/set sth.-----------------------------
// several categories:
* get/set a direct child/grandchild node or fields
* get/set a property flag value
* get a descendent child node using preorder searching
* get an ancestor node using bottomup/reverse searching

        // SgName or string?
  std::string getFunctionName (SgFunctionCallExp* functionCallExp);
  std::string getFunctionTypeName ( SgFunctionCallExp* functionCallExpression );

    // do we need them anymore? or existing member functions are enought?
    // a generic one:
   std::string get_name (const SgNode* node);
   std::string get_name (const SgDeclarationStatement * declaration);

  // get/set some property: should moved to SgXXX as an inherent memeber function?
  // access modifier
  void  setExtern (SgFunctionDeclartion*)
  void  clearExtern()

   // similarly for other declarations and other properties
  void setExtern (SgVariableDeclaration*)
  void setPublic()
  void setPrivate()


#endif
}// end of namespace

#endif

---