ROSE  0.10.7.0
sageInterface.h
1 #ifndef ROSE_SAGE_INTERFACE
2 #define ROSE_SAGE_INTERFACE
3 
4 #include "sage3basic.hhh"
5 #include <stdint.h>
6 #include <utility>
7 
8 #include "rosePublicConfig.h" // for ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
9 #include "OmpAttribute.h"
10 
11 
12 #if 0 // FMZ(07/07/2010): the argument "nextErrorCode" should be call-by-reference
13 SgFile* determineFileType ( std::vector<std::string> argv, int nextErrorCode, SgProject* project );
14 #else
15 SgFile* determineFileType ( std::vector<std::string> argv, int& nextErrorCode, SgProject* project );
16 #endif
17 
18 #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
19 #include "rewrite.h"
20 #endif
21 
22 // DQ (7/20/2008): Added support for unparsing abitrary strings in the unparser.
23 #include "astUnparseAttribute.h"
24 #include <set>
25 
26 #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
27 #include "LivenessAnalysis.h"
28 #include "abstract_handle.h"
29 #include "ClassHierarchyGraph.h"
30 #endif
31 
32 // DQ (8/19/2004): Moved from ROSE/src/midend/astRewriteMechanism/rewrite.h
34 ROSE_DLL_API std::string getVariantName (VariantT v);
35 
36 // DQ (12/9/2004): Qing, Rich and Dan have decided to start this namespace within ROSE
37 // This namespace is specific to interface functions that operate on the Sage III AST.
38 // The name was chosen so as not to conflict with other classes within ROSE.
39 // This will become the future home of many interface functions which operate on
40 // the AST and which are generally useful to users. As a namespace multiple files can be used
41 // to represent the compete interface and different developers may contribute interface
42 // functions easily.
43 
44 // Constructor handling: (We have sageBuilder.h now for this purpose, Liao 2/1/2008)
45 // We could add simpler layers of support for construction of IR nodes by
46 // hiding many details in "makeSg***()" functions. Such functions would
47 // return pointers to the associated Sg*** objects and would be able to hide
48 // many IR specific details, including:
49 // memory handling
50 // optional parameter settings not often required
51 // use of Sg_File_Info objects (and setting them as transformations)
52 //
53 // namespace AST_Interface (this name is taken already by some of Qing's work :-)
54 
56 #define TRANS_FILE Sg_File_Info::generateDefaultFileInfoForTransformationNode()
57 
58 
64 namespace SageInterface
65  {
66  // Liao 6/22/2016: keep records of loop init-stmt normalization, later help undo it to support autoPar.
68  {
69  // a lookup table to check if a for loop has been normalized for its c99-style init-stmt
70  std::map <SgForStatement* , bool > forLoopInitNormalizationTable;
71  // Detailed record about the original declaration (1st in the pair) and the normalization generated new declaration (2nd in the pair)
72  std::map <SgForStatement* , std::pair<SgVariableDeclaration*, SgVariableDeclaration*> > forLoopInitNormalizationRecord;
73  } ;
74 
75  ROSE_DLL_API extern Transformation_Record trans_records;
76 
77  // DQ (4/3/2014): Added general AST support separate from the AST.
78 
79  // Container and API for analysis information that is outside of the AST and as a result
80  // prevents frequent modification of the IR.
82  {
83  // DQ (4/3/2014): This stores all associated declarations as a map of sets.
84  // the key to the map is the first nondefining declaration and the elements of the set are
85  // all of the associated declarations (including the defining declaration).
86 
87  private:
89  std::map<SgDeclarationStatement*,std::set<SgDeclarationStatement*>* > declarationMap;
90 
91  public:
92  void addDeclaration(SgDeclarationStatement* decl);
93  const std::set<SgDeclarationStatement*>* getDeclarations(SgDeclarationStatement* decl);
94 
95  std::map<SgDeclarationStatement*,std::set<SgDeclarationStatement*>* > & getDeclarationMap();
96 
97  bool isLocatedInDefiningScope(SgDeclarationStatement* decl);
98 
99  };
100 
101  // DQ (4/3/2014): This constructs a data structure that holds analysis information about
102  // the AST that is separate from the AST. This is intended to be a general mechanism
103  // to support analysis information without constantly modifying the IR.
104  DeclarationSets* buildDeclarationSets(SgNode*);
105 
107 ROSE_DLL_API extern int gensym_counter;
108 
109 #ifdef ROSE_BUILD_BINARY_ANALYSIS_SUPPORT
112 
115 
118 #endif
119 
121  void addMessageStatement( SgStatement* stmt, std::string message );
122 
124  class UniqueNameAttribute : public AstAttribute
125  {
126  private:
127  std::string name;
128  public:
129  UniqueNameAttribute(std::string n="") {name =n; };
130  void set_name (std::string n) {name = n;};
131  std::string get_name () {return name;};
132  };
133 
134  //------------------------------------------------------------------------
136 
139  // Liao 1/22/2008, used for get symbols for generating variable reference nodes
140  // ! Find a variable symbol in current and ancestor scopes for a given name
141  ROSE_DLL_API SgVariableSymbol *lookupVariableSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope=NULL);
142 
143 // DQ (8/21/2013): Modified to make newest function parameters be default arguments.
144 // DQ (8/16/2013): For now we want to remove the use of default parameters and add the support for template parameters and template arguments.
146 // SgSymbol *lookupSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope=NULL);
147 // SgSymbol *lookupSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList);
148  ROSE_DLL_API SgSymbol *lookupSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
149 
150  // DQ (11/24/2007): Functions moved from the Fortran support so that they could be called from within astPostProcessing.
152  ROSE_DLL_API SgFunctionSymbol *lookupFunctionSymbolInParentScopes (const SgName & functionName, SgScopeStatement *currentScope=NULL);
153 
154  // Liao, 1/24/2008, find exact match for a function
156  ROSE_DLL_API SgFunctionSymbol *lookupFunctionSymbolInParentScopes (const SgName & functionName,
157  const SgType* t,
158  SgScopeStatement *currentScope=NULL);
159 
160  ROSE_DLL_API SgFunctionSymbol *lookupTemplateFunctionSymbolInParentScopes (const SgName & functionName, SgFunctionType * ftype, SgTemplateParameterPtrList * tplparams, SgScopeStatement *currentScope=NULL);
161  ROSE_DLL_API SgFunctionSymbol *lookupTemplateMemberFunctionSymbolInParentScopes (const SgName & functionName, SgFunctionType * ftype, SgTemplateParameterPtrList * tplparams, SgScopeStatement *currentScope=NULL);
162 
163  ROSE_DLL_API SgTemplateVariableSymbol * lookupTemplateVariableSymbolInParentScopes (const SgName & name, SgTemplateParameterPtrList * tplparams, SgTemplateArgumentPtrList* tplargs, SgScopeStatement *currentScope=NULL);
164 
165 
166 // DQ (8/21/2013): Modified to make newest function parameters be default arguments.
167 // DQ (8/16/2013): For now we want to remove the use of default parameters and add the support for template parameters and template arguments.
168 // DQ (5/7/2011): Added support for SgClassSymbol (used in name qualification support).
169 // SgClassSymbol* lookupClassSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
170  ROSE_DLL_API SgClassSymbol* lookupClassSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
171  ROSE_DLL_API SgTypedefSymbol* lookupTypedefSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
172 
173  ROSE_DLL_API SgNonrealSymbol* lookupNonrealSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
174 #if 0
175  // DQ (8/13/2013): This function does not make since any more, now that we have made the symbol
176  // table handling more precise and we have to provide template parameters for any template lookup.
177  // We also have to know if we want to lookup template classes, template functions, or template
178  // member functions (since each have specific requirements).
179  SgTemplateSymbol* lookupTemplateSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
180 #endif
181 #if 0
182 // DQ (8/13/2013): I am not sure if we want this functions in place of lookupTemplateSymbolInParentScopes.
183 // Where these are called we might not know enough information about the template parameters or function
184 // types, for example.
185  SgTemplateClassSymbol* lookupTemplateClassSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
186  SgTemplateFunctionSymbol* lookupTemplateFunctionSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
187  SgTemplateMemberFunctionSymbol* lookupTemplateMemberFunctionSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
188 #endif
189 
190 // DQ (8/21/2013): Modified to make some of the newest function parameters be default arguments.
191 // DQ (8/13/2013): I am not sure if we want this functions in place of lookupTemplateSymbolInParentScopes.
192  ROSE_DLL_API SgTemplateClassSymbol* lookupTemplateClassSymbolInParentScopes (const SgName & name, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList, SgScopeStatement *cscope = NULL);
193 
194  ROSE_DLL_API SgEnumSymbol* lookupEnumSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
195  ROSE_DLL_API SgNamespaceSymbol* lookupNamespaceSymbolInParentScopes(const SgName & name, SgScopeStatement *currentScope = NULL);
196 
197 // DQ (7/17/2011): Added function from cxx branch that I need here for the Java support.
198 // SgClassSymbol* lookupClassSymbolInParentScopes (const SgName & name, SgScopeStatement *cscope);
199 
208  // DQ (12/9/2004): Moved this function (by Alin Jula) from being a member of SgInitializedName
209  // to this location where it can be a part of the interface for the Sage III AST.
210  ROSE_DLL_API int set_name (SgInitializedName * initializedNameNode, SgName new_name);
211 
215 
216  // DQ (6/27/2005):
221  ROSE_DLL_API void outputLocalSymbolTables (SgNode * node);
222 
224  {
225  public:
226  void visit (SgNode * node);
227  };
233  // DQ (9/28/2005):
234  void rebuildSymbolTable (SgScopeStatement * scope);
235 
238  void clearUnusedVariableSymbols (SgNode* root = NULL);
239 
240  // DQ (3/1/2009):
242  void fixupReferencesToSymbols( const SgScopeStatement* this_scope, SgScopeStatement* copy_scope, SgCopyHelp & help );
243 
245 
246  //------------------------------------------------------------------------
248 
255  // DQ (9/21/2005): General function for extracting the name of declarations (when they have names)
256  std::string get_name (const SgNode * node);
257 
262  // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
263  std::string get_name (const SgStatement * stmt);
264 
269  std::string get_name (const SgExpression * expr);
270 
275  // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
276  std::string get_name (const SgDeclarationStatement * declaration);
277 
282  // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
283  std::string get_name (const SgScopeStatement * scope);
284 
289  // DQ (2/11/2007): Added this function to make debugging support more complete (useful for symbol table debugging support).
290  std::string get_name (const SgSymbol * symbol);
291 
296  std::string get_name (const SgType * type);
297 
298 
301  std::string get_name (const SgSupport * node);
302 
303 
306  std::string get_name (const SgLocatedNodeSupport * node);
307 
310  std::string get_name ( const SgC_PreprocessorDirectiveStatement* directive );
311 
314  std::string get_name ( const SgToken* token );
315 
316  // DQ (3/20/2016): Added to refactor some of the DSL infrastructure support.
326 
329  extern std::map<std::string,int> local_name_collision_map;
330  extern std::map<std::string,SgNode*> local_name_to_node_map;
331  extern std::map<SgNode*,std::string> local_node_to_name_map;
332 
336 
340 
342 
343  //------------------------------------------------------------------------
345 
350  // DQ (6/21/2005): Get the default destructor from the class declaration
352  classDeclaration);
353 
356  // DQ (6/22/2005): Get the default constructor from the class declaration
358  classDeclaration);
361  // DQ (8/27/2005):
363  * memberFunctionDeclaration);
364 
369  // DQ (9/17/2005):
372  (SgTemplateInstantiationMemberFunctionDecl * memberFunctionInstantiation);
373 
375  bool isStructDeclaration(SgNode * node);
377  bool isUnionDeclaration(SgNode * node);
378  #if 0
379  // DQ (8/28/2005): This is already a member function of the SgFunctionDeclaration
380  // (so that it can handle template functions and member functions)
381 
385  // DQ (8/27/2005):
386  bool isTemplateMemberFunction (SgTemplateInstantiationMemberFunctionDecl *
387  memberFunctionDeclaration);
388  #endif
389 
391 
392  //------------------------------------------------------------------------
394 
398  void saveToPDF(SgNode* node, std::string filename);
400  void saveToPDF(SgNode* node); // enable calling from gdb
401 
402  // DQ (2/12/2012): Added some diagnostic support.
404  void whereAmI(SgNode* node);
405 
407  std::string extractPragmaKeyword(const SgPragmaDeclaration *);
408 
410  ROSE_DLL_API bool isOmpStatement(SgNode* );
413  // DQ (8/27/2005):
414  bool isOverloaded (SgFunctionDeclaration * functionDeclaration);
415 
416 // DQ (2/14/2012): Added support function used for variable declarations in conditionals.
418  void initializeIfStmt(SgIfStmt *ifstmt, SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);
419 
421  void initializeSwitchStatement(SgSwitchStatement* switchStatement,SgStatement *item_selector,SgStatement *body);
422 
424  void initializeWhileStatement(SgWhileStmt* whileStatement, SgStatement * condition, SgStatement *body, SgStatement *else_body);
425 
428 
430  ROSE_DLL_API bool isMain (const SgNode* node);
431  // DQ (6/22/2005):
442  std::string generateUniqueName ( const SgNode * node, bool ignoreDifferenceBetweenDefiningAndNondefiningDeclarations);
443 
446  std::string generateUniqueVariableName(SgScopeStatement* scope, std::string baseName = "temp");
447 
448  // DQ (8/10/2010): Added const to first parameter.
449  // DQ (3/10/2007):
451  std::string declarationPositionString (const SgDeclarationStatement * declaration);
452 
453  // DQ (1/20/2007):
455  ROSE_DLL_API std::string generateProjectName (const SgProject * project, bool supressSuffix = false );
456 
460 
463 
465  void addVarRefExpFromArrayDimInfo(SgNode * astNode, Rose_STL_Container<SgNode *>& NodeList_t);
466 
467  // DQ (10/6/2006): Added support for faster mangled name generation (caching avoids recomputation).
471 #ifndef SWIG
472 // DQ (3/10/2013): This appears to be a problem for the SWIG interface (undefined reference at link-time).
473  void clearMangledNameCache (SgGlobal * globalScope);
474  void resetMangledNameCache (SgGlobal * globalScope);
475 #endif
476 
477  std::string getMangledNameFromCache (SgNode * astNode);
478  std::string addMangledNameToCache (SgNode * astNode, const std::string & mangledName);
479 
481 
485 
486  // DQ (10/14/2006): This function tests the AST to see if for a non-defining declaration, the
487  // bool declarationPreceedsDefinition ( SgClassDeclaration* classNonDefiningDeclaration, SgClassDeclaration* classDefiningDeclaration );
489  bool declarationPreceedsDefinition (SgDeclarationStatement *nonDefiningDeclaration, SgDeclarationStatement *definingDeclaration);
490 
491  // DQ (10/19/2006): Function calls have interesting context dependent rules to determine if
492  // they are output with a global qualifier or not. Were this is true we have to avoid global
493  // qualifiers, since the function's scope has not been defined. This is an example of where
494  // qualification of function names in function calls are context dependent; an interesting
495  // example of where the C++ language is not friendly to source-to-source processing :-).
497 
502  ROSE_DLL_API std::vector < SgNode * >astIntersection (SgNode * original, SgNode * copy, SgCopyHelp * help = NULL);
503 
505  ROSE_DLL_API SgNode* deepCopyNode (const SgNode* subtree);
506 
508  template <typename NodeType>
509  NodeType* deepCopy (const NodeType* subtree) {
510  return dynamic_cast<NodeType*>(deepCopyNode(subtree));
511  }
512 
514  ROSE_DLL_API SgExpression* copyExpression(SgExpression* e);
515 
517  ROSE_DLL_API SgStatement* copyStatement(SgStatement* s);
518 
519 // from VarSym.cc in src/midend/astOutlining/src/ASTtools
522 
525 
527 ROSE_DLL_API void myRemoveStatement(SgStatement* stmt);
528 
529 ROSE_DLL_API bool isConstantTrue(SgExpression* e);
530 ROSE_DLL_API bool isConstantFalse(SgExpression* e);
531 
533 ROSE_DLL_API bool isCallToParticularFunction(const std::string& qualifiedName, size_t arity, SgExpression* e);
534 
536 bool ROSE_DLL_API isStatic(SgDeclarationStatement* stmt);
537 
539 ROSE_DLL_API void setStatic(SgDeclarationStatement* stmt);
540 
542 ROSE_DLL_API bool isExtern(SgDeclarationStatement* stmt);
543 
545 ROSE_DLL_API void setExtern(SgDeclarationStatement* stmt);
546 
550  public:
551  virtual ~StatementGenerator() {};
552  virtual SgStatement* generate(SgExpression* where_to_write_answer) = 0;
553 };
554 
558  bool isAssignmentStatement(SgNode* _s, SgExpression** lhs=NULL, SgExpression** rhs=NULL, bool* readlhs=NULL);
559 
561 ROSE_DLL_API SgInitializedName* convertRefToInitializedName(SgNode* current, bool coarseGrain=true);
562 
565 
567 ROSE_DLL_API SgNode* getSgNodeFromAbstractHandleString(const std::string& input_string);
568 
570 ROSE_DLL_API void dumpInfo(SgNode* node, std::string desc="");
571 
573 ROSE_DLL_API std::vector<SgDeclarationStatement*>
574 sortSgNodeListBasedOnAppearanceOrderInSource(const std::vector<SgDeclarationStatement*>& nodevec);
575 
576 // DQ (4/13/2013): We need these to support the unparing of operators defined by operator syntax or member function names.
578 // bool isPrefixOperator( const SgMemberFunctionRefExp* memberFunctionRefExp );
579 bool isPrefixOperator( SgExpression* exp );
580 
582 bool isPrefixOperatorName( const SgName & functionName );
583 
585 bool isPostfixOperator( SgExpression* exp );
586 
588 bool isIndexOperator( SgExpression* exp );
589 
590 // DQ (1/10/2014): Adding more general support for token based unparsing.
592 SgStatement* lastStatementOfScopeWithTokenInfo (SgScopeStatement* scope, std::map<SgNode*,TokenStreamSequenceToNodeMapping*> & tokenStreamSequenceMap);
593 
595 
596 //------------------------------------------------------------------------
598 
602 // std::string version(); // utility_functions.h, version number
605  ROSE_DLL_API bool is_Ada_language ();
606  ROSE_DLL_API bool is_C_language ();
607  ROSE_DLL_API bool is_Cobol_language ();
608  ROSE_DLL_API bool is_OpenMP_language ();
609  ROSE_DLL_API bool is_UPC_language ();
611  ROSE_DLL_API bool is_UPC_dynamic_threads();
612  ROSE_DLL_API bool is_C99_language ();
613  ROSE_DLL_API bool is_Cxx_language ();
614  ROSE_DLL_API bool is_Java_language ();
615  ROSE_DLL_API bool is_Jovial_language ();
616  ROSE_DLL_API bool is_Fortran_language ();
617  ROSE_DLL_API bool is_CAF_language ();
618  ROSE_DLL_API bool is_PHP_language();
619  ROSE_DLL_API bool is_Python_language();
620  ROSE_DLL_API bool is_Cuda_language();
621  ROSE_DLL_API bool is_OpenCL_language();
622  ROSE_DLL_API bool is_X10_language();
623  ROSE_DLL_API bool is_binary_executable();
624  ROSE_DLL_API bool is_mixed_C_and_Cxx_language ();
625  ROSE_DLL_API bool is_mixed_Fortran_and_C_language ();
626  ROSE_DLL_API bool is_mixed_Fortran_and_Cxx_language ();
627  ROSE_DLL_API bool is_mixed_Fortran_and_C_and_Cxx_language ();
628 
629  ROSE_DLL_API bool is_language_case_insensitive ();
631 
633 
634 //------------------------------------------------------------------------
636 
640  // DQ (10/5/2006): Added support for faster (non-quadratic) computation of unique
641  // labels for scopes in a function (as required for name mangling).
647  void resetScopeNumbers (SgFunctionDefinition * functionDeclaration);
648 
649  // DQ (10/5/2006): Added support for faster (non-quadratic) computation of unique
650  // labels for scopes in a function (as required for name mangling).
659  void clearScopeNumbers (SgFunctionDefinition * functionDefinition);
660 
661 
664 // SgNamespaceDefinitionStatement * getEnclosingNamespaceScope (SgNode * node);
665 
666  bool isPrototypeInScope (SgScopeStatement * scope,
667  SgFunctionDeclaration * functionDeclaration,
668  SgDeclarationStatement * startingAtDeclaration);
669 
671  bool ROSE_DLL_API isAncestor(SgNode* node1, SgNode* node2);
673 //------------------------------------------------------------------------
675 
679  void dumpPreprocInfo (SgLocatedNode* locatedNode);
681 
683 PreprocessingInfo * insertHeader(SgSourceFile * source_file, const std::string & header_file_name, bool isSystemHeader, bool asLastHeader);
684 
686 void insertHeader (SgStatement* stmt, PreprocessingInfo* newheader, bool asLastHeader);
687 
689 PreprocessingInfo * insertHeader(SgSourceFile * source_file, const std::string & header_file_name, bool isSystemHeader = false, PreprocessingInfo::RelativePositionType position = PreprocessingInfo::before);
690 
692 ROSE_DLL_API PreprocessingInfo* insertHeader(const std::string& filename, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::after, bool isSystemHeader=false, SgScopeStatement* scope=NULL);
693 
695 ROSE_DLL_API void moveUpPreprocessingInfo (SgStatement* stmt_dst, SgStatement* stmt_src, PreprocessingInfo::RelativePositionType src_position=PreprocessingInfo::undef, PreprocessingInfo::RelativePositionType dst_position=PreprocessingInfo::undef, bool usePrepend= false);
696 
698 ROSE_DLL_API void movePreprocessingInfo (SgStatement* stmt_src, SgStatement* stmt_dst, PreprocessingInfo::RelativePositionType src_position=PreprocessingInfo::undef,
699  PreprocessingInfo::RelativePositionType dst_position=PreprocessingInfo::undef, bool usePrepend= false);
700 
701 
703 ROSE_DLL_API void cutPreprocessingInfo (SgLocatedNode* src_node, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType& save_buf);
704 
706 ROSE_DLL_API void pastePreprocessingInfo (SgLocatedNode* dst_node, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType& saved_buf);
707 
710  const std::string & text,
711  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before);
712 
716 
719  SgSourceFile * source_file,
720  const std::string & content,
721  PreprocessingInfo::DirectiveType directive_type = PreprocessingInfo::C_StyleComment,
722  PreprocessingInfo::RelativePositionType position = PreprocessingInfo::before
723 );
724 
726  ROSE_DLL_API PreprocessingInfo* attachComment(SgLocatedNode* target, const std::string & content,
727  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before,
728  PreprocessingInfo::DirectiveType dtype= PreprocessingInfo::CpreprocessorUnknownDeclaration);
729 
730 // DQ (7/20/2008): I am not clear were I should put this function, candidates include: SgLocatedNode or SgInterface
732  ROSE_DLL_API void addTextForUnparser ( SgNode* astNode, std::string s, AstUnparseAttribute::RelativePositionType inputlocation );
733 
738 void guardNode(SgLocatedNode * target, std::string guard);
739 
741 
742 
743 //------------------------------------------------------------------------
745 
749 // ************************************************************************
750 // Newer versions of now depricated functions
751 // ************************************************************************
752 
753 // DQ (5/1/2012): This function queries the SageBuilder::SourcePositionClassification mode (stored in the SageBuilder
754 // interface) and used the specified mode to initialize the source position data (Sg_File_Info objects). This
755 // function is the only function that should be called directly (though in a namespace we can't define permissions).
757  ROSE_DLL_API void setSourcePosition(SgNode* node);
758 
759 // A better name might be "setSourcePositionForSubTree"
761  ROSE_DLL_API void setSourcePositionAtRootAndAllChildren(SgNode *root);
762 
765 
766 // DQ (5/1/2012): Newly renamed function (previous name preserved for backward compatability).
768 
769 // ************************************************************************
770 
771 
772 
773 // ************************************************************************
774 // Older deprecated functions
775 // ************************************************************************
776  // Liao, 1/8/2007, set file info. for a whole subtree as transformation generated
778  ROSE_DLL_API void setOneSourcePositionForTransformation(SgNode *node);
779 
781  ROSE_DLL_API void setOneSourcePositionNull(SgNode *node);
782 
784  ROSE_DLL_API void setSourcePositionForTransformation (SgNode * root);
785 
787 // ROSE_DLL_API void setSourcePositionForTransformation_memoryPool();
788 
790  ROSE_DLL_API bool insideSystemHeader (SgLocatedNode* node);
791 
793 // ROSE_DLL_API void setSourcePosition (SgLocatedNode * locatedNode);
794 // ************************************************************************
795 
797 
798 
799 //------------------------------------------------------------------------
801 
805 // from src/midend/astInlining/typeTraits.h
806 // src/midend/astUtil/astInterface/AstInterface.h
807 
810 
811 
815 ROSE_DLL_API bool isStrictIntegerType(SgType* t);
817 ROSE_DLL_API SgType* getFirstVarType(SgVariableDeclaration* decl);
818 
820 ROSE_DLL_API bool isDefaultConstructible(SgType* type);
821 
823 ROSE_DLL_API bool isCopyConstructible(SgType* type);
824 
826 ROSE_DLL_API bool isAssignable(SgType* type);
827 
828 #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
829 ROSE_DLL_API bool isPureVirtualClass(SgType* type, const ClassHierarchyWrapper& classHierarchy);
833 #endif
834 
836 ROSE_DLL_API bool hasTrivialDestructor(SgType* t);
837 
839 ROSE_DLL_API bool isNonconstReference(SgType* t);
840 
842 ROSE_DLL_API bool isReferenceType(SgType* t);
843 
845 ROSE_DLL_API bool isPointerType(SgType* t);
846 
852 ROSE_DLL_API bool isPointerToNonConstType(SgType* type);
853 
855 /* const char* p = "aa"; is not treated as having a const type. It is a pointer to const char.
856  * Similarly, neither for const int b[10]; or const int & c =10;
857  * The standard says, "A compound type is not cv-qualified by the cv-qualifiers (if any) of
858 the types from which it is compounded. Any cv-qualifiers applied to an array type affect the array element type, not the array type".
859  */
860 ROSE_DLL_API bool isConstType(SgType* t);
861 
864 
866 ROSE_DLL_API bool isVolatileType(SgType* t);
867 
869 ROSE_DLL_API bool isRestrictType(SgType* t);
870 
872 
874 ROSE_DLL_API bool isScalarType(SgType* t);
875 
879 ROSE_DLL_API bool isStrictIntegerType(SgType* t);
880 
882 ROSE_DLL_API bool isStructType(SgType* t);
883 
885 ROSE_DLL_API std::string mangleType(SgType* type);
886 
888 ROSE_DLL_API std::string mangleScalarType(SgType* type);
889 
891 ROSE_DLL_API std::string mangleModifierType(SgModifierType* type);
892 
894 ROSE_DLL_API size_t getArrayElementCount(SgArrayType* t);
895 
897 ROSE_DLL_API int getDimensionCount(SgType* t);
898 
900 ROSE_DLL_API SgType* getArrayElementType(SgType* t);
901 
903 ROSE_DLL_API SgType* getElementType(SgType* t);
904 
905 
922 std::vector<SgExpression*>
923 get_C_array_dimensions(const SgArrayType& arrtype);
924 
945 std::vector<SgExpression*>
946 get_C_array_dimensions(const SgArrayType& arrtype, const SgVarRefExp& varref);
947 
951 std::vector<SgExpression*>
952 get_C_array_dimensions(const SgArrayType& arrtype, SgInitializedName& initname);
953 
954 
956 ROSE_DLL_API bool isArrayReference(SgExpression* ref, SgExpression** arrayNameExp=NULL, std::vector<SgExpression*>** subscripts=NULL);
957 
958 
960 ROSE_DLL_API int collectVariableReferencesInArrayTypes (SgLocatedNode* root, Rose_STL_Container<SgNode*> & currentVarRefList);
962 
971 ROSE_DLL_API bool hasUpcSharedType(SgType* t, SgModifierType ** mod_type_out = NULL );
972 
974 
977 ROSE_DLL_API bool isUpcSharedType(SgType* t, SgModifierType ** mod_type_out = NULL);
978 
980 ROSE_DLL_API bool isUpcSharedModifierType (SgModifierType* mod_type);
981 
983 ROSE_DLL_API bool isUpcSharedArrayType (SgArrayType* array_type);
984 
986 ROSE_DLL_API bool isUpcStrictSharedModifierType(SgModifierType* mode_type);
987 
989 ROSE_DLL_API size_t getUpcSharedBlockSize(SgModifierType* mod_type);
990 
992 ROSE_DLL_API size_t getUpcSharedBlockSize(SgType* t);
993 
995 ROSE_DLL_API bool isUpcPhaseLessSharedType (SgType* t);
996 
998 ROSE_DLL_API bool isUpcPrivateToSharedType(SgType* t);
999 
1001 ROSE_DLL_API bool isUpcArrayWithThreads(SgArrayType* t);
1002 
1004 ROSE_DLL_API SgType* lookupNamedTypeInParentScopes(const std::string& type_name, SgScopeStatement* scope=NULL);
1005 
1006 // DQ (7/22/2014): Added support for comparing expression types in actual arguments with those expected from the formal function parameter types.
1008 ROSE_DLL_API SgType* getAssociatedTypeFromFunctionTypeList(SgExpression* actual_argument_expression);
1009 
1011 ROSE_DLL_API bool templateArgumentEquivalence(SgTemplateArgument * arg1, SgTemplateArgument * arg2);
1012 
1014 ROSE_DLL_API bool templateArgumentListEquivalence(const SgTemplateArgumentPtrList & list1, const SgTemplateArgumentPtrList & list2);
1015 
1017 ROSE_DLL_API bool isEquivalentType (const SgType* lhs, const SgType* rhs);
1018 
1019 
1022 ROSE_DLL_API bool isEquivalentFunctionType (const SgFunctionType* lhs, const SgFunctionType* rhs);
1023 
1025 
1026 //------------------------------------------------------------------------
1028 
1032 // by Jeremiah
1041 ROSE_DLL_API void addStepToLoopBody(SgScopeStatement* loopStmt, SgStatement* step);
1042 
1044 ROSE_DLL_API void convertForToWhile(SgForStatement* f);
1045 ROSE_DLL_API void convertAllForsToWhiles(SgNode* top);
1047 ROSE_DLL_API void changeContinuesToGotos(SgStatement* stmt, SgLabelStatement* label);
1048 
1050 ROSE_DLL_API SgInitializedName* getLoopIndexVariable(SgNode* loop);
1051 
1054 ROSE_DLL_API bool isLoopIndexVariable(SgInitializedName* ivar, SgNode* subtree_root);
1055 
1057 
1061 ROSE_DLL_API bool hasMultipleInitStatmentsOrExpressions (SgForStatement* for_loop);
1062 
1064 ROSE_DLL_API SgStatement* getLoopBody(SgScopeStatement* loop);
1065 
1066 ROSE_DLL_API void setLoopBody(SgScopeStatement* loop, SgStatement* body);
1067 
1069 ROSE_DLL_API SgStatement* getLoopCondition(SgScopeStatement* loop);
1070 
1072 ROSE_DLL_API void setLoopCondition(SgScopeStatement* loop, SgStatement* cond);
1073 
1077 ROSE_DLL_API 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);
1078 
1080 ROSE_DLL_API 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*/);
1081 
1083 ROSE_DLL_API void setLoopLowerBound(SgNode* loop, SgExpression* lb);
1084 
1086 ROSE_DLL_API void setLoopUpperBound(SgNode* loop, SgExpression* ub);
1087 
1089 ROSE_DLL_API void setLoopStride(SgNode* loop, SgExpression* stride);
1090 
1091 
1093 ROSE_DLL_API bool normalizeForLoopInitDeclaration(SgForStatement* loop);
1094 
1096 ROSE_DLL_API bool unnormalizeForLoopInitDeclaration(SgForStatement* loop);
1097 
1109 ROSE_DLL_API bool forLoopNormalization(SgForStatement* loop, bool foldConstant = true);
1110 
1114 ROSE_DLL_API bool normalizeForLoopTest(SgForStatement* loop);
1115 ROSE_DLL_API bool normalizeForLoopIncrement(SgForStatement* loop);
1116 
1118 ROSE_DLL_API bool doLoopNormalization(SgFortranDo* loop);
1119 
1121 ROSE_DLL_API bool loopUnrolling(SgForStatement* loop, size_t unrolling_factor);
1122 
1124 ROSE_DLL_API bool loopInterchange(SgForStatement* loop, size_t depth, size_t lexicoOrder);
1125 
1127 ROSE_DLL_API bool loopTiling(SgForStatement* loopNest, size_t targetLevel, size_t tileSize);
1128 
1129 //Winnie Loop Collapsing
1130 SgExprListExp * loopCollapsing(SgForStatement* target_loop, size_t collapsing_factor);
1131 
1133  SgForStatement * for_loop,
1134  SgVariableSymbol * & iterator,
1135  SgExpression * & lower_bound,
1136  SgExpression * & upper_bound,
1137  SgExpression * & stride
1138 );
1139 
1141 
1142 //------------------------------------------------------------------------
1144 
1148 template <typename NodeType>
1150 std::vector<NodeType*> querySubTree(SgNode* top, VariantT variant = (VariantT)NodeType::static_variant)
1151  {
1152 #if 0
1153  printf ("Top of SageInterface::querySubTree() \n");
1154 #endif
1155 
1156  Rose_STL_Container<SgNode*> nodes = NodeQuery::querySubTree(top,variant);
1157  std::vector<NodeType*> result(nodes.size(), NULL);
1158  int count = 0;
1159 #if 0
1160  printf ("In SageInterface::querySubTree(): before initialization loop \n");
1161 #endif
1162 
1163  for (Rose_STL_Container<SgNode*>::const_iterator i = nodes.begin(); i != nodes.end(); ++i, ++count)
1164  {
1165 #if 0
1166  printf ("In SageInterface::querySubTree(): in loop: count = %d \n",count);
1167 #endif
1168  NodeType* node = dynamic_cast<NodeType*>(*i);
1169  ROSE_ASSERT (node);
1170  result[count] = node;
1171  }
1172 #if 0
1173  printf ("Leaving SageInterface::querySubTree(): after initialization loop \n");
1174 #endif
1175 
1176  return result;
1177  }
1182  std::vector < SgFile * >generateFileList ();
1183 
1188 ROSE_DLL_API SgProject * getProject();
1189 
1191  SgProject * getProject(const SgNode * node);
1192 
1194 template <typename NodeType>
1195 static std::vector<NodeType*> getSgNodeListFromMemoryPool()
1196 {
1197  // This function uses a memory pool traversal specific to the SgFile IR nodes
1198  class MyTraversal : public ROSE_VisitTraversal
1199  {
1200  public:
1201  std::vector<NodeType*> resultlist;
1202  void visit ( SgNode* node)
1203  {
1204  NodeType* result = dynamic_cast<NodeType* > (node);
1205  ROSE_ASSERT(result!= NULL);
1206  if (result!= NULL)
1207  {
1208  resultlist.push_back(result);
1209  }
1210  };
1211  virtual ~MyTraversal() {}
1212  };
1213 
1214  MyTraversal my_traversal;
1215  NodeType::traverseMemoryPoolNodes(my_traversal);
1216  return my_traversal.resultlist;
1217 }
1218 
1219 
1222 ROSE_DLL_API SgFunctionDeclaration* findMain(SgNode* currentNode);
1223 
1225 SgStatement* findLastDeclarationStatement(SgScopeStatement * scope, bool includePragma = false);
1226 
1227  //midend/programTransformation/partialRedundancyElimination/pre.h
1229 std::vector<SgVariableSymbol*> getSymbolsUsedInExpression(SgExpression* expr);
1230 
1232 
1237 std::vector<SgBreakStmt*> findBreakStmts(SgStatement* code, const std::string& fortranLabel = "");
1238 
1240 
1245 std::vector<SgContinueStmt*> findContinueStmts(SgStatement* code, const std::string& fortranLabel = "");
1246 std::vector<SgGotoStatement*> findGotoStmts(SgStatement* scope, SgLabelStatement* l);
1247 std::vector<SgStatement*> getSwitchCases(SgSwitchStatement* sw);
1248 
1250 void collectVarRefs(SgLocatedNode* root, std::vector<SgVarRefExp* >& result);
1251 
1253 template <typename T>
1254 T* findDeclarationStatement(SgNode* root, std::string name, SgScopeStatement* scope, bool isDefining)
1255  {
1256  bool found = false;
1257 
1258 #if 0
1259  printf ("In findDeclarationStatement(): root = %p \n",root);
1260  printf ("In findDeclarationStatement(): name = %s \n",name.c_str());
1261  printf ("In findDeclarationStatement(): scope = %p \n",scope);
1262  printf ("In findDeclarationStatement(): isDefining = %s \n",isDefining ? "true" : "false");
1263 #endif
1264 
1265  // Do we really want a NULL pointer to be acceptable input to this function?
1266  // Maybe we should have an assertion that it is non-null?
1267  if (!root) return NULL;
1268 
1269  T* decl = dynamic_cast<T*>(root);
1270 
1271 #if 0
1272  printf ("In findDeclarationStatement(): decl = %p \n",decl);
1273 #endif
1274 
1275  if (decl != NULL)
1276  {
1277  if (scope)
1278  {
1279  if ((decl->get_scope() == scope) && (decl->search_for_symbol_from_symbol_table()->get_name() == name))
1280  {
1281  found = true;
1282  }
1283  }
1284  else // Liao 2/9/2010. We should allow NULL scope
1285  {
1286 #if 0
1287  // DQ (12/6/2016): Include this into the debugging code to aboid compiler warning about unused variable.
1288  SgSymbol* symbol = decl->search_for_symbol_from_symbol_table();
1289  printf ("In findDeclarationStatement(): decl->search_for_symbol_from_symbol_table() = %p \n",symbol);
1290  printf ("In findDeclarationStatement(): decl->search_for_symbol_from_symbol_table()->get_name() = %s \n",symbol->get_name().str());
1291 #endif
1292  if (decl->search_for_symbol_from_symbol_table()->get_name() == name)
1293  {
1294  found = true;
1295  }
1296  }
1297  }
1298 
1299  if (found)
1300  {
1301  if (isDefining)
1302  {
1303 #if 0
1304  printf ("In findDeclarationStatement(): decl->get_firstNondefiningDeclaration() = %p \n",decl->get_firstNondefiningDeclaration());
1305  printf ("In findDeclarationStatement(): decl->get_definingDeclaration() = %p \n",decl->get_definingDeclaration());
1306 #endif
1307  ROSE_ASSERT (decl->get_definingDeclaration() != NULL);
1308 #if 0
1309  printf ("In findDeclarationStatement(): returing decl->get_definingDeclaration() = %p \n",decl->get_definingDeclaration());
1310 #endif
1311  return dynamic_cast<T*> (decl->get_definingDeclaration());
1312  }
1313  else
1314  {
1315 #if 0
1316  printf ("In findDeclarationStatement(): returing decl = %p \n",decl);
1317 #endif
1318  return decl;
1319  }
1320  }
1321 
1322  std::vector<SgNode*> children = root->get_traversalSuccessorContainer();
1323 
1324 #if 0
1325  printf ("In findDeclarationStatement(): children.size() = %zu \n",children.size());
1326 #endif
1327 
1328  // DQ (4/10/2016): Note that if we are searching for a function member that has it's defining
1329  // declaration defined outside of the class then it will not be found in the child list.
1330  for (std::vector<SgNode*>::const_iterator i = children.begin(); i != children.end(); ++i)
1331  {
1332  T* target = findDeclarationStatement<T> (*i,name,scope,isDefining);
1333 
1334  if (target)
1335  {
1336  return target;
1337  }
1338  }
1339 
1340  return NULL;
1341  }
1343  SgFunctionDeclaration* findFunctionDeclaration(SgNode* root, std::string name, SgScopeStatement* scope, bool isDefining);
1344 
1345 #if 0 //TODO
1346  // 1. preorder traversal from current SgNode till find next SgNode of type V_SgXXX
1347  // until reach the end node
1348  SgNode* getNextSgNode( const SgNode* astSourceNode, VariantT=V_SgNode, SgNode* astEndNode=NULL);
1349 
1350  // 2. return all nodes of type VariantT following the source node
1351  std::vector<SgNode*> getAllNextSgNode( const SgNode* astSourceNode, VariantT=V_SgNode, SgNode* astEndNode=NULL);
1352 #endif
1353 
1355 
1356 //------------------------------------------------------------------------
1358 
1361 // remember to put const to all arguments.
1362 
1363 
1378 template <typename NodeType>
1379 NodeType* getEnclosingNode(const SgNode* astNode, const bool includingSelf = false)
1380  {
1381 #define DEBUG_GET_ENCLOSING_NODE 0
1382 
1383 #if 1
1384  // DQ (12/31/2019): This version does not detect a cycle that Robb's version detects in processing Cxx11_tests/test2016_23.C.
1385  // This will have to be investigated seperately from the issue I am working on currently.
1386 
1387  // DQ (10/20/2012): This is the older version of this implementation. Until I am sure that
1388  // the newer version (below) is what we want to use I will resolve this conflict by keeping
1389  // the previous version in place.
1390 
1391  if (NULL == astNode)
1392  {
1393  return NULL;
1394  }
1395 
1396  if ( (includingSelf ) && (dynamic_cast<const NodeType*>(astNode)) )
1397  {
1398  return const_cast<NodeType*>(dynamic_cast<const NodeType*> (astNode));
1399  }
1400 
1401  // DQ (3/5/2012): Check for reference to self...
1402  ROSE_ASSERT(astNode->get_parent() != astNode);
1403 
1404  SgNode* parent = astNode->get_parent();
1405 
1406  // DQ (3/5/2012): Check for loops that will cause infinite loops.
1407  SgNode* previouslySeenParent = parent;
1408  bool foundCycle = false;
1409  int counter = 0;
1410 
1411 #if DEBUG_GET_ENCLOSING_NODE
1412  printf ("In getEnclosingNode(): previouslySeenParent = %p = %s \n",previouslySeenParent,previouslySeenParent->class_name().c_str());
1413 #endif
1414 
1415  while ( (foundCycle == false) && (parent != NULL) && (!dynamic_cast<const NodeType*>(parent)) )
1416  {
1417  ROSE_ASSERT(parent->get_parent() != parent);
1418 
1419 #if DEBUG_GET_ENCLOSING_NODE
1420  printf (" --- parent = %p = %s \n",parent,parent->class_name().c_str());
1421  printf (" --- --- parent->get_parent() = %p = %s \n",parent->get_parent(),parent->get_parent()->class_name().c_str());
1422 #endif
1423 
1424 #if 1
1425  // DQ (1/8/2020): ROSE-82 (on RZ) This limit needs to be larger and increasing it to 500 was enough
1426  // for a specific code with a long chain of if-then-else nesting, So to make this sufficent for more
1427  // general code we have increased the lomit to 100,000. Note that 50 was not enough for real code,
1428  // but was enough for our regression tests.
1429  // DQ (12/30/2019): This is added to support detection of infinite loops over parent pointers.
1430  // if (counter >= 500)
1431  if (counter >= 100000)
1432  {
1433  printf ("Exiting: In getEnclosingNode(): loop limit exceeded: counter = %d \n",counter);
1434  ROSE_ASSERT(false);
1435  }
1436 #endif
1437  parent = parent->get_parent();
1438 
1439  // DQ (3/5/2012): Check for loops that will cause infinite loops.
1440  // ROSE_ASSERT(parent != previouslySeenParent);
1441  if (parent == previouslySeenParent)
1442  {
1443  foundCycle = true;
1444  }
1445  counter++;
1446 
1447  }
1448 
1449 #if DEBUG_GET_ENCLOSING_NODE
1450  printf ("previouslySeenParent = %p = %s \n",previouslySeenParent,previouslySeenParent->class_name().c_str());
1451 #endif
1452 
1453  parent = previouslySeenParent;
1454 
1455  SgDeclarationStatement* declarationStatement = isSgDeclarationStatement(parent);
1456  if (declarationStatement != NULL)
1457  {
1458 #if 0
1459  printf ("Found a SgDeclarationStatement \n");
1460 #endif
1461  SgDeclarationStatement* definingDeclaration = declarationStatement->get_definingDeclaration();
1462  SgDeclarationStatement* firstNondefiningDeclaration = declarationStatement->get_firstNondefiningDeclaration();
1463 
1464 #if 0
1465  printf (" --- declarationStatement = %p \n",declarationStatement);
1466  printf (" --- definingDeclaration = %p \n",definingDeclaration);
1467  if (definingDeclaration != NULL && definingDeclaration->get_parent() != NULL)
1468  printf (" --- definingDeclaration ->get_parent() = %p = %s \n",definingDeclaration->get_parent(),definingDeclaration->get_parent()->class_name().c_str());
1469  printf (" --- firstNondefiningDeclaration = %p \n",firstNondefiningDeclaration);
1470  if (firstNondefiningDeclaration != NULL && firstNondefiningDeclaration->get_parent() != NULL)
1471  printf (" --- firstNondefiningDeclaration ->get_parent() = %p = %s \n",firstNondefiningDeclaration->get_parent(),firstNondefiningDeclaration->get_parent()->class_name().c_str());
1472 #endif
1473  if (definingDeclaration != NULL && declarationStatement != firstNondefiningDeclaration)
1474  {
1475 #if 0
1476  printf ("Found a nondefining declaration so use the non-defining declaration instead \n");
1477 #endif
1478  // DQ (10/19/2012): Use the defining declaration instead.
1479  // parent = firstNondefiningDeclaration;
1480  parent = definingDeclaration;
1481  }
1482  }
1483 
1484 #if 0
1485  printf ("reset: previouslySeenParent = %p = %s \n",previouslySeenParent,previouslySeenParent->class_name().c_str());
1486 #endif
1487 
1488  // DQ (10/19/2012): This branch is just to document the cycle that was previously detected, it is for
1489  // debugging only. Thus it ony make sense for it to be executed when "(foundCycle == true)". However,
1490  // this will have to be revisited later since it appears clear that it is a problem for the binary analysis
1491  // work when it is visited for this case. Since the cycle is detected, but there is no assertion on the
1492  // cycle, we don't exit when a cycle is identified (which is the point of the code below).
1493  // Note also that I have fixed the code (above and below) to only chase pointers through defining
1494  // declarations (where they exist), this is important since non-defining declarations can be almost
1495  // anywhere (and thus chasing them can make it appear that there are cycles where there are none
1496  // (I think); test2012_234.C demonstrates an example of this.
1497  // DQ (10/9/2012): Robb has suggested this change to fix the binary analysis work.
1498  // if (foundCycle == true)
1499  if (foundCycle == false)
1500  {
1501 
1502 
1503  while ( (parent != NULL) && (!dynamic_cast<const NodeType*>(parent)) )
1504  {
1505  ROSE_ASSERT(parent->get_parent() != parent);
1506 #if 0
1507  printf ("In getEnclosingNode() (2nd try): parent = %p = %s \n",parent,parent->class_name().c_str());
1508  if (parent->get_file_info() != NULL)
1509  parent->get_file_info()->display("In getEnclosingNode() (2nd try): debug");
1510 #endif
1511  SgDeclarationStatement* declarationStatement = isSgDeclarationStatement(parent);
1512  if (declarationStatement != NULL)
1513  {
1514 #if DEBUG_GET_ENCLOSING_NODE
1515  printf ("Found a SgDeclarationStatement \n");
1516 #endif
1517  SgDeclarationStatement* definingDeclaration = declarationStatement->get_definingDeclaration();
1518  SgDeclarationStatement* firstNondefiningDeclaration = declarationStatement->get_firstNondefiningDeclaration();
1519 #if 0
1520  printf (" --- declarationStatement = %p = %s \n",declarationStatement,(declarationStatement != NULL) ? declarationStatement->class_name().c_str() : "null");
1521 
1522  printf (" --- definingDeclaration = %p \n",definingDeclaration);
1523  if (definingDeclaration != NULL && definingDeclaration->get_parent() != NULL)
1524  printf (" --- definingDeclaration ->get_parent() = %p = %s \n",definingDeclaration->get_parent(),definingDeclaration->get_parent()->class_name().c_str());
1525 
1526  printf (" --- firstNondefiningDeclaration = %p \n",firstNondefiningDeclaration);
1527  if (firstNondefiningDeclaration != NULL && firstNondefiningDeclaration->get_parent() != NULL)
1528  printf (" --- firstNondefiningDeclaration ->get_parent() = %p = %s \n",firstNondefiningDeclaration->get_parent(),firstNondefiningDeclaration->get_parent()->class_name().c_str());
1529 #endif
1530  if (definingDeclaration != NULL && declarationStatement != firstNondefiningDeclaration)
1531  {
1532 #if 0
1533  printf ("Found a nondefining declaration so use the firstNondefining declaration instead \n");
1534 #endif
1535  // DQ (10/19/2012): Use the defining declaration instead.
1536  // parent = firstNondefiningDeclaration;
1537  parent = definingDeclaration;
1538  }
1539  }
1540 
1541  parent = parent->get_parent();
1542 
1543 #if 1
1544  // DQ (3/5/2012): Check for loops that will cause infinite loops.
1545  ROSE_ASSERT(parent != previouslySeenParent);
1546 #else
1547  printf ("WARNING::WARNING::WARNING commented out assertion for parent != previouslySeenParent \n");
1548  if (parent == previouslySeenParent)
1549  break;
1550 #endif
1551  }
1552  }
1553 
1554  return const_cast<NodeType*>(dynamic_cast<const NodeType*> (parent));
1555 #else
1556  // DQ (10/20/2012): Using Robb's newer version with my modification to use the definingDeclaration rather than firstNondefiningDeclaration (below).
1557 
1558  // Find the parent of specified type, but watch out for cycles in the ancestry (which would cause an infinite loop).
1559  // Cast away const because isSg* functions aren't defined for const node pointers; and our return is not const.
1560  SgNode *node = const_cast<SgNode*>(!astNode || includingSelf ? astNode : astNode->get_parent());
1561  std::set<const SgNode*> seen; // nodes we've seen, in order to detect cycles
1562  while (node) {
1563  if (NodeType *found = dynamic_cast<NodeType*>(node))
1564  return found;
1565 
1566  // FIXME: Cycle detection could be moved elsewhere so we don't need to do it on every call. [RPM 2012-10-09]
1567  // DQ (12/30/2019): Provide more detail in error message.
1568  if (seen.insert(node).second == false)
1569  {
1570  printf ("Error: node is already in set and defines a cycle: node = %p = %s \n",node,node->class_name().c_str());
1571  std::set<const SgNode*>::const_iterator i = seen.begin();
1572  while (i != seen.end())
1573  {
1574  const SgNode* element = *i;
1575  printf (" --- seen element: element = %p = %s \n",element,element->class_name().c_str());
1576  i++;
1577  }
1578 
1579  printf ("Exiting after error! \n");
1580  ROSE_ASSERT(false);
1581  }
1582  // ROSE_ASSERT(seen.insert(node).second);
1583 
1584  // Traverse to parent (declaration statements are a special case)
1585  if (SgDeclarationStatement *declarationStatement = isSgDeclarationStatement(node)) {
1586  SgDeclarationStatement *definingDeclaration = declarationStatement->get_definingDeclaration();
1587  SgDeclarationStatement *firstNondefiningDeclaration = declarationStatement->get_firstNondefiningDeclaration();
1588  if (definingDeclaration && firstNondefiningDeclaration && declarationStatement != firstNondefiningDeclaration) {
1589  // DQ (10/19/2012): Use the defining declaration instead.
1590  // node = firstNondefiningDeclaration;
1591  node = definingDeclaration;
1592  }
1593  } else {
1594  node = node->get_parent();
1595  }
1596  }
1597  return NULL;
1598 #endif
1599  }
1600 
1602  ROSE_DLL_API SgSourceFile* getEnclosingSourceFile(SgNode* n, const bool includingSelf=false);
1603 
1605  ROSE_DLL_API SgScopeStatement* getScope(const SgNode* astNode);
1606 
1608  ROSE_DLL_API SgScopeStatement* getEnclosingScope(SgNode* n, const bool includingSelf=false);
1609 
1611  ROSE_DLL_API SgGlobal* getGlobalScope( const SgNode* astNode);
1612 
1613 
1615  ROSE_DLL_API SgFunctionDefinition* getEnclosingProcedure(SgNode* n, const bool includingSelf=false);
1616 
1617  ROSE_DLL_API SgFunctionDefinition* getEnclosingFunctionDefinition(SgNode* astNode, const bool includingSelf=false);
1618 
1620  ROSE_DLL_API SgStatement* getEnclosingStatement(SgNode* n);
1621 
1624 
1627 
1629  ROSE_DLL_API SgScopeStatement* findEnclosingLoop(SgStatement* s, const std::string& fortranLabel = "", bool stopOnSwitches = false);
1630 
1632  ROSE_DLL_API SgFunctionDeclaration * getEnclosingFunctionDeclaration (SgNode * astNode, const bool includingSelf=false);
1633  //roseSupport/utility_functions.h
1635  ROSE_DLL_API SgFile* getEnclosingFileNode (SgNode* astNode );
1636 
1639 
1641  ROSE_DLL_API SgClassDefinition* getEnclosingClassDefinition(SgNode* astnode, const bool includingSelf=false);
1642 
1644  ROSE_DLL_API SgClassDeclaration* getEnclosingClassDeclaration( SgNode* astNode );
1645 
1646  // DQ (2/7/2019): Adding support for name qualification of variable references associated with SgPointerMemberType function parameters.
1648  ROSE_DLL_API SgExprListExp* getEnclosingExprListExp(SgNode* astNode, const bool includingSelf = false);
1649 
1650  // DQ (2/7/2019): Need a function to return when an expression is in an expression subtree.
1651  // This is part of index evaluation ofr expressions in function argument lists, but likely usefule elsewhere as well.
1652  ROSE_DLL_API bool isInSubTree(SgExpression* subtree, SgExpression* exp);
1653 
1654  // DQ (2/7/2019): Need a function to return the SgFunctionDeclaration from a SgFunctionCallExp.
1655  ROSE_DLL_API SgFunctionDeclaration* getFunctionDeclaration ( SgFunctionCallExp* functionCallExp );
1656 
1657  // DQ (2/17/2019): Generalizing this support for SgVarRefExp and SgMemberFunctionRefExp nodes.
1658  // DQ (2/8/2019): Adding support for detecting when to use added name qualification for pointer-to-member expressions.
1659  ROSE_DLL_API bool isDataMemberReference(SgVarRefExp* varRefExp);
1660  // ROSE_DLL_API bool isAddressTaken(SgVarRefExp* varRefExp);
1661  ROSE_DLL_API bool isAddressTaken(SgExpression* refExp);
1662 
1663  // DQ (2/17/2019): Adding support for detecting when to use added name qualification for membr function references.
1664  ROSE_DLL_API bool isMemberFunctionMemberReference(SgMemberFunctionRefExp* memberFunctionRefExp);
1665 
1666  // DQ (2/15/2019): Adding support for detecting which class a member reference is being made from.
1667  // ROSE_DLL_API SgClassType* getClassTypeForDataMemberReference(SgVarRefExp* varRefExp);
1668  // ROSE_DLL_API std::list<SgClassType*> getClassTypeChainForDataMemberReference(SgVarRefExp* varRefExp);
1669  ROSE_DLL_API std::list<SgClassType*> getClassTypeChainForMemberReference(SgExpression* refExp);
1670 
1671  ROSE_DLL_API std::set<SgNode*> getFrontendSpecificNodes();
1672 
1673  // DQ (2/17/2019): Display the shared nodes in the AST for debugging.
1674  ROSE_DLL_API void outputSharedNodes( SgNode* node );
1675 
1676 
1677 // TODO
1678 #if 0
1679  SgNode * getEnclosingSgNode(SgNode* source,VariantT, SgNode* endNode=NULL);
1680  std::vector<SgNode *> getAllEnclosingSgNode(SgNode* source,VariantT, SgNode* endNode=NULL);
1681  SgVariableDeclaration* findVariableDeclaratin( const string& varname)
1682 
1684 
1685  // e.g. for some expression, find its parent statement
1686  SgStatement* getEnclosingStatement(const SgNode* astNode);
1687 
1688  SgSwitchStatement* getEnclosingSwitch(SgStatement* s);
1689  SgModuleStatement* getEnclosingModuleStatement( const SgNode* astNode);
1690 
1691  // used to build a variable reference for compiler generated code in current scope
1692  SgSymbol * findReachingDefinition (SgScopeStatement* startScope, SgName &name);
1693 #endif
1694 
1695 
1696 //------------------------------------------------------------------------
1698 
1701  // Liao, 1/9/2008
1705  ROSE_DLL_API SgGlobal * getFirstGlobalScope(SgProject *project);
1706 
1710  ROSE_DLL_API SgStatement* getLastStatement(SgScopeStatement *scope);
1711 
1713  ROSE_DLL_API SgStatement* getFirstStatement(SgScopeStatement *scope,bool includingCompilerGenerated=false);
1716 
1718  ROSE_DLL_API SgStatement* getNextStatement(SgStatement * currentStmt);
1719 
1721  ROSE_DLL_API SgStatement* getPreviousStatement(SgStatement * currentStmt, bool climbOutScope = true);
1722 #if 0 //TODO
1723  // preorder traversal from current SgNode till find next SgNode of type V_SgXXX
1724  SgNode* getNextSgNode( const SgNode* currentNode, VariantT=V_SgNode);
1725 #endif
1726 
1727  // DQ (11/15/2018): Adding support for traversals over the include file tree.
1729  void listHeaderFiles ( SgIncludeFile* includeFile );
1730 
1731 
1733 
1734 //------------------------------------------------------------------------
1736 
1739  ROSE_DLL_API bool isEqualToIntConst(SgExpression* e, int value);
1741 
1743 
1746  ROSE_DLL_API bool isSameFunction(SgFunctionDeclaration* func1, SgFunctionDeclaration* func2);
1747 
1749  ROSE_DLL_API bool isLastStatement(SgStatement* stmt);
1750 
1752 
1753 //------------------------------------------------------------------------
1755 
1761 // DQ (2/24/2009): Simple function to delete an AST subtree (used in outlining).
1763 ROSE_DLL_API void deleteAST(SgNode* node);
1764 
1767 
1768 // DQ (2/25/2009): Added new function to support outliner.
1770 ROSE_DLL_API void moveStatementsBetweenBlocks ( SgBasicBlock* sourceBlock, SgBasicBlock* targetBlock );
1771 
1773 ROSE_DLL_API void moveVariableDeclaration(SgVariableDeclaration* decl, SgScopeStatement* target_scope);
1775 ROSE_DLL_API void appendStatement(SgStatement *stmt, SgScopeStatement* scope=NULL);
1776 
1778 ROSE_DLL_API void appendStatement(SgStatement *stmt, SgForInitStatement* for_init_stmt);
1779 
1781 ROSE_DLL_API void appendStatementList(const std::vector<SgStatement*>& stmt, SgScopeStatement* scope=NULL);
1782 
1783 // DQ (2/6/2009): Added function to support outlining into separate file.
1785 ROSE_DLL_API void appendStatementWithDependentDeclaration( SgDeclarationStatement* decl, SgGlobal* scope, SgStatement* original_statement, bool excludeHeaderFiles );
1786 
1789 ROSE_DLL_API void prependStatement(SgStatement *stmt, SgScopeStatement* scope=NULL);
1790 
1792 ROSE_DLL_API void prependStatement(SgStatement *stmt, SgForInitStatement* for_init_stmt);
1793 
1796 ROSE_DLL_API void prependStatementList(const std::vector<SgStatement*>& stmt, SgScopeStatement* scope=NULL);
1797 
1801 ROSE_DLL_API bool hasSimpleChildrenList (SgScopeStatement* scope);
1802 
1804 ROSE_DLL_API void insertStatement(SgStatement *targetStmt, SgStatement* newStmt, bool insertBefore= true, bool autoMovePreprocessingInfo = true);
1805 
1807 //target's scope
1808 ROSE_DLL_API void insertStatementList(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmts, bool insertBefore= true);
1809 
1811 ROSE_DLL_API void insertStatementBefore(SgStatement *targetStmt, SgStatement* newStmt, bool autoMovePreprocessingInfo = true);
1812 
1814 ROSE_DLL_API void insertStatementListBefore(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmts);
1815 
1817 ROSE_DLL_API void insertStatementAfter(SgStatement *targetStmt, SgStatement* newStmt, bool autoMovePreprocessingInfo = true);
1818 
1820 ROSE_DLL_API void insertStatementListAfter(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmt);
1821 
1823 ROSE_DLL_API void insertStatementAfterLastDeclaration(SgStatement* stmt, SgScopeStatement* scope);
1824 
1826 ROSE_DLL_API void insertStatementAfterLastDeclaration(std::vector<SgStatement*> stmt_list, SgScopeStatement* scope);
1827 
1829 // then the statement is inserted at the end of the scope.
1830 ROSE_DLL_API void insertStatementBeforeFirstNonDeclaration(SgStatement *newStmt, SgScopeStatement *scope,
1831  bool movePreprocessingInfo=true);
1832 
1834 //then the new statements are inserted at the end of the scope.
1835 ROSE_DLL_API void insertStatementListBeforeFirstNonDeclaration(const std::vector<SgStatement*> &newStmts, SgScopeStatement *scope);
1836 
1837 // DQ (11/21/2018): We need to sometimes insert something after the last statement of the collection from rose_edg_required_macros_and_functions.h.
1838 ROSE_DLL_API SgStatement* lastFrontEndSpecificStatement( SgGlobal* globalScope );
1839 
1841 ROSE_DLL_API void removeStatement(SgStatement* stmt, bool autoRelocatePreprocessingInfo = true);
1842 
1844 ROSE_DLL_API void deepDelete(SgNode* root);
1845 
1847 ROSE_DLL_API void replaceStatement(SgStatement* oldStmt, SgStatement* newStmt, bool movePreprocessinInfo = false);
1848 
1850 ROSE_DLL_API SgNode* replaceWithPattern (SgNode * anchor, SgNode* new_pattern);
1851 
1853 // Essentially replace variable a with b.
1854 ROSE_DLL_API void replaceVariableReferences(SgVariableSymbol* old_sym, SgVariableSymbol* new_sym, SgScopeStatement * scope );
1855 
1856 // DQ (11/12/2018): Adding test to avoid issues that we can't test for in the unparsing of header files using the token based unparsing.
1860 ROSE_DLL_API bool statementCanBeTransformed(SgStatement* stmt);
1861 
1862 
1873 std::pair<SgVariableDeclaration*, SgExpression* > createTempVariableForExpression(SgExpression* expression,
1874  SgScopeStatement* scope, bool initializeInDeclaration, SgAssignOp** reEvaluate = NULL);
1875 
1876 /* This function creates a temporary variable for a given expression in the given scope
1877  This is different from SageInterface::createTempVariableForExpression in that it does not
1878  try to be smart to create pointers to reference types and so on. The tempt is initialized to expression.
1879  The caller is responsible for setting the parent of SgVariableDeclaration since buildVariableDeclaration
1880  may not set_parent() when the scope stack is empty. See programTransformation/extractFunctionArgumentsNormalization/ExtractFunctionArguments.C for sample usage.
1881  @param expression Expression which will be replaced by a variable
1882  @param scope scope in which the temporary variable will be generated
1883 */
1884 
1885 std::pair<SgVariableDeclaration*, SgExpression*> createTempVariableAndReferenceForExpression
1886  (SgExpression* expression, SgScopeStatement* scope);
1887 
1889 
1896 
1898 ROSE_DLL_API void appendExpression(SgExprListExp *, SgExpression*);
1899 
1901 ROSE_DLL_API void appendExpressionList(SgExprListExp *, const std::vector<SgExpression*>&);
1902 
1904 template <class actualFunction>
1905 void setParameterList(actualFunction *func,SgFunctionParameterList *paralist) {
1906 
1907  // TODO consider the difference between C++ and Fortran
1908  // fixup the scope of arguments,no symbols for nondefining function declaration's arguments
1909 
1910  // DQ (11/25/2011): templated function so that we can handle both
1911  // SgFunctionDeclaration and SgTemplateFunctionDeclaration (and their associated member
1912  // function derived classes).
1913 
1914  ROSE_ASSERT(func != NULL);
1915  ROSE_ASSERT(paralist != NULL);
1916 
1917 #if 0
1918  // At this point we don't have cerr and endl defined, so comment this code out.
1919  // Warn to users if a paralist is being shared
1920  if (paralist->get_parent() !=NULL)
1921  {
1922  cerr << "Waring! Setting a used SgFunctionParameterList to function: "
1923  << (func->get_name()).getString()<<endl
1924  << " Sharing parameter lists can corrupt symbol tables!"<<endl
1925  << " Please use deepCopy() to get an exclusive parameter list for each function declaration!"<<endl;
1926  // ROSE_ASSERT(false);
1927  }
1928 #endif
1929 
1930  // Liao,2/5/2008 constructor of SgFunctionDeclaration will automatically generate SgFunctionParameterList, so be cautious when set new paralist!!
1931  if (func->get_parameterList() != NULL)
1932  {
1933  if (func->get_parameterList() != paralist)
1934  {
1935  delete func->get_parameterList();
1936  }
1937  }
1938 
1939  func->set_parameterList(paralist);
1940  paralist->set_parent(func);
1941 
1942  // DQ (5/15/2012): Need to set the declptr in each SgInitializedName IR node.
1943  // This is needed to support the AST Copy mechanism (at least). The files: test2005_150.C,
1944  // test2012_81.C and testcode2012_82.C demonstrate this problem.
1945  SgInitializedNamePtrList & args = paralist->get_args();
1946  for (SgInitializedNamePtrList::iterator i = args.begin(); i != args.end(); i++)
1947  {
1948  (*i)->set_declptr(func);
1949  }
1950  }
1951 
1953 ROSE_DLL_API void setPragma(SgPragmaDeclaration* decl, SgPragma *pragma);
1954 
1956 ROSE_DLL_API void replaceExpression(SgExpression* oldExp, SgExpression* newExp, bool keepOldExp=false);
1957 
1959 ROSE_DLL_API void replaceExpressionWithStatement(SgExpression* from,
1963 ROSE_DLL_API void replaceSubexpressionWithStatement(SgExpression* from,
1965 
1967 ROSE_DLL_API void setOperand(SgExpression* target, SgExpression* operand);
1968 
1970 ROSE_DLL_API void setLhsOperand(SgExpression* target, SgExpression* lhs);
1971 
1973 ROSE_DLL_API void setRhsOperand(SgExpression* target, SgExpression* rhs);
1974 
1976 ROSE_DLL_API void removeAllOriginalExpressionTrees(SgNode* top);
1977 
1978 // DQ (1/25/2010): Added support for directories
1980 ROSE_DLL_API void moveToSubdirectory ( std::string directoryName, SgFile* file );
1981 
1983 ROSE_DLL_API SgStatement* findSurroundingStatementFromSameFile(SgStatement* targetStmt, bool & surroundingStatementPreceedsTargetStatement);
1984 
1986 ROSE_DLL_API void moveCommentsToNewStatement(SgStatement* sourceStatement, const std::vector<int> & indexList, SgStatement* targetStatement, bool surroundingStatementPreceedsTargetStatement);
1987 
1988 // DQ (7/19/2015): This is required to support general unparsing of template instantations for the GNU g++
1989 // compiler which does not permit name qualification to be used to support the expression of the namespace
1990 // where a template instantiatoon would be places. Such name qualification would also sometimes require
1991 // global qualification which is also not allowed by the GNU g++ compiler. These issues appear to be
1992 // specific to the GNU compiler versions, at least versions 4.4 through 4.8.
1994 ROSE_DLL_API void moveDeclarationToAssociatedNamespace ( SgDeclarationStatement* declarationStatement );
1995 
1996 ROSE_DLL_API bool isTemplateInstantiationNode(SgNode* node);
1997 
1999 
2000 // DQ (12/1/2015): Adding support for fixup internal data struuctures that have references to statements (e.g. macro expansions).
2001 ROSE_DLL_API void resetInternalMapsForTargetStatement(SgStatement* sourceStatement);
2002 
2003 // DQ (6/7/2019): Add support for transforming function definitions to function prototypes in a subtree.
2004 // We might have to make this specific to a file (only traversing the functions in that file).
2013 
2014 // DQ (11/10/2019): Lower level support for convertFunctionDefinitionsToFunctionPrototypes().
2015 ROSE_DLL_API void replaceDefiningFunctionDeclarationWithFunctionPrototype ( SgFunctionDeclaration* functionDeclaration );
2016 ROSE_DLL_API std::vector<SgFunctionDeclaration*> generateFunctionDefinitionsList(SgNode* node);
2017 
2018 
2020 //------------------------------------------------------------------------
2022 
2029 
2035 ROSE_DLL_API int fixVariableReferences(SgNode* root, bool cleanUnusedSymbol=true);
2036 
2038 
2042 ROSE_DLL_API void fixVariableDeclaration(SgVariableDeclaration* varDecl, SgScopeStatement* scope);
2043 
2045 ROSE_DLL_API void fixStructDeclaration(SgClassDeclaration* structDecl, SgScopeStatement* scope);
2047 ROSE_DLL_API void fixClassDeclaration(SgClassDeclaration* classDecl, SgScopeStatement* scope);
2048 
2050 ROSE_DLL_API void fixNamespaceDeclaration(SgNamespaceDeclarationStatement* structDecl, SgScopeStatement* scope);
2051 
2052 
2054 ROSE_DLL_API void fixLabelStatement(SgLabelStatement* label_stmt, SgScopeStatement* scope);
2055 
2057 ROSE_DLL_API void setFortranNumericLabel(SgStatement* stmt, int label_value,
2058  SgLabelSymbol::label_type_enum label_type=SgLabelSymbol::e_start_label_type,
2059  SgScopeStatement* label_scope=NULL);
2060 
2062 ROSE_DLL_API int suggestNextNumericLabel(SgFunctionDefinition* func_def);
2063 
2065 ROSE_DLL_API void fixFunctionDeclaration(SgFunctionDeclaration* stmt, SgScopeStatement* scope);
2066 
2068 ROSE_DLL_API void fixTemplateDeclaration(SgTemplateDeclaration* stmt, SgScopeStatement* scope);
2069 
2071 ROSE_DLL_API void fixStatement(SgStatement* stmt, SgScopeStatement* scope);
2072 
2073 // DQ (6/11/2015): This reports the statements that are marked as transformed (used to debug the token-based unparsing).
2075 ROSE_DLL_API std::set<SgStatement*> collectTransformedStatements( SgNode* node );
2076 
2078 ROSE_DLL_API std::set<SgStatement*> collectModifiedStatements( SgNode* node );
2079 
2081 ROSE_DLL_API std::set<SgLocatedNode*> collectModifiedLocatedNodes( SgNode* node );
2082 
2083 // DQ (6/5/2019): Use the previously constructed set (above) to reset the IR nodes to be marked as isModified.
2085 ROSE_DLL_API void resetModifiedLocatedNodes(const std::set<SgLocatedNode*> & modifiedNodeSet);
2086 
2087 
2088 // DQ (10/23/2018): Report nodes that are marked as modified.
2089 ROSE_DLL_API void reportModifiedStatements(const std::string & label, SgNode* node);
2090 
2091 // DQ (3/22/2019): Translate CPP directives from attached preprocessor information to CPP Directive Declaration IR nodes.
2092 ROSE_DLL_API void translateToUseCppDeclarations( SgNode* n );
2093 
2094 ROSE_DLL_API void translateScopeToUseCppDeclarations( SgScopeStatement* scope );
2095 
2096 ROSE_DLL_API std::vector<SgC_PreprocessorDirectiveStatement*> translateStatementToUseCppDeclarations( SgStatement* statement, SgScopeStatement* scope);
2097 ROSE_DLL_API void printOutComments ( SgLocatedNode* locatedNode );
2098 ROSE_DLL_API bool skipTranslateToUseCppDeclaration( PreprocessingInfo* currentPreprocessingInfo );
2099 
2100 // DQ (12/2/2019): Debugging support.
2101 ROSE_DLL_API void outputFileIds( SgNode* node );
2102 
2103 
2105 
2107 
2113 
2114 //------------------------------------------------------------------------
2116 
2120 ROSE_DLL_API bool
2122 collectReadWriteRefs(SgStatement* stmt, std::vector<SgNode*>& readRefs, std::vector<SgNode*>& writeRefs, bool useCachedDefUse=false);
2123 
2125 ROSE_DLL_API bool collectReadWriteVariables(SgStatement* stmt, std::set<SgInitializedName*>& readVars, std::set<SgInitializedName*>& writeVars, bool coarseGrain=true);
2126 
2128 ROSE_DLL_API void collectReadOnlyVariables(SgStatement* stmt, std::set<SgInitializedName*>& readOnlyVars, bool coarseGrain=true);
2129 
2131 ROSE_DLL_API void collectReadOnlySymbols(SgStatement* stmt, std::set<SgVariableSymbol*>& readOnlySymbols, bool coarseGrain=true);
2132 
2134 ROSE_DLL_API bool isUseByAddressVariableRef(SgVarRefExp* ref);
2135 
2137 ROSE_DLL_API void collectUseByAddressVariableRefs (const SgStatement* s, std::set<SgVarRefExp* >& varSetB);
2138 
2139 #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
2140 ROSE_DLL_API LivenessAnalysis * call_liveness_analysis(SgProject* project, bool debug=false);
2142 
2144 ROSE_DLL_API void getLiveVariables(LivenessAnalysis * liv, SgForStatement* loop, std::set<SgInitializedName*>& liveIns, std::set<SgInitializedName*> & liveOuts);
2145 #endif
2146 
2148 ROSE_DLL_API void ReductionRecognition(SgForStatement* loop, std::set< std::pair <SgInitializedName*, OmpSupport::omp_construct_enum> > & results);
2149 
2151 
2152 ROSE_DLL_API void constantFolding(SgNode* r);
2153 
2155 
2157 ROSE_DLL_API int instrumentEndOfFunction(SgFunctionDeclaration * func, SgStatement* s);
2158 
2160 ROSE_DLL_API void removeJumpsToNextStatement(SgNode*);
2161 
2163 ROSE_DLL_API void removeUnusedLabels(SgNode* top);
2164 
2166 ROSE_DLL_API void removeConsecutiveLabels(SgNode* top);
2167 
2169 
2175 ROSE_DLL_API bool mergeDeclarationAndAssignment (SgVariableDeclaration* decl, SgExprStatement* assign_stmt, bool removeAssignStmt = true);
2176 
2177 
2179 ROSE_DLL_API bool mergeAssignmentWithDeclaration (SgExprStatement* assign_stmt, SgVariableDeclaration* decl, bool removeAssignStmt = true);
2180 
2182 
2185 ROSE_DLL_API bool mergeDeclarationWithAssignment (SgVariableDeclaration* decl, SgExprStatement* assign_stmt);
2186 
2188 
2193 
2195 ROSE_DLL_API int splitVariableDeclaration (SgScopeStatement* scope, bool topLevelOnly = true);
2196 
2198 
2205  ROSE_DLL_API SgAssignInitializer* splitExpression(SgExpression* from, std::string newName = "");
2206 
2208 ROSE_DLL_API void splitExpressionIntoBasicBlock(SgExpression* expr);
2209 
2211 ROSE_DLL_API void removeLabeledGotos(SgNode* top);
2212 
2214 ROSE_DLL_API void changeBreakStatementsToGotos(SgStatement* loopOrSwitch);
2215 
2218 
2221 
2224 
2227 
2230 
2233 
2236 
2239 
2241 ROSE_DLL_API SgBasicBlock* ensureBasicBlockAsFalseBodyOfIf(SgIfStmt* ifs, bool createEmptyBody = true);
2242 
2245 
2248 
2249 // DQ (1/18/2015): This is added to support better quality token-based unparsing.
2251 ROSE_DLL_API void cleanupNontransformedBasicBlockNode();
2252 
2253 // DQ (1/18/2015): This is added to support better quality token-based unparsing.
2255 ROSE_DLL_API void recordNormalizations(SgStatement* s);
2256 
2259 bool isBodyStatement (SgStatement* s);
2260 
2262 void changeAllBodiesToBlocks(SgNode* top, bool createEmptyBody = true);
2263 
2264 // The same as changeAllBodiesToBlocks(SgNode* top). Phased out.
2265 //void changeAllLoopBodiesToBlocks(SgNode* top);
2266 
2269 
2270 #if 0
2271 
2274 SgLocatedNode* ensureBasicBlockAsParent(SgStatement* s);
2275 #endif
2276 
2279 unsigned long long getIntegerConstantValue(SgValueExp* expr);
2280 
2282 std::vector<SgDeclarationStatement*> getDependentDeclarations (SgStatement* stmt );
2283 
2284 
2287 
2289 SgCommaOpExp *insertAfterUsingCommaOp (SgExpression* new_exp, SgExpression* anchor_exp, SgStatement** temp_decl = NULL, SgVarRefExp** temp_ref = NULL);
2290 
2291 
2321 std::pair<SgStatement*, SgInitializedName*>
2322 wrapFunction(SgFunctionDeclaration& definingDeclaration, SgName newName);
2323 
2329 template <class NameGen>
2330 std::pair<SgStatement*, SgInitializedName*>
2331 wrapFunction(SgFunctionDeclaration& definingDeclaration, NameGen nameGen)
2332 {
2333  return wrapFunction(definingDeclaration, nameGen(definingDeclaration.get_name()));
2334 }
2335 
2339 
2340 
2342 
2343 // DQ (6/7/2012): Unclear where this function should go...
2344  bool hasTemplateSyntax( const SgName & name );
2345 
2346 #if 0
2347 
2348 //------------------------AST dump, stringify-----------------------------
2349 //------------------------------------------------------------------------
2350  std::string buildOperatorString ( SgNode* astNode ); //transformationSupport.h
2351 
2352  // do we need these?
2353  std::string dump_node(const SgNode* astNode);
2354  std::string dump_tree(const SgNode* astNode);
2355 
2356  // or a friendly version of unparseToString(), as a memeber function
2357  std::string SgNode::toString(bool asSubTree=true); // dump node or subtree
2358 
2359 //----------------------------AST comparison------------------------------
2360 //------------------------------------------------------------------------
2361 // How to get generic functions for comparison?
2362  bool isNodeEqual(SgNode* node1, SgNode* node2); //?
2363  bool isTreeEqual(SgNode* tree1, SgNode* tree2);
2364 
2366  bool expressionTreeEqual(SgExpression*, SgExpression*);
2368  bool expressionTreeEqualStar(const SgExpressionPtrList&,
2369  const SgExpressionPtrList&);
2370 
2371 //----------------------AST verfication/repair----------------------------
2372 //------------------------------------------------------------------------
2373 // sanity check of AST subtree, any suggestions?
2374 // TODO
2375  verifySgNode(SgNode* node, bool subTree=true);
2376  //src/midend/astDiagnostics/AstConsistencyTests.h
2377  // AstTests::runAllTests(SgProject * )
2378 
2379  //src/midend/astUtil/astInterface/AstInterface.h.C
2380  //FixSgProject(SgProject &project)
2381  //FixSgTree(SgNode* r)
2382 
2383  //src/frontend/SageIII/astPostProcessing
2384  //AstPostProcessing(SgNode * node)
2385 
2386 //--------------------------AST modification------------------------------
2387 //------------------------------------------------------------------------
2388 // any operations changing AST tree, including
2389 // insert, copy, delete(remove), replace
2390 
2391  // insert before or after some point, argument list is consistent with LowLevelRewrite
2392  void insertAst(SgNode* targetPosition, SgNode* newNode, bool insertBefore=true);
2393 
2394  // previous examples
2395  //void myStatementInsert(SgStatement* target,...)
2396  // void AstInterfaceBase::InsertStmt(AstNodePtr const & orig, AstNodePtr const &n, bool insertbefore, bool extractfromBasicBlock)
2397 
2398  // copy
2399  // copy children of one basic block to another basic block
2400  //void appendStatementCopy (const SgBasicBlock* a, SgBasicBlock* b);
2401  void copyStatements (const SgBasicBlock* src, SgBasicBlock* dst);
2402 
2403  // delete (remove) a node or a whole subtree
2404  void removeSgNode(SgNode* targetNode); // need this?
2405  void removeSgNodeTree(SgNode* subtree); // need this?
2406 
2407  void removeStatement( SgStatement* targetStmt);
2408 
2409  //Move = delete + insert
2410  void moveAst (SgNode* src, SgNode* target); // need this?
2411  // similar to
2412  void moveStatements (SgBasicBlock* src, SgBasicBlock* target);
2413 
2414  // replace= delete old + insert new (via building or copying)
2415 
2416 // DQ (1/25/2010): This does not appear to exist as a definition anywhere in ROSE.
2417 // void replaceAst(SgNode* oldNode, SgNode* newNode);
2418 
2419  //void replaceChild(SgNode* parent, SgNode* from, SgNode* to);
2420  //bool AstInterface::ReplaceAst( const AstNodePtr& orig, const AstNodePtr& n)
2421 
2422 //--------------------------AST transformations---------------------------
2423 //------------------------------------------------------------------------
2424 // Advanced AST modifications through basic AST modifications
2425 // Might not be included in AST utitlity list, but listed here for the record.
2426 
2427  // extract statements/content from a scope
2428  void flattenBlocks(SgNode* n);
2429 
2430  //src/midend/astInlining/inlinerSupport.h
2431  void renameVariables(SgNode* n);
2432  void renameLabels(SgNode* n, SgFunctionDefinition* enclosingFunctionDefinition);
2433 
2434  void simpleCopyAndConstantPropagation(SgNode* top);
2435  void changeAllMembersToPublic(SgNode* n);
2436 
2437  void removeVariableDeclaration(SgInitializedName* initname);
2438 
2440  SgAssignOp* convertInitializerIntoAssignment(SgAssignInitializer* init);
2441 
2446  void pushTestIntoBody(LoopStatement* loopStmt);
2447 
2448  //programTransformation/finiteDifferencing/finiteDifferencing.h
2450  void moveForDeclaredVariables(SgNode* root);
2451 
2452 //------------------------ Is/Has functions ------------------------------
2453 //------------------------------------------------------------------------
2454 // misc. boolean functions
2455 // some of them could moved to SgXXX class as a member function
2456 
2457  bool isOverloaded (SgFunctionDeclaration * functionDeclaration);
2458 
2459  bool isSwitchCond (const SgStatement* s);
2460  bool isIfCond (const SgStatement* s);
2461  bool isWhileCond (const SgStatement* s);
2462  bool isStdNamespace (const SgScopeStatement* scope);
2463  bool isTemplateInst (const SgDeclarationStatement* decl);
2464 
2465 
2466  bool isCtor (const SgFunctionDeclaration* func);
2467  bool isDtor (const SgFunctionDeclaration* func);
2468 
2469  // src/midend/astInlining/typeTraits.h
2470  bool hasTrivialDestructor(SgType* t);
2471  ROSE_DLL_API bool isNonconstReference(SgType* t);
2472  ROSE_DLL_API bool isReferenceType(SgType* t);
2473 
2474  // generic ones, or move to the SgXXX class as a member function
2475 
2476  bool isConst(SgNode* node); // const type, variable, function, etc.
2477  // .... and more
2478 
2479  bool isConstType (const SgType* type);
2480  bool isConstFunction (const SgFunctionDeclaration* decl);
2481 
2482 
2483  bool isMemberVariable(const SgInitializedName & var);
2484  //bool isMemberVariable(const SgNode& in);
2485 
2486  bool isPrototypeInScope (SgScopeStatement * scope,
2487  SgFunctionDeclaration * functionDeclaration,
2488  SgDeclarationStatement * startingAtDeclaration);
2489 
2490  bool MayRedefined(SgExpression* expr, SgNode* root);
2491  // bool isPotentiallyModified(SgExpression* expr, SgNode* root); // inlinderSupport.h
2492  bool hasAddressTaken(SgExpression* expr, SgNode* root);
2493 
2494  //src/midend/astInlining/inlinerSupport.C
2495  // can also classified as topdown search
2496  bool containsVariableReference(SgNode* root, SgInitializedName* var);
2497 
2498  bool isDeclarationOf(SgVariableDeclaration* decl, SgInitializedName* var);
2499  bool isPotentiallyModifiedDuringLifeOf(SgBasicBlock* sc,
2500  SgInitializedName* toCheck,
2501  SgInitializedName* lifetime)
2502  //src/midend/programTransformation/partialRedundancyElimination/pre.h
2503  bool anyOfListPotentiallyModifiedIn(const std::vector<SgVariableSymbol*>& syms, SgNode* n);
2504 
2505 //------------------------ loop handling ---------------------------------
2506 //------------------------------------------------------------------------
2507  //get and set loop control expressions
2508  // 0: init expr, 1: condition expr, 2: stride expr
2509 
2510  SgExpression* getForLoopTripleValues(int valuetype,SgForStatement* forstmt );
2511  int setForLoopTripleValues(int valuetype,SgForStatement* forstmt, SgExpression* exp);
2512 
2513  bool isLoopIndexVarRef(SgForStatement* forstmt, SgVarRefExp *varref);
2514  SgInitializedName * getLoopIndexVar(SgForStatement* forstmt);
2515 
2516 //------------------------expressions-------------------------------------
2517 //------------------------------------------------------------------------
2518  //src/midend/programTransformation/partialRedundancyElimination/pre.h
2519  int countComputationsOfExpressionIn(SgExpression* expr, SgNode* root);
2520 
2521  //src/midend/astInlining/replaceExpressionWithStatement.h
2522  void replaceAssignmentStmtWithStatement(SgExprStatement* from, StatementGenerator* to);
2523 
2525  StatementGenerator* to);
2526  SgExpression* getRootOfExpression(SgExpression* n);
2527 
2528 //--------------------------preprocessing info. -------------------------
2529 //------------------------------------------------------------------------
2531  void cutPreprocInfo (SgBasicBlock* b,
2533  AttachedPreprocessingInfoType& save_buf);
2535  void pastePreprocInfoFront (AttachedPreprocessingInfoType& save_buf,
2536  SgStatement* s);
2538  void pastePreprocInfoBack (AttachedPreprocessingInfoType& save_buf,
2539  SgStatement* s);
2540 
2546  // a generic one for all
2548  void moveBeforePreprocInfo (SgStatement* src, SgStatement* dest);
2549  void moveInsidePreprocInfo (SgBasicBlock* src, SgBasicBlock* dest);
2550  void moveAfterPreprocInfo (SgStatement* src, SgStatement* dest);
2551 
2552 //--------------------------------operator--------------------------------
2553 //------------------------------------------------------------------------
2554  from transformationSupport.h, not sure if they should be included here
2555  /* return enum code for SAGE operators */
2556  operatorCodeType classifyOverloadedOperator(); // transformationSupport.h
2557 
2563  std::string stringifyOperator (std::string name);
2564 
2565 //--------------------------------macro ----------------------------------
2566 //------------------------------------------------------------------------
2567  std::string buildMacro ( std::string s ); //transformationSupport.h
2568 
2569 //--------------------------------access functions---------------------------
2570 //----------------------------------get/set sth.-----------------------------
2571 // several categories:
2572 * get/set a direct child/grandchild node or fields
2573 * get/set a property flag value
2574 * get a descendent child node using preorder searching
2575 * get an ancestor node using bottomup/reverse searching
2576 
2577  // SgName or string?
2578  std::string getFunctionName (SgFunctionCallExp* functionCallExp);
2579  std::string getFunctionTypeName ( SgFunctionCallExp* functionCallExpression );
2580 
2581  // do we need them anymore? or existing member functions are enought?
2582  // a generic one:
2583  std::string get_name (const SgNode* node);
2584  std::string get_name (const SgDeclarationStatement * declaration);
2585 
2586  // get/set some property: should moved to SgXXX as an inherent memeber function?
2587  // access modifier
2588  void setExtern (SgFunctionDeclartion*)
2589  void clearExtern()
2590 
2591  // similarly for other declarations and other properties
2593  void setPublic()
2594  void setPrivate()
2595 
2596 #endif
2597 
2598 // DQ (1/23/2013): Added support for generated a set of source sequence entries.
2599  std::set<unsigned int> collectSourceSequenceNumbers( SgNode* astNode );
2600 
2601 //--------------------------------Type Traits (C++)---------------------------
2602  bool HasNoThrowAssign(const SgType * const inputType);
2603  bool HasNoThrowCopy(const SgType * const inputType);
2604  bool HasNoThrowConstructor(const SgType * const inputType);
2605  bool HasTrivialAssign(const SgType * const inputType);
2606  bool HasTrivialCopy(const SgType * const inputType);
2607  bool HasTrivialConstructor(const SgType * const inputType);
2608  bool HasTrivialDestructor(const SgType * const inputType);
2609  bool HasVirtualDestructor(const SgType * const inputType);
2610  bool IsBaseOf(const SgType * const inputBaseType, const SgType * const inputDerivedType);
2611  bool IsAbstract(const SgType * const inputType);
2612  bool IsClass(const SgType * const inputType);
2613  bool IsEmpty(const SgType * const inputType);
2614  bool IsEnum(const SgType * const inputType);
2615  bool IsPod(const SgType * const inputType);
2616  bool IsPolymorphic(const SgType * const inputType);
2617  bool IsStandardLayout(const SgType * const inputType);
2618  bool IsLiteralType(const SgType * const inputType);
2619  bool IsTrivial(const SgType * const inputType);
2620  bool IsUnion(const SgType * const inputType);
2621  SgType * UnderlyingType(SgType *type);
2622 
2623 // DQ (3/2/2014): Added a new interface function (used in the snippet insertion support).
2624 // void supportForInitializedNameLists ( SgScopeStatement* scope, SgInitializedNamePtrList & variableList );
2625 
2626 // DQ (3/4/2014): Added support for testing two trees for equivalents using the AST iterators.
2627  bool isStructurallyEquivalentAST( SgNode* tree1, SgNode* tree2 );
2628 
2629 // JP (10/14/24): Moved code to evaluate a const integer expression (like in array size definitions) to SageInterface
2632  size_t value_;
2633  bool hasValue_;
2634  };
2637 
2638 // JP (9/17/14): Added function to test whether two SgType* are equivalent or not
2639  bool checkTypesAreEqual(SgType *typeA, SgType *typeB);
2640 
2641 //--------------------------------Java interface functions ---------------------
2642 #ifdef ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
2643  ROSE_DLL_API std::string getTempDirectory(SgProject *project);
2644  ROSE_DLL_API void destroyTempDirectory(std::string);
2645  ROSE_DLL_API SgFile *processFile(SgProject *, std::string, bool unparse = false);
2646  ROSE_DLL_API std::string preprocessPackage(SgProject *, std::string);
2647  ROSE_DLL_API std::string preprocessImport(SgProject *, std::string);
2648  ROSE_DLL_API SgFile* preprocessCompilationUnit(SgProject *, std::string, std::string, bool unparse = true);
2649  ROSE_DLL_API SgClassDefinition *findJavaPackage(SgScopeStatement *, std::string);
2650  ROSE_DLL_API SgClassDefinition *findOrInsertJavaPackage(SgProject *, std::string, bool create_directory = false);
2651  ROSE_DLL_API SgClassDeclaration *findOrImportJavaClass(SgProject *, SgClassDefinition *package_definition, std::string);
2652  ROSE_DLL_API SgClassDeclaration *findOrImportJavaClass(SgProject *, std::string, std::string);
2653  ROSE_DLL_API SgClassDeclaration *findOrImportJavaClass(SgProject *, SgClassType *);
2654  ROSE_DLL_API SgMemberFunctionDeclaration *findJavaMain(SgClassDefinition *);
2655  ROSE_DLL_API SgMemberFunctionDeclaration *findJavaMain(SgClassType *);
2656 #endif // ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
2657 
2658 
2659 
2660 // DQ (8/31/2016): Making this a template function so that we can have it work with user defined filters.
2662 
2668 template < class T >
2670  {
2671  // DQ (9/1/2016): This function is called in the Call graph generation to avoid filtering out EDG normalized
2672  // function template instnatiations (which come from normalized template functions and member functions).
2673  // Note that because of the EDG normailzation the membr function is moved outside of the class, and
2674  // thus marked as compiler generated. However the template instantiations are always marked as compiler
2675  // generated (if not specializations) and so we want to include a template instantiation that is marked
2676  // as compiler generated, but is from a template declaration that satisfyied a specific user defined filter.
2677  // The complexity of this detection is isolated here, but knowing that it must be called is more complex.
2678  // This function is call in the CG.C file of tests/nonsmoke/functional/roseTests/programAnalysisTests/testCallGraphAnalysis.
2679 
2680  bool retval = false;
2681 
2682 #define DEBUG_TEMPLATE_NORMALIZATION_DETECTION 0
2683 
2684 #if DEBUG_TEMPLATE_NORMALIZATION_DETECTION
2685  printf ("In isNormalizedTemplateInstantiation(): function = %p = %s = %s \n",function,function->class_name().c_str(),function->get_name().str());
2686 #endif
2687 
2688  // Test for this to be a template instantation (in which case it was marked as
2689  // compiler generated but we may want to allow it to be used in the call graph,
2690  // if it's template was a part was defined in the current directory).
2691  SgTemplateInstantiationFunctionDecl* templateInstantiationFunction = isSgTemplateInstantiationFunctionDecl(function);
2692  SgTemplateInstantiationMemberFunctionDecl* templateInstantiationMemberFunction = isSgTemplateInstantiationMemberFunctionDecl(function);
2693 
2694  if (templateInstantiationFunction != NULL)
2695  {
2696  // When the defining function has been normalized by EDG, only the non-defining declaration will have a source position.
2697  templateInstantiationFunction = isSgTemplateInstantiationFunctionDecl(templateInstantiationFunction->get_firstNondefiningDeclaration());
2698  SgTemplateFunctionDeclaration* templateFunctionDeclaration = templateInstantiationFunction->get_templateDeclaration();
2699  if (templateFunctionDeclaration != NULL)
2700  {
2701  retval = filter->operator()(templateFunctionDeclaration);
2702  }
2703  else
2704  {
2705  // Assume false.
2706  }
2707 
2708 #if DEBUG_TEMPLATE_NORMALIZATION_DETECTION
2709  printf (" --- case of templateInstantiationFunction: retval = %s \n",retval ? "true" : "false");
2710 #endif
2711  }
2712  else
2713  {
2714  if (templateInstantiationMemberFunction != NULL)
2715  {
2716  // When the defining function has been normalized by EDG, only the non-defining declaration will have a source position.
2717  templateInstantiationMemberFunction = isSgTemplateInstantiationMemberFunctionDecl(templateInstantiationMemberFunction->get_firstNondefiningDeclaration());
2718  SgTemplateMemberFunctionDeclaration* templateMemberFunctionDeclaration = templateInstantiationMemberFunction->get_templateDeclaration();
2719  if (templateMemberFunctionDeclaration != NULL)
2720  {
2721  retval = filter->operator()(templateMemberFunctionDeclaration);
2722  }
2723  else
2724  {
2725  // Assume false.
2726  }
2727 
2728 #if DEBUG_TEMPLATE_NORMALIZATION_DETECTION
2729  printf (" --- case of templateInstantiationMemberFunction: retval = %s \n",retval ? "true" : "false");
2730 #endif
2731  }
2732  }
2733 
2734  return retval;
2735  }
2736 
2737 void detectCycleInType(SgType * type, const std::string & from);
2738 
2739 }// end of namespace
2740 
2741 #endif
std::string extractPragmaKeyword(const SgPragmaDeclaration *)
Extract a SgPragmaDeclaration's leading keyword . For example "#pragma omp parallel" has a keyword of...
ROSE_DLL_API void constantFolding(SgNode *r)
Constant folding an AST subtree rooted at 'r' (replacing its children with their constant values...
ROSE_DLL_API SgStatement * findSurroundingStatementFromSameFile(SgStatement *targetStmt, bool &surroundingStatementPreceedsTargetStatement)
Supporting function to comment relocation in insertStatement() and removeStatement().
ROSE_DLL_API SgFunctionDeclaration * findFirstDefiningFunctionDecl(SgScopeStatement *scope)
Find the first defining function declaration statement in a scope.
This class represents the notion of an initializer for a variable declaration or expression in a func...
ROSE_DLL_API bool isCanonicalDoLoop(SgFortranDo *loop, SgInitializedName **ivar, SgExpression **lb, SgExpression **ub, SgExpression **step, SgStatement **body, bool *hasIncrementalIterationSpace, bool *isInclusiveUpperBound)
Check if a Fortran Do loop has a complete canonical form: Do I=1, 10, 1.
ROSE_DLL_API bool is_mixed_Fortran_and_C_and_Cxx_language()
ROSE_DLL_API size_t getUpcSharedBlockSize(SgModifierType *mod_type)
Get the block size of a UPC shared modifier type.
ROSE_DLL_API void prependStatement(SgStatement *stmt, SgScopeStatement *scope=NULL)
Prepend a statement to the beginning of the current scope, handling side effects as appropriate...
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
ROSE_DLL_API void insertStatementListAfter(SgStatement *targetStmt, const std::vector< SgStatement * > &newStmt)
Insert a list of statements after a target statement.
This class represents the concept of an instantiation of member function template or a member functio...
bool getForLoopInformations(SgForStatement *for_loop, SgVariableSymbol *&iterator, SgExpression *&lower_bound, SgExpression *&upper_bound, SgExpression *&stride)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
A persistent attribute to represent a unique name for an expression.
ROSE_DLL_API SgFile * getEnclosingFileNode(SgNode *astNode)
get the SgFile node from current node
This class represents the concept of a class declaration statement. It includes the concept of an ins...
bool declarationPreceedsDefinition(SgDeclarationStatement *nonDefiningDeclaration, SgDeclarationStatement *definingDeclaration)
Check if a defining declaration comes before of after the non-defining declaration.
SgExprListExp * loopCollapsing(SgForStatement *target_loop, size_t collapsing_factor)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsFalseBodyOfIf(SgIfStmt *ifs, bool createEmptyBody=true)
Check if the false body of a 'if' statement is a SgBasicBlock, create one if not when the flag is tru...
ROSE_DLL_API bool isEquivalentType(const SgType *lhs, const SgType *rhs)
Test for equivalence of types independent of access permissions (private or protected modes for membe...
ROSE_DLL_API SgStatement * getEnclosingStatement(SgNode *n)
Find the closest enclosing statement, including the given node.
std::string generateUniqueNameForUseAsIdentifier(SgDeclarationStatement *declaration)
Generate a useful name to support construction of identifiers from declarations.
ROSE_DLL_API SgScopeStatement * getEnclosingScope(SgNode *n, const bool includingSelf=false)
Get the enclosing scope from a node n.
ROSE_DLL_API bool mergeDeclarationAndAssignment(SgVariableDeclaration *decl, SgExprStatement *assign_stmt, bool removeAssignStmt=true)
Merge a variable assignment statement into a matching variable declaration statement. Callers should make sure the merge is semantically correct (by not introducing compilation errors). This function simply does the merge transformation, without eligibility check.
This class represents the concept of a declaration list.
ROSE_DLL_API bool hasMultipleInitStatmentsOrExpressions(SgForStatement *for_loop)
Check if a for loop uses C99 style initialization statement with multiple expressions like for (int i...
ROSE_DLL_API SgVariableSymbol * getFirstVarSym(SgVariableDeclaration *decl)
Get the variable symbol for the first initialized name of a declaration stmt.
ROSE_DLL_API void insertStatementBefore(SgStatement *targetStmt, SgStatement *newStmt, bool autoMovePreprocessingInfo=true)
Insert a statement before a target statement.
void fixupReferencesToSymbols(const SgScopeStatement *this_scope, SgScopeStatement *copy_scope, SgCopyHelp &help)
All the symbol table references in the copied AST need to be reset after rebuilding the copied scope'...
ROSE_DLL_API bool isUpcSharedModifierType(SgModifierType *mod_type)
Check if a modifier type is a UPC shared type.
ROSE_DLL_API std::string mangleType(SgType *type)
Generate a mangled string for a given type based on Itanium C++ ABI.
ROSE_DLL_API SgExprStatement * splitVariableDeclaration(SgVariableDeclaration *decl)
Split a variable declaration with an rhs assignment into two statements: a declaration and an assignm...
SgStatement * findLastDeclarationStatement(SgScopeStatement *scope, bool includePragma=false)
Find the last declaration statement within a scope (if any). This is often useful to decide where to ...
ROSE_DLL_API void insertStatementList(SgStatement *targetStmt, const std::vector< SgStatement * > &newStmts, bool insertBefore=true)
Insert a list of statements before or after the target statement within the.
ROSE_DLL_API bool is_Fortran_language()
ROSE_DLL_API void removeAllOriginalExpressionTrees(SgNode *top)
Set original expression trees to NULL for SgValueExp or SgCastExp expressions, so you can change the ...
ROSE_DLL_API bool isAddressTaken(SgExpression *refExp)
Find a node by type using upward traversal.
ROSE_DLL_API void insertStatementListBefore(SgStatement *targetStmt, const std::vector< SgStatement * > &newStmts)
Insert a list of statements before a target statement.
ROSE_DLL_API bool hasTrivialDestructor(SgType *t)
Does a type have a trivial (built-in) destructor?
ROSE_DLL_API void setOneSourcePositionNull(SgNode *node)
Set current node's source position as NULL.
bool isPostfixOperator(SgExpression *exp)
Is an overloaded operator a postfix operator. (e.g. ).
PreprocessingInfo * attachComment(SgSourceFile *source_file, const std::string &content, PreprocessingInfo::DirectiveType directive_type=PreprocessingInfo::C_StyleComment, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before)
Build and attach comment onto the global scope of a source file.
std::string getMangledNameFromCache(SgNode *astNode)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
ROSE_DLL_API SgFunctionDefinition * getEnclosingFunctionDefinition(SgNode *astNode, const bool includingSelf=false)
Find a node by type using upward traversal.
ROSE_DLL_API SgClassDeclaration * getEnclosingClassDeclaration(SgNode *astNode)
Get the closest class declaration enclosing the specified AST node,.
ROSE_DLL_API bool is_Ada_language()
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsBodyOfOmpBodyStmt(SgOmpBodyStatement *ompbodyStmt)
Check if the body of a SgOmpBodyStatement is a SgBasicBlock, create one if not.
This class represents the concept of a C or C++ statement which contains a expression.
ROSE_DLL_API SgOmpClauseBodyStatement * findEnclosingOmpClauseBodyStatement(SgStatement *s)
Find enclosing OpenMP clause body statement from s. If s is already one, return it directly...
ROSE_DLL_API AbstractHandle::abstract_handle * buildAbstractHandle(SgNode *)
Build an abstract handle from an AST node, reuse previously built handle when possible.
std::string generateUniqueName(const SgNode *node, bool ignoreDifferenceBetweenDefiningAndNondefiningDeclarations)
Generate unique name from C and C++ constructs. The name may contain space.
ROSE_DLL_API std::string mangleModifierType(SgModifierType *type)
Generated mangled modifier types, include const, volatile,according to Itanium C++ ABI...
ROSE_DLL_API void fixTemplateDeclaration(SgTemplateDeclaration *stmt, SgScopeStatement *scope)
Fix the symbol table and set scope (only if scope in declaration is not already set).
This class represents a source file for a project (which may contian many source files and or directo...
ROSE_DLL_API void removeLabeledGotos(SgNode *top)
Remove labeled goto statements.
This class represents the variable declaration or variable initialization withn a for loop...
ROSE_DLL_API bool isInSubTree(SgExpression *subtree, SgExpression *exp)
Find a node by type using upward traversal.
ROSE_DLL_API void insertStatementAfter(SgStatement *targetStmt, SgStatement *newStmt, bool autoMovePreprocessingInfo=true)
Insert a statement after a target statement, Move around preprocessing info automatically by default...
bool templateDefinitionIsInClass(SgTemplateInstantiationMemberFunctionDecl *memberFunctionDeclaration)
Return true if template definition is in the class, false if outside of class.
ROSE_DLL_API SgMemberFunctionDeclaration * getDefaultConstructor(SgClassDeclaration *classDeclaration)
Get the default constructor from the class declaration.
ROSE_DLL_API bool normalizeForLoopTest(SgForStatement *loop)
Normalize a for loop's test expression ix is normalized to i>= (x...
ROSE_DLL_API void cutPreprocessingInfo(SgLocatedNode *src_node, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType &save_buf)
Cut preprocessing information from a source node and save it into a buffer. Used in combination of pa...
void initializeIfStmt(SgIfStmt *ifstmt, SgStatement *conditional, SgStatement *true_body, SgStatement *false_body)
Support function used for variable declarations in conditionals.
Class for traversing the AST.
bool isTemplateInstantiationFromTemplateDeclarationSatisfyingFilter(SgFunctionDeclaration *function, T *filter)
This function detects template instantiations that are relevant when filters are used.
void guardNode(SgLocatedNode *target, std::string guard)
Add preproccessor guard around a given node.
This class represents the rhs of a variable declaration which includes an optional assignment (e...
ROSE_DLL_API bool is_language_case_insensitive()
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsBodyOfSwitch(SgSwitchStatement *ws)
Check if the body of a 'switch' statement is a SgBasicBlock, create one if not.
ROSE_DLL_API bool is_Java_language()
ROSE_DLL_API bool isLoopIndexVariable(SgInitializedName *ivar, SgNode *subtree_root)
Check if a SgInitializedName is used as a loop index within a AST subtree This function will use a bo...
ROSE_DLL_API void setPragma(SgPragmaDeclaration *decl, SgPragma *pragma)
Set a pragma of a pragma declaration. handle memory release for preexisting pragma, and set parent pointer.
ROSE_DLL_API void insertStatementBeforeFirstNonDeclaration(SgStatement *newStmt, SgScopeStatement *scope, bool movePreprocessingInfo=true)
Insert a statement before the first non-declaration statement in a scope. If the scope has no non-dec...
ROSE_DLL_API SgFunctionDeclaration * getFunctionDeclaration(SgFunctionCallExp *functionCallExp)
Find a node by type using upward traversal.
This class represents the base class for all types.
SgType * removeConst(SgType *t)
Remove const (if present) from a type. stripType() cannot do this because it removes all modifiers...
ROSE_DLL_API SgNode * deepCopyNode(const SgNode *subtree)
Deep copy an arbitrary subtree.
This class represents the concept of a do-while statement.
ROSE_DLL_API bool isUpcStrictSharedModifierType(SgModifierType *mode_type)
Check if a shared UPC type is strict memory consistency or not. Return false if it is relaxed...
struct const_int_expr_t evaluateConstIntegerExpression(SgExpression *expr)
The function tries to evaluate const integer expressions (such as are used in array dimension sizes)...
ROSE_DLL_API void getLiveVariables(LivenessAnalysis *liv, SgForStatement *loop, std::set< SgInitializedName * > &liveIns, std::set< SgInitializedName * > &liveOuts)
get liveIn and liveOut variables for a for loop from liveness analysis result liv.
This class represents the concept of a class name within the compiler.
SgFunctionDeclaration * findFunctionDeclaration(SgNode *root, std::string name, SgScopeStatement *scope, bool isDefining)
Topdown traverse a subtree from root to find the first function declaration matching the given name...
ROSE_DLL_API void replaceDefiningFunctionDeclarationWithFunctionPrototype(SgFunctionDeclaration *functionDeclaration)
Function to delete AST subtree's nodes only, users must take care of any dangling pointers...
ROSE_DLL_API void moveStatementsBetweenBlocks(SgBasicBlock *sourceBlock, SgBasicBlock *targetBlock)
Move statements in first block to the second block (preserves order and rebuilds the symbol table)...
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsTrueBodyOfIf(SgIfStmt *ifs)
Check if the true body of a 'if' statement is a SgBasicBlock, create one if not.
SgMemberFunctionDeclaration * getDefaultDestructor(SgClassDeclaration *classDeclaration)
Get the default destructor from the class declaration.
ROSE_DLL_API bool isUpcArrayWithThreads(SgArrayType *t)
Is a UPC array with dimension of X*THREADS.
ROSE_DLL_API bool loopInterchange(SgForStatement *loop, size_t depth, size_t lexicoOrder)
Interchange/permutate a n-level perfectly-nested loop rooted at 'loop' using a lexicographical order ...
ROSE_DLL_API void appendExpressionList(SgExprListExp *, const std::vector< SgExpression * > &)
Append an expression list to a SgExprListExp, set the parent pointers also.
ROSE_DLL_API std::string mangleScalarType(SgType *type)
Generate mangled scalar type names according to Itanium C++ ABI, the input type should pass isScalarT...
label_type_enum
Type of label used (fortran only)
void set_parent(SgNode *parent)
All nodes in the AST contain a reference to a parent node.
void setSourcePositionPointersToNull(SgNode *node)
Set the source code positon for the current (input) node.
ROSE_DLL_API bool isEquivalentFunctionType(const SgFunctionType *lhs, const SgFunctionType *rhs)
Test if two types are equivalent SgFunctionType nodes.
std::vector< SgVariableSymbol * > getSymbolsUsedInExpression(SgExpression *expr)
Find referenced symbols within an expression.
ROSE_DLL_API SgTemplateClassSymbol * lookupTemplateClassSymbolInParentScopes(const SgName &name, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateArgumentList, SgScopeStatement *cscope=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
ROSE_DLL_API void setLhsOperand(SgExpression *target, SgExpression *lhs)
set left hand operand for binary expressions, transparently downcasting target expressions when neces...
This class represents the notion of a declared variable.
ROSE_DLL_API void setSourcePositionAtRootAndAllChildren(SgNode *root)
Set the source code positon for the subtree (including the root).
ROSE_DLL_API std::string generateProjectName(const SgProject *project, bool supressSuffix=false)
Added mechanism to generate project name from list of file names.
bool isBodyStatement(SgStatement *s)
Check if a statement is a (true or false) body of a container-like parent, such as For...
ROSE_DLL_API SgVariableSymbol * prependArg(SgFunctionParameterList *, SgInitializedName *)
Prepend an argument to SgFunctionParameterList.
NodeType * deepCopy(const NodeType *subtree)
A template function for deep copying a subtree. It is also used to create deepcopy functions with spe...
This class represents the concept of a member function declaration statement.
This class represents the concept of a C and C++ case option (used within a switch statement)...
SgBasicBlock * ensureBasicBlockAsBodyOfDefaultOption(SgDefaultOptionStmt *cs)
Check if the body of a 'default option' statement is a SgBasicBlock, create one if not...
This class represents the concept of a function declaration statement.
ROSE_DLL_API int instrumentEndOfFunction(SgFunctionDeclaration *func, SgStatement *s)
Instrument(Add a statement, often a function call) into a function right before the return points...
void saveToPDF(SgNode *node, std::string filename)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
ROSE_DLL_API bool isOmpStatement(SgNode *)
Check if a node is SgOmp*Statement.
ROSE_DLL_API void convertFunctionDefinitionsToFunctionPrototypes(SgNode *node)
XXX This function operates on the new file used to support outlined function definitions. We use a copy of the file where the code will be outlined FROM, so that if there are references to declarations in the outlined code we can support the outpiled code with those references. This approach has the added advantage of also supporting the same include file tree as the original file where the outlined code is being taken from.
bool isStructDeclaration(SgNode *node)
Check if a SgNode is a declaration for a structure.
ROSE_DLL_API bool is_mixed_Fortran_and_Cxx_language()
Interface for creating a statement whose computation writes its answer into a given variable...
std::string generateUniqueVariableName(SgScopeStatement *scope, std::string baseName="temp")
Generate a name like temp# that is unique in the current scope and any parent and children scopes...
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
SgType * getBoolType(SgNode *n)
Get the right bool type according to C or C++ language input.
ROSE_DLL_API SgSourceFile * getEnclosingSourceFile(SgNode *n, const bool includingSelf=false)
Find enclosing source file node.
ROSE_DLL_API bool is_Python_language()
bool ROSE_DLL_API isStatic(SgDeclarationStatement *stmt)
Check if a declaration has a "static' modifier.
unsigned long long getIntegerConstantValue(SgValueExp *expr)
Get the constant value from a constant integer expression; abort on everything else.
This class represents the concept of a C and C++ expression list.
void clearScopeNumbers(SgFunctionDefinition *functionDefinition)
Clears the cache of scope,integer pairs for the input function.
ROSE_DLL_API void setStatic(SgDeclarationStatement *stmt)
Set a declaration as static.
ROSE_DLL_API void outputLocalSymbolTables(SgNode *node)
Output the local symbol tables.
ROSE_DLL_API bool isUpcSharedArrayType(SgArrayType *array_type)
Check if an array type is a UPC shared type. ROSE AST represents a UPC shared array as regular array ...
ROSE_DLL_API void printOutComments(SgLocatedNode *locatedNode)
Connect variable reference to the right variable symbols when feasible, return the number of referenc...
std::string get_name(const SgNode *node)
Generate a useful name to describe the SgNode.
ROSE_DLL_API bool is_binary_executable()
ROSE_DLL_API SgClassSymbol * lookupClassSymbolInParentScopes(const SgName &name, SgScopeStatement *currentScope=NULL, SgTemplateArgumentPtrList *templateArgumentList=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
PreprocessingInfo * insertHeader(SgSourceFile *source_file, const std::string &header_file_name, bool isSystemHeader, bool asLastHeader)
Insert #include "filename" or #include (system header) onto the global scope of a source f...
std::vector< SgBreakStmt * > findBreakStmts(SgStatement *code, const std::string &fortranLabel="")
Find break statements inside a particular statement, stopping at nested loops or switches.
ROSE_DLL_API void setSourcePositionForTransformation(SgNode *root)
Recursively set source position info(Sg_File_Info) as transformation generated.
ROSE_DLL_API void setLoopCondition(SgScopeStatement *loop, SgStatement *cond)
Set the condition statement of a loop, including While-loop, For-loop, and Do-While-loop.
ROSE_DLL_API SgStatement * getLoopBody(SgScopeStatement *loop)
Routines to get and set the body of a loop.
std::vector< SgFile * > generateFileList()
Returns STL vector of SgFile IR node pointers.
std::string generateUniqueNameForUseAsIdentifier_support(SgDeclarationStatement *declaration)
Global map of name collisions to support generateUniqueNameForUseAsIdentifier() function.
ROSE_DLL_API SgStatement * getPreviousStatement(SgStatement *currentStmt, bool climbOutScope=true)
Get previous statement of the current statement. It may return a previous statement of a parent scope...
ROSE_DLL_API int set_name(SgInitializedName *initializedNameNode, SgName new_name)
set_name of symbol in symbol table.
void changeAllBodiesToBlocks(SgNode *top, bool createEmptyBody=true)
Fix up ifs, loops, while, switch, Catch, OmpBodyStatement, etc. to have blocks as body components...
ROSE_DLL_API bool isPointerType(SgType *t)
Is this type a pointer type? (Handles typedefs correctly)
bool isOverloaded(SgFunctionDeclaration *functionDeclaration)
Return true if function is overloaded.
ROSE_DLL_API SgNode * getSgNodeFromAbstractHandleString(const std::string &input_string)
Obtain a matching SgNode from an abstract handle string.
ROSE_DLL_API void fixStatement(SgStatement *stmt, SgScopeStatement *scope)
A wrapper containing fixes (fixVariableDeclaration(),fixStructDeclaration(), fixLabelStatement(), etc) for all kinds statements. Should be used before attaching the statement into AST.
ROSE_DLL_API void deleteExpressionTreeWithOriginalExpressionSubtrees(SgNode *root)
Special purpose function for deleting AST expression tress containing valid original expression trees...
ROSE_DLL_API bool isCopyConstructible(SgType *type)
Is a type copy constructible? This may not quite work properly.
This class represents the base class of a numbr of IR nodes that don't otherwise fit into the existin...
bool isPrefixOperator(SgExpression *exp)
Is an overloaded operator a prefix operator (e.g. address operator X * operator&(), dereference operator X & operator*(), unary plus operator X & operator+(), etc.
SgAsmInterpretation * getMainInterpretation(SgAsmGenericFile *file)
Find the main interpretation.
ROSE_DLL_API PreprocessingInfo * attachArbitraryText(SgLocatedNode *target, const std::string &text, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before)
Attach an arbitrary string to a located node. A workaround to insert irregular statements or vendor-s...
ROSE_DLL_API bool isStructType(SgType *t)
Check if a type is a struct type (a special SgClassType in ROSE)
void resetScopeNumbers(SgFunctionDefinition *functionDeclaration)
Assigns unique numbers to each SgScopeStatement of a function.
ROSE_DLL_API void changeBreakStatementsToGotos(SgStatement *loopOrSwitch)
If the given statement contains any break statements in its body, add a new label below the statement...
SgExpression * forallMaskExpression(SgForAllStatement *stmt)
Get the mask expression from the header of a SgForAllStatement.
ROSE_DLL_API void resetModifiedLocatedNodes(const std::set< SgLocatedNode * > &modifiedNodeSet)
Use the set of IR nodes and set the isModified flag in each IR node to true.
ROSE_DLL_API bool isSameFunction(SgFunctionDeclaration *func1, SgFunctionDeclaration *func2)
Check if two function declarations refer to the same one. Two function declarations are the same when...
ROSE_DLL_API void convertAllForsToWhiles(SgNode *top)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
ROSE_DLL_API bool isConstantTrue(SgExpression *e)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
SgDeclarationStatement * getNonInstantiatonDeclarationForClass(SgTemplateInstantiationMemberFunctionDecl *memberFunctionInstantiation)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
ROSE_DLL_API void reportModifiedStatements(const std::string &label, SgNode *node)
Connect variable reference to the right variable symbols when feasible, return the number of referenc...
ROSE_DLL_API int getDimensionCount(SgType *t)
Get the number of dimensions of an array type.
void visit(SgNode *node)
this method is called at every traversed node.
RelativePositionType
MK: Enum type to store if the directive goes before or after the corresponding line of source code...
void clearMangledNameCache(SgGlobal *globalScope)
Support for faster mangled name generation (caching avoids recomputation).
void whereAmI(SgNode *node)
Diagnostic function for tracing back through the parent list to understand at runtime where in the AS...
ROSE_DLL_API SgExprListExp * getEnclosingExprListExp(SgNode *astNode, const bool includingSelf=false)
Get the enclosing SgExprListExp (used as part of function argument index evaluation in subexpressions...
ROSE_DLL_API bool isStrictIntegerType(SgType *t)
Check if a type is an integral type, only allowing signed/unsigned short, int, long, long long. /! /! There is another similar function named SgType::isIntegerType(), which allows additional types char, wchar, and bool to be treated as integer types.
ROSE_DLL_API void removeUnusedLabels(SgNode *top)
Remove labels which are not targets of any goto statements.
SgBasicBlock * makeSingleStatementBodyToBlock(SgStatement *singleStmt)
Make a single statement body to be a basic block. Its parent is if, while, catch, or upc_forall etc...
ROSE_DLL_API SgInitializer * getInitializerOfExpression(SgExpression *n)
Get the initializer containing an expression if it is within an initializer.
ROSE_DLL_API void replaceExpression(SgExpression *oldExp, SgExpression *newExp, bool keepOldExp=false)
Replace an expression with another, used for variable reference substitution and others. the old expression can be deleted (default case) or kept.
ROSE_DLL_API bool is_OpenMP_language()
ROSE_DLL_API void moveUpPreprocessingInfo(SgStatement *stmt_dst, SgStatement *stmt_src, PreprocessingInfo::RelativePositionType src_position=PreprocessingInfo::undef, PreprocessingInfo::RelativePositionType dst_position=PreprocessingInfo::undef, bool usePrepend=false)
Identical to movePreprocessingInfo(), except for the stale name and confusing order of parameters...
This class represents the notion of an expression. Expressions are derived from SgLocatedNodes, since similar to statement, expressions have a concrete location within the user's source code.
ROSE_DLL_API std::set< SgNode * > getFrontendSpecificNodes()
Find a node by type using upward traversal.
ROSE_DLL_API SgNonrealSymbol * lookupNonrealSymbolInParentScopes(const SgName &name, SgScopeStatement *currentScope=NULL, SgTemplateParameterPtrList *templateParameterList=NULL, SgTemplateArgumentPtrList *templateArgumentList=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
ROSE_DLL_API bool is_UPC_language()
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsBodyOfUpcForAll(SgUpcForAllStatement *fs)
Check if the body of a 'upc_forall' statement is a SgBasicBlock, create one if not.
void outputGlobalFunctionTypeSymbolTable()
Output function type symbols in global function type symbol table.
ROSE_DLL_API bool insideSystemHeader(SgLocatedNode *node)
Set source position info(Sg_File_Info) as transformation generated for all SgNodes in memory pool...
std::vector< NodeType * > querySubTree(SgNode *top, VariantT variant=(VariantT) NodeType::static_variant)
Query a subtree to get all nodes of a given type, with an appropriate downcast.
std::vector< SgContinueStmt * > findContinueStmts(SgStatement *code, const std::string &fortranLabel="")
Find all continue statements inside a particular statement, stopping at nested loops.
void setBaseTypeDefiningDeclaration(SgVariableDeclaration *var_decl, SgDeclarationStatement *base_decl)
a better version for SgVariableDeclaration::set_baseTypeDefininingDeclaration(), handling all side ef...
ROSE_DLL_API bool templateArgumentListEquivalence(const SgTemplateArgumentPtrList &list1, const SgTemplateArgumentPtrList &list2)
Verify that 2 SgTemplateArgumentPtrList are equivalent.
const SgInitializedNamePtrList & get_args() const
Access function for p_args.
ROSE_DLL_API SgGlobal * getGlobalScope(const SgNode *astNode)
Traverse back through a node's parents to find the enclosing global scope.
ROSE_DLL_API bool mergeAssignmentWithDeclaration(SgExprStatement *assign_stmt, SgVariableDeclaration *decl, bool removeAssignStmt=true)
Merge an assignment into its upstream declaration statement. Callers should make sure the merge is se...
This class represents the concept of a name within the compiler.
T * findDeclarationStatement(SgNode *root, std::string name, SgScopeStatement *scope, bool isDefining)
Topdown traverse a subtree from root to find the first declaration given its name, scope (optional, can be NULL), and defining or nondefining flag.
ROSE_DLL_API SgInitializedName * convertRefToInitializedName(SgNode *current, bool coarseGrain=true)
Variable references can be introduced by SgVarRef, SgPntrArrRefExp, SgInitializedName, SgMemberFunctionRef etc. For Dot and Arrow Expressions, their lhs is used to obtain SgInitializedName (coarse grain) by default. Otherwise, fine-grain rhs is used.
ROSE_DLL_API std::vector< SgFunctionDeclaration * > generateFunctionDefinitionsList(SgNode *node)
Function to delete AST subtree's nodes only, users must take care of any dangling pointers...
void dumpPreprocInfo(SgLocatedNode *locatedNode)
Dumps a located node's preprocessing information.
bool isAssignmentStatement(SgNode *_s, SgExpression **lhs=NULL, SgExpression **rhs=NULL, bool *readlhs=NULL)
Check if a SgNode _s is an assignment statement (any of =,+=,-=,&=,/=, ^=, etc)
ROSE_DLL_API void replaceSubexpressionWithStatement(SgExpression *from, SageInterface::StatementGenerator *to)
Similar to replaceExpressionWithStatement, but with more restrictions.
ROSE_DLL_API SgVariableSymbol * lookupVariableSymbolInParentScopes(const SgName &name, SgScopeStatement *currentScope=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
SgCommaOpExp * insertBeforeUsingCommaOp(SgExpression *new_exp, SgExpression *anchor_exp)
Insert an expression (new_exp )before another expression (anchor_exp) has possible side effects...
ROSE_DLL_API bool is_Cobol_language()
Supporting class from copy mechanism within ROSE.
Definition: Cxx_Grammar.h:8988
ROSE_DLL_API void setSourcePosition(SgNode *node)
Set the source code positon for the current (input) node.
ROSE_DLL_API bool isPureVirtualClass(SgType *type, const ClassHierarchyWrapper &classHierarchy)
Check if a class type is a pure virtual class.
ROSE_DLL_API void removeStatement(SgStatement *stmt, bool autoRelocatePreprocessingInfo=true)
Remove a statement from its attach point of the AST. Automatically keep its associated preprocessing ...
ROSE_DLL_API bool isUseByAddressVariableRef(SgVarRefExp *ref)
Check if a variable reference is used by its address: including &a expression and foo(a) when type2 f...
ROSE_DLL_API SgGlobal * getFirstGlobalScope(SgProject *project)
return the first global scope under current project
ROSE_DLL_API void replaceExpressionWithStatement(SgExpression *from, SageInterface::StatementGenerator *to)
Replace a given expression with a list of statements produced by a generator.
ROSE_DLL_API void fixStructDeclaration(SgClassDeclaration *structDecl, SgScopeStatement *scope)
Fix symbols, parent and scope pointers. Used internally within appendStatment(), insertStatement() et...
ROSE_DLL_API SgType * getFirstVarType(SgVariableDeclaration *decl)
Get the data type of the first initialized name of a declaration statement.
ROSE_DLL_API bool isUpcSharedType(SgType *t, SgModifierType **mod_type_out=NULL)
Check if a type is a UPC shared type, including shared array, shared pointers etc. Exclude private pointers to shared types. Optionally return the modifier type with the UPC shared property.
ROSE_DLL_API void setLoopBody(SgScopeStatement *loop, SgStatement *body)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
ROSE_DLL_API int collectVariableReferencesInArrayTypes(SgLocatedNode *root, Rose_STL_Container< SgNode * > &currentVarRefList)
Collect variable references in array types. The default NodeQuery::querySubTree() will miss variables...
This class represents the concept of a class definition in C++.
This class represents strings within the IR nodes.
ROSE_DLL_API bool isMemberFunctionMemberReference(SgMemberFunctionRefExp *memberFunctionRefExp)
Find a node by type using upward traversal.
SgCommaOpExp * insertAfterUsingCommaOp(SgExpression *new_exp, SgExpression *anchor_exp, SgStatement **temp_decl=NULL, SgVarRefExp **temp_ref=NULL)
Insert an expression (new_exp ) after another expression (anchor_exp) has possible side effects...
void resetMangledNameCache(SgGlobal *globalScope)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsBodyOfWhile(SgWhileStmt *ws)
Check if the body of a 'while' statement is a SgBasicBlock, create one if not.
ROSE_DLL_API bool collectReadWriteVariables(SgStatement *stmt, std::set< SgInitializedName * > &readVars, std::set< SgInitializedName * > &writeVars, bool coarseGrain=true)
Collect unique variables which are read or written within a statement. Note that a variable can be bo...
ROSE_DLL_API size_t getArrayElementCount(SgArrayType *t)
Calculate the number of elements of an array type: dim1* dim2*... , assume element count is 1 for int...
ROSE_DLL_API void moveCommentsToNewStatement(SgStatement *sourceStatement, const std::vector< int > &indexList, SgStatement *targetStatement, bool surroundingStatementPreceedsTargetStatement)
Relocate comments and CPP directives from one statement to another.
ROSE_DLL_API bool isMain(const SgNode *node)
Check if a SgNode is a main() function declaration.
ROSE_DLL_API void setExtern(SgDeclarationStatement *stmt)
Set a declaration as extern.
ROSE_DLL_API void replaceStatement(SgStatement *oldStmt, SgStatement *newStmt, bool movePreprocessinInfo=false)
Replace a statement with another. Move preprocessing information from oldStmt to newStmt if requested...
std::vector< SgStatement * > getSwitchCases(SgSwitchStatement *sw)
Query a subtree to get all nodes of a given type, with an appropriate downcast.
void setSourcePositionAsTransformation(SgNode *node)
DQ (5/1/2012): New function with improved name.
bool isPrototypeInScope(SgScopeStatement *scope, SgFunctionDeclaration *functionDeclaration, SgDeclarationStatement *startingAtDeclaration)
Assigns unique numbers to each SgScopeStatement of a function.
Functions that are useful when operating on the AST.
Definition: sageBuilder.h:25
ROSE_DLL_API bool doLoopNormalization(SgFortranDo *loop)
Normalize a Fortran Do loop. Make the default increment expression (1) explicit.
ROSE_DLL_API bool isConstantFalse(SgExpression *e)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
ROSE_DLL_API bool isExtern(SgDeclarationStatement *stmt)
Check if a declaration has an "extern" modifier.
ROSE_DLL_API SgFunctionDeclaration * findMain(SgNode *currentNode)
top-down traversal from current node to find the main() function declaration
ROSE_DLL_API SgInitializedName * getFirstInitializedName(SgVariableDeclaration *decl)
Get the first initialized name of a declaration statement.
ROSE_DLL_API SgType * lookupNamedTypeInParentScopes(const std::string &type_name, SgScopeStatement *scope=NULL)
Lookup a named type based on its name, bottomup searching from a specified scope. Note name collison ...
ROSE_DLL_API bool is_UPC_dynamic_threads()
Check if dynamic threads compilation is used for UPC programs.
ROSE_DLL_API void translateScopeToUseCppDeclarations(SgScopeStatement *scope)
Connect variable reference to the right variable symbols when feasible, return the number of referenc...
ROSE_DLL_API void cleanupNontransformedBasicBlockNode()
Remove unused basic block IR nodes added as part of normalization.
ROSE_DLL_API void setOperand(SgExpression *target, SgExpression *operand)
Set operands for expressions with single operand, such as unary expressions. handle file info...
ROSE_DLL_API bool isVolatileType(SgType *t)
Is this a volatile type?
ROSE_DLL_API SgAssignInitializer * splitExpression(SgExpression *from, std::string newName="")
Replace an expression with a temporary variable and an assignment statement.
ROSE_DLL_API void setFortranNumericLabel(SgStatement *stmt, int label_value, SgLabelSymbol::label_type_enum label_type=SgLabelSymbol::e_start_label_type, SgScopeStatement *label_scope=NULL)
Set a numerical label for a Fortran statement. The statement should have a enclosing function definit...
std::pair< SgVariableDeclaration *, SgExpression * > createTempVariableForExpression(SgExpression *expression, SgScopeStatement *scope, bool initializeInDeclaration, SgAssignOp **reEvaluate=NULL)
Given an expression, generates a temporary variable whose initializer optionally evaluates that expre...
ROSE_DLL_API std::set< SgStatement * > collectModifiedStatements(SgNode *node)
This collects the statements that are marked as modified (a flag automatically set by all set_* gener...
ROSE_DLL_API void ReductionRecognition(SgForStatement *loop, std::set< std::pair< SgInitializedName *, OmpSupport::omp_construct_enum > > &results)
Recognize and collect reduction variables and operations within a C/C++ loop, following OpenMP 3...
ROSE_DLL_API SgStatement * getLoopCondition(SgScopeStatement *loop)
Routines to get the condition of a loop. It recognize While-loop, For-loop, and Do-While-loop.
This class represents the concept of a namespace name within the compiler.
ROSE_DLL_API void fixFunctionDeclaration(SgFunctionDeclaration *stmt, SgScopeStatement *scope)
Fix the symbol table and set scope (only if scope in declaration is not already set).
SgBasicBlock * ensureBasicBlockAsBodyOfCaseOption(SgCaseOptionStmt *cs)
Check if the body of a 'case option' statement is a SgBasicBlock, create one if not.
ROSE_DLL_API std::list< SgClassType * > getClassTypeChainForMemberReference(SgExpression *refExp)
Find a node by type using upward traversal.
This class represents the base class for all IR nodes within Sage III.
Definition: Cxx_Grammar.h:9247
This class represents the concept of a catch within a try-catch construct used in C++ exception handl...
uint64_t getAsmConstant(SgAsmValueExpression *e)
Get the unsigned value of a disassembled constant.
This class represents the notion of an value (expression value).
This class represents the concept of a variable name within the compiler (a shared container for the ...
This class represents the concept of an instantiation of function template.
bool isPrefixOperatorName(const SgName &functionName)
Check for proper names of possible prefix operators (used in isPrefixOperator()). ...
bool isUnionDeclaration(SgNode *node)
Check if a SgNode is a declaration for a union.
ROSE_DLL_API std::set< SgStatement * > collectTransformedStatements(SgNode *node)
This collects the statements that are marked as transformed (useful in debugging).
NodeType * getEnclosingNode(const SgNode *astNode, const bool includingSelf=false)
Find a node by type using upward traversal.
ROSE_DLL_API bool is_Jovial_language()
ROSE_DLL_API void collectReadOnlySymbols(SgStatement *stmt, std::set< SgVariableSymbol * > &readOnlySymbols, bool coarseGrain=true)
Collect read only variable symbols within a statement. The statement can be either of a function...
ROSE_DLL_API void moveForStatementIncrementIntoBody(SgForStatement *f)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
SgTemplateMemberFunctionDeclaration * get_templateDeclaration() const
Returns pointer to SgTemplateDeclaration from which instantiation is generated.
std::vector< SgDeclarationStatement * > getDependentDeclarations(SgStatement *stmt)
Get a statement's dependent declarations which declares the types used in the statement. The returned vector of declaration statements are sorted according to their appearance order in the original AST. Any reference to a class or template class from a namespace will treated as a reference to the enclosing namespace.
ROSE_DLL_API void prependStatementList(const std::vector< SgStatement * > &stmt, SgScopeStatement *scope=NULL)
prepend a list of statements to the beginning of the current scope, handling side effects as appropri...
ROSE_DLL_API SgClassDefinition * getEnclosingClassDefinition(SgNode *astnode, const bool includingSelf=false)
Get the closest class definition enclosing the specified AST node,.
std::map< std::string, SgNode * > local_name_to_node_map
Global map of name collisions to support generateUniqueNameForUseAsIdentifier() function.
ROSE_DLL_API void replaceVariableReferences(SgVariableSymbol *old_sym, SgVariableSymbol *new_sym, SgScopeStatement *scope)
Replace all variable references to an old symbol in a scope to being references to a new symbol...
SgStatement * lastStatementOfScopeWithTokenInfo(SgScopeStatement *scope, std::map< SgNode *, TokenStreamSequenceToNodeMapping * > &tokenStreamSequenceMap)
Used to support token unparsing (when the output the trailing token sequence).
ROSE_DLL_API bool unnormalizeForLoopInitDeclaration(SgForStatement *loop)
Undo the normalization of for loop's C99 init declaration. Previous record of normalization is used t...
ROSE_DLL_API bool is_OpenCL_language()
ROSE_DLL_API bool normalizeForLoopInitDeclaration(SgForStatement *loop)
Normalize loop init stmt by promoting the single variable declaration statement outside of the for lo...
ROSE_DLL_API bool isLastStatement(SgStatement *stmt)
Check if a statement is the last statement within its closed scope.
ROSE_DLL_API SgType * getAssociatedTypeFromFunctionTypeList(SgExpression *actual_argument_expression)
Get the type of the associated argument expression from the function type.
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsBodyOfFor(SgForStatement *fs)
Check if the body of a 'for' statement is a SgBasicBlock, create one if not.
std::vector< SgExpression * > get_C_array_dimensions(const SgArrayType &arrtype)
returns the array dimensions in an array as defined for arrtype
This class represents the concept of a block (not a basic block from control flow analysis)...
ROSE_DLL_API std::vector< SgC_PreprocessorDirectiveStatement * > translateStatementToUseCppDeclarations(SgStatement *statement, SgScopeStatement *scope)
Connect variable reference to the right variable symbols when feasible, return the number of referenc...
This class represents the concept of a C++ namespace declaration.
ROSE_DLL_API SgFunctionDefinition * getEnclosingProcedure(SgNode *n, const bool includingSelf=false)
Find the function definition.
ROSE_DLL_API SgFunctionDeclaration * getEnclosingFunctionDeclaration(SgNode *astNode, const bool includingSelf=false)
Find the enclosing function declaration, including its derived instances like isSgProcedureHeaderStat...
This class represents the notion of a statement.
For preprocessing information including source comments, #include , #if, #define, etc...
ROSE_DLL_API void pastePreprocessingInfo(SgLocatedNode *dst_node, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType &saved_buf)
Paste preprocessing information from a buffer to a destination node. Used in combination of cutPrepro...
ROSE_DLL_API bool is_C_language()
ROSE_DLL_API SgStatement * lastFrontEndSpecificStatement(SgGlobal *globalScope)
Function to delete AST subtree's nodes only, users must take care of any dangling pointers...
This class represents the concept of a namespace definition.
This class represents the concept of a for loop.
ROSE_DLL_API SgStatement * getLastStatement(SgScopeStatement *scope)
get the last statement within a scope, return NULL if it does not exit
void clearUnusedVariableSymbols(SgNode *root=NULL)
Clear those variable symbols with unknown type (together with initialized names) which are also not r...
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsBodyOfDoWhile(SgDoWhileStmt *ws)
Check if the body of a 'do .. while' statement is a SgBasicBlock, create one if not.
ROSE_DLL_API bool skipTranslateToUseCppDeclaration(PreprocessingInfo *currentPreprocessingInfo)
Connect variable reference to the right variable symbols when feasible, return the number of referenc...
ROSE_DLL_API void resetInternalMapsForTargetStatement(SgStatement *sourceStatement)
Function to delete AST subtree's nodes only, users must take care of any dangling pointers...
SgDeclarationStatement * get_definingDeclaration() const
This is an access function for the SgDeclarationStatement::p_definingDeclaration data member (see tha...
ROSE_DLL_API void recordNormalizations(SgStatement *s)
Record where normalization have been done so that we can preform denormalizations as required for the...
ROSE_DLL_API SgInitializedName * getLoopIndexVariable(SgNode *loop)
Return the loop index variable for a for loop.
ROSE_DLL_API bool is_X10_language()
ROSE_DLL_API bool statementCanBeTransformed(SgStatement *stmt)
If header file unparsing and token-based unparsing are used, then some statements in header files use...
This class represents a type for all functions.
void annotateExpressionsWithUniqueNames(SgProject *project)
Generate unique names for expressions and attach the names as persistent attributes ("UniqueNameAttri...
SgInitializedName & getFirstVariable(SgVariableDeclaration &vardecl)
convenience function that returns the first initialized name in a list of variable declarations...
ROSE_DLL_API bool isCallToParticularFunction(SgFunctionDeclaration *decl, SgExpression *e)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
This class represents the concept of a namespace definition.
ROSE_DLL_API void moveVariableDeclaration(SgVariableDeclaration *decl, SgScopeStatement *target_scope)
Move a variable declaration to a new scope, handle symbol, special scopes like For loop...
ROSE_DLL_API SgStatement * copyStatement(SgStatement *s)
Deep copy a statement.
void addMessageStatement(SgStatement *stmt, std::string message)
Function to add "C" style comment to statement.
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsBodyOfCatch(SgCatchOptionStmt *cos)
Check if the body of a 'catch' statement is a SgBasicBlock, create one if not.
ROSE_DLL_API bool isScalarType(SgType *t)
Is this a scalar type?
This class represents the concept of a C Assembler statement (untested).
ROSE_DLL_API void appendExpression(SgExprListExp *, SgExpression *)
Append an expression to a SgExprListExp, set the parent pointer also.
ROSE_DLL_API void updateDefiningNondefiningLinks(SgFunctionDeclaration *func, SgScopeStatement *scope)
Update defining and nondefining links due to a newly introduced function declaration. Should be used after inserting the function into a scope.
ROSE_DLL_API bool hasUpcSharedType(SgType *t, SgModifierType **mod_type_out=NULL)
Has a UPC shared type of any kinds (shared-to-shared, private-to-shared, shared-to-private, shared scalar/array)? An optional parameter, mod_type_out, stores the first SgModifierType with UPC access information.
bool isIndexOperator(SgExpression *exp)
Is an overloaded operator an index operator (also referred to as call or subscript operators)...
ROSE_DLL_API bool hasSimpleChildrenList(SgScopeStatement *scope)
Check if a scope statement has a simple children statement list so insert additional statements under...
ROSE_DLL_API bool isNonconstReference(SgType *t)
Is this type a non-constant reference type? (Handles typedefs correctly)
This class represents the concept of a C or C++ default case within a switch statement.
ROSE_DLL_API bool templateArgumentEquivalence(SgTemplateArgument *arg1, SgTemplateArgument *arg2)
Verify that 2 SgTemplateArgument are equivalent (same type, same expression, or same template declara...
This class represents the concept of an "if" construct.
ROSE_DLL_API SgSymbol * lookupSymbolInParentScopes(const SgName &name, SgScopeStatement *currentScope=NULL, SgTemplateParameterPtrList *templateParameterList=NULL, SgTemplateArgumentPtrList *templateArgumentList=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
to specify a construct using a specifier Can be used alone or with parent handles when relative speci...
ROSE_DLL_API void fixVariableDeclaration(SgVariableDeclaration *varDecl, SgScopeStatement *scope)
Patch up symbol, scope, and parent information when a SgVariableDeclaration's scope is known...
ROSE_DLL_API void outputFileIds(SgNode *node)
Connect variable reference to the right variable symbols when feasible, return the number of referenc...
virtual std::string class_name() const
returns a string representing the class name
ROSE_DLL_API void deleteAST(SgNode *node)
Function to delete AST subtree's nodes only, users must take care of any dangling pointers...
std::vector< SgGotoStatement * > findGotoStmts(SgStatement *scope, SgLabelStatement *l)
Query a subtree to get all nodes of a given type, with an appropriate downcast.
virtual std::vector< SgNode * > get_traversalSuccessorContainer()
container of pointers to AST successor nodes used in the traversal overridden in every class by gener...
ROSE_DLL_API SgScopeStatement * getScope(const SgNode *astNode)
Get the closest scope from astNode. Return astNode if it is already a scope.
void setParameterList(actualFunction *func, SgFunctionParameterList *paralist)
Set parameter list for a function declaration, considering existing parameter list etc...
This class represents the concept of a template declaration.
ROSE_DLL_API void fixClassDeclaration(SgClassDeclaration *classDecl, SgScopeStatement *scope)
Fix symbols, parent and scope pointers. Used internally within appendStatment(), insertStatement() et...
ROSE_DLL_API bool forLoopNormalization(SgForStatement *loop, bool foldConstant=true)
Normalize a for loop, return true if successful.
ROSE_DLL_API SgNamespaceSymbol * lookupNamespaceSymbolInParentScopes(const SgName &name, SgScopeStatement *currentScope=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
ROSE_DLL_API SgScopeStatement * findEnclosingLoop(SgStatement *s, const std::string &fortranLabel="", bool stopOnSwitches=false)
Find the closest loop outside the given statement; if fortranLabel is not empty, the Fortran label of...
This class represents the notion of an expression or statement which has a position within the source...
ROSE_DLL_API bool isReferenceType(SgType *t)
Is this type a const or non-const reference type? (Handles typedefs correctly)
This class represents template argument within the use of a template to build an instantiation.
ROSE_DLL_API void appendStatement(SgStatement *stmt, SgScopeStatement *scope=NULL)
Append a statement to the end of the current scope, handle side effect of appending statements...
This class represents the variable refernece in expressions.
ROSE_DLL_API void insertStatementAfterLastDeclaration(SgStatement *stmt, SgScopeStatement *scope)
Insert a statement after the last declaration within a scope. The statement will be prepended to the ...
This class represents the concept of a do-while statement.
ROSE_DLL_API std::vector< SgNode * > astIntersection(SgNode *original, SgNode *copy, SgCopyHelp *help=NULL)
Compute the intersection set for two ASTs.
ROSE_DLL_API bool isUpcPrivateToSharedType(SgType *t)
Is a UPC private-to-shared pointer? SgPointerType comes first compared to SgModifierType with UPC inf...
void initializeSwitchStatement(SgSwitchStatement *switchStatement, SgStatement *item_selector, SgStatement *body)
Support function used for variable declarations in conditionals.
ROSE_DLL_API int fixVariableReferences(SgNode *root, bool cleanUnusedSymbol=true)
Connect variable reference to the right variable symbols when feasible, return the number of referenc...
std::map< std::string, int > local_name_collision_map
Global map of name collisions to support generateUniqueNameForUseAsIdentifier() function.
ROSE_DLL_API void setLoopUpperBound(SgNode *loop, SgExpression *ub)
Set the upper bound of a loop header,regardless the condition expression type. for (i=lb; i op up...
ROSE_DLL_API SgEnumSymbol * lookupEnumSymbolInParentScopes(const SgName &name, SgScopeStatement *currentScope=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
ROSE_DLL_API std::set< SgLocatedNode * > collectModifiedLocatedNodes(SgNode *node)
This collects the SgLocatedNodes that are marked as modified (a flag automatically set by all set_* g...
ROSE_DLL_API bool isDefaultConstructible(SgType *type)
Is a type default constructible? This may not quite work properly.
ROSE_DLL_API void wrapAllTemplateInstantiationsInAssociatedNamespaces(SgProject *root)
Function to delete AST subtree's nodes only, users must take care of any dangling pointers...
ROSE_DLL_API void convertForToWhile(SgForStatement *f)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
ROSE_DLL_API SgTypedefSymbol * lookupTypedefSymbolInParentScopes(const SgName &name, SgScopeStatement *currentScope=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
ROSE_DLL_API bool loopTiling(SgForStatement *loopNest, size_t targetLevel, size_t tileSize)
Tile the n-level (starting from 1) loop of a perfectly nested loop nest using tiling size s...
Base class for values.
SgTemplateInstantiationMemberFunctionDecl * buildForwardFunctionDeclaration(SgTemplateInstantiationMemberFunctionDecl *memberFunctionInstantiation)
Generate a non-defining (forward) declaration from a defining function declaration.
ROSE_DLL_API bool mergeDeclarationWithAssignment(SgVariableDeclaration *decl, SgExprStatement *assign_stmt)
Merge a declaration statement into a matching followed variable assignment. Callers should make sure ...
void computeUniqueNameForUseAsIdentifier(SgNode *astNode)
Traversal to set the global map of names to node and node to names.collisions to support generateUniq...
ROSE_DLL_API bool isAssignable(SgType *type)
Is a type assignable? This may not quite work properly.
ROSE_DLL_API void setLoopLowerBound(SgNode *loop, SgExpression *lb)
Set the lower bound of a loop header for (i=lb; ...)
ROSE_DLL_API SgProject * getProject()
Get the current SgProject IR Node.
This class represents the member function being called and must be assembled in the SgFunctionCall wi...
ROSE_DLL_API bool is_PHP_language()
ROSE_DLL_API bool normalizeForLoopIncrement(SgForStatement *loop)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
ROSE_DLL_API void splitExpressionIntoBasicBlock(SgExpression *expr)
Split long expressions into blocks of statements.
void initializeWhileStatement(SgWhileStmt *whileStatement, SgStatement *condition, SgStatement *body, SgStatement *else_body)
Support function used for variable declarations in conditionals.
void addVarRefExpFromArrayDimInfo(SgNode *astNode, Rose_STL_Container< SgNode * > &NodeList_t)
Find all SgPntrArrRefExp under astNode, then add SgVarRefExp (if any) of SgPntrArrRefExp's dim_info i...
ROSE_DLL_API void removeConsecutiveLabels(SgNode *top)
Remove consecutive labels.
ROSE_DLL_API void setOneSourcePositionForTransformation(SgNode *root)
Set current node's source position as transformation generated.
ROSE_DLL_API void moveDeclarationToAssociatedNamespace(SgDeclarationStatement *declarationStatement)
Relocate the declaration to be explicitly represented in its associated namespace (required for some ...
ROSE_DLL_API void setRhsOperand(SgExpression *target, SgExpression *rhs)
set left hand operand for binary expression
SgNode * get_parent() const
Access function for parent node.
ROSE_DLL_API void myRemoveStatement(SgStatement *stmt)
A special purpose statement removal function, originally from inlinerSupport.h, Need Jeremiah's atten...
bool functionCallExpressionPreceedsDeclarationWhichAssociatesScope(SgFunctionCallExp *functionCall)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
ROSE_DLL_API int suggestNextNumericLabel(SgFunctionDefinition *func_def)
Suggest next usable (non-conflicting) numeric label value for a Fortran function definition scope...
ROSE_DLL_API int gensym_counter
An internal counter for generating unique SgName.
ROSE_DLL_API void outputSharedNodes(SgNode *node)
Find a node by type using upward traversal.
ROSE_DLL_API bool isEqualToIntConst(SgExpression *e, int value)
Check if a SgIntVal node has a given value.
ROSE_DLL_API void setLoopStride(SgNode *loop, SgExpression *stride)
Set the stride(step) of a loop 's incremental expression, regardless the expression types (i+=s; i= i...
ROSE_DLL_API SgStatement * getFirstStatement(SgScopeStatement *scope, bool includingCompilerGenerated=false)
Get the first statement within a scope, return NULL if it does not exist. Skip compiler-generated sta...
ROSE_DLL_API void changeContinuesToGotos(SgStatement *stmt, SgLabelStatement *label)
Change continue statements in a given block of code to gotos to a label.
ROSE_DLL_API SgSwitchStatement * findEnclosingSwitch(SgStatement *s)
Find the closest switch outside a given statement (normally used for case and default statements) ...
ROSE_DLL_API bool is_Cxx_language()
ROSE_DLL_API bool isDataMemberReference(SgVarRefExp *varRefExp)
Find a node by type using upward traversal.
ROSE_DLL_API bool language_may_contain_nondeclarations_in_scope()
void rebuildSymbolTable(SgScopeStatement *scope)
Regenerate the symbol table.
ROSE_DLL_API void collectUseByAddressVariableRefs(const SgStatement *s, std::set< SgVarRefExp * > &varSetB)
Collect variable references involving use by address: including &a expression and foo(a) when type2 f...
ROSE_DLL_API bool isConstType(SgType *t)
Is this a const type?
ROSE_DLL_API LivenessAnalysis * call_liveness_analysis(SgProject *project, bool debug=false)
Call liveness analysis on an entire project.
SgFunctionDeclaration * getDeclarationOfNamedFunction(SgExpression *func)
Given a SgExpression that represents a named function (or bound member function), return the mentione...
ROSE_DLL_API bool isRestrictType(SgType *t)
Is this a restrict type?
ROSE_DLL_API bool is_C99_language()
This class represents a source project, with a list of SgFile objects and global information about th...
ROSE_DLL_API SgStatement * getNextStatement(SgStatement *currentStmt)
Get next statement within the same scope of current statement.
ROSE_DLL_API SgType * getElementType(SgType *t)
Get the element type of an array, pointer or string, or NULL if not applicable. This function only ch...
ROSE_DLL_API void fixLabelStatement(SgLabelStatement *label_stmt, SgScopeStatement *scope)
Fix symbol table for SgLabelStatement. Used Internally when the label is built without knowing its ta...
ROSE_DLL_API void movePreprocessingInfo(SgStatement *stmt_src, SgStatement *stmt_dst, PreprocessingInfo::RelativePositionType src_position=PreprocessingInfo::undef, PreprocessingInfo::RelativePositionType dst_position=PreprocessingInfo::undef, bool usePrepend=false)
Move preprocessing information of stmt_src to stmt_dst, Only move preprocessing information from the ...
ROSE_DLL_API void appendStatementWithDependentDeclaration(SgDeclarationStatement *decl, SgGlobal *scope, SgStatement *original_statement, bool excludeHeaderFiles)
Append a copy ('decl') of a function ('original_statement') into a 'scope', include any referenced de...
virtual std::string class_name() const ROSE_OVERRIDE
returns a string representing the class name
ROSE_DLL_API SgVariableSymbol * appendArg(SgFunctionParameterList *, SgInitializedName *)
Append an argument to SgFunctionParameterList, transparently set parent,scope, and symbols for argume...
ROSE_DLL_API bool isTemplateInstantiationNode(SgNode *node)
Function to delete AST subtree's nodes only, users must take care of any dangling pointers...
ROSE_DLL_API bool is_mixed_Fortran_and_C_language()
SgNamespaceDefinitionStatement * enclosingNamespaceScope(SgDeclarationStatement *declaration)
Find the enclosing namespace of a declaration.
ROSE_DLL_API bool is_CAF_language()
ROSE_DLL_API void removeJumpsToNextStatement(SgNode *)
Remove jumps whose label is immediately after the jump. Used to clean up inlined code fragments...
ROSE_DLL_API void translateToUseCppDeclarations(SgNode *n)
Connect variable reference to the right variable symbols when feasible, return the number of referenc...
void collectVarRefs(SgLocatedNode *root, std::vector< SgVarRefExp * > &result)
Collect all variable references in a subtree.
ROSE_DLL_API 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)
Check if a for-loop has a canonical form, return loop index, bounds, step, and body if requested...
ROSE_DLL_API void deepDelete(SgNode *root)
Deep delete a sub AST tree. It uses postorder traversal to delete each child node. Users must take care of any dangling pointers, symbols or types that result. This is identical to deleteAST()
std::string declarationPositionString(const SgDeclarationStatement *declaration)
Generate a unique string from the source file position information.
This class represents the concept of a C or C++ variable declaration.
ROSE_DLL_API SgFunctionSymbol * lookupFunctionSymbolInParentScopes(const SgName &functionName, SgScopeStatement *currentScope=NULL)
look up the first matched function symbol in parent scopes given only a function name, starting from top of ScopeStack if currentscope is not given or NULL
ROSE_DLL_API std::vector< SgDeclarationStatement * > sortSgNodeListBasedOnAppearanceOrderInSource(const std::vector< SgDeclarationStatement * > &nodevec)
Reorder a list of declaration statements based on their appearance order in source files...
std::map< SgNode *, std::string > local_node_to_name_map
Global map of name collisions to support generateUniqueNameForUseAsIdentifier() function.
ROSE_DLL_API SgFunctionSymbol * lookupTemplateMemberFunctionSymbolInParentScopes(const SgName &functionName, SgFunctionType *ftype, SgTemplateParameterPtrList *tplparams, SgScopeStatement *currentScope=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
Represents an interpretation of a binary container.
std::pair< SgStatement *, SgInitializedName * > wrapFunction(SgFunctionDeclaration &definingDeclaration, SgName newName)
moves the body of a function f to a new function f; f's body is replaced with code that forwards the ...
This class represents the concept of a C or C++ label statement.
ROSE_DLL_API void appendStatementList(const std::vector< SgStatement * > &stmt, SgScopeStatement *scope=NULL)
Append a list of statements to the end of the current scope, handle side effect of appending statemen...
ROSE_DLL_API bool isPointerToNonConstType(SgType *type)
Is this a pointer to a non-const type? Note that this function will return true for const pointers po...
SgDeclarationStatement * get_firstNondefiningDeclaration() const
This is an access function for the SgDeclarationStatement::p_firstNondefiningDeclaration data member ...
ROSE_DLL_API void dumpInfo(SgNode *node, std::string desc="")
Dump information about a SgNode for debugging.
ROSE_DLL_API void addTextForUnparser(SgNode *astNode, std::string s, AstUnparseAttribute::RelativePositionType inputlocation)
Add a string to be unparsed to support code generation for back-end specific tools or compilers...
ROSE_DLL_API void fixNamespaceDeclaration(SgNamespaceDeclarationStatement *structDecl, SgScopeStatement *scope)
Fix symbols, parent and scope pointers. Used internally within appendStatment(), insertStatement() et...
ROSE_DLL_API void insertStatement(SgStatement *targetStmt, SgStatement *newStmt, bool insertBefore=true, bool autoMovePreprocessingInfo=true)
Insert a statement before or after the target statement within the target's scope. Move around preprocessing info automatically.
ROSE_DLL_API void collectReadOnlyVariables(SgStatement *stmt, std::set< SgInitializedName * > &readOnlyVars, bool coarseGrain=true)
Collect read only variables within a statement. The statement can be either of a function, a scope, or a single line statement. For accesses to members of aggregate data, we return the coarse grain aggregate mem obj by default.
This class represents the concept of a C++ function call (which is an expression).
void reset_name_collision_map()
Reset map variables used to support generateUniqueNameForUseAsIdentifier() function.
Base class for binary files.
std::pair< SgVariableDeclaration *, SgExpression * > createTempVariableAndReferenceForExpression(SgExpression *expression, SgScopeStatement *scope)
Function to delete AST subtree's nodes only, users must take care of any dangling pointers...
ROSE_DLL_API void addStepToLoopBody(SgScopeStatement *loopStmt, SgStatement *step)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
ROSE_DLL_API bool is_Cuda_language()
ROSE_DLL_API SgNode * replaceWithPattern(SgNode *anchor, SgNode *new_pattern)
Replace an anchor node with a specified pattern subtree with optional SgVariantExpression. All SgVariantExpression in the pattern will be replaced with copies of the anchor node.
ROSE_DLL_API SgTemplateVariableSymbol * lookupTemplateVariableSymbolInParentScopes(const SgName &name, SgTemplateParameterPtrList *tplparams, SgTemplateArgumentPtrList *tplargs, SgScopeStatement *currentScope=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
ROSE_DLL_API bool loopUnrolling(SgForStatement *loop, size_t unrolling_factor)
Unroll a target loop with a specified unrolling factor. It handles steps larger than 1 and adds a fri...
std::string addMangledNameToCache(SgNode *astNode, const std::string &mangledName)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
bool ROSE_DLL_API isAncestor(SgNode *node1, SgNode *node2)
check if node1 is a strict ancestor of node 2. (a node is not considered its own ancestor) ...
ROSE_DLL_API SgFunctionSymbol * lookupTemplateFunctionSymbolInParentScopes(const SgName &functionName, SgFunctionType *ftype, SgTemplateParameterPtrList *tplparams, SgScopeStatement *currentScope=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
This class represents the concept of a declaration statement.
virtual SgName get_name() const =0
Access function for getting name from declarations or types internally.
This class represents the concept of a switch.
ROSE_DLL_API SgExpression * copyExpression(SgExpression *e)
Deep copy an expression.
int64_t getAsmSignedConstant(SgAsmValueExpression *e)
Get the signed value of a disassembled constant.
ROSE_DLL_API bool isUpcPhaseLessSharedType(SgType *t)
Is UPC phase-less shared type? Phase-less means block size of the first SgModifierType with UPC infor...
ROSE_DLL_API SgType * getArrayElementType(SgType *t)
Get the element type of an array. It recursively find the base type for multi-dimension array types...
void listHeaderFiles(SgIncludeFile *includeFile)
return path prefix for subtree of include files.
ROSE_DLL_API void insertStatementListBeforeFirstNonDeclaration(const std::vector< SgStatement * > &newStmts, SgScopeStatement *scope)
Insert statements before the first non-declaration statement in a scope. If the scope has no non-decl...
ROSE_DLL_API void moveToSubdirectory(std::string directoryName, SgFile *file)
Move file to be generated in a subdirectory (will be generated by the unparser).
ROSE_DLL_API bool collectReadWriteRefs(SgStatement *stmt, std::vector< SgNode * > &readRefs, std::vector< SgNode * > &writeRefs, bool useCachedDefUse=false)
Collect all read and write references within stmt, which can be a function, a scope statement...
ROSE_DLL_API void replaceMacroCallsWithExpandedStrings(SgPragmaDeclaration *target)
Check if a pragma declaration node has macro calls attached, if yes, replace macro calls within the p...
ROSE_DLL_API bool is_mixed_C_and_Cxx_language()
ROSE_DLL_API bool isArrayReference(SgExpression *ref, SgExpression **arrayNameExp=NULL, std::vector< SgExpression * > **subscripts=NULL)
Check if an expression is an array access (SgPntrArrRefExp). If so, return its name expression and su...