ROSE  0.11.66.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_ENABLE_BINARY_ANALYSIS
110 SgAsmInterpretation* getMainInterpretation(SgAsmGenericFile* file);
112 
114 uint64_t getAsmConstant(SgAsmValueExpression* e);
115 
117 int64_t getAsmSignedConstant(SgAsmValueExpression *e);
118 #endif
119 
121  void addMessageStatement( SgStatement* stmt, std::string message );
122 
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 
140 // DQ (8/5/2020): the "using namespace" directive will not hide existing visability of symbols in resolving visability.
141 // So we need to test if a symbol is visible exclusing matching alises due to using direectives before we can decide to
142 // persue name space qualification. This is best demonstrated by Cxx_tests/test2020_18.C, test2020_19.C, test2020_20.C,
143 // and test2020_21.C.
144  ROSE_DLL_API SgSymbol *lookupSymbolInParentScopesIgnoringAliasSymbols (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
145 
146 // DQ (8/21/2013): Modified to make newest function parameters be default arguments.
147 // 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.
149 // SgSymbol *lookupSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope=NULL);
150 // SgSymbol *lookupSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList);
151  ROSE_DLL_API SgSymbol *lookupSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
152 
153  // Liao 1/22/2008, used for get symbols for generating variable reference nodes
154  // ! Find a variable symbol in current and ancestor scopes for a given name
155  ROSE_DLL_API SgVariableSymbol *lookupVariableSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope=NULL);
156 
157  // DQ (11/24/2007): Functions moved from the Fortran support so that they could be called from within astPostProcessing.
159  ROSE_DLL_API SgFunctionSymbol *lookupFunctionSymbolInParentScopes (const SgName & functionName, SgScopeStatement *currentScope=NULL);
160 
161  // Liao, 1/24/2008, find exact match for a function
163  ROSE_DLL_API SgFunctionSymbol *lookupFunctionSymbolInParentScopes (const SgName & functionName,
164  const SgType* t,
165  SgScopeStatement *currentScope=NULL);
166 
167  ROSE_DLL_API SgFunctionSymbol *lookupTemplateFunctionSymbolInParentScopes (const SgName & functionName, SgFunctionType * ftype, SgTemplateParameterPtrList * tplparams, SgScopeStatement *currentScope=NULL);
168  ROSE_DLL_API SgFunctionSymbol *lookupTemplateMemberFunctionSymbolInParentScopes (const SgName & functionName, SgFunctionType * ftype, SgTemplateParameterPtrList * tplparams, SgScopeStatement *currentScope=NULL);
169 
170  ROSE_DLL_API SgTemplateVariableSymbol * lookupTemplateVariableSymbolInParentScopes (const SgName & name, SgTemplateParameterPtrList * tplparams, SgTemplateArgumentPtrList* tplargs, SgScopeStatement *currentScope=NULL);
171 
172 
173 // DQ (8/21/2013): Modified to make newest function parameters be default arguments.
174 // 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.
175 // DQ (5/7/2011): Added support for SgClassSymbol (used in name qualification support).
176 // SgClassSymbol* lookupClassSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
177  ROSE_DLL_API SgClassSymbol* lookupClassSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
178  ROSE_DLL_API SgTypedefSymbol* lookupTypedefSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
179 
180  ROSE_DLL_API SgNonrealSymbol* lookupNonrealSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
181 #if 0
182  // DQ (8/13/2013): This function does not make since any more, now that we have made the symbol
183  // table handling more precise and we have to provide template parameters for any template lookup.
184  // We also have to know if we want to lookup template classes, template functions, or template
185  // member functions (since each have specific requirements).
186  SgTemplateSymbol* lookupTemplateSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
187 #endif
188 #if 0
189 // DQ (8/13/2013): I am not sure if we want this functions in place of lookupTemplateSymbolInParentScopes.
190 // Where these are called we might not know enough information about the template parameters or function
191 // types, for example.
192  SgTemplateClassSymbol* lookupTemplateClassSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
193  SgTemplateFunctionSymbol* lookupTemplateFunctionSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
194  SgTemplateMemberFunctionSymbol* lookupTemplateMemberFunctionSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
195 #endif
196 
197 // DQ (8/21/2013): Modified to make some of the newest function parameters be default arguments.
198 // DQ (8/13/2013): I am not sure if we want this functions in place of lookupTemplateSymbolInParentScopes.
199  ROSE_DLL_API SgTemplateClassSymbol* lookupTemplateClassSymbolInParentScopes (const SgName & name, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList, SgScopeStatement *cscope = NULL);
200 
201  ROSE_DLL_API SgEnumSymbol* lookupEnumSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
202  ROSE_DLL_API SgNamespaceSymbol* lookupNamespaceSymbolInParentScopes(const SgName & name, SgScopeStatement *currentScope = NULL);
203 
204 // DQ (7/17/2011): Added function from cxx branch that I need here for the Java support.
205 // SgClassSymbol* lookupClassSymbolInParentScopes (const SgName & name, SgScopeStatement *cscope);
206 
215  // DQ (12/9/2004): Moved this function (by Alin Jula) from being a member of SgInitializedName
216  // to this location where it can be a part of the interface for the Sage III AST.
217  ROSE_DLL_API int set_name (SgInitializedName * initializedNameNode, SgName new_name);
218 
222 
223  // DQ (6/27/2005):
228  ROSE_DLL_API void outputLocalSymbolTables (SgNode * node);
229 
231  {
232  public:
233  void visit (SgNode * node);
234  };
240  // DQ (9/28/2005):
241  void rebuildSymbolTable (SgScopeStatement * scope);
242 
245  void clearUnusedVariableSymbols (SgNode* root = NULL);
246 
247  // DQ (3/1/2009):
249  void fixupReferencesToSymbols( const SgScopeStatement* this_scope, SgScopeStatement* copy_scope, SgCopyHelp & help );
250 
252 
253  //------------------------------------------------------------------------
255 
262  // DQ (9/21/2005): General function for extracting the name of declarations (when they have names)
263  std::string get_name (const SgNode * node);
264 
269  // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
270  std::string get_name (const SgStatement * stmt);
271 
276  std::string get_name (const SgExpression * expr);
277 
282  // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
283  std::string get_name (const SgDeclarationStatement * declaration);
284 
289  // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
290  std::string get_name (const SgScopeStatement * scope);
291 
296  // DQ (2/11/2007): Added this function to make debugging support more complete (useful for symbol table debugging support).
297  std::string get_name (const SgSymbol * symbol);
298 
303  std::string get_name (const SgType * type);
304 
305 
308  std::string get_name (const SgSupport * node);
309 
310 
313  std::string get_name (const SgLocatedNodeSupport * node);
314 
317  std::string get_name ( const SgC_PreprocessorDirectiveStatement* directive );
318 
321  std::string get_name ( const SgToken* token );
322 
325  // PP (11/22/2021): General function for extracting the type of declarations (when they declare types)
326  SgType* getDeclaredType(const SgDeclarationStatement* declaration);
327 
328 
329  // DQ (3/20/2016): Added to refactor some of the DSL infrastructure support.
339 
342  extern std::map<std::string,int> local_name_collision_map;
343  extern std::map<std::string,SgNode*> local_name_to_node_map;
344  extern std::map<SgNode*,std::string> local_node_to_name_map;
345 
349 
353 
355 
356  //------------------------------------------------------------------------
358 
363  // DQ (6/21/2005): Get the default destructor from the class declaration
364  ROSE_DLL_API SgMemberFunctionDeclaration *getDefaultDestructor (SgClassDeclaration* classDeclaration);
365 
368  // DQ (6/22/2005): Get the default constructor from the class declaration
369  ROSE_DLL_API SgMemberFunctionDeclaration *getDefaultConstructor (SgClassDeclaration* classDeclaration);
372  // DQ (8/27/2005):
373  ROSE_DLL_API bool templateDefinitionIsInClass (SgTemplateInstantiationMemberFunctionDecl* memberFunctionDeclaration);
374 
379  // DQ (9/17/2005):
381 
383  ROSE_DLL_API bool isStructDeclaration(SgNode * node);
385  ROSE_DLL_API bool isUnionDeclaration(SgNode * node);
386 
387 #if 0
388  // DQ (8/28/2005): This is already a member function of the SgFunctionDeclaration
389  // (so that it can handle template functions and member functions)
390 
394  // DQ (8/27/2005):
395  bool isTemplateMemberFunction (SgTemplateInstantiationMemberFunctionDecl* memberFunctionDeclaration);
396 #endif
397 
398  // DQ (11/9/2020): Added function to support adding a default constructor definition to a class
399  // if it does not have a default constructor, but has any other constructor that would prevend
400  // a compiler generated default constructor from being generated by the compiler.
401  // Note the physical_file_id is so that it can be marked to be unparsed when header file unparsing is active.
402  ROSE_DLL_API bool addDefaultConstructorIfRequired ( SgClassType* classType, int physical_file_id = Sg_File_Info::TRANSFORMATION_FILE_ID );
403 
405 
406  //------------------------------------------------------------------------
408 
414 
416  void saveToPDF(SgNode* node, std::string filename);
417  void saveToPDF(SgNode* node); // enable calling from gdb
418 
420  void printAST (SgNode* node);
421 
423  void printAST2TextFile (SgNode* node, const char* filename, bool printType=true);
424 
426  void printAST2TextFile (SgNode* node, std::string filename, bool printType=true);
427 
428  // DQ (2/12/2012): Added some diagnostic support.
430  void whereAmI(SgNode* node);
431 
433  std::string extractPragmaKeyword(const SgPragmaDeclaration *);
434 
436  ROSE_DLL_API bool isOmpStatement(SgNode* );
439  // DQ (8/27/2005):
440  bool isOverloaded (SgFunctionDeclaration * functionDeclaration);
441 
442 // DQ (2/14/2012): Added support function used for variable declarations in conditionals.
444  void initializeIfStmt(SgIfStmt *ifstmt, SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);
445 
447  void initializeSwitchStatement(SgSwitchStatement* switchStatement,SgStatement *item_selector,SgStatement *body);
448 
450  void initializeWhileStatement(SgWhileStmt* whileStatement, SgStatement * condition, SgStatement *body, SgStatement *else_body);
451 
454 
456  ROSE_DLL_API bool isMain (const SgNode* node);
457  // DQ (6/22/2005):
468  std::string generateUniqueName ( const SgNode * node, bool ignoreDifferenceBetweenDefiningAndNondefiningDeclarations);
469 
472  std::string generateUniqueVariableName(SgScopeStatement* scope, std::string baseName = "temp");
473 
474  // DQ (8/10/2010): Added const to first parameter.
475  // DQ (3/10/2007):
477  std::string declarationPositionString (const SgDeclarationStatement * declaration);
478 
479  // DQ (1/20/2007):
481  ROSE_DLL_API std::string generateProjectName (const SgProject * project, bool supressSuffix = false );
482 
486 
489 
491  void addVarRefExpFromArrayDimInfo(SgNode * astNode, Rose_STL_Container<SgNode *>& NodeList_t);
492 
493  // DQ (10/6/2006): Added support for faster mangled name generation (caching avoids recomputation).
497 #ifndef SWIG
498 // DQ (3/10/2013): This appears to be a problem for the SWIG interface (undefined reference at link-time).
499  void clearMangledNameCache (SgGlobal * globalScope);
500  void resetMangledNameCache (SgGlobal * globalScope);
501 #endif
502 
503  std::string getMangledNameFromCache (SgNode * astNode);
504  std::string addMangledNameToCache (SgNode * astNode, const std::string & mangledName);
505 
507 
511 
512  // DQ (10/14/2006): This function tests the AST to see if for a non-defining declaration, the
513  // bool declarationPreceedsDefinition ( SgClassDeclaration* classNonDefiningDeclaration, SgClassDeclaration* classDefiningDeclaration );
515  bool declarationPreceedsDefinition (SgDeclarationStatement *nonDefiningDeclaration, SgDeclarationStatement *definingDeclaration);
516 
517  // DQ (10/19/2006): Function calls have interesting context dependent rules to determine if
518  // they are output with a global qualifier or not. Were this is true we have to avoid global
519  // qualifiers, since the function's scope has not been defined. This is an example of where
520  // qualification of function names in function calls are context dependent; an interesting
521  // example of where the C++ language is not friendly to source-to-source processing :-).
523 
528  ROSE_DLL_API std::vector < SgNode * >astIntersection (SgNode * original, SgNode * copy, SgCopyHelp * help = NULL);
529 
531  ROSE_DLL_API SgNode* deepCopyNode (const SgNode* subtree);
532 
534  template <typename NodeType>
535  NodeType* deepCopy (const NodeType* subtree) {
536  return dynamic_cast<NodeType*>(deepCopyNode(subtree));
537  }
538 
540  ROSE_DLL_API SgExpression* copyExpression(SgExpression* e);
541 
543  ROSE_DLL_API SgStatement* copyStatement(SgStatement* s);
544 
545 // from VarSym.cc in src/midend/astOutlining/src/ASTtools
548 
551 
553 ROSE_DLL_API void myRemoveStatement(SgStatement* stmt);
554 
556 ROSE_DLL_API bool isConstantTrue(SgExpression* e);
557 
559 ROSE_DLL_API bool isConstantFalse(SgExpression* e);
560 
562 ROSE_DLL_API bool isCallToParticularFunction(const std::string& qualifiedName, size_t arity, SgExpression* e);
563 
565 bool ROSE_DLL_API isStatic(SgDeclarationStatement* stmt);
566 
568 ROSE_DLL_API void setStatic(SgDeclarationStatement* stmt);
569 
571 ROSE_DLL_API bool isExtern(SgDeclarationStatement* stmt);
572 
574 ROSE_DLL_API void setExtern(SgDeclarationStatement* stmt);
575 
577 bool ROSE_DLL_API isMutable(SgInitializedName* name);
578 
580 bool ROSE_DLL_API isJovialOutParam(SgInitializedName* name);
581 
583 std::vector<SgInitializedName*> getInParameters(const SgInitializedNamePtrList &params);
584 
586 std::vector<SgInitializedName*> getOutParameters(const SgInitializedNamePtrList &params);
587 
591  public:
592  virtual ~StatementGenerator() {};
593  virtual SgStatement* generate(SgExpression* where_to_write_answer) = 0;
594 };
595 
599  bool isAssignmentStatement(SgNode* _s, SgExpression** lhs=NULL, SgExpression** rhs=NULL, bool* readlhs=NULL);
600 
602 ROSE_DLL_API SgInitializedName* convertRefToInitializedName(SgNode* current, bool coarseGrain=true);
603 
606 
608 ROSE_DLL_API SgNode* getSgNodeFromAbstractHandleString(const std::string& input_string);
609 
611 ROSE_DLL_API void dumpInfo(SgNode* node, std::string desc="");
612 
614 ROSE_DLL_API std::vector<SgDeclarationStatement*>
615 sortSgNodeListBasedOnAppearanceOrderInSource(const std::vector<SgDeclarationStatement*>& nodevec);
616 
617 // DQ (4/13/2013): We need these to support the unparing of operators defined by operator syntax or member function names.
619 // bool isPrefixOperator( const SgMemberFunctionRefExp* memberFunctionRefExp );
620 bool isPrefixOperator( SgExpression* exp );
621 
623 bool isPrefixOperatorName( const SgName & functionName );
624 
626 bool isPostfixOperator( SgExpression* exp );
627 
629 bool isIndexOperator( SgExpression* exp );
630 
631 // DQ (1/10/2014): Adding more general support for token based unparsing.
633 SgStatement* lastStatementOfScopeWithTokenInfo (SgScopeStatement* scope, std::map<SgNode*,TokenStreamSequenceToNodeMapping*> & tokenStreamSequenceMap);
634 
635 // DQ (8/12/2020): Check the access permissions of all defining and nodefining declarations.
637 
638 // DQ (8/14/2020): Check the symbol tables for specific scopes (debugging support).
639 void checkSymbolTables ( SgNode* );
640 
641 // DQ (11/9/2020): Added support for makring IR nodes and subtrees of the AST to be unparsed (physical_file_id
642 // is required when unparsing header files is true or support multiple files and shared IR nodes).
643 void markSubtreeToBeUnparsed(SgNode* root, int physical_file_id);
644 void markNodeToBeUnparsed(SgNode* node, int physical_file_id);
645 
646 
648 
649 //------------------------------------------------------------------------
651 
655 // DQ (11/25/2020): Add support to set this as a specific language kind file (there is at least one language kind file processed by ROSE).
656 // The value of 0 allows the old implementation to be tested, and the value of 1 allows the new optimized implementation to be tested.
657 // However to get all of the functions to be inlined, we have to recompile all of ROSE.
658 #define INLINE_OPTIMIZED_IS_LANGUAGE_KIND_FUNCTIONS 1
659 
660 // std::string version(); // utility_functions.h, version number
663 #if INLINE_OPTIMIZED_IS_LANGUAGE_KIND_FUNCTIONS
664  ROSE_DLL_API inline bool is_Ada_language () { return Rose::is_Ada_language; }
665  ROSE_DLL_API inline bool is_C_language () { return Rose::is_C_language; }
666  ROSE_DLL_API inline bool is_Cobol_language () { return Rose::is_Cobol_language; }
667  ROSE_DLL_API inline bool is_OpenMP_language () { return Rose::is_OpenMP_language; }
668  ROSE_DLL_API inline bool is_UPC_language () { return Rose::is_UPC_language; }
669  ROSE_DLL_API inline bool is_UPC_dynamic_threads() { return Rose::is_UPC_dynamic_threads; }
670  ROSE_DLL_API inline bool is_C99_language () { return Rose::is_C99_language; }
671  ROSE_DLL_API inline bool is_Cxx_language () { return Rose::is_Cxx_language; }
672  ROSE_DLL_API inline bool is_Java_language () { return Rose::is_Java_language; }
673  ROSE_DLL_API inline bool is_Jovial_language () { return Rose::is_Jovial_language; }
674  ROSE_DLL_API inline bool is_Fortran_language () { return Rose::is_Fortran_language; }
675  ROSE_DLL_API inline bool is_CAF_language () { return Rose::is_CAF_language; }
676  ROSE_DLL_API inline bool is_PHP_language() { return Rose::is_PHP_language; }
677  ROSE_DLL_API inline bool is_Python_language() { return Rose::is_Python_language; }
678  ROSE_DLL_API inline bool is_Cuda_language() { return Rose::is_Cuda_language; }
679  ROSE_DLL_API inline bool is_OpenCL_language() { return Rose::is_OpenCL_language; }
680  ROSE_DLL_API inline bool is_X10_language() { return Rose::is_X10_language; }
681  ROSE_DLL_API inline bool is_binary_executable() { return Rose::is_binary_executable; }
682 #else
683  ROSE_DLL_API bool is_Ada_language ();
684  ROSE_DLL_API bool is_C_language ();
685  ROSE_DLL_API bool is_Cobol_language ();
686  ROSE_DLL_API bool is_OpenMP_language ();
687  ROSE_DLL_API bool is_UPC_language ();
689  ROSE_DLL_API bool is_UPC_dynamic_threads();
690  ROSE_DLL_API bool is_C99_language ();
691  ROSE_DLL_API bool is_Cxx_language ();
692  ROSE_DLL_API bool is_Java_language ();
693  ROSE_DLL_API bool is_Jovial_language ();
694  ROSE_DLL_API bool is_Fortran_language ();
695  ROSE_DLL_API bool is_CAF_language ();
696  ROSE_DLL_API bool is_PHP_language();
697  ROSE_DLL_API bool is_Python_language();
698  ROSE_DLL_API bool is_Cuda_language();
699  ROSE_DLL_API bool is_OpenCL_language();
700  ROSE_DLL_API bool is_X10_language();
701  ROSE_DLL_API bool is_binary_executable();
702 #endif
703 
704  ROSE_DLL_API bool is_mixed_C_and_Cxx_language ();
705  ROSE_DLL_API bool is_mixed_Fortran_and_C_language ();
706  ROSE_DLL_API bool is_mixed_Fortran_and_Cxx_language ();
707  ROSE_DLL_API bool is_mixed_Fortran_and_C_and_Cxx_language ();
708 
709  ROSE_DLL_API bool is_language_case_insensitive ();
711 
713 
714 //------------------------------------------------------------------------
716 
720  // DQ (10/5/2006): Added support for faster (non-quadratic) computation of unique
721  // labels for scopes in a function (as required for name mangling).
727  void resetScopeNumbers (SgFunctionDefinition * functionDeclaration);
728 
729  // DQ (10/5/2006): Added support for faster (non-quadratic) computation of unique
730  // labels for scopes in a function (as required for name mangling).
739  void clearScopeNumbers (SgFunctionDefinition * functionDefinition);
740 
741 
744 // SgNamespaceDefinitionStatement * getEnclosingNamespaceScope (SgNode * node);
745 
746  bool isPrototypeInScope (SgScopeStatement * scope,
747  SgFunctionDeclaration * functionDeclaration,
748  SgDeclarationStatement * startingAtDeclaration);
749 
751  bool ROSE_DLL_API isAncestor(SgNode* node1, SgNode* node2);
753 //------------------------------------------------------------------------
755 
759  void dumpPreprocInfo (SgLocatedNode* locatedNode);
761 
763 ROSE_DLL_API PreprocessingInfo * findHeader(SgSourceFile * source_file, const std::string & header_file_name, bool isSystemHeader);
764 
766 ROSE_DLL_API PreprocessingInfo * insertHeader(SgSourceFile * source_file, const std::string & header_file_name, bool isSystemHeader, bool asLastHeader);
767 
769 ROSE_DLL_API void insertHeader (SgStatement* stmt, PreprocessingInfo* newheader, bool asLastHeader);
770 
772 ROSE_DLL_API PreprocessingInfo * insertHeader(SgSourceFile * source_file, const std::string & header_file_name, bool isSystemHeader = false, PreprocessingInfo::RelativePositionType position = PreprocessingInfo::before);
773 
775 ROSE_DLL_API PreprocessingInfo* insertHeader(const std::string& filename, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::after, bool isSystemHeader=false, SgScopeStatement* scope=NULL);
776 
778 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);
779 
781 ROSE_DLL_API void movePreprocessingInfo (SgStatement* stmt_src, SgStatement* stmt_dst, PreprocessingInfo::RelativePositionType src_position=PreprocessingInfo::undef,
782  PreprocessingInfo::RelativePositionType dst_position=PreprocessingInfo::undef, bool usePrepend= false);
783 
784 
786 ROSE_DLL_API void cutPreprocessingInfo (SgLocatedNode* src_node, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType& save_buf);
787 
789 ROSE_DLL_API void pastePreprocessingInfo (SgLocatedNode* dst_node, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType& saved_buf);
790 
793  const std::string & text,
794  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before);
795 
799 
802  SgSourceFile * source_file,
803  const std::string & content,
804  PreprocessingInfo::DirectiveType directive_type = PreprocessingInfo::C_StyleComment,
805  PreprocessingInfo::RelativePositionType position = PreprocessingInfo::before
806 );
807 
809  ROSE_DLL_API PreprocessingInfo* attachComment(SgLocatedNode* target, const std::string & content,
810  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before,
811  PreprocessingInfo::DirectiveType dtype= PreprocessingInfo::CpreprocessorUnknownDeclaration);
812 
813 // DQ (7/20/2008): I am not clear were I should put this function, candidates include: SgLocatedNode or SgInterface
815  ROSE_DLL_API void addTextForUnparser ( SgNode* astNode, std::string s, AstUnparseAttribute::RelativePositionType inputlocation );
816 
821 void guardNode(SgLocatedNode * target, std::string guard);
822 
824 
825 
826 //------------------------------------------------------------------------
828 
832 // ************************************************************************
833 // Newer versions of now depricated functions
834 // ************************************************************************
835 
836 // DQ (5/1/2012): This function queries the SageBuilder::SourcePositionClassification mode (stored in the SageBuilder
837 // interface) and used the specified mode to initialize the source position data (Sg_File_Info objects). This
838 // function is the only function that should be called directly (though in a namespace we can't define permissions).
840  ROSE_DLL_API void setSourcePosition(SgNode* node);
841 
842 // A better name might be "setSourcePositionForSubTree"
844  ROSE_DLL_API void setSourcePositionAtRootAndAllChildren(SgNode *root);
845 
848 
849 // DQ (5/1/2012): Newly renamed function (previous name preserved for backward compatability).
851 
852 // ************************************************************************
853 
854 
855 
856 // ************************************************************************
857 // Older deprecated functions
858 // ************************************************************************
859  // Liao, 1/8/2007, set file info. for a whole subtree as transformation generated
861  ROSE_DLL_API void setOneSourcePositionForTransformation(SgNode *node);
862 
864  ROSE_DLL_API void setOneSourcePositionNull(SgNode *node);
865 
867  ROSE_DLL_API void setSourcePositionForTransformation (SgNode * root);
868 
870 // ROSE_DLL_API void setSourcePositionForTransformation_memoryPool();
871 
873  ROSE_DLL_API bool insideSystemHeader (SgLocatedNode* node);
874 
875 // DQ (2/27/2021): Adding support to detect if a SgLocatedNode is located in a header file.
877  ROSE_DLL_API bool insideHeader (SgLocatedNode* node);
878 
880 // ROSE_DLL_API void setSourcePosition (SgLocatedNode * locatedNode);
881 // ************************************************************************
882 
884 
885 
886 //------------------------------------------------------------------------
888 
892 // from src/midend/astInlining/typeTraits.h
893 // src/midend/astUtil/astInterface/AstInterface.h
894 
897 
898 
902 ROSE_DLL_API bool isStrictIntegerType(SgType* t);
904 ROSE_DLL_API SgType* getFirstVarType(SgVariableDeclaration* decl);
905 
907 ROSE_DLL_API bool isDefaultConstructible(SgType* type);
908 
910 ROSE_DLL_API bool isCopyConstructible(SgType* type);
911 
913 ROSE_DLL_API bool isAssignable(SgType* type);
914 
915 #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
916 ROSE_DLL_API bool isPureVirtualClass(SgType* type, const ClassHierarchyWrapper& classHierarchy);
920 #endif
921 
923 ROSE_DLL_API bool hasTrivialDestructor(SgType* t);
924 
926 ROSE_DLL_API bool isNonconstReference(SgType* t);
927 
929 ROSE_DLL_API bool isReferenceType(SgType* t);
930 
932 ROSE_DLL_API bool isPointerType(SgType* t);
933 
939 ROSE_DLL_API bool isPointerToNonConstType(SgType* type);
940 
942 /* const char* p = "aa"; is not treated as having a const type. It is a pointer to const char.
943  * Similarly, neither for const int b[10]; or const int & c =10;
944  * The standard says, "A compound type is not cv-qualified by the cv-qualifiers (if any) of
945 the types from which it is compounded. Any cv-qualifiers applied to an array type affect the array element type, not the array type".
946  */
947 ROSE_DLL_API bool isConstType(SgType* t);
948 
951 
953 ROSE_DLL_API bool isVolatileType(SgType* t);
954 
956 ROSE_DLL_API bool isRestrictType(SgType* t);
957 
959 
961 ROSE_DLL_API bool isScalarType(SgType* t);
962 
966 ROSE_DLL_API bool isStrictIntegerType(SgType* t);
967 
969 ROSE_DLL_API bool isStructType(SgType* t);
970 
972 ROSE_DLL_API std::string mangleType(SgType* type);
973 
975 ROSE_DLL_API std::string mangleScalarType(SgType* type);
976 
978 ROSE_DLL_API std::string mangleModifierType(SgModifierType* type);
979 
981 ROSE_DLL_API size_t getArrayElementCount(SgArrayType* t);
982 
984 ROSE_DLL_API int getDimensionCount(SgType* t);
985 
987 ROSE_DLL_API SgType* getArrayElementType(SgType* t);
988 
990 ROSE_DLL_API SgType* getElementType(SgType* t);
991 
992 
1009 std::vector<SgExpression*>
1010 get_C_array_dimensions(const SgArrayType& arrtype);
1011 
1032 std::vector<SgExpression*>
1033 get_C_array_dimensions(const SgArrayType& arrtype, const SgVarRefExp& varref);
1034 
1038 std::vector<SgExpression*>
1039 get_C_array_dimensions(const SgArrayType& arrtype, SgInitializedName& initname);
1040 
1041 
1043 ROSE_DLL_API bool isArrayReference(SgExpression* ref, SgExpression** arrayNameExp=NULL, std::vector<SgExpression*>** subscripts=NULL);
1044 
1045 
1047 ROSE_DLL_API int collectVariableReferencesInArrayTypes (SgLocatedNode* root, Rose_STL_Container<SgNode*> & currentVarRefList);
1049 
1058 ROSE_DLL_API bool hasUpcSharedType(SgType* t, SgModifierType ** mod_type_out = NULL );
1059 
1061 
1064 ROSE_DLL_API bool isUpcSharedType(SgType* t, SgModifierType ** mod_type_out = NULL);
1065 
1067 ROSE_DLL_API bool isUpcSharedModifierType (SgModifierType* mod_type);
1068 
1070 ROSE_DLL_API bool isUpcSharedArrayType (SgArrayType* array_type);
1071 
1073 ROSE_DLL_API bool isUpcStrictSharedModifierType(SgModifierType* mode_type);
1074 
1076 ROSE_DLL_API size_t getUpcSharedBlockSize(SgModifierType* mod_type);
1077 
1079 ROSE_DLL_API size_t getUpcSharedBlockSize(SgType* t);
1080 
1082 ROSE_DLL_API bool isUpcPhaseLessSharedType (SgType* t);
1083 
1085 ROSE_DLL_API bool isUpcPrivateToSharedType(SgType* t);
1086 
1088 ROSE_DLL_API bool isUpcArrayWithThreads(SgArrayType* t);
1089 
1091 ROSE_DLL_API SgType* lookupNamedTypeInParentScopes(const std::string& type_name, SgScopeStatement* scope=NULL);
1092 
1093 // DQ (7/22/2014): Added support for comparing expression types in actual arguments with those expected from the formal function parameter types.
1095 ROSE_DLL_API SgType* getAssociatedTypeFromFunctionTypeList(SgExpression* actual_argument_expression);
1096 
1098 ROSE_DLL_API bool templateArgumentEquivalence(SgTemplateArgument * arg1, SgTemplateArgument * arg2);
1099 
1101 ROSE_DLL_API bool templateArgumentListEquivalence(const SgTemplateArgumentPtrList & list1, const SgTemplateArgumentPtrList & list2);
1102 
1104 ROSE_DLL_API bool isEquivalentType (const SgType* lhs, const SgType* rhs);
1105 
1107 ROSE_DLL_API SgFunctionType* findFunctionType (SgType* return_type, SgFunctionParameterTypeList* typeList);
1108 
1111 ROSE_DLL_API bool isEquivalentFunctionType (const SgFunctionType* lhs, const SgFunctionType* rhs);
1112 
1114 
1115 //------------------------------------------------------------------------
1117 
1121 // by Jeremiah
1130 ROSE_DLL_API void addStepToLoopBody(SgScopeStatement* loopStmt, SgStatement* step);
1131 
1133 ROSE_DLL_API void convertForToWhile(SgForStatement* f);
1134 ROSE_DLL_API void convertAllForsToWhiles(SgNode* top);
1136 ROSE_DLL_API void changeContinuesToGotos(SgStatement* stmt, SgLabelStatement* label);
1137 
1139 ROSE_DLL_API SgInitializedName* getLoopIndexVariable(SgNode* loop);
1140 
1143 ROSE_DLL_API bool isLoopIndexVariable(SgInitializedName* ivar, SgNode* subtree_root);
1144 
1146 
1150 ROSE_DLL_API bool hasMultipleInitStatmentsOrExpressions (SgForStatement* for_loop);
1151 
1153 ROSE_DLL_API SgStatement* getLoopBody(SgScopeStatement* loop);
1154 
1155 ROSE_DLL_API void setLoopBody(SgScopeStatement* loop, SgStatement* body);
1156 
1158 ROSE_DLL_API SgStatement* getLoopCondition(SgScopeStatement* loop);
1159 
1161 ROSE_DLL_API void setLoopCondition(SgScopeStatement* loop, SgStatement* cond);
1162 
1166 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);
1167 
1169 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*/);
1170 
1172 ROSE_DLL_API void setLoopLowerBound(SgNode* loop, SgExpression* lb);
1173 
1175 ROSE_DLL_API void setLoopUpperBound(SgNode* loop, SgExpression* ub);
1176 
1178 ROSE_DLL_API void setLoopStride(SgNode* loop, SgExpression* stride);
1179 
1180 
1182 ROSE_DLL_API bool normalizeForLoopInitDeclaration(SgForStatement* loop);
1183 
1185 ROSE_DLL_API bool unnormalizeForLoopInitDeclaration(SgForStatement* loop);
1186 
1198 ROSE_DLL_API bool forLoopNormalization(SgForStatement* loop, bool foldConstant = true);
1199 
1203 ROSE_DLL_API bool normalizeForLoopTest(SgForStatement* loop);
1204 ROSE_DLL_API bool normalizeForLoopIncrement(SgForStatement* loop);
1205 
1207 ROSE_DLL_API bool doLoopNormalization(SgFortranDo* loop);
1208 
1210 ROSE_DLL_API bool loopUnrolling(SgForStatement* loop, size_t unrolling_factor);
1211 
1213 ROSE_DLL_API bool loopInterchange(SgForStatement* loop, size_t depth, size_t lexicoOrder);
1214 
1216 ROSE_DLL_API bool loopTiling(SgForStatement* loopNest, size_t targetLevel, size_t tileSize);
1217 
1218 //Winnie Loop Collapsing
1219 SgExprListExp * loopCollapsing(SgForStatement* target_loop, size_t collapsing_factor);
1220 
1222  SgForStatement * for_loop,
1223  SgVariableSymbol * & iterator,
1224  SgExpression * & lower_bound,
1225  SgExpression * & upper_bound,
1226  SgExpression * & stride
1227 );
1228 
1230 
1231 //------------------------------------------------------------------------
1233 
1237 template <typename NodeType>
1239 std::vector<NodeType*> querySubTree(SgNode* top, VariantT variant = (VariantT)NodeType::static_variant)
1240  {
1241 #if 0
1242  printf ("Top of SageInterface::querySubTree() \n");
1243 #endif
1244 
1245  Rose_STL_Container<SgNode*> nodes = NodeQuery::querySubTree(top,variant);
1246  std::vector<NodeType*> result(nodes.size(), NULL);
1247  int count = 0;
1248 #if 0
1249  printf ("In SageInterface::querySubTree(): before initialization loop \n");
1250 #endif
1251 
1252  for (Rose_STL_Container<SgNode*>::const_iterator i = nodes.begin(); i != nodes.end(); ++i, ++count)
1253  {
1254 #if 0
1255  printf ("In SageInterface::querySubTree(): in loop: count = %d \n",count);
1256 #endif
1257  NodeType* node = dynamic_cast<NodeType*>(*i);
1258  ROSE_ASSERT (node);
1259  result[count] = node;
1260  }
1261 #if 0
1262  printf ("Leaving SageInterface::querySubTree(): after initialization loop \n");
1263 #endif
1264 
1265  return result;
1266  }
1271  std::vector < SgFile * >generateFileList ();
1272 
1277 ROSE_DLL_API SgProject * getProject();
1278 
1280  SgProject * getProject(const SgNode * node);
1281 
1283 template <typename NodeType>
1284 static std::vector<NodeType*> getSgNodeListFromMemoryPool()
1285 {
1286  // This function uses a memory pool traversal specific to the SgFile IR nodes
1287  class MyTraversal : public ROSE_VisitTraversal
1288  {
1289  public:
1290  std::vector<NodeType*> resultlist;
1291  void visit ( SgNode* node)
1292  {
1293  NodeType* result = dynamic_cast<NodeType* > (node);
1294  ROSE_ASSERT(result!= NULL);
1295  if (result!= NULL)
1296  {
1297  resultlist.push_back(result);
1298  }
1299  };
1300  virtual ~MyTraversal() {}
1301  };
1302 
1303  MyTraversal my_traversal;
1304  NodeType::traverseMemoryPoolNodes(my_traversal);
1305  return my_traversal.resultlist;
1306 }
1307 
1308 
1311 ROSE_DLL_API SgFunctionDeclaration* findMain(SgNode* currentNode);
1312 
1314 SgStatement* findLastDeclarationStatement(SgScopeStatement * scope, bool includePragma = false);
1315 
1316  //midend/programTransformation/partialRedundancyElimination/pre.h
1318 std::vector<SgVariableSymbol*> getSymbolsUsedInExpression(SgExpression* expr);
1319 
1321 
1326 std::vector<SgBreakStmt*> findBreakStmts(SgStatement* code, const std::string& fortranLabel = "");
1327 
1329 
1334 std::vector<SgContinueStmt*> findContinueStmts(SgStatement* code, const std::string& fortranLabel = "");
1335 std::vector<SgGotoStatement*> findGotoStmts(SgStatement* scope, SgLabelStatement* l);
1336 std::vector<SgStatement*> getSwitchCases(SgSwitchStatement* sw);
1337 
1339 void collectVarRefs(SgLocatedNode* root, std::vector<SgVarRefExp* >& result);
1340 
1342 template <typename T>
1343 T* findDeclarationStatement(SgNode* root, std::string name, SgScopeStatement* scope, bool isDefining)
1344  {
1345  bool found = false;
1346 
1347 #if 0
1348  printf ("In findDeclarationStatement(): root = %p \n",root);
1349  printf ("In findDeclarationStatement(): name = %s \n",name.c_str());
1350  printf ("In findDeclarationStatement(): scope = %p \n",scope);
1351  printf ("In findDeclarationStatement(): isDefining = %s \n",isDefining ? "true" : "false");
1352 #endif
1353 
1354  // Do we really want a NULL pointer to be acceptable input to this function?
1355  // Maybe we should have an assertion that it is non-null?
1356  if (!root) return NULL;
1357 
1358  T* decl = dynamic_cast<T*>(root);
1359 
1360 #if 0
1361  printf ("In findDeclarationStatement(): decl = %p \n",decl);
1362 #endif
1363 
1364  if (decl != NULL)
1365  {
1366  if (scope)
1367  {
1368  if ((decl->get_scope() == scope) && (decl->search_for_symbol_from_symbol_table()->get_name() == name))
1369  {
1370  found = true;
1371  }
1372  }
1373  else // Liao 2/9/2010. We should allow NULL scope
1374  {
1375 #if 0
1376  // DQ (12/6/2016): Include this into the debugging code to aboid compiler warning about unused variable.
1377  SgSymbol* symbol = decl->search_for_symbol_from_symbol_table();
1378  printf ("In findDeclarationStatement(): decl->search_for_symbol_from_symbol_table() = %p \n",symbol);
1379  printf ("In findDeclarationStatement(): decl->search_for_symbol_from_symbol_table()->get_name() = %s \n",symbol->get_name().str());
1380 #endif
1381  if (decl->search_for_symbol_from_symbol_table()->get_name() == name)
1382  {
1383  found = true;
1384  }
1385  }
1386  }
1387 
1388  if (found)
1389  {
1390  if (isDefining)
1391  {
1392 #if 0
1393  printf ("In findDeclarationStatement(): decl->get_firstNondefiningDeclaration() = %p \n",decl->get_firstNondefiningDeclaration());
1394  printf ("In findDeclarationStatement(): decl->get_definingDeclaration() = %p \n",decl->get_definingDeclaration());
1395 #endif
1396  ROSE_ASSERT (decl->get_definingDeclaration() != NULL);
1397 #if 0
1398  printf ("In findDeclarationStatement(): returing decl->get_definingDeclaration() = %p \n",decl->get_definingDeclaration());
1399 #endif
1400  return dynamic_cast<T*> (decl->get_definingDeclaration());
1401  }
1402  else
1403  {
1404 #if 0
1405  printf ("In findDeclarationStatement(): returing decl = %p \n",decl);
1406 #endif
1407  return decl;
1408  }
1409  }
1410 
1411  std::vector<SgNode*> children = root->get_traversalSuccessorContainer();
1412 
1413 #if 0
1414  printf ("In findDeclarationStatement(): children.size() = %zu \n",children.size());
1415 #endif
1416 
1417  // DQ (4/10/2016): Note that if we are searching for a function member that has it's defining
1418  // declaration defined outside of the class then it will not be found in the child list.
1419  for (std::vector<SgNode*>::const_iterator i = children.begin(); i != children.end(); ++i)
1420  {
1421  T* target = findDeclarationStatement<T> (*i,name,scope,isDefining);
1422 
1423  if (target)
1424  {
1425  return target;
1426  }
1427  }
1428 
1429  return NULL;
1430  }
1432  SgFunctionDeclaration* findFunctionDeclaration(SgNode* root, std::string name, SgScopeStatement* scope, bool isDefining);
1433 
1434 #if 0 //TODO
1435  // 1. preorder traversal from current SgNode till find next SgNode of type V_SgXXX
1436  // until reach the end node
1437  SgNode* getNextSgNode( const SgNode* astSourceNode, VariantT=V_SgNode, SgNode* astEndNode=NULL);
1438 
1439  // 2. return all nodes of type VariantT following the source node
1440  std::vector<SgNode*> getAllNextSgNode( const SgNode* astSourceNode, VariantT=V_SgNode, SgNode* astEndNode=NULL);
1441 #endif
1442 
1444 
1445 //------------------------------------------------------------------------
1447 
1450 // remember to put const to all arguments.
1451 
1452 
1467 template <typename NodeType>
1468 NodeType* getEnclosingNode(const SgNode* astNode, const bool includingSelf = false)
1469  {
1470 #define DEBUG_GET_ENCLOSING_NODE 0
1471 
1472 #if 1 /* TOP_LEVEL_IF */
1473  // DQ (12/31/2019): This version does not detect a cycle that Robb's version detects in processing Cxx11_tests/test2016_23.C.
1474  // This will have to be investigated seperately from the issue I am working on currently.
1475 
1476  // DQ (10/20/2012): This is the older version of this implementation. Until I am sure that
1477  // the newer version (below) is what we want to use I will resolve this conflict by keeping
1478  // the previous version in place.
1479 
1480  if (NULL == astNode)
1481  {
1482  return NULL;
1483  }
1484 
1485  if ( (includingSelf ) && (dynamic_cast<const NodeType*>(astNode)) )
1486  {
1487  return const_cast<NodeType*>(dynamic_cast<const NodeType*> (astNode));
1488  }
1489 
1490  // DQ (3/5/2012): Check for reference to self...
1491  ROSE_ASSERT(astNode->get_parent() != astNode);
1492 
1493  SgNode* parent = astNode->get_parent();
1494 
1495  // DQ (3/5/2012): Check for loops that will cause infinite loops.
1496  SgNode* previouslySeenParent = parent;
1497  bool foundCycle = false;
1498  int counter = 0;
1499 
1500 #if DEBUG_GET_ENCLOSING_NODE
1501  printf ("In getEnclosingNode(): previouslySeenParent = %p = %s \n",previouslySeenParent,previouslySeenParent->class_name().c_str());
1502 #endif
1503 
1504  while ( (foundCycle == false) && (parent != NULL) && (!dynamic_cast<const NodeType*>(parent)) )
1505  {
1506  ROSE_ASSERT(parent->get_parent() != parent);
1507 
1508 #if DEBUG_GET_ENCLOSING_NODE
1509  printf (" --- parent = %p = %s \n",parent,parent->class_name().c_str());
1510  printf (" --- --- parent->get_parent() = %p = %s \n",parent->get_parent(),parent->get_parent()->class_name().c_str());
1511 #endif
1512 
1513 #if 1
1514  // DQ (1/8/2020): ROSE-82 (on RZ) This limit needs to be larger and increasing it to 500 was enough
1515  // for a specific code with a long chain of if-then-else nesting, So to make this sufficent for more
1516  // general code we have increased the lomit to 100,000. Note that 50 was not enough for real code,
1517  // but was enough for our regression tests.
1518  // DQ (12/30/2019): This is added to support detection of infinite loops over parent pointers.
1519  // if (counter >= 500)
1520  if (counter >= 100000)
1521  {
1522  printf ("Exiting: In getEnclosingNode(): loop limit exceeded: counter = %d \n",counter);
1523  ROSE_ABORT();
1524  }
1525 #endif
1526  parent = parent->get_parent();
1527 
1528  // DQ (3/5/2012): Check for loops that will cause infinite loops.
1529  // ROSE_ASSERT(parent != previouslySeenParent);
1530  if (parent == previouslySeenParent)
1531  {
1532  foundCycle = true;
1533  }
1534  counter++;
1535 
1536  }
1537 
1538 #if DEBUG_GET_ENCLOSING_NODE
1539  printf ("previouslySeenParent = %p = %s \n",previouslySeenParent,previouslySeenParent->class_name().c_str());
1540 #endif
1541 
1542  parent = previouslySeenParent;
1543 
1544  SgDeclarationStatement* declarationStatement = isSgDeclarationStatement(parent);
1545  if (declarationStatement != NULL)
1546  {
1547 #if 0
1548  printf ("Found a SgDeclarationStatement \n");
1549 #endif
1550  SgDeclarationStatement* definingDeclaration = declarationStatement->get_definingDeclaration();
1551  SgDeclarationStatement* firstNondefiningDeclaration = declarationStatement->get_firstNondefiningDeclaration();
1552 
1553 #if 0
1554  printf (" --- declarationStatement = %p \n",declarationStatement);
1555  printf (" --- definingDeclaration = %p \n",definingDeclaration);
1556  if (definingDeclaration != NULL && definingDeclaration->get_parent() != NULL)
1557  printf (" --- definingDeclaration ->get_parent() = %p = %s \n",definingDeclaration->get_parent(),definingDeclaration->get_parent()->class_name().c_str());
1558  printf (" --- firstNondefiningDeclaration = %p \n",firstNondefiningDeclaration);
1559  if (firstNondefiningDeclaration != NULL && firstNondefiningDeclaration->get_parent() != NULL)
1560  printf (" --- firstNondefiningDeclaration ->get_parent() = %p = %s \n",firstNondefiningDeclaration->get_parent(),firstNondefiningDeclaration->get_parent()->class_name().c_str());
1561 #endif
1562  if (definingDeclaration != NULL && declarationStatement != firstNondefiningDeclaration)
1563  {
1564 #if 0
1565  printf ("Found a nondefining declaration so use the non-defining declaration instead \n");
1566 #endif
1567  // DQ (10/19/2012): Use the defining declaration instead.
1568  // parent = firstNondefiningDeclaration;
1569  parent = definingDeclaration;
1570  }
1571  }
1572 
1573 #if 0
1574  printf ("reset: previouslySeenParent = %p = %s \n",previouslySeenParent,previouslySeenParent->class_name().c_str());
1575 #endif
1576 
1577  // DQ (10/19/2012): This branch is just to document the cycle that was previously detected, it is for
1578  // debugging only. Thus it ony make sense for it to be executed when "(foundCycle == true)". However,
1579  // this will have to be revisited later since it appears clear that it is a problem for the binary analysis
1580  // work when it is visited for this case. Since the cycle is detected, but there is no assertion on the
1581  // cycle, we don't exit when a cycle is identified (which is the point of the code below).
1582  // Note also that I have fixed the code (above and below) to only chase pointers through defining
1583  // declarations (where they exist), this is important since non-defining declarations can be almost
1584  // anywhere (and thus chasing them can make it appear that there are cycles where there are none
1585  // (I think); test2012_234.C demonstrates an example of this.
1586  // DQ (10/9/2012): Robb has suggested this change to fix the binary analysis work.
1587  // if (foundCycle == true)
1588  if (foundCycle == false)
1589  {
1590 
1591 
1592  while ( (parent != NULL) && (!dynamic_cast<const NodeType*>(parent)) )
1593  {
1594  ROSE_ASSERT(parent->get_parent() != parent);
1595 #if 0
1596  printf ("In getEnclosingNode() (2nd try): parent = %p = %s \n",parent,parent->class_name().c_str());
1597  if (parent->get_file_info() != NULL)
1598  parent->get_file_info()->display("In getEnclosingNode() (2nd try): debug");
1599 #endif
1600  SgDeclarationStatement* declarationStatement = isSgDeclarationStatement(parent);
1601  if (declarationStatement != NULL)
1602  {
1603 #if DEBUG_GET_ENCLOSING_NODE
1604  printf ("Found a SgDeclarationStatement \n");
1605 #endif
1606  SgDeclarationStatement* definingDeclaration = declarationStatement->get_definingDeclaration();
1607  SgDeclarationStatement* firstNondefiningDeclaration = declarationStatement->get_firstNondefiningDeclaration();
1608 #if 0
1609  printf (" --- declarationStatement = %p = %s \n",declarationStatement,(declarationStatement != NULL) ? declarationStatement->class_name().c_str() : "null");
1610 
1611  printf (" --- definingDeclaration = %p \n",definingDeclaration);
1612  if (definingDeclaration != NULL && definingDeclaration->get_parent() != NULL)
1613  printf (" --- definingDeclaration ->get_parent() = %p = %s \n",definingDeclaration->get_parent(),definingDeclaration->get_parent()->class_name().c_str());
1614 
1615  printf (" --- firstNondefiningDeclaration = %p \n",firstNondefiningDeclaration);
1616  if (firstNondefiningDeclaration != NULL && firstNondefiningDeclaration->get_parent() != NULL)
1617  printf (" --- firstNondefiningDeclaration ->get_parent() = %p = %s \n",firstNondefiningDeclaration->get_parent(),firstNondefiningDeclaration->get_parent()->class_name().c_str());
1618 #endif
1619  if (definingDeclaration != NULL && declarationStatement != firstNondefiningDeclaration)
1620  {
1621 #if 0
1622  printf ("Found a nondefining declaration so use the firstNondefining declaration instead \n");
1623 #endif
1624  // DQ (10/19/2012): Use the defining declaration instead.
1625  // parent = firstNondefiningDeclaration;
1626  parent = definingDeclaration;
1627  }
1628  }
1629 
1630  parent = parent->get_parent();
1631 
1632 #if 1
1633  // DQ (3/5/2012): Check for loops that will cause infinite loops.
1634  ROSE_ASSERT(parent != previouslySeenParent);
1635 #else
1636  printf ("WARNING::WARNING::WARNING commented out assertion for parent != previouslySeenParent \n");
1637  if (parent == previouslySeenParent)
1638  break;
1639 #endif
1640  }
1641  }
1642 
1643  return const_cast<NodeType*>(dynamic_cast<const NodeType*> (parent));
1644 #else /* TOP_LEVEL_IF */
1645  // DQ (10/20/2012): Using Robb's newer version with my modification to use the definingDeclaration rather than firstNondefiningDeclaration (below).
1646 
1647  // Find the parent of specified type, but watch out for cycles in the ancestry (which would cause an infinite loop).
1648  // Cast away const because isSg* functions aren't defined for const node pointers; and our return is not const.
1649  SgNode *node = const_cast<SgNode*>(!astNode || includingSelf ? astNode : astNode->get_parent());
1650  std::set<const SgNode*> seen; // nodes we've seen, in order to detect cycles
1651  while (node) {
1652  if (NodeType *found = dynamic_cast<NodeType*>(node))
1653  return found;
1654 
1655  // FIXME: Cycle detection could be moved elsewhere so we don't need to do it on every call. [RPM 2012-10-09]
1656  // DQ (12/30/2019): Provide more detail in error message.
1657  if (seen.insert(node).second == false)
1658  {
1659  printf ("Error: node is already in set and defines a cycle: node = %p = %s \n",node,node->class_name().c_str());
1660  std::set<const SgNode*>::const_iterator i = seen.begin();
1661  while (i != seen.end())
1662  {
1663  const SgNode* element = *i;
1664  printf (" --- seen element: element = %p = %s \n",element,element->class_name().c_str());
1665  i++;
1666  }
1667 
1668  printf ("Exiting after error! \n");
1669  ROSE_ABORT();
1670  }
1671  // ROSE_ASSERT(seen.insert(node).second);
1672 
1673  // Traverse to parent (declaration statements are a special case)
1674  if (SgDeclarationStatement *declarationStatement = isSgDeclarationStatement(node)) {
1675  SgDeclarationStatement *definingDeclaration = declarationStatement->get_definingDeclaration();
1676  SgDeclarationStatement *firstNondefiningDeclaration = declarationStatement->get_firstNondefiningDeclaration();
1677  if (definingDeclaration && firstNondefiningDeclaration && declarationStatement != firstNondefiningDeclaration) {
1678  // DQ (10/19/2012): Use the defining declaration instead.
1679  // node = firstNondefiningDeclaration;
1680  node = definingDeclaration;
1681  }
1682  } else {
1683  node = node->get_parent();
1684  }
1685  }
1686  return NULL;
1687 #endif /* TOP_LEVEL_IF */
1688  }
1689 
1691  ROSE_DLL_API SgSourceFile* getEnclosingSourceFile(SgNode* n, const bool includingSelf=false);
1692 
1694  ROSE_DLL_API SgScopeStatement* getScope(const SgNode* astNode);
1695 
1697  ROSE_DLL_API SgScopeStatement* getEnclosingScope(SgNode* n, const bool includingSelf=false);
1698 
1700  ROSE_DLL_API SgGlobal* getGlobalScope( const SgNode* astNode);
1701 
1702  // DQ (12/7/2020): This is supporting the recognition of functions in header files from two different AST.
1704  ROSE_DLL_API bool hasSameGlobalScope ( SgStatement* statement_1, SgStatement* statement_2 );
1705 
1707  ROSE_DLL_API SgFunctionDefinition* getEnclosingProcedure(SgNode* n, const bool includingSelf=false);
1708 
1709  ROSE_DLL_API SgFunctionDefinition* getEnclosingFunctionDefinition(SgNode* astNode, const bool includingSelf=false);
1710 
1712  ROSE_DLL_API SgStatement* getEnclosingStatement(SgNode* n);
1713 
1716 
1719 
1721  ROSE_DLL_API SgScopeStatement* findEnclosingLoop(SgStatement* s, const std::string& fortranLabel = "", bool stopOnSwitches = false);
1722 
1724  ROSE_DLL_API SgFunctionDeclaration * getEnclosingFunctionDeclaration (SgNode * astNode, const bool includingSelf=false);
1725  //roseSupport/utility_functions.h
1727  ROSE_DLL_API SgFile* getEnclosingFileNode (SgNode* astNode );
1728 
1731 
1733  ROSE_DLL_API SgClassDefinition* getEnclosingClassDefinition(SgNode* astnode, const bool includingSelf=false);
1734 
1736  ROSE_DLL_API SgClassDeclaration* getEnclosingClassDeclaration( SgNode* astNode );
1737 
1738  // DQ (2/7/2019): Adding support for name qualification of variable references associated with SgPointerMemberType function parameters.
1740  ROSE_DLL_API SgExprListExp* getEnclosingExprListExp(SgNode* astNode, const bool includingSelf = false);
1741 
1742  // DQ (2/7/2019): Need a function to return when an expression is in an expression subtree.
1743  // This is part of index evaluation ofr expressions in function argument lists, but likely usefule elsewhere as well.
1744  ROSE_DLL_API bool isInSubTree(SgExpression* subtree, SgExpression* exp);
1745 
1746  // DQ (2/7/2019): Need a function to return the SgFunctionDeclaration from a SgFunctionCallExp.
1747  ROSE_DLL_API SgFunctionDeclaration* getFunctionDeclaration ( SgFunctionCallExp* functionCallExp );
1748 
1749  // DQ (2/17/2019): Generalizing this support for SgVarRefExp and SgMemberFunctionRefExp nodes.
1750  // DQ (2/8/2019): Adding support for detecting when to use added name qualification for pointer-to-member expressions.
1751  ROSE_DLL_API bool isDataMemberReference(SgVarRefExp* varRefExp);
1752  // ROSE_DLL_API bool isAddressTaken(SgVarRefExp* varRefExp);
1753  ROSE_DLL_API bool isAddressTaken(SgExpression* refExp);
1754 
1755  // DQ (2/17/2019): Adding support for detecting when to use added name qualification for membr function references.
1756  ROSE_DLL_API bool isMemberFunctionMemberReference(SgMemberFunctionRefExp* memberFunctionRefExp);
1757 
1758  // DQ (2/15/2019): Adding support for detecting which class a member reference is being made from.
1759  // ROSE_DLL_API SgClassType* getClassTypeForDataMemberReference(SgVarRefExp* varRefExp);
1760  // ROSE_DLL_API std::list<SgClassType*> getClassTypeChainForDataMemberReference(SgVarRefExp* varRefExp);
1761  ROSE_DLL_API std::list<SgClassType*> getClassTypeChainForMemberReference(SgExpression* refExp);
1762 
1763  ROSE_DLL_API std::set<SgNode*> getFrontendSpecificNodes();
1764 
1765  // DQ (2/17/2019): Display the shared nodes in the AST for debugging.
1766  ROSE_DLL_API void outputSharedNodes( SgNode* node );
1767 
1768  // DQ (10/31/2020): Added function to help debug edits to statements in scopes.
1769  ROSE_DLL_API void displayScope(SgScopeStatement* scope);
1770 
1771 // TODO
1772 #if 0
1773  SgNode * getEnclosingSgNode(SgNode* source,VariantT, SgNode* endNode=NULL);
1774  std::vector<SgNode *> getAllEnclosingSgNode(SgNode* source,VariantT, SgNode* endNode=NULL);
1775  SgVariableDeclaration* findVariableDeclaratin( const string& varname)
1776 
1778 
1779  // e.g. for some expression, find its parent statement
1780  SgStatement* getEnclosingStatement(const SgNode* astNode);
1781 
1782  SgSwitchStatement* getEnclosingSwitch(SgStatement* s);
1783  SgModuleStatement* getEnclosingModuleStatement( const SgNode* astNode);
1784 
1785  // used to build a variable reference for compiler generated code in current scope
1786  SgSymbol * findReachingDefinition (SgScopeStatement* startScope, SgName &name);
1787 #endif
1788 
1789 
1790 //------------------------------------------------------------------------
1792 
1795  // Liao, 1/9/2008
1799  ROSE_DLL_API SgGlobal * getFirstGlobalScope(SgProject *project);
1800 
1804  ROSE_DLL_API SgStatement* getLastStatement(SgScopeStatement *scope);
1805 
1807  ROSE_DLL_API SgStatement* getFirstStatement(SgScopeStatement *scope,bool includingCompilerGenerated=false);
1810 
1812  ROSE_DLL_API SgStatement* getNextStatement(SgStatement * currentStmt);
1813 
1815  ROSE_DLL_API SgStatement* getPreviousStatement(SgStatement * currentStmt, bool climbOutScope = true);
1816 #if 0 //TODO
1817  // preorder traversal from current SgNode till find next SgNode of type V_SgXXX
1818  SgNode* getNextSgNode( const SgNode* currentNode, VariantT=V_SgNode);
1819 #endif
1820 
1821  // DQ (11/15/2018): Adding support for traversals over the include file tree.
1823  void listHeaderFiles ( SgIncludeFile* includeFile );
1824 
1825 
1827 
1828 //------------------------------------------------------------------------
1830 
1833  ROSE_DLL_API bool isEqualToIntConst(SgExpression* e, int value);
1835 
1837 
1840  ROSE_DLL_API bool isSameFunction(SgFunctionDeclaration* func1, SgFunctionDeclaration* func2);
1841 
1843  ROSE_DLL_API bool isLastStatement(SgStatement* stmt);
1844 
1846 
1847 //------------------------------------------------------------------------
1849 
1855 #if 1
1857  {
1858  // DQ (11/19/2020): We need to expand the use of this to cover deffered transformations of common SageInterface transformations (e.g. replaceStatement).
1859  // So I needed to move this out of being specific to the outliner and make it more generally data structure in the SageInterface.
1860 
1861  // DQ (11/15/2020): Need to add the concept of deffered transformation to cover replaceStatement operations.
1862 
1863  // DQ (8/7/2019): Store data required to support defering the transformation to insert the outlined function prototypes
1864  // into class declaration (when this is required to support the outlined function's access to protected or private data members).
1865  // This is part of an optimization to support the optimization of header file unparsing (limiting the overhead of supporting any
1866  // header file to just focus on the few (typically one) header file that would have to be unparsed.
1867 
1868  enum TransformationKind
1869  {
1870  // DQ (11/22/2020): Might need to also add SageInterface::addDefaultConstructorIfRequired() and SageStatement::insert_statment()
1871  // to support the processStatements.C transforamtions to pre-process the AST (return expressions and variable initializations).
1872  e_error,
1873  e_default,
1874  e_outliner,
1875  e_replaceStatement,
1876  e_removeStatement,
1877  e_replaceDefiningFunctionDeclarationWithFunctionPrototype,
1878  e_last
1879  };
1880 
1881  TransformationKind deferredTransformationKind;
1882 
1883  // DQ (12/12/2020): Adding a string label so that we can name the different kinds of transformations.
1884  // E.g. moving pattern matched function from header file to dynamic library, vs. replacing function
1885  // definitions in the dynamic library file with function prototypes.
1886  std::string transformationLabel;
1887 
1888  // Remove sets statementToRemove, replace sets statementToRemove and StatementToAdd.
1889  SgStatement* statementToRemove;
1890  SgStatement* statementToAdd;
1891 
1892  SgClassDefinition* class_definition;
1893  SgDeclarationStatement* target_class_member;
1894  SgDeclarationStatement* new_function_prototype;
1895 
1896  typedef std::set<SgClassDefinition *> ClassDefSet_t;
1897  ClassDefSet_t targetClasses;
1898 
1899  typedef std::vector<SgFunctionDeclaration *> FuncDeclList_t;
1900  FuncDeclList_t targetFriends;
1901 
1902  // DQ (2/28/2021): Adding support for outlining where it involves building up pre-transformations.
1903  // For example, in the code segregation, we build a conditiona around the interval of statements
1904  // that we are outlining. This conditional is used to overwrite the first statement in the interval
1905  // list. Because we don't want to transform the AST until after the outlining, we need so save the
1906  // whole interval so that we, after the outlining, remove the statements in the interval after that
1907  // first statement.
1908  typedef std::vector<SgStatement*> IntervalType;
1909  IntervalType statementInterval;
1910  SgStatement* locationToOverwriteWithTransformation;
1911  SgStatement* transformationToOverwriteFirstStatementInInterval;
1912  SgBasicBlock* blockOfStatementsToOutline;
1913 
1914  // DQ (12/5/2019): Added ROSE_DLL_API prefix for Windows support (too all of these functions).
1915  ROSE_DLL_API DeferredTransformation();
1916  ROSE_DLL_API DeferredTransformation(SgClassDefinition* class_definition, SgDeclarationStatement* target_class_member, SgDeclarationStatement* new_function_prototype);
1917  ROSE_DLL_API DeferredTransformation (const DeferredTransformation& X);
1918  ROSE_DLL_API ~DeferredTransformation (void);
1919 
1920  ROSE_DLL_API DeferredTransformation & operator= (const DeferredTransformation& X);
1921 
1922  // DQ (11/20/20): static function to generate specialized version of deferred transformation object.
1923  static ROSE_DLL_API DeferredTransformation replaceDefiningFunctionDeclarationWithFunctionPrototype( SgFunctionDeclaration* functionDeclaration );
1924  static ROSE_DLL_API DeferredTransformation replaceStatement(SgStatement* oldStmt, SgStatement* newStmt, bool movePreprocessinInfo = false);
1925 
1926  static ROSE_DLL_API std::string outputDeferredTransformationKind(const TransformationKind & kind);
1927  ROSE_DLL_API void display ( std::string label ) const;
1928 
1929  };
1930 #endif
1931 
1932 
1933 // DQ (2/24/2009): Simple function to delete an AST subtree (used in outlining).
1935 ROSE_DLL_API void deleteAST(SgNode* node);
1936 
1939 
1940 // DQ (2/25/2009): Added new function to support outliner.
1942 ROSE_DLL_API void moveStatementsBetweenBlocks ( SgBasicBlock* sourceBlock, SgBasicBlock* targetBlock );
1943 
1945 ROSE_DLL_API void moveStatementsBetweenBlocks ( SgAdaPackageSpec * sourceBlock, SgNamespaceDefinitionStatement* targetBlock );
1946 
1948 ROSE_DLL_API void moveStatementsBetweenBlocks ( SgAdaPackageBody* sourceBlock, SgNamespaceDefinitionStatement* targetBlock );
1949 
1951 ROSE_DLL_API void moveStatementsBetweenBlocks ( SgNamespaceDefinitionStatement* sourceBlock, SgNamespaceDefinitionStatement* targetBlock );
1952 
1954 ROSE_DLL_API bool isLambdaFunction (SgFunctionDeclaration* func);
1955 
1957 ROSE_DLL_API bool isLambdaCapturedVariable (SgVarRefExp* varRef);
1958 
1959 
1961 ROSE_DLL_API void moveVariableDeclaration(SgVariableDeclaration* decl, SgScopeStatement* target_scope);
1963 ROSE_DLL_API void appendStatement(SgStatement *stmt, SgScopeStatement* scope=NULL);
1964 
1966 ROSE_DLL_API void appendStatement(SgStatement *stmt, SgForInitStatement* for_init_stmt);
1967 
1969 ROSE_DLL_API void appendStatementList(const std::vector<SgStatement*>& stmt, SgScopeStatement* scope=NULL);
1970 
1971 // DQ (2/6/2009): Added function to support outlining into separate file.
1973 ROSE_DLL_API void appendStatementWithDependentDeclaration( SgDeclarationStatement* decl, SgGlobal* scope, SgStatement* original_statement, bool excludeHeaderFiles );
1974 
1977 ROSE_DLL_API void prependStatement(SgStatement *stmt, SgScopeStatement* scope=NULL);
1978 
1980 ROSE_DLL_API void prependStatement(SgStatement *stmt, SgForInitStatement* for_init_stmt);
1981 
1984 ROSE_DLL_API void prependStatementList(const std::vector<SgStatement*>& stmt, SgScopeStatement* scope=NULL);
1985 
1989 ROSE_DLL_API bool hasSimpleChildrenList (SgScopeStatement* scope);
1990 
1992 ROSE_DLL_API void insertStatement(SgStatement *targetStmt, SgStatement* newStmt, bool insertBefore= true, bool autoMovePreprocessingInfo = true);
1993 
1995 //target's scope
1996 ROSE_DLL_API void insertStatementList(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmts, bool insertBefore= true);
1997 
1999 ROSE_DLL_API void insertStatementBefore(SgStatement *targetStmt, SgStatement* newStmt, bool autoMovePreprocessingInfo = true);
2000 
2002 ROSE_DLL_API void insertStatementListBefore(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmts);
2003 
2005 ROSE_DLL_API void insertStatementAfter(SgStatement *targetStmt, SgStatement* newStmt, bool autoMovePreprocessingInfo = true);
2006 
2008 ROSE_DLL_API void insertStatementListAfter(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmt);
2009 
2011 ROSE_DLL_API void insertStatementAfterLastDeclaration(SgStatement* stmt, SgScopeStatement* scope);
2012 
2014 ROSE_DLL_API void insertStatementAfterLastDeclaration(std::vector<SgStatement*> stmt_list, SgScopeStatement* scope);
2015 
2017 // then the statement is inserted at the end of the scope.
2018 ROSE_DLL_API void insertStatementBeforeFirstNonDeclaration(SgStatement *newStmt, SgScopeStatement *scope,
2019  bool movePreprocessingInfo=true);
2020 
2022 //then the new statements are inserted at the end of the scope.
2023 ROSE_DLL_API void insertStatementListBeforeFirstNonDeclaration(const std::vector<SgStatement*> &newStmts, SgScopeStatement *scope);
2024 
2025 // 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.
2026 ROSE_DLL_API SgStatement* lastFrontEndSpecificStatement( SgGlobal* globalScope );
2027 
2029 ROSE_DLL_API void removeStatement(SgStatement* stmt, bool autoRelocatePreprocessingInfo = true);
2030 
2032 ROSE_DLL_API void deepDelete(SgNode* root);
2033 
2035 ROSE_DLL_API void replaceStatement(SgStatement* oldStmt, SgStatement* newStmt, bool movePreprocessinInfo = false);
2036 
2038 ROSE_DLL_API SgNode* replaceWithPattern (SgNode * anchor, SgNode* new_pattern);
2039 
2041 // Essentially replace variable a with b.
2042 ROSE_DLL_API void replaceVariableReferences(SgVariableSymbol* old_sym, SgVariableSymbol* new_sym, SgScopeStatement * scope );
2043 
2044 // 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.
2048 ROSE_DLL_API bool statementCanBeTransformed(SgStatement* stmt);
2049 
2050 
2061 std::pair<SgVariableDeclaration*, SgExpression* > createTempVariableForExpression(SgExpression* expression,
2062  SgScopeStatement* scope, bool initializeInDeclaration, SgAssignOp** reEvaluate = NULL);
2063 
2064 /* This function creates a temporary variable for a given expression in the given scope
2065  This is different from SageInterface::createTempVariableForExpression in that it does not
2066  try to be smart to create pointers to reference types and so on. The tempt is initialized to expression.
2067  The caller is responsible for setting the parent of SgVariableDeclaration since buildVariableDeclaration
2068  may not set_parent() when the scope stack is empty. See programTransformation/extractFunctionArgumentsNormalization/ExtractFunctionArguments.C for sample usage.
2069  @param expression Expression which will be replaced by a variable
2070  @param scope scope in which the temporary variable will be generated
2071 */
2072 
2073 std::pair<SgVariableDeclaration*, SgExpression*> createTempVariableAndReferenceForExpression
2074  (SgExpression* expression, SgScopeStatement* scope);
2075 
2077 
2084 
2086 ROSE_DLL_API void appendExpression(SgExprListExp *, SgExpression*);
2087 
2089 ROSE_DLL_API void appendExpressionList(SgExprListExp *, const std::vector<SgExpression*>&);
2090 
2092 template <class actualFunction>
2093 void setParameterList(actualFunction *func,SgFunctionParameterList *paralist) {
2094 
2095  // TODO consider the difference between C++ and Fortran
2096  // fixup the scope of arguments,no symbols for nondefining function declaration's arguments
2097 
2098  // DQ (11/25/2011): templated function so that we can handle both
2099  // SgFunctionDeclaration and SgTemplateFunctionDeclaration (and their associated member
2100  // function derived classes).
2101 
2102  ROSE_ASSERT(func != NULL);
2103  ROSE_ASSERT(paralist != NULL);
2104 
2105 #if 0
2106  // At this point we don't have cerr and endl defined, so comment this code out.
2107  // Warn to users if a paralist is being shared
2108  if (paralist->get_parent() !=NULL)
2109  {
2110  cerr << "Waring! Setting a used SgFunctionParameterList to function: "
2111  << (func->get_name()).getString()<<endl
2112  << " Sharing parameter lists can corrupt symbol tables!"<<endl
2113  << " Please use deepCopy() to get an exclusive parameter list for each function declaration!"<<endl;
2114  // ROSE_ASSERT(false);
2115  }
2116 #endif
2117 
2118  // Liao,2/5/2008 constructor of SgFunctionDeclaration will automatically generate SgFunctionParameterList, so be cautious when set new paralist!!
2119  if (func->get_parameterList() != NULL)
2120  {
2121  if (func->get_parameterList() != paralist)
2122  {
2123  delete func->get_parameterList();
2124  }
2125  }
2126 
2127  func->set_parameterList(paralist);
2128  paralist->set_parent(func);
2129 
2131  {
2132  // Ada stores variable declarations in the function parameter scope (for functions)
2133  // and in a discriminantScope (for discriminated declarations).
2134  // ==> just make sure that these are set.
2135  SgInitializedNamePtrList& args = paralist->get_args();
2136  for (SgInitializedNamePtrList::iterator i = args.begin(); i != args.end(); ++i)
2137  {
2138  ROSE_ASSERT(*i && isSgVariableDeclaration((*i)->get_declptr()));
2139  }
2140  }
2141  else
2142  {
2143  // DQ (5/15/2012): Need to set the declptr in each SgInitializedName IR node.
2144  // This is needed to support the AST Copy mechanism (at least). The files: test2005_150.C,
2145  // test2012_81.C and testcode2012_82.C demonstrate this problem.
2146  SgInitializedNamePtrList & args = paralist->get_args();
2147  for (SgInitializedNamePtrList::iterator i = args.begin(); i != args.end(); i++)
2148  {
2149  (*i)->set_declptr(func);
2150  }
2151  }
2152  }
2153 
2155 ROSE_DLL_API void setPragma(SgPragmaDeclaration* decl, SgPragma *pragma);
2156 
2158 ROSE_DLL_API void replaceExpression(SgExpression* oldExp, SgExpression* newExp, bool keepOldExp=false);
2159 
2161 ROSE_DLL_API void replaceExpressionWithStatement(SgExpression* from,
2165 ROSE_DLL_API void replaceSubexpressionWithStatement(SgExpression* from,
2167 
2169 ROSE_DLL_API void setOperand(SgExpression* target, SgExpression* operand);
2170 
2172 ROSE_DLL_API void setLhsOperand(SgExpression* target, SgExpression* lhs);
2173 
2175 ROSE_DLL_API void setRhsOperand(SgExpression* target, SgExpression* rhs);
2176 
2178 ROSE_DLL_API void removeAllOriginalExpressionTrees(SgNode* top);
2179 
2180 // DQ (1/25/2010): Added support for directories
2182 ROSE_DLL_API void moveToSubdirectory ( std::string directoryName, SgFile* file );
2183 
2185 ROSE_DLL_API SgStatement* findSurroundingStatementFromSameFile(SgStatement* targetStmt, bool & surroundingStatementPreceedsTargetStatement);
2186 
2188 ROSE_DLL_API void moveCommentsToNewStatement(SgStatement* sourceStatement, const std::vector<int> & indexList, SgStatement* targetStatement, bool surroundingStatementPreceedsTargetStatement);
2189 
2190 // DQ (7/19/2015): This is required to support general unparsing of template instantations for the GNU g++
2191 // compiler which does not permit name qualification to be used to support the expression of the namespace
2192 // where a template instantiatoon would be places. Such name qualification would also sometimes require
2193 // global qualification which is also not allowed by the GNU g++ compiler. These issues appear to be
2194 // specific to the GNU compiler versions, at least versions 4.4 through 4.8.
2196 ROSE_DLL_API void moveDeclarationToAssociatedNamespace ( SgDeclarationStatement* declarationStatement );
2197 
2198 ROSE_DLL_API bool isTemplateInstantiationNode(SgNode* node);
2199 
2201 
2202 // DQ (12/1/2015): Adding support for fixup internal data struuctures that have references to statements (e.g. macro expansions).
2203 ROSE_DLL_API void resetInternalMapsForTargetStatement(SgStatement* sourceStatement);
2204 
2205 // DQ (6/7/2019): Add support for transforming function definitions to function prototypes in a subtree.
2206 // We might have to make this specific to a file (only traversing the functions in that file).
2215 
2216 // DQ (11/10/2019): Lower level support for convertFunctionDefinitionsToFunctionPrototypes().
2217 // DQ (10/27/2020): Need to return the generated function prototype (incase we want to mark it for output or template unparsing from the AST).
2218 // ROSE_DLL_API void replaceDefiningFunctionDeclarationWithFunctionPrototype ( SgFunctionDeclaration* functionDeclaration );
2219 // ROSE_DLL_API SgDeclarationStatement* replaceDefiningFunctionDeclarationWithFunctionPrototype ( SgFunctionDeclaration* functionDeclaration );
2221 ROSE_DLL_API std::vector<SgFunctionDeclaration*> generateFunctionDefinitionsList(SgNode* node);
2222 
2223 // DQ (10/29/2020): build a function prototype for all but member functions outside of the class (except for template instantiations).
2224 // The reason why member functions outside of the class are an exception is because they can not be used except in a class and there
2225 // would already be one present for the code to compile.
2226 ROSE_DLL_API SgFunctionDeclaration* buildFunctionPrototype ( SgFunctionDeclaration* functionDeclaration );
2227 
2228 
2230 //------------------------------------------------------------------------
2232 
2239 
2245 ROSE_DLL_API int fixVariableReferences(SgNode* root, bool cleanUnusedSymbol=true);
2246 
2248 
2252 ROSE_DLL_API void fixVariableDeclaration(SgVariableDeclaration* varDecl, SgScopeStatement* scope);
2253 
2255 ROSE_DLL_API void fixStructDeclaration(SgClassDeclaration* structDecl, SgScopeStatement* scope);
2257 ROSE_DLL_API void fixClassDeclaration(SgClassDeclaration* classDecl, SgScopeStatement* scope);
2258 
2260 ROSE_DLL_API void fixNamespaceDeclaration(SgNamespaceDeclarationStatement* structDecl, SgScopeStatement* scope);
2261 
2262 
2264 ROSE_DLL_API void fixLabelStatement(SgLabelStatement* label_stmt, SgScopeStatement* scope);
2265 
2267 ROSE_DLL_API void setFortranNumericLabel(SgStatement* stmt, int label_value,
2268  SgLabelSymbol::label_type_enum label_type=SgLabelSymbol::e_start_label_type,
2269  SgScopeStatement* label_scope=NULL);
2270 
2272 ROSE_DLL_API int suggestNextNumericLabel(SgFunctionDefinition* func_def);
2273 
2275 ROSE_DLL_API void fixFunctionDeclaration(SgFunctionDeclaration* stmt, SgScopeStatement* scope);
2276 
2278 ROSE_DLL_API void fixTemplateDeclaration(SgTemplateDeclaration* stmt, SgScopeStatement* scope);
2279 
2281 ROSE_DLL_API void fixStatement(SgStatement* stmt, SgScopeStatement* scope);
2282 
2283 // DQ (6/11/2015): This reports the statements that are marked as transformed (used to debug the token-based unparsing).
2285 ROSE_DLL_API std::set<SgStatement*> collectTransformedStatements( SgNode* node );
2286 
2288 ROSE_DLL_API std::set<SgStatement*> collectModifiedStatements( SgNode* node );
2289 
2291 ROSE_DLL_API std::set<SgLocatedNode*> collectModifiedLocatedNodes( SgNode* node );
2292 
2293 // DQ (6/5/2019): Use the previously constructed set (above) to reset the IR nodes to be marked as isModified.
2295 ROSE_DLL_API void resetModifiedLocatedNodes(const std::set<SgLocatedNode*> & modifiedNodeSet);
2296 
2297 
2298 // DQ (10/23/2018): Report nodes that are marked as modified.
2299 ROSE_DLL_API void reportModifiedStatements(const std::string & label, SgNode* node);
2300 
2301 // DQ (3/22/2019): Translate CPP directives from attached preprocessor information to CPP Directive Declaration IR nodes.
2302 ROSE_DLL_API void translateToUseCppDeclarations( SgNode* n );
2303 
2304 ROSE_DLL_API void translateScopeToUseCppDeclarations( SgScopeStatement* scope );
2305 
2306 ROSE_DLL_API std::vector<SgC_PreprocessorDirectiveStatement*> translateStatementToUseCppDeclarations( SgStatement* statement, SgScopeStatement* scope);
2307 ROSE_DLL_API void printOutComments ( SgLocatedNode* locatedNode );
2308 ROSE_DLL_API bool skipTranslateToUseCppDeclaration( PreprocessingInfo* currentPreprocessingInfo );
2309 
2310 // DQ (12/2/2019): Debugging support.
2311 ROSE_DLL_API void outputFileIds( SgNode* node );
2312 
2313 
2315 
2317 
2323 
2324 //------------------------------------------------------------------------
2326 
2330 ROSE_DLL_API bool
2332 collectReadWriteRefs(SgStatement* stmt, std::vector<SgNode*>& readRefs, std::vector<SgNode*>& writeRefs, bool useCachedDefUse=false);
2333 
2335 ROSE_DLL_API bool collectReadWriteVariables(SgStatement* stmt, std::set<SgInitializedName*>& readVars, std::set<SgInitializedName*>& writeVars, bool coarseGrain=true);
2336 
2338 ROSE_DLL_API void collectReadOnlyVariables(SgStatement* stmt, std::set<SgInitializedName*>& readOnlyVars, bool coarseGrain=true);
2339 
2341 ROSE_DLL_API void collectReadOnlySymbols(SgStatement* stmt, std::set<SgVariableSymbol*>& readOnlySymbols, bool coarseGrain=true);
2342 
2344 ROSE_DLL_API bool isUseByAddressVariableRef(SgVarRefExp* ref);
2345 
2347 ROSE_DLL_API void collectUseByAddressVariableRefs (const SgStatement* s, std::set<SgVarRefExp* >& varSetB);
2348 
2349 #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
2350 ROSE_DLL_API LivenessAnalysis * call_liveness_analysis(SgProject* project, bool debug=false);
2352 
2354 ROSE_DLL_API void getLiveVariables(LivenessAnalysis * liv, SgForStatement* loop, std::set<SgInitializedName*>& liveIns, std::set<SgInitializedName*> & liveOuts);
2355 #endif
2356 
2358 ROSE_DLL_API void ReductionRecognition(SgForStatement* loop, std::set< std::pair <SgInitializedName*, OmpSupport::omp_construct_enum> > & results);
2359 
2361 
2362 ROSE_DLL_API void constantFolding(SgNode* r);
2363 
2365 
2367 ROSE_DLL_API int instrumentEndOfFunction(SgFunctionDeclaration * func, SgStatement* s);
2368 
2370 ROSE_DLL_API void removeJumpsToNextStatement(SgNode*);
2371 
2373 ROSE_DLL_API void removeUnusedLabels(SgNode* top, bool keepChild =false);
2374 
2376 ROSE_DLL_API std::set<SgLabelStatement*> findUnusedLabels (SgNode* top);
2377 
2379 ROSE_DLL_API void removeConsecutiveLabels(SgNode* top);
2380 
2382 
2388 ROSE_DLL_API bool mergeDeclarationAndAssignment (SgVariableDeclaration* decl, SgExprStatement* assign_stmt, bool removeAssignStmt = true);
2389 
2390 
2392 ROSE_DLL_API bool mergeAssignmentWithDeclaration (SgExprStatement* assign_stmt, SgVariableDeclaration* decl, bool removeAssignStmt = true);
2393 
2395 
2398 ROSE_DLL_API bool mergeDeclarationWithAssignment (SgVariableDeclaration* decl, SgExprStatement* assign_stmt);
2399 
2401 
2406 
2408 ROSE_DLL_API int splitVariableDeclaration (SgScopeStatement* scope, bool topLevelOnly = true);
2409 
2411 
2418  ROSE_DLL_API SgAssignInitializer* splitExpression(SgExpression* from, std::string newName = "");
2419 
2421 ROSE_DLL_API void splitExpressionIntoBasicBlock(SgExpression* expr);
2422 
2424 ROSE_DLL_API void removeLabeledGotos(SgNode* top);
2425 
2427 ROSE_DLL_API void changeBreakStatementsToGotos(SgStatement* loopOrSwitch);
2428 
2431 
2434 
2437 
2440 
2443 
2446 
2449 
2452 
2454 ROSE_DLL_API SgBasicBlock* ensureBasicBlockAsFalseBodyOfIf(SgIfStmt* ifs, bool createEmptyBody = true);
2455 
2458 
2461 
2462 // DQ (1/18/2015): This is added to support better quality token-based unparsing.
2464 ROSE_DLL_API void cleanupNontransformedBasicBlockNode();
2465 
2466 // DQ (1/18/2015): This is added to support better quality token-based unparsing.
2468 ROSE_DLL_API void recordNormalizations(SgStatement* s);
2469 
2472 bool isBodyStatement (SgStatement* s);
2473 
2475 void changeAllBodiesToBlocks(SgNode* top, bool createEmptyBody = true);
2476 
2477 // The same as changeAllBodiesToBlocks(SgNode* top). Phased out.
2478 //void changeAllLoopBodiesToBlocks(SgNode* top);
2479 
2482 
2483 #if 0
2484 
2487 SgLocatedNode* ensureBasicBlockAsParent(SgStatement* s);
2488 #endif
2489 
2492 unsigned long long getIntegerConstantValue(SgValueExp* expr);
2493 
2495 std::vector<SgDeclarationStatement*> getDependentDeclarations (SgStatement* stmt );
2496 
2497 
2500 
2502 SgCommaOpExp *insertAfterUsingCommaOp (SgExpression* new_exp, SgExpression* anchor_exp, SgStatement** temp_decl = NULL, SgVarRefExp** temp_ref = NULL);
2503 
2504 
2534 std::pair<SgStatement*, SgInitializedName*>
2535 wrapFunction(SgFunctionDeclaration& definingDeclaration, SgName newName);
2536 
2542 template <class NameGen>
2543 std::pair<SgStatement*, SgInitializedName*>
2544 wrapFunction(SgFunctionDeclaration& definingDeclaration, NameGen nameGen)
2545 {
2546  return wrapFunction(definingDeclaration, nameGen(definingDeclaration.get_name()));
2547 }
2548 
2552 
2553 
2555 
2556 // DQ (6/7/2012): Unclear where this function should go...
2557  bool hasTemplateSyntax( const SgName & name );
2558 
2559 #if 0
2560 
2561 //------------------------AST dump, stringify-----------------------------
2562 //------------------------------------------------------------------------
2563  std::string buildOperatorString ( SgNode* astNode ); //transformationSupport.h
2564 
2565  // do we need these?
2566  std::string dump_node(const SgNode* astNode);
2567  std::string dump_tree(const SgNode* astNode);
2568 
2569  // or a friendly version of unparseToString(), as a memeber function
2570  std::string SgNode::toString(bool asSubTree=true); // dump node or subtree
2571 
2572 //----------------------------AST comparison------------------------------
2573 //------------------------------------------------------------------------
2574 // How to get generic functions for comparison?
2575  bool isNodeEqual(SgNode* node1, SgNode* node2); //?
2576  bool isTreeEqual(SgNode* tree1, SgNode* tree2);
2577 
2579  bool expressionTreeEqual(SgExpression*, SgExpression*);
2581  bool expressionTreeEqualStar(const SgExpressionPtrList&,
2582  const SgExpressionPtrList&);
2583 
2584 //----------------------AST verfication/repair----------------------------
2585 //------------------------------------------------------------------------
2586 // sanity check of AST subtree, any suggestions?
2587 // TODO
2588  verifySgNode(SgNode* node, bool subTree=true);
2589  //src/midend/astDiagnostics/AstConsistencyTests.h
2590  // AstTests::runAllTests(SgProject * )
2591 
2592  //src/midend/astUtil/astInterface/AstInterface.h.C
2593  //FixSgProject(SgProject &project)
2594  //FixSgTree(SgNode* r)
2595 
2596  //src/frontend/SageIII/astPostProcessing
2597  //AstPostProcessing(SgNode * node)
2598 
2599 //--------------------------AST modification------------------------------
2600 //------------------------------------------------------------------------
2601 // any operations changing AST tree, including
2602 // insert, copy, delete(remove), replace
2603 
2604  // insert before or after some point, argument list is consistent with LowLevelRewrite
2605  void insertAst(SgNode* targetPosition, SgNode* newNode, bool insertBefore=true);
2606 
2607  // previous examples
2608  //void myStatementInsert(SgStatement* target,...)
2609  // void AstInterfaceBase::InsertStmt(AstNodePtr const & orig, AstNodePtr const &n, bool insertbefore, bool extractfromBasicBlock)
2610 
2611  // copy
2612  // copy children of one basic block to another basic block
2613  //void appendStatementCopy (const SgBasicBlock* a, SgBasicBlock* b);
2614  void copyStatements (const SgBasicBlock* src, SgBasicBlock* dst);
2615 
2616  // delete (remove) a node or a whole subtree
2617  void removeSgNode(SgNode* targetNode); // need this?
2618  void removeSgNodeTree(SgNode* subtree); // need this?
2619 
2620  void removeStatement( SgStatement* targetStmt);
2621 
2622  //Move = delete + insert
2623  void moveAst (SgNode* src, SgNode* target); // need this?
2624  // similar to
2625  void moveStatements (SgBasicBlock* src, SgBasicBlock* target);
2626 
2627  // replace= delete old + insert new (via building or copying)
2628 
2629 // DQ (1/25/2010): This does not appear to exist as a definition anywhere in ROSE.
2630 // void replaceAst(SgNode* oldNode, SgNode* newNode);
2631 
2632  //void replaceChild(SgNode* parent, SgNode* from, SgNode* to);
2633  //bool AstInterface::ReplaceAst( const AstNodePtr& orig, const AstNodePtr& n)
2634 
2635 //--------------------------AST transformations---------------------------
2636 //------------------------------------------------------------------------
2637 // Advanced AST modifications through basic AST modifications
2638 // Might not be included in AST utitlity list, but listed here for the record.
2639 
2640  // extract statements/content from a scope
2641  void flattenBlocks(SgNode* n);
2642 
2643  //src/midend/astInlining/inlinerSupport.h
2644  void renameVariables(SgNode* n);
2645  void renameLabels(SgNode* n, SgFunctionDefinition* enclosingFunctionDefinition);
2646 
2647  void simpleCopyAndConstantPropagation(SgNode* top);
2648  void changeAllMembersToPublic(SgNode* n);
2649 
2650  void removeVariableDeclaration(SgInitializedName* initname);
2651 
2653  SgAssignOp* convertInitializerIntoAssignment(SgAssignInitializer* init);
2654 
2659  void pushTestIntoBody(LoopStatement* loopStmt);
2660 
2661  //programTransformation/finiteDifferencing/finiteDifferencing.h
2663  void moveForDeclaredVariables(SgNode* root);
2664 
2665 //------------------------ Is/Has functions ------------------------------
2666 //------------------------------------------------------------------------
2667 // misc. boolean functions
2668 // some of them could moved to SgXXX class as a member function
2669 
2670  bool isOverloaded (SgFunctionDeclaration * functionDeclaration);
2671 
2672  bool isSwitchCond (const SgStatement* s);
2673  bool isIfCond (const SgStatement* s);
2674  bool isWhileCond (const SgStatement* s);
2675  bool isStdNamespace (const SgScopeStatement* scope);
2676  bool isTemplateInst (const SgDeclarationStatement* decl);
2677 
2678 
2679  bool isCtor (const SgFunctionDeclaration* func);
2680  bool isDtor (const SgFunctionDeclaration* func);
2681 
2682  // src/midend/astInlining/typeTraits.h
2683  bool hasTrivialDestructor(SgType* t);
2684  ROSE_DLL_API bool isNonconstReference(SgType* t);
2685  ROSE_DLL_API bool isReferenceType(SgType* t);
2686 
2687  // generic ones, or move to the SgXXX class as a member function
2688 
2689  bool isConst(SgNode* node); // const type, variable, function, etc.
2690  // .... and more
2691 
2692  bool isConstType (const SgType* type);
2693  bool isConstFunction (const SgFunctionDeclaration* decl);
2694 
2695 
2696  bool isMemberVariable(const SgInitializedName & var);
2697  //bool isMemberVariable(const SgNode& in);
2698 
2699  bool isPrototypeInScope (SgScopeStatement * scope,
2700  SgFunctionDeclaration * functionDeclaration,
2701  SgDeclarationStatement * startingAtDeclaration);
2702 
2703  bool MayRedefined(SgExpression* expr, SgNode* root);
2704  // bool isPotentiallyModified(SgExpression* expr, SgNode* root); // inlinderSupport.h
2705  bool hasAddressTaken(SgExpression* expr, SgNode* root);
2706 
2707  //src/midend/astInlining/inlinerSupport.C
2708  // can also classified as topdown search
2709  bool containsVariableReference(SgNode* root, SgInitializedName* var);
2710 
2711  bool isDeclarationOf(SgVariableDeclaration* decl, SgInitializedName* var);
2712  bool isPotentiallyModifiedDuringLifeOf(SgBasicBlock* sc,
2713  SgInitializedName* toCheck,
2714  SgInitializedName* lifetime)
2715  //src/midend/programTransformation/partialRedundancyElimination/pre.h
2716  bool anyOfListPotentiallyModifiedIn(const std::vector<SgVariableSymbol*>& syms, SgNode* n);
2717 
2718 //------------------------ loop handling ---------------------------------
2719 //------------------------------------------------------------------------
2720  //get and set loop control expressions
2721  // 0: init expr, 1: condition expr, 2: stride expr
2722 
2723  SgExpression* getForLoopTripleValues(int valuetype,SgForStatement* forstmt );
2724  int setForLoopTripleValues(int valuetype,SgForStatement* forstmt, SgExpression* exp);
2725 
2726  bool isLoopIndexVarRef(SgForStatement* forstmt, SgVarRefExp *varref);
2727  SgInitializedName * getLoopIndexVar(SgForStatement* forstmt);
2728 
2729 //------------------------expressions-------------------------------------
2730 //------------------------------------------------------------------------
2731  //src/midend/programTransformation/partialRedundancyElimination/pre.h
2732  int countComputationsOfExpressionIn(SgExpression* expr, SgNode* root);
2733 
2734  //src/midend/astInlining/replaceExpressionWithStatement.h
2735  void replaceAssignmentStmtWithStatement(SgExprStatement* from, StatementGenerator* to);
2736 
2738  StatementGenerator* to);
2739  SgExpression* getRootOfExpression(SgExpression* n);
2740 
2741 //--------------------------preprocessing info. -------------------------
2742 //------------------------------------------------------------------------
2744  void cutPreprocInfo (SgBasicBlock* b,
2746  AttachedPreprocessingInfoType& save_buf);
2748  void pastePreprocInfoFront (AttachedPreprocessingInfoType& save_buf,
2749  SgStatement* s);
2751  void pastePreprocInfoBack (AttachedPreprocessingInfoType& save_buf,
2752  SgStatement* s);
2753 
2759  // a generic one for all
2761  void moveBeforePreprocInfo (SgStatement* src, SgStatement* dest);
2762  void moveInsidePreprocInfo (SgBasicBlock* src, SgBasicBlock* dest);
2763  void moveAfterPreprocInfo (SgStatement* src, SgStatement* dest);
2764 
2765 //--------------------------------operator--------------------------------
2766 //------------------------------------------------------------------------
2767  from transformationSupport.h, not sure if they should be included here
2768  /* return enum code for SAGE operators */
2769  operatorCodeType classifyOverloadedOperator(); // transformationSupport.h
2770 
2776  std::string stringifyOperator (std::string name);
2777 
2778 //--------------------------------macro ----------------------------------
2779 //------------------------------------------------------------------------
2780  std::string buildMacro ( std::string s ); //transformationSupport.h
2781 
2782 //--------------------------------access functions---------------------------
2783 //----------------------------------get/set sth.-----------------------------
2784 // several categories:
2785 * get/set a direct child/grandchild node or fields
2786 * get/set a property flag value
2787 * get a descendent child node using preorder searching
2788 * get an ancestor node using bottomup/reverse searching
2789 
2790  // SgName or string?
2791  std::string getFunctionName (SgFunctionCallExp* functionCallExp);
2792  std::string getFunctionTypeName ( SgFunctionCallExp* functionCallExpression );
2793 
2794  // do we need them anymore? or existing member functions are enought?
2795  // a generic one:
2796  std::string get_name (const SgNode* node);
2797  std::string get_name (const SgDeclarationStatement * declaration);
2798 
2799  // get/set some property: should moved to SgXXX as an inherent memeber function?
2800  // access modifier
2801  void setExtern (SgFunctionDeclartion*)
2802  void clearExtern()
2803 
2804  // similarly for other declarations and other properties
2806  void setPublic()
2807  void setPrivate()
2808 
2809 #endif
2810 
2811 // DQ (1/23/2013): Added support for generated a set of source sequence entries.
2812  std::set<unsigned int> collectSourceSequenceNumbers( SgNode* astNode );
2813 
2814 //--------------------------------Type Traits (C++)---------------------------
2815  bool HasNoThrowAssign(const SgType * const inputType);
2816  bool HasNoThrowCopy(const SgType * const inputType);
2817  bool HasNoThrowConstructor(const SgType * const inputType);
2818  bool HasTrivialAssign(const SgType * const inputType);
2819  bool HasTrivialCopy(const SgType * const inputType);
2820  bool HasTrivialConstructor(const SgType * const inputType);
2821  bool HasTrivialDestructor(const SgType * const inputType);
2822  bool HasVirtualDestructor(const SgType * const inputType);
2823  bool IsBaseOf(const SgType * const inputBaseType, const SgType * const inputDerivedType);
2824  bool IsAbstract(const SgType * const inputType);
2826  bool IsClass(const SgType * const inputType);
2827  bool IsEmpty(const SgType * const inputType);
2828  bool IsEnum(const SgType * const inputType);
2829  bool IsPod(const SgType * const inputType);
2830  bool IsPolymorphic(const SgType * const inputType);
2831  bool IsStandardLayout(const SgType * const inputType);
2832  bool IsLiteralType(const SgType * const inputType);
2833  bool IsTrivial(const SgType * const inputType);
2834  bool IsUnion(const SgType * const inputType);
2835  SgType * UnderlyingType(SgType *type);
2836 
2837 // DQ (3/2/2014): Added a new interface function (used in the snippet insertion support).
2838 // void supportForInitializedNameLists ( SgScopeStatement* scope, SgInitializedNamePtrList & variableList );
2839 
2840 // DQ (3/4/2014): Added support for testing two trees for equivalents using the AST iterators.
2841  bool isStructurallyEquivalentAST( SgNode* tree1, SgNode* tree2 );
2842 
2843 // JP (10/14/24): Moved code to evaluate a const integer expression (like in array size definitions) to SageInterface
2846  size_t value_;
2847  bool hasValue_;
2848  };
2851 
2852 // JP (9/17/14): Added function to test whether two SgType* are equivalent or not
2853  bool checkTypesAreEqual(SgType *typeA, SgType *typeB);
2854 
2855 //--------------------------------Java interface functions ---------------------
2856 #ifdef ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
2857  ROSE_DLL_API std::string getTempDirectory(SgProject *project);
2858  ROSE_DLL_API void destroyTempDirectory(std::string);
2859  ROSE_DLL_API SgFile *processFile(SgProject *, std::string, bool unparse = false);
2860  ROSE_DLL_API std::string preprocessPackage(SgProject *, std::string);
2861  ROSE_DLL_API std::string preprocessImport(SgProject *, std::string);
2862  ROSE_DLL_API SgFile* preprocessCompilationUnit(SgProject *, std::string, std::string, bool unparse = true);
2863  ROSE_DLL_API SgClassDefinition *findJavaPackage(SgScopeStatement *, std::string);
2864  ROSE_DLL_API SgClassDefinition *findOrInsertJavaPackage(SgProject *, std::string, bool create_directory = false);
2865  ROSE_DLL_API SgClassDeclaration *findOrImportJavaClass(SgProject *, SgClassDefinition *package_definition, std::string);
2866  ROSE_DLL_API SgClassDeclaration *findOrImportJavaClass(SgProject *, std::string, std::string);
2867  ROSE_DLL_API SgClassDeclaration *findOrImportJavaClass(SgProject *, SgClassType *);
2868  ROSE_DLL_API SgMemberFunctionDeclaration *findJavaMain(SgClassDefinition *);
2869  ROSE_DLL_API SgMemberFunctionDeclaration *findJavaMain(SgClassType *);
2870 #endif // ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
2871 
2872 
2873 
2874 // DQ (8/31/2016): Making this a template function so that we can have it work with user defined filters.
2876 
2882 template < class T >
2884  {
2885  // DQ (9/1/2016): This function is called in the Call graph generation to avoid filtering out EDG normalized
2886  // function template instnatiations (which come from normalized template functions and member functions).
2887  // Note that because of the EDG normailzation the membr function is moved outside of the class, and
2888  // thus marked as compiler generated. However the template instantiations are always marked as compiler
2889  // generated (if not specializations) and so we want to include a template instantiation that is marked
2890  // as compiler generated, but is from a template declaration that satisfyied a specific user defined filter.
2891  // The complexity of this detection is isolated here, but knowing that it must be called is more complex.
2892  // This function is call in the CG.C file of tests/nonsmoke/functional/roseTests/programAnalysisTests/testCallGraphAnalysis.
2893 
2894  bool retval = false;
2895 
2896 #define DEBUG_TEMPLATE_NORMALIZATION_DETECTION 0
2897 
2898 #if DEBUG_TEMPLATE_NORMALIZATION_DETECTION
2899  printf ("In isNormalizedTemplateInstantiation(): function = %p = %s = %s \n",function,function->class_name().c_str(),function->get_name().str());
2900 #endif
2901 
2902  // Test for this to be a template instantation (in which case it was marked as
2903  // compiler generated but we may want to allow it to be used in the call graph,
2904  // if it's template was a part was defined in the current directory).
2905  SgTemplateInstantiationFunctionDecl* templateInstantiationFunction = isSgTemplateInstantiationFunctionDecl(function);
2906  SgTemplateInstantiationMemberFunctionDecl* templateInstantiationMemberFunction = isSgTemplateInstantiationMemberFunctionDecl(function);
2907 
2908  if (templateInstantiationFunction != NULL)
2909  {
2910  // When the defining function has been normalized by EDG, only the non-defining declaration will have a source position.
2911  templateInstantiationFunction = isSgTemplateInstantiationFunctionDecl(templateInstantiationFunction->get_firstNondefiningDeclaration());
2912  SgTemplateFunctionDeclaration* templateFunctionDeclaration = templateInstantiationFunction->get_templateDeclaration();
2913  if (templateFunctionDeclaration != NULL)
2914  {
2915  retval = filter->operator()(templateFunctionDeclaration);
2916  }
2917  else
2918  {
2919  // Assume false.
2920  }
2921 
2922 #if DEBUG_TEMPLATE_NORMALIZATION_DETECTION
2923  printf (" --- case of templateInstantiationFunction: retval = %s \n",retval ? "true" : "false");
2924 #endif
2925  }
2926  else
2927  {
2928  if (templateInstantiationMemberFunction != NULL)
2929  {
2930  // When the defining function has been normalized by EDG, only the non-defining declaration will have a source position.
2931  templateInstantiationMemberFunction = isSgTemplateInstantiationMemberFunctionDecl(templateInstantiationMemberFunction->get_firstNondefiningDeclaration());
2932  SgTemplateMemberFunctionDeclaration* templateMemberFunctionDeclaration = templateInstantiationMemberFunction->get_templateDeclaration();
2933  if (templateMemberFunctionDeclaration != NULL)
2934  {
2935  retval = filter->operator()(templateMemberFunctionDeclaration);
2936  }
2937  else
2938  {
2939  // Assume false.
2940  }
2941 
2942 #if DEBUG_TEMPLATE_NORMALIZATION_DETECTION
2943  printf (" --- case of templateInstantiationMemberFunction: retval = %s \n",retval ? "true" : "false");
2944 #endif
2945  }
2946  }
2947 
2948  return retval;
2949  }
2950 
2951 void detectCycleInType(SgType * type, const std::string & from);
2952 
2953 // DQ (7/14/2020): Debugging support.
2954 void checkForInitializers( SgNode* node );
2955 
2956 }// end of namespace
2957 
2958 
2959 
2960 #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.
bool ROSE_DLL_API isMutable(SgInitializedName *name)
True if an SgInitializedName is "mutable' (has storage modifier set)
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)
Recursively print current and parent nodes. used within gdb to probe the context of a node...
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...
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.
virtual std::string class_name() const override
returns a string representing the class name
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...
void markNodeToBeUnparsed(SgNode *node, int physical_file_id)
Recursively print current and parent nodes. used within gdb to probe the context of a node...
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...
void printAST2TextFile(SgNode *node, const char *filename, bool printType=true)
Pretty print AST horizontally, output to a specified text file. If printType is set to false...
ROSE_DLL_API bool templateDefinitionIsInClass(SgTemplateInstantiationMemberFunctionDecl *memberFunctionDeclaration)
Return true if template definition is in the class, false if outside of class.
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...
void printAST(SgNode *node)
Pretty print AST horizontally, output to std output.
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.
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)
ROSE_DLL_API void removeUnusedLabels(SgNode *top, bool keepChild=false)
Remove labels which are not targets of any goto statements: its child statement is also removed by de...
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.
ROSE_DLL_API bool is_mixed_Fortran_and_Cxx_language()
Interface for creating a statement whose computation writes its answer into a given variable...
ROSE_DLL_API DeferredTransformation & operator=(const DeferredTransformation &X)
Shallow; does not delete fields.
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...
void checkSymbolTables(SgNode *)
Recursively print current and parent nodes. used within gdb to probe the context of a node...
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...
std::vector< SgBreakStmt * > findBreakStmts(SgStatement *code, const std::string &fortranLabel="")
Find break statements inside a particular statement, stopping at nested loops or switches.
AncestorNode * ancestor(SgNode *n)
finds an ancestor node with a given type
Definition: sageGeneric.h:1277
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.
bool ROSE_DLL_API isJovialOutParam(SgInitializedName *name)
True if a parameter name is a Jovial output parameter.
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.
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). Typedef and modifier types are not ...
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 SgSymbol * lookupSymbolInParentScopesIgnoringAliasSymbols(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 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)
Check if a bool or int constant expression evaluates to be a true value.
SgDeclarationStatement * getNonInstantiatonDeclarationForClass(SgTemplateInstantiationMemberFunctionDecl *memberFunctionInstantiation)
Recursively print current and parent nodes. used within gdb to probe the context of a node...
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.
ROSE_DLL_API ~DeferredTransformation(void)
Copy constructor.
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).
ROSE_DLL_API SgMemberFunctionDeclaration * getDefaultDestructor(SgClassDeclaration *classDeclaration)
Get the default destructor from the class declaration.
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.
SgBasicBlock * makeSingleStatementBodyToBlock(SgStatement *singleStmt)
Make a single statement body to be a basic block. Its parent is if, while, catch, or upc_forall etc...
SgType * getDeclaredType(const SgDeclarationStatement *declaration)
Returns the type introduced by a declaration.
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 PreprocessingInfo * findHeader(SgSourceFile *source_file, const std::string &header_file_name, bool isSystemHeader)
Find the preprocessingInfo node representing #include or #include "header.h" within a source file. Return NULL if not found.
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:9368
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
Base class for all IR node attribute values.
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...
void checkAccessPermissions(SgNode *)
Recursively print current and parent nodes. used within gdb to probe the context of a node...
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)
Recursively print current and parent nodes. used within gdb to probe the context of a node...
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 displayScope(SgScopeStatement *scope)
Find a node by type using upward traversal.
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
static ROSE_DLL_API DeferredTransformation replaceDefiningFunctionDeclarationWithFunctionPrototype(SgFunctionDeclaration *functionDeclaration)
operator=()
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)
Check if a bool or int constant expression evaluates to be a false value.
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()
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 bool hasSameGlobalScope(SgStatement *statement_1, SgStatement *statement_2)
This is supporting the recognition of functions in header files from two different ASTs...
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 SgTemplateInstantiationMemberFunctionDecl * buildForwardFunctionDeclaration(SgTemplateInstantiationMemberFunctionDecl *memberFunctionInstantiation)
Generate a non-defining (forward) declaration from a defining function declaration.
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:9627
This class represents the concept of a catch within a try-catch construct used in C++ exception handl...
void markSubtreeToBeUnparsed(SgNode *root, int physical_file_id)
Recursively print current and parent nodes. used within gdb to probe the context of a node...
This class represents the notion of an value (expression value).
std::vector< SgInitializedName * > getInParameters(const SgInitializedNamePtrList &params)
Get a vector of Jovial input parameters from the function parameter list (may work for Fortran in the...
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()). ...
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 bool isStructDeclaration(SgNode *node)
Check if a SgNode is a declaration for a structure.
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 isUnionDeclaration(SgNode *node)
Check if a SgNode is a declaration for a union.
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)
Recursively print current and parent nodes. used within gdb to probe the context of a node...
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...
void recursivePrintCurrentAndParent(SgNode *n)
Recursively print current and parent nodes. used within gdb to probe the context of a node...
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 bool isLambdaCapturedVariable(SgVarRefExp *varRef)
check if a variable reference is this->a[i] inside of a lambda function
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 std::set< SgLabelStatement * > findUnusedLabels(SgNode *top)
Find unused labels which are not targets of any goto statements.
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...
std::vector< SgInitializedName * > getOutParameters(const SgInitializedNamePtrList &params)
Get a vector of Jovial output parameters from the function parameter list (may work for Fortran in th...
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...
ROSE_DLL_API SgFunctionDeclaration * buildFunctionPrototype(SgFunctionDeclaration *functionDeclaration)
Function to delete AST subtree's nodes only, users must take care of any dangling pointers...
Base class for values.
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.
ROSE_DLL_API SgFunctionType * findFunctionType(SgType *return_type, SgFunctionParameterTypeList *typeList)
Find the function type matching a function signature plus a given return type.
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.
bool IsClass(const SgType *const inputType)
strip off typedef and modifer types, then check if a type is a class type, excluding union type...
ROSE_DLL_API SgFunctionDeclaration * replaceDefiningFunctionDeclarationWithFunctionPrototype(SgFunctionDeclaration *functionDeclaration)
Function to delete AST subtree's nodes only, users must take care of any dangling pointers...
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)
Recursively print current and parent nodes. used within gdb to probe the context of a node...
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 addDefaultConstructorIfRequired(SgClassType *classType, int physical_file_id=Sg_File_Info::TRANSFORMATION_FILE_ID)
Get the default destructor from the class declaration.
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 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...
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...
ROSE_DLL_API bool isLambdaFunction(SgFunctionDeclaration *func)
Check if a function declaration is a C++11 lambda function.
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...
ROSE_DLL_API bool insideHeader(SgLocatedNode *node)
Check if a node is from a header file.
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)
Recursively print current and parent nodes. used within gdb to probe the context of a node...
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.
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...