ROSE  0.9.10.25
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 // tps : 28 Oct 2008 - support for finding the main interpretation
110  SgAsmInterpretation* getMainInterpretation(SgAsmGenericFile* file);
111 
114 
117 
119  void addMessageStatement( SgStatement* stmt, std::string message );
120 
122  class UniqueNameAttribute : public AstAttribute
123  {
124  private:
125  std::string name;
126  public:
127  UniqueNameAttribute(std::string n="") {name =n; };
128  void set_name (std::string n) {name = n;};
129  std::string get_name () {return name;};
130  };
131 
132 // DQ (3/2/2009): Added support for collectiong an merging the referenced symbols in the outlined
133 // function into the list used to edit the outlined code subtree to fixup references (from symbols
134 // in the original file to the symbols in the newer separate file).
135 // typedef rose_hash::unordered_map<SgNode*, SgNode*, hash_nodeptr> ReplacementMapType;
136 // void supplementReplacementSymbolMap ( const ReplacementMapTraversal::ReplacementMapType & inputReplacementMap );
137 
138 // CH (4/9/2010): Use boost::hash instead
139 //#ifdef _MSC_VER
140 #if 0
141 inline size_t hash_value(SgNode* t) {return (size_t)t;}
142 #endif
143 
144 #if 0
145 // DQ (8/3/2015): We expect that this is not used and is generating a warnings so we
146 // can best fix it by removing it.
147 struct hash_nodeptr
148  {
149 // CH (4/9/2010): Use boost::hash instead
150 //#ifndef _MSC_VER
151 #if 0
152  //rose_hash::hash<char*> hasher;
153 #endif
154  public:
155  size_t operator()(SgNode* node) const
156  {
157 // CH (4/9/2010): Use boost::hash instead
158 //#ifdef _MSC_VER
159  #if 0
160  return (size_t) hash_value(node);
161  #else
162  return (size_t) node;
163  #endif
164  }
165  };
166 
167 #ifndef SWIG
168 // DQ (3/10/2013): This appears to be a problem for the SWIG interface (undefined reference at link-time).
169  void supplementReplacementSymbolMap ( rose_hash::unordered_map<SgNode*, SgNode*, hash_nodeptr> & inputReplacementMap );
170 #endif
171 #endif
172 
173  //------------------------------------------------------------------------
175 
178  // Liao 1/22/2008, used for get symbols for generating variable reference nodes
179  // ! Find a variable symbol in current and ancestor scopes for a given name
180  ROSE_DLL_API SgVariableSymbol *lookupVariableSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope=NULL);
181 
182 // DQ (8/21/2013): Modified to make newest function parameters be default arguments.
183 // 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.
185 // SgSymbol *lookupSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope=NULL);
186 // SgSymbol *lookupSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList);
187  ROSE_DLL_API SgSymbol *lookupSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
188 
189  // DQ (11/24/2007): Functions moved from the Fortran support so that they could be called from within astPostProcessing.
191  ROSE_DLL_API SgFunctionSymbol *lookupFunctionSymbolInParentScopes (const SgName & functionName, SgScopeStatement *currentScope=NULL);
192 
193  // Liao, 1/24/2008, find exact match for a function
195  ROSE_DLL_API SgFunctionSymbol *lookupFunctionSymbolInParentScopes (const SgName & functionName,
196  const SgType* t,
197  SgScopeStatement *currentScope=NULL);
198 
199 // DQ (8/21/2013): Modified to make newest function parameters be default arguments.
200 // 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.
201 // DQ (5/7/2011): Added support for SgClassSymbol (used in name qualification support).
202 // SgClassSymbol* lookupClassSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
203  ROSE_DLL_API SgClassSymbol* lookupClassSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
204  ROSE_DLL_API SgTypedefSymbol* lookupTypedefSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
205 
206 #if 0
207  // DQ (8/13/2013): This function does not make since any more, now that we have made the symbol
208  // table handling more precise and we have to provide template parameters for any template lookup.
209  // We also have to know if we want to lookup template classes, template functions, or template
210  // member functions (since each have specific requirements).
211  SgTemplateSymbol* lookupTemplateSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
212 #endif
213 #if 0
214 // DQ (8/13/2013): I am not sure if we want this functions in place of lookupTemplateSymbolInParentScopes.
215 // Where these are called we might not know enough information about the template parameters or function
216 // types, for example.
217  SgTemplateClassSymbol* lookupTemplateClassSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
218  SgTemplateFunctionSymbol* lookupTemplateFunctionSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
219  SgTemplateMemberFunctionSymbol* lookupTemplateMemberFunctionSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
220 #endif
221 
222 // DQ (8/21/2013): Modified to make some of the newest function parameters be default arguments.
223 // DQ (8/13/2013): I am not sure if we want this functions in place of lookupTemplateSymbolInParentScopes.
224  ROSE_DLL_API SgTemplateClassSymbol* lookupTemplateClassSymbolInParentScopes (const SgName & name, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList, SgScopeStatement *cscope = NULL);
225 
226  ROSE_DLL_API SgEnumSymbol* lookupEnumSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
227  ROSE_DLL_API SgNamespaceSymbol* lookupNamespaceSymbolInParentScopes(const SgName & name, SgScopeStatement *currentScope = NULL);
228 
229 // DQ (7/17/2011): Added function from cxx branch that I need here for the Java support.
230 // SgClassSymbol* lookupClassSymbolInParentScopes (const SgName & name, SgScopeStatement *cscope);
231 
240  // DQ (12/9/2004): Moved this function (by Alin Jula) from being a member of SgInitializedName
241  // to this location where it can be a part of the interface for the Sage III AST.
242  ROSE_DLL_API int set_name (SgInitializedName * initializedNameNode, SgName new_name);
243 
247 
248  // DQ (6/27/2005):
253  ROSE_DLL_API void outputLocalSymbolTables (SgNode * node);
254 
256  {
257  public:
258  void visit (SgNode * node);
259  };
265  // DQ (9/28/2005):
266  void rebuildSymbolTable (SgScopeStatement * scope);
267 
270  void clearUnusedVariableSymbols (SgNode* root = NULL);
271 
272  // DQ (3/1/2009):
274  void fixupReferencesToSymbols( const SgScopeStatement* this_scope, SgScopeStatement* copy_scope, SgCopyHelp & help );
275 
277 
278  //------------------------------------------------------------------------
280 
287  // DQ (9/21/2005): General function for extracting the name of declarations (when they have names)
288  std::string get_name (const SgNode * node);
289 
294  // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
295  std::string get_name (const SgStatement * stmt);
296 
301  std::string get_name (const SgExpression * expr);
302 
307  // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
308  std::string get_name (const SgDeclarationStatement * declaration);
309 
314  // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
315  std::string get_name (const SgScopeStatement * scope);
316 
321  // DQ (2/11/2007): Added this function to make debugging support more complete (useful for symbol table debugging support).
322  std::string get_name (const SgSymbol * symbol);
323 
328  std::string get_name (const SgType * type);
329 
330 
333  std::string get_name (const SgSupport * node);
334 
335 
338  std::string get_name (const SgLocatedNodeSupport * node);
339 
342  std::string get_name ( const SgC_PreprocessorDirectiveStatement* directive );
343 
346  std::string get_name ( const SgToken* token );
347 
348  // DQ (3/20/2016): Added to refactor some of the DSL infrastructure support.
358 
361  extern std::map<std::string,int> local_name_collision_map;
362  extern std::map<std::string,SgNode*> local_name_to_node_map;
363  extern std::map<SgNode*,std::string> local_node_to_name_map;
364 
368 
372 
374 
375  //------------------------------------------------------------------------
377 
382  // DQ (6/21/2005): Get the default destructor from the class declaration
384  classDeclaration);
385 
388  // DQ (6/22/2005): Get the default constructor from the class declaration
390  classDeclaration);
393  // DQ (8/27/2005):
395  * memberFunctionDeclaration);
396 
401  // DQ (9/17/2005):
404  (SgTemplateInstantiationMemberFunctionDecl * memberFunctionInstantiation);
405 
407  bool isStructDeclaration(SgNode * node);
409  bool isUnionDeclaration(SgNode * node);
410  #if 0
411  // DQ (8/28/2005): This is already a member function of the SgFunctionDeclaration
412  // (so that it can handle template functions and member functions)
413 
417  // DQ (8/27/2005):
418  bool isTemplateMemberFunction (SgTemplateInstantiationMemberFunctionDecl *
419  memberFunctionDeclaration);
420  #endif
421 
423 
424  //------------------------------------------------------------------------
426 
430  void saveToPDF(SgNode* node, std::string filename);
432  void saveToPDF(SgNode* node); // enable calling from gdb
433 
434  // DQ (2/12/2012): Added some diagnostic support.
436  void whereAmI(SgNode* node);
437 
439  std::string extractPragmaKeyword(const SgPragmaDeclaration *);
440 
442  ROSE_DLL_API bool isOmpStatement(SgNode* );
445  // DQ (8/27/2005):
446  bool isOverloaded (SgFunctionDeclaration * functionDeclaration);
447 
448 // DQ (2/14/2012): Added support function used for variable declarations in conditionals.
450  void initializeIfStmt(SgIfStmt *ifstmt, SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);
451 
453  void initializeSwitchStatement(SgSwitchStatement* switchStatement,SgStatement *item_selector,SgStatement *body);
454 
456  void initializeWhileStatement(SgWhileStmt* whileStatement, SgStatement * condition, SgStatement *body, SgStatement *else_body);
457 
460 
462  ROSE_DLL_API bool isMain (const SgNode* node);
463  // DQ (6/22/2005):
474  std::string generateUniqueName ( const SgNode * node, bool ignoreDifferenceBetweenDefiningAndNondefiningDeclarations);
475 
478  std::string generateUniqueVariableName(SgScopeStatement* scope, std::string baseName = "temp");
479 
480  // DQ (8/10/2010): Added const to first parameter.
481  // DQ (3/10/2007):
483  std::string declarationPositionString (const SgDeclarationStatement * declaration);
484 
485  // DQ (1/20/2007):
487  ROSE_DLL_API std::string generateProjectName (const SgProject * project, bool supressSuffix = false );
488 
492 
495 
497  void addVarRefExpFromArrayDimInfo(SgNode * astNode, Rose_STL_Container<SgNode *>& NodeList_t);
498 
499  // DQ (10/6/2006): Added support for faster mangled name generation (caching avoids recomputation).
503 #ifndef SWIG
504 // DQ (3/10/2013): This appears to be a problem for the SWIG interface (undefined reference at link-time).
505  void clearMangledNameCache (SgGlobal * globalScope);
506  void resetMangledNameCache (SgGlobal * globalScope);
507 #endif
508 
509  std::string getMangledNameFromCache (SgNode * astNode);
510  std::string addMangledNameToCache (SgNode * astNode, const std::string & mangledName);
511 
513 
517 
518  // DQ (10/14/2006): This function tests the AST to see if for a non-defining declaration, the
519  // bool declarationPreceedsDefinition ( SgClassDeclaration* classNonDefiningDeclaration, SgClassDeclaration* classDefiningDeclaration );
521  bool declarationPreceedsDefinition (SgDeclarationStatement *nonDefiningDeclaration, SgDeclarationStatement *definingDeclaration);
522 
523  // DQ (10/19/2006): Function calls have interesting context dependent rules to determine if
524  // they are output with a global qualifier or not. Were this is true we have to avoid global
525  // qualifiers, since the function's scope has not been defined. This is an example of where
526  // qualification of function names in function calls are context dependent; an interesting
527  // example of where the C++ language is not friendly to source-to-source processing :-).
529 
534  ROSE_DLL_API std::vector < SgNode * >astIntersection (SgNode * original, SgNode * copy, SgCopyHelp * help = NULL);
535 
537  ROSE_DLL_API SgNode* deepCopyNode (const SgNode* subtree);
538 
540  template <typename NodeType>
541  NodeType* deepCopy (const NodeType* subtree) {
542  return dynamic_cast<NodeType*>(deepCopyNode(subtree));
543  }
544 
546  ROSE_DLL_API SgExpression* copyExpression(SgExpression* e);
547 
549  ROSE_DLL_API SgStatement* copyStatement(SgStatement* s);
550 
551 // from VarSym.cc in src/midend/astOutlining/src/ASTtools
554 
557 
559 ROSE_DLL_API void myRemoveStatement(SgStatement* stmt);
560 
561 ROSE_DLL_API bool isConstantTrue(SgExpression* e);
562 ROSE_DLL_API bool isConstantFalse(SgExpression* e);
563 
565 ROSE_DLL_API bool isCallToParticularFunction(const std::string& qualifiedName, size_t arity, SgExpression* e);
566 
568 bool ROSE_DLL_API isStatic(SgDeclarationStatement* stmt);
569 
571 ROSE_DLL_API void setStatic(SgDeclarationStatement* stmt);
572 
574 ROSE_DLL_API bool isExtern(SgDeclarationStatement* stmt);
575 
577 ROSE_DLL_API void setExtern(SgDeclarationStatement* stmt);
578 
582  public:
583  virtual ~StatementGenerator() {};
584  virtual SgStatement* generate(SgExpression* where_to_write_answer) = 0;
585 };
586 
590  bool isAssignmentStatement(SgNode* _s, SgExpression** lhs=NULL, SgExpression** rhs=NULL, bool* readlhs=NULL);
591 
593 ROSE_DLL_API SgInitializedName* convertRefToInitializedName(SgNode* current, bool coarseGrain=true);
594 
597 
599 ROSE_DLL_API SgNode* getSgNodeFromAbstractHandleString(const std::string& input_string);
600 
602 ROSE_DLL_API void dumpInfo(SgNode* node, std::string desc="");
603 
605 ROSE_DLL_API std::vector<SgDeclarationStatement*>
606 sortSgNodeListBasedOnAppearanceOrderInSource(const std::vector<SgDeclarationStatement*>& nodevec);
607 
608 // DQ (4/13/2013): We need these to support the unparing of operators defined by operator syntax or member function names.
610 // bool isPrefixOperator( const SgMemberFunctionRefExp* memberFunctionRefExp );
611 bool isPrefixOperator( SgExpression* exp );
612 
614 bool isPrefixOperatorName( const SgName & functionName );
615 
617 bool isPostfixOperator( SgExpression* exp );
618 
620 bool isIndexOperator( SgExpression* exp );
621 
622 // DQ (1/10/2014): Adding more general support for token based unparsing.
624 SgStatement* lastStatementOfScopeWithTokenInfo (SgScopeStatement* scope, std::map<SgNode*,TokenStreamSequenceToNodeMapping*> & tokenStreamSequenceMap);
625 
627 
628 //------------------------------------------------------------------------
630 
634 // std::string version(); // utility_functions.h, version number
637  ROSE_DLL_API bool is_Ada_language ();
638  ROSE_DLL_API bool is_C_language ();
639  ROSE_DLL_API bool is_Cobol_language ();
640  ROSE_DLL_API bool is_OpenMP_language ();
641  ROSE_DLL_API bool is_UPC_language ();
643  ROSE_DLL_API bool is_UPC_dynamic_threads();
644  ROSE_DLL_API bool is_C99_language ();
645  ROSE_DLL_API bool is_Cxx_language ();
646  ROSE_DLL_API bool is_Java_language ();
647  ROSE_DLL_API bool is_Jovial_language ();
648  ROSE_DLL_API bool is_Fortran_language ();
649  ROSE_DLL_API bool is_CAF_language ();
650  ROSE_DLL_API bool is_PHP_language();
651  ROSE_DLL_API bool is_Python_language();
652  ROSE_DLL_API bool is_Cuda_language();
653  ROSE_DLL_API bool is_OpenCL_language();
654  ROSE_DLL_API bool is_X10_language();
655  ROSE_DLL_API bool is_binary_executable();
656  ROSE_DLL_API bool is_mixed_C_and_Cxx_language ();
657  ROSE_DLL_API bool is_mixed_Fortran_and_C_language ();
658  ROSE_DLL_API bool is_mixed_Fortran_and_Cxx_language ();
659  ROSE_DLL_API bool is_mixed_Fortran_and_C_and_Cxx_language ();
661 
662 //------------------------------------------------------------------------
664 
668  // DQ (10/5/2006): Added support for faster (non-quadratic) computation of unique
669  // labels for scopes in a function (as required for name mangling).
675  void resetScopeNumbers (SgFunctionDefinition * functionDeclaration);
676 
677  // DQ (10/5/2006): Added support for faster (non-quadratic) computation of unique
678  // labels for scopes in a function (as required for name mangling).
687  void clearScopeNumbers (SgFunctionDefinition * functionDefinition);
688 
689 
692 // SgNamespaceDefinitionStatement * getEnclosingNamespaceScope (SgNode * node);
693 
694  bool isPrototypeInScope (SgScopeStatement * scope,
695  SgFunctionDeclaration * functionDeclaration,
696  SgDeclarationStatement * startingAtDeclaration);
697 
699  bool ROSE_DLL_API isAncestor(SgNode* node1, SgNode* node2);
701 //------------------------------------------------------------------------
703 
707  void dumpPreprocInfo (SgLocatedNode* locatedNode);
709 
711 PreprocessingInfo * insertHeader(SgSourceFile * source_file, const std::string & header_file_name, bool isSystemHeader, bool asLastHeader);
712 
714 void insertHeader (SgStatement* stmt, PreprocessingInfo* newheader, bool asLastHeader);
715 
717 PreprocessingInfo * insertHeader(SgSourceFile * source_file, const std::string & header_file_name, bool isSystemHeader = false, PreprocessingInfo::RelativePositionType position = PreprocessingInfo::before);
718 
720 ROSE_DLL_API PreprocessingInfo* insertHeader(const std::string& filename, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::after, bool isSystemHeader=false, SgScopeStatement* scope=NULL);
721 
723 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);
724 
726 ROSE_DLL_API void movePreprocessingInfo (SgStatement* stmt_src, SgStatement* stmt_dst, PreprocessingInfo::RelativePositionType src_position=PreprocessingInfo::undef,
727  PreprocessingInfo::RelativePositionType dst_position=PreprocessingInfo::undef, bool usePrepend= false);
728 
729 
731 ROSE_DLL_API void cutPreprocessingInfo (SgLocatedNode* src_node, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType& save_buf);
732 
734 ROSE_DLL_API void pastePreprocessingInfo (SgLocatedNode* dst_node, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType& saved_buf);
735 
738  const std::string & text,
739  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before);
740 
744 
747  SgSourceFile * source_file,
748  const std::string & content,
749  PreprocessingInfo::DirectiveType directive_type = PreprocessingInfo::C_StyleComment,
750  PreprocessingInfo::RelativePositionType position = PreprocessingInfo::before
751 );
752 
754  ROSE_DLL_API PreprocessingInfo* attachComment(SgLocatedNode* target, const std::string & content,
755  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before,
756  PreprocessingInfo::DirectiveType dtype= PreprocessingInfo::CpreprocessorUnknownDeclaration);
757 
758 // DQ (11/25/2009): Added matching support for adding comments to SgAsm nodes.
759 // Build and attach comment
760 // void attachComment(SgAsmStatement* target, const std::string & content );
761 
762 // DQ (7/20/2008): I am not clear were I should put this function, candidates include: SgLocatedNode or SgInterface
764  ROSE_DLL_API void addTextForUnparser ( SgNode* astNode, std::string s, AstUnparseAttribute::RelativePositionType inputlocation );
765 
770 void guardNode(SgLocatedNode * target, std::string guard);
771 
773 
774 
775 //------------------------------------------------------------------------
777 
781 // ************************************************************************
782 // Newer versions of now depricated functions
783 // ************************************************************************
784 
785 // DQ (5/1/2012): This function queries the SageBuilder::SourcePositionClassification mode (stored in the SageBuilder
786 // interface) and used the specified mode to initialize the source position data (Sg_File_Info objects). This
787 // function is the only function that should be called directly (though in a namespace we can't define permissions).
789  ROSE_DLL_API void setSourcePosition(SgNode* node);
790 
791 // A better name might be "setSourcePositionForSubTree"
793  ROSE_DLL_API void setSourcePositionAtRootAndAllChildren(SgNode *root);
794 
797 
798 // DQ (5/1/2012): Newly renamed function (previous name preserved for backward compatability).
800 
801 // ************************************************************************
802 
803 
804 
805 // ************************************************************************
806 // Older deprecated functions
807 // ************************************************************************
808  // Liao, 1/8/2007, set file info. for a whole subtree as transformation generated
810  ROSE_DLL_API void setOneSourcePositionForTransformation(SgNode *node);
811 
813  ROSE_DLL_API void setOneSourcePositionNull(SgNode *node);
814 
816  ROSE_DLL_API void setSourcePositionForTransformation (SgNode * root);
817 
819 // ROSE_DLL_API void setSourcePositionForTransformation_memoryPool();
820 
822  ROSE_DLL_API bool insideSystemHeader (SgLocatedNode* node);
823 
825 // ROSE_DLL_API void setSourcePosition (SgLocatedNode * locatedNode);
826 // ************************************************************************
827 
829 
830 
831 //------------------------------------------------------------------------
833 
837 // from src/midend/astInlining/typeTraits.h
838 // src/midend/astUtil/astInterface/AstInterface.h
839 
842 
843 
847 ROSE_DLL_API bool isStrictIntegerType(SgType* t);
849 ROSE_DLL_API SgType* getFirstVarType(SgVariableDeclaration* decl);
850 
852 ROSE_DLL_API bool isDefaultConstructible(SgType* type);
853 
855 ROSE_DLL_API bool isCopyConstructible(SgType* type);
856 
858 ROSE_DLL_API bool isAssignable(SgType* type);
859 
860 #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
861 ROSE_DLL_API bool isPureVirtualClass(SgType* type, const ClassHierarchyWrapper& classHierarchy);
865 #endif
866 
868 ROSE_DLL_API bool hasTrivialDestructor(SgType* t);
869 
871 ROSE_DLL_API bool isNonconstReference(SgType* t);
872 
874 ROSE_DLL_API bool isReferenceType(SgType* t);
875 
877 ROSE_DLL_API bool isPointerType(SgType* t);
878 
884 ROSE_DLL_API bool isPointerToNonConstType(SgType* type);
885 
887 /* const char* p = "aa"; is not treated as having a const type. It is a pointer to const char.
888  * Similarly, neither for const int b[10]; or const int & c =10;
889  * The standard says, "A compound type is not cv-qualified by the cv-qualifiers (if any) of
890 the types from which it is compounded. Any cv-qualifiers applied to an array type affect the array element type, not the array type".
891  */
892 ROSE_DLL_API bool isConstType(SgType* t);
893 
896 
898 ROSE_DLL_API bool isVolatileType(SgType* t);
899 
901 ROSE_DLL_API bool isRestrictType(SgType* t);
902 
904 
906 ROSE_DLL_API bool isScalarType(SgType* t);
907 
911 ROSE_DLL_API bool isStrictIntegerType(SgType* t);
912 
914 ROSE_DLL_API bool isStructType(SgType* t);
915 
917 ROSE_DLL_API std::string mangleType(SgType* type);
918 
920 ROSE_DLL_API std::string mangleScalarType(SgType* type);
921 
923 ROSE_DLL_API std::string mangleModifierType(SgModifierType* type);
924 
926 ROSE_DLL_API size_t getArrayElementCount(SgArrayType* t);
927 
929 ROSE_DLL_API int getDimensionCount(SgType* t);
930 
932 ROSE_DLL_API SgType* getArrayElementType(SgType* t);
933 
935 ROSE_DLL_API SgType* getElementType(SgType* t);
936 
937 
954 std::vector<SgExpression*>
955 get_C_array_dimensions(const SgArrayType& arrtype);
956 
977 std::vector<SgExpression*>
978 get_C_array_dimensions(const SgArrayType& arrtype, const SgVarRefExp& varref);
979 
983 std::vector<SgExpression*>
984 get_C_array_dimensions(const SgArrayType& arrtype, SgInitializedName& initname);
985 
986 
988 ROSE_DLL_API bool isArrayReference(SgExpression* ref, SgExpression** arrayNameExp=NULL, std::vector<SgExpression*>** subscripts=NULL);
989 
990 
992 ROSE_DLL_API int collectVariableReferencesInArrayTypes (SgLocatedNode* root, Rose_STL_Container<SgNode*> & currentVarRefList);
994 
1003 ROSE_DLL_API bool hasUpcSharedType(SgType* t, SgModifierType ** mod_type_out = NULL );
1004 
1006 
1009 ROSE_DLL_API bool isUpcSharedType(SgType* t, SgModifierType ** mod_type_out = NULL);
1010 
1012 ROSE_DLL_API bool isUpcSharedModifierType (SgModifierType* mod_type);
1013 
1015 ROSE_DLL_API bool isUpcSharedArrayType (SgArrayType* array_type);
1016 
1018 ROSE_DLL_API bool isUpcStrictSharedModifierType(SgModifierType* mode_type);
1019 
1021 ROSE_DLL_API size_t getUpcSharedBlockSize(SgModifierType* mod_type);
1022 
1024 ROSE_DLL_API size_t getUpcSharedBlockSize(SgType* t);
1025 
1027 ROSE_DLL_API bool isUpcPhaseLessSharedType (SgType* t);
1028 
1030 ROSE_DLL_API bool isUpcPrivateToSharedType(SgType* t);
1031 
1033 ROSE_DLL_API bool isUpcArrayWithThreads(SgArrayType* t);
1034 
1036 ROSE_DLL_API SgType* lookupNamedTypeInParentScopes(const std::string& type_name, SgScopeStatement* scope=NULL);
1037 
1038 // DQ (7/22/2014): Added support for comparing expression types in actual arguments with those expected from the formal function parameter types.
1040 ROSE_DLL_API SgType* getAssociatedTypeFromFunctionTypeList(SgExpression* actual_argument_expression);
1041 
1043 ROSE_DLL_API bool templateArgumentEquivalence(SgTemplateArgument * arg1, SgTemplateArgument * arg2);
1044 
1046 ROSE_DLL_API bool templateArgumentListEquivalence(const SgTemplateArgumentPtrList & list1, const SgTemplateArgumentPtrList & list2);
1047 
1049 ROSE_DLL_API bool isEquivalentType (const SgType* lhs, const SgType* rhs);
1050 
1051 
1054 ROSE_DLL_API bool isEquivalentFunctionType (const SgFunctionType* lhs, const SgFunctionType* rhs);
1055 
1057 
1058 //------------------------------------------------------------------------
1060 
1064 // by Jeremiah
1073 ROSE_DLL_API void addStepToLoopBody(SgScopeStatement* loopStmt, SgStatement* step);
1074 
1076 ROSE_DLL_API void convertForToWhile(SgForStatement* f);
1077 ROSE_DLL_API void convertAllForsToWhiles(SgNode* top);
1079 ROSE_DLL_API void changeContinuesToGotos(SgStatement* stmt, SgLabelStatement* label);
1080 
1082 ROSE_DLL_API SgInitializedName* getLoopIndexVariable(SgNode* loop);
1083 
1086 ROSE_DLL_API bool isLoopIndexVariable(SgInitializedName* ivar, SgNode* subtree_root);
1087 
1089 
1093 ROSE_DLL_API bool hasMultipleInitStatmentsOrExpressions (SgForStatement* for_loop);
1094 
1096 ROSE_DLL_API SgStatement* getLoopBody(SgScopeStatement* loop);
1097 
1098 ROSE_DLL_API void setLoopBody(SgScopeStatement* loop, SgStatement* body);
1099 
1101 ROSE_DLL_API SgStatement* getLoopCondition(SgScopeStatement* loop);
1102 
1104 ROSE_DLL_API void setLoopCondition(SgScopeStatement* loop, SgStatement* cond);
1105 
1109 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);
1110 
1112 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*/);
1113 
1115 ROSE_DLL_API void setLoopLowerBound(SgNode* loop, SgExpression* lb);
1116 
1118 ROSE_DLL_API void setLoopUpperBound(SgNode* loop, SgExpression* ub);
1119 
1121 ROSE_DLL_API void setLoopStride(SgNode* loop, SgExpression* stride);
1122 
1123 
1125 ROSE_DLL_API bool normalizeForLoopInitDeclaration(SgForStatement* loop);
1126 
1128 ROSE_DLL_API bool unnormalizeForLoopInitDeclaration(SgForStatement* loop);
1129 
1141 ROSE_DLL_API bool forLoopNormalization(SgForStatement* loop, bool foldConstant = true);
1142 
1146 ROSE_DLL_API bool normalizeForLoopTest(SgForStatement* loop);
1147 ROSE_DLL_API bool normalizeForLoopIncrement(SgForStatement* loop);
1148 
1150 ROSE_DLL_API bool doLoopNormalization(SgFortranDo* loop);
1151 
1153 ROSE_DLL_API bool loopUnrolling(SgForStatement* loop, size_t unrolling_factor);
1154 
1156 ROSE_DLL_API bool loopInterchange(SgForStatement* loop, size_t depth, size_t lexicoOrder);
1157 
1159 ROSE_DLL_API bool loopTiling(SgForStatement* loopNest, size_t targetLevel, size_t tileSize);
1160 
1161 //Winnie Loop Collapsing
1162 SgExprListExp * loopCollapsing(SgForStatement* target_loop, size_t collapsing_factor);
1163 
1165  SgForStatement * for_loop,
1166  SgVariableSymbol * & iterator,
1167  SgExpression * & lower_bound,
1168  SgExpression * & upper_bound,
1169  SgExpression * & stride
1170 );
1171 
1173 
1174 //------------------------------------------------------------------------
1176 
1180 template <typename NodeType>
1182 std::vector<NodeType*> querySubTree(SgNode* top, VariantT variant = (VariantT)NodeType::static_variant)
1183  {
1184 #if 0
1185  printf ("Top of SageInterface::querySubTree() \n");
1186 #endif
1187 
1188  Rose_STL_Container<SgNode*> nodes = NodeQuery::querySubTree(top,variant);
1189  std::vector<NodeType*> result(nodes.size(), NULL);
1190  int count = 0;
1191 #if 0
1192  printf ("In SageInterface::querySubTree(): before initialization loop \n");
1193 #endif
1194 
1195  for (Rose_STL_Container<SgNode*>::const_iterator i = nodes.begin(); i != nodes.end(); ++i, ++count)
1196  {
1197 #if 0
1198  printf ("In SageInterface::querySubTree(): in loop: count = %d \n",count);
1199 #endif
1200  NodeType* node = dynamic_cast<NodeType*>(*i);
1201  ROSE_ASSERT (node);
1202  result[count] = node;
1203  }
1204 #if 0
1205  printf ("Leaving SageInterface::querySubTree(): after initialization loop \n");
1206 #endif
1207 
1208  return result;
1209  }
1214  std::vector < SgFile * >generateFileList ();
1215 
1220 ROSE_DLL_API SgProject * getProject();
1221 
1223  SgProject * getProject(const SgNode * node);
1224 
1226 template <typename NodeType>
1227 static std::vector<NodeType*> getSgNodeListFromMemoryPool()
1228 {
1229  // This function uses a memory pool traversal specific to the SgFile IR nodes
1230  class MyTraversal : public ROSE_VisitTraversal
1231  {
1232  public:
1233  std::vector<NodeType*> resultlist;
1234  void visit ( SgNode* node)
1235  {
1236  NodeType* result = dynamic_cast<NodeType* > (node);
1237  ROSE_ASSERT(result!= NULL);
1238  if (result!= NULL)
1239  {
1240  resultlist.push_back(result);
1241  }
1242  };
1243  virtual ~MyTraversal() {}
1244  };
1245 
1246  MyTraversal my_traversal;
1247  NodeType::traverseMemoryPoolNodes(my_traversal);
1248  return my_traversal.resultlist;
1249 }
1250 
1251 
1254 ROSE_DLL_API SgFunctionDeclaration* findMain(SgNode* currentNode);
1255 
1257 SgStatement* findLastDeclarationStatement(SgScopeStatement * scope, bool includePragma = false);
1258 
1259  //midend/programTransformation/partialRedundancyElimination/pre.h
1261 std::vector<SgVariableSymbol*> getSymbolsUsedInExpression(SgExpression* expr);
1262 
1264 
1269 std::vector<SgBreakStmt*> findBreakStmts(SgStatement* code, const std::string& fortranLabel = "");
1270 
1272 
1277 std::vector<SgContinueStmt*> findContinueStmts(SgStatement* code, const std::string& fortranLabel = "");
1278 std::vector<SgGotoStatement*> findGotoStmts(SgStatement* scope, SgLabelStatement* l);
1279 std::vector<SgStatement*> getSwitchCases(SgSwitchStatement* sw);
1280 
1282 void collectVarRefs(SgLocatedNode* root, std::vector<SgVarRefExp* >& result);
1283 
1285 template <typename T>
1286 T* findDeclarationStatement(SgNode* root, std::string name, SgScopeStatement* scope, bool isDefining)
1287  {
1288  bool found = false;
1289 
1290 #if 0
1291  printf ("In findDeclarationStatement(): root = %p \n",root);
1292  printf ("In findDeclarationStatement(): name = %s \n",name.c_str());
1293  printf ("In findDeclarationStatement(): scope = %p \n",scope);
1294  printf ("In findDeclarationStatement(): isDefining = %s \n",isDefining ? "true" : "false");
1295 #endif
1296 
1297  // Do we really want a NULL pointer to be acceptable input to this function?
1298  // Maybe we should have an assertion that it is non-null?
1299  if (!root) return NULL;
1300 
1301  T* decl = dynamic_cast<T*>(root);
1302 
1303 #if 0
1304  printf ("In findDeclarationStatement(): decl = %p \n",decl);
1305 #endif
1306 
1307  if (decl != NULL)
1308  {
1309  if (scope)
1310  {
1311  if ((decl->get_scope() == scope) && (decl->search_for_symbol_from_symbol_table()->get_name() == name))
1312  {
1313  found = true;
1314  }
1315  }
1316  else // Liao 2/9/2010. We should allow NULL scope
1317  {
1318 #if 0
1319  // DQ (12/6/2016): Include this into the debugging code to aboid compiler warning about unused variable.
1320  SgSymbol* symbol = decl->search_for_symbol_from_symbol_table();
1321  printf ("In findDeclarationStatement(): decl->search_for_symbol_from_symbol_table() = %p \n",symbol);
1322  printf ("In findDeclarationStatement(): decl->search_for_symbol_from_symbol_table()->get_name() = %s \n",symbol->get_name().str());
1323 #endif
1324  if (decl->search_for_symbol_from_symbol_table()->get_name() == name)
1325  {
1326  found = true;
1327  }
1328  }
1329  }
1330 
1331  if (found)
1332  {
1333  if (isDefining)
1334  {
1335 #if 0
1336  printf ("In findDeclarationStatement(): decl->get_firstNondefiningDeclaration() = %p \n",decl->get_firstNondefiningDeclaration());
1337  printf ("In findDeclarationStatement(): decl->get_definingDeclaration() = %p \n",decl->get_definingDeclaration());
1338 #endif
1339  ROSE_ASSERT (decl->get_definingDeclaration() != NULL);
1340 #if 0
1341  printf ("In findDeclarationStatement(): returing decl->get_definingDeclaration() = %p \n",decl->get_definingDeclaration());
1342 #endif
1343  return dynamic_cast<T*> (decl->get_definingDeclaration());
1344  }
1345  else
1346  {
1347 #if 0
1348  printf ("In findDeclarationStatement(): returing decl = %p \n",decl);
1349 #endif
1350  return decl;
1351  }
1352  }
1353 
1354  std::vector<SgNode*> children = root->get_traversalSuccessorContainer();
1355 
1356 #if 0
1357  printf ("In findDeclarationStatement(): children.size() = %zu \n",children.size());
1358 #endif
1359 
1360  // DQ (4/10/2016): Note that if we are searching for a function member that has it's defining
1361  // declaration defined outside of the class then it will not be found in the child list.
1362  for (std::vector<SgNode*>::const_iterator i = children.begin(); i != children.end(); ++i)
1363  {
1364  T* target = findDeclarationStatement<T> (*i,name,scope,isDefining);
1365 
1366  if (target)
1367  {
1368  return target;
1369  }
1370  }
1371 
1372  return NULL;
1373  }
1375  SgFunctionDeclaration* findFunctionDeclaration(SgNode* root, std::string name, SgScopeStatement* scope, bool isDefining);
1376 
1377 #if 0 //TODO
1378  // 1. preorder traversal from current SgNode till find next SgNode of type V_SgXXX
1379  // until reach the end node
1380  SgNode* getNextSgNode( const SgNode* astSourceNode, VariantT=V_SgNode, SgNode* astEndNode=NULL);
1381 
1382  // 2. return all nodes of type VariantT following the source node
1383  std::vector<SgNode*> getAllNextSgNode( const SgNode* astSourceNode, VariantT=V_SgNode, SgNode* astEndNode=NULL);
1384 #endif
1385 
1387 
1388 //------------------------------------------------------------------------
1390 
1393 // remember to put const to all arguments.
1394 
1395 
1410 template <typename NodeType>
1411 NodeType* getEnclosingNode(const SgNode* astNode, const bool includingSelf = false)
1412  {
1413 #if 1
1414  // DQ (10/20/2012): This is the older version of this implementation. Until I am sure that
1415  // the newer version (below) is what we want to use I will resolve this conflict by keeping
1416  // the previous version in place.
1417 
1418  if (NULL == astNode)
1419  {
1420  return NULL;
1421  }
1422 
1423  if ( (includingSelf ) && (dynamic_cast<const NodeType*>(astNode)) )
1424  {
1425  return const_cast<NodeType*>(dynamic_cast<const NodeType*> (astNode));
1426  }
1427 
1428  // DQ (3/5/2012): Check for reference to self...
1429  ROSE_ASSERT(astNode->get_parent() != astNode);
1430 
1431  SgNode* parent = astNode->get_parent();
1432 
1433  // DQ (3/5/2012): Check for loops that will cause infinite loops.
1434  SgNode* previouslySeenParent = parent;
1435  bool foundCycle = false;
1436  while ( (foundCycle == false) && (parent != NULL) && (!dynamic_cast<const NodeType*>(parent)) )
1437  {
1438  ROSE_ASSERT(parent->get_parent() != parent);
1439 #if 0
1440  printf ("In getEnclosingNode(): parent = %p = %s \n",parent,parent->class_name().c_str());
1441 #endif
1442  parent = parent->get_parent();
1443 
1444  // DQ (3/5/2012): Check for loops that will cause infinite loops.
1445  // ROSE_ASSERT(parent != previouslySeenParent);
1446  if (parent == previouslySeenParent)
1447  {
1448  foundCycle = true;
1449  }
1450  }
1451 
1452 #if 0
1453  printf ("previouslySeenParent = %p = %s \n",previouslySeenParent,previouslySeenParent->class_name().c_str());
1454 #endif
1455 
1456  parent = previouslySeenParent;
1457 
1458  SgDeclarationStatement* declarationStatement = isSgDeclarationStatement(parent);
1459  if (declarationStatement != NULL)
1460  {
1461 #if 0
1462  printf ("Found a SgDeclarationStatement \n");
1463 #endif
1464  SgDeclarationStatement* definingDeclaration = declarationStatement->get_definingDeclaration();
1465  SgDeclarationStatement* firstNondefiningDeclaration = declarationStatement->get_firstNondefiningDeclaration();
1466 
1467 #if 0
1468  printf (" --- declarationStatement = %p \n",declarationStatement);
1469  printf (" --- definingDeclaration = %p \n",definingDeclaration);
1470  if (definingDeclaration != NULL && definingDeclaration->get_parent() != NULL)
1471  printf (" --- definingDeclaration ->get_parent() = %p = %s \n",definingDeclaration->get_parent(),definingDeclaration->get_parent()->class_name().c_str());
1472  printf (" --- firstNondefiningDeclaration = %p \n",firstNondefiningDeclaration);
1473  if (firstNondefiningDeclaration != NULL && firstNondefiningDeclaration->get_parent() != NULL)
1474  printf (" --- firstNondefiningDeclaration ->get_parent() = %p = %s \n",firstNondefiningDeclaration->get_parent(),firstNondefiningDeclaration->get_parent()->class_name().c_str());
1475 #endif
1476  if (definingDeclaration != NULL && declarationStatement != firstNondefiningDeclaration)
1477  {
1478 #if 0
1479  printf ("Found a nondefining declaration so use the non-defining declaration instead \n");
1480 #endif
1481  // DQ (10/19/2012): Use the defining declaration instead.
1482  // parent = firstNondefiningDeclaration;
1483  parent = definingDeclaration;
1484  }
1485  }
1486 
1487 #if 0
1488  printf ("reset: previouslySeenParent = %p = %s \n",previouslySeenParent,previouslySeenParent->class_name().c_str());
1489 #endif
1490 
1491  // DQ (10/19/2012): This branch is just to document the cycle that was previously detected, it is for
1492  // debugging only. Thus it ony make sense for it to be executed when "(foundCycle == true)". However,
1493  // this will have to be revisited later since it appears clear that it is a problem for the binary analysis
1494  // work when it is visited for this case. Since the cycle is detected, but there is no assertion on the
1495  // cycle, we don't exit when a cycle is identified (which is the point of the code below).
1496  // Note also that I have fixed the code (above and below) to only chase pointers through defining
1497  // declarations (where they exist), this is important since non-defining declarations can be almost
1498  // anywhere (and thus chasing them can make it appear that there are cycles where there are none
1499  // (I think); test2012_234.C demonstrates an example of this.
1500  // DQ (10/9/2012): Robb has suggested this change to fix the binary analysis work.
1501  // if (foundCycle == true)
1502  if (foundCycle == false)
1503  {
1504 
1505 
1506  while ( (parent != NULL) && (!dynamic_cast<const NodeType*>(parent)) )
1507  {
1508  ROSE_ASSERT(parent->get_parent() != parent);
1509 #if 0
1510  printf ("In getEnclosingNode() (2nd try): parent = %p = %s \n",parent,parent->class_name().c_str());
1511  if (parent->get_file_info() != NULL)
1512  parent->get_file_info()->display("In getEnclosingNode() (2nd try): debug");
1513 #endif
1514  SgDeclarationStatement* declarationStatement = isSgDeclarationStatement(parent);
1515  if (declarationStatement != NULL)
1516  {
1517 #if 0
1518  printf ("Found a SgDeclarationStatement \n");
1519 #endif
1520  SgDeclarationStatement* definingDeclaration = declarationStatement->get_definingDeclaration();
1521  SgDeclarationStatement* firstNondefiningDeclaration = declarationStatement->get_firstNondefiningDeclaration();
1522 #if 0
1523  printf (" --- declarationStatement = %p = %s \n",declarationStatement,(declarationStatement != NULL) ? declarationStatement->class_name().c_str() : "null");
1524 
1525  printf (" --- definingDeclaration = %p \n",definingDeclaration);
1526  if (definingDeclaration != NULL && definingDeclaration->get_parent() != NULL)
1527  printf (" --- definingDeclaration ->get_parent() = %p = %s \n",definingDeclaration->get_parent(),definingDeclaration->get_parent()->class_name().c_str());
1528 
1529  printf (" --- firstNondefiningDeclaration = %p \n",firstNondefiningDeclaration);
1530  if (firstNondefiningDeclaration != NULL && firstNondefiningDeclaration->get_parent() != NULL)
1531  printf (" --- firstNondefiningDeclaration ->get_parent() = %p = %s \n",firstNondefiningDeclaration->get_parent(),firstNondefiningDeclaration->get_parent()->class_name().c_str());
1532 #endif
1533  if (definingDeclaration != NULL && declarationStatement != firstNondefiningDeclaration)
1534  {
1535 #if 0
1536  printf ("Found a nondefining declaration so use the firstNondefining declaration instead \n");
1537 #endif
1538  // DQ (10/19/2012): Use the defining declaration instead.
1539  // parent = firstNondefiningDeclaration;
1540  parent = definingDeclaration;
1541  }
1542  }
1543 
1544  parent = parent->get_parent();
1545 
1546 #if 1
1547  // DQ (3/5/2012): Check for loops that will cause infinite loops.
1548  ROSE_ASSERT(parent != previouslySeenParent);
1549 #else
1550  printf ("WARNING::WARNING::WARNING commented out assertion for parent != previouslySeenParent \n");
1551  if (parent == previouslySeenParent)
1552  break;
1553 #endif
1554  }
1555  }
1556 
1557  return const_cast<NodeType*>(dynamic_cast<const NodeType*> (parent));
1558 #else
1559  // DQ (10/20/2012): Using Robb's newer version with my modification to use the definingDeclaration rather than firstNondefiningDeclaration (below).
1560 
1561  // Find the parent of specified type, but watch out for cycles in the ancestry (which would cause an infinite loop).
1562  // Cast away const because isSg* functions aren't defined for const node pointers; and our return is not const.
1563  SgNode *node = const_cast<SgNode*>(!astNode || includingSelf ? astNode : astNode->get_parent());
1564  std::set<const SgNode*> seen; // nodes we've seen, in order to detect cycles
1565  while (node) {
1566  if (NodeType *found = dynamic_cast<NodeType*>(node))
1567  return found;
1568 
1569  // FIXME: Cycle detection could be moved elsewhere so we don't need to do it on every call. [RPM 2012-10-09]
1570  ROSE_ASSERT(seen.insert(node).second);
1571 
1572  // Traverse to parent (declaration statements are a special case)
1573  if (SgDeclarationStatement *declarationStatement = isSgDeclarationStatement(node)) {
1574  SgDeclarationStatement *definingDeclaration = declarationStatement->get_definingDeclaration();
1575  SgDeclarationStatement *firstNondefiningDeclaration = declarationStatement->get_firstNondefiningDeclaration();
1576  if (definingDeclaration && firstNondefiningDeclaration && declarationStatement != firstNondefiningDeclaration) {
1577  // DQ (10/19/2012): Use the defining declaration instead.
1578  // node = firstNondefiningDeclaration;
1579  node = definingDeclaration;
1580  }
1581  } else {
1582  node = node->get_parent();
1583  }
1584  }
1585  return NULL;
1586 #endif
1587  }
1588 
1590  ROSE_DLL_API SgSourceFile* getEnclosingSourceFile(SgNode* n, const bool includingSelf=false);
1591 
1593  ROSE_DLL_API SgScopeStatement* getScope(const SgNode* astNode);
1594 
1596  ROSE_DLL_API SgScopeStatement* getEnclosingScope(SgNode* n, const bool includingSelf=false);
1597 
1599  ROSE_DLL_API SgGlobal* getGlobalScope( const SgNode* astNode);
1600 
1601 
1603  ROSE_DLL_API SgFunctionDefinition* getEnclosingProcedure(SgNode* n, const bool includingSelf=false);
1604 
1605  ROSE_DLL_API SgFunctionDefinition* getEnclosingFunctionDefinition(SgNode* astNode, const bool includingSelf=false);
1606 
1608  ROSE_DLL_API SgStatement* getEnclosingStatement(SgNode* n);
1609 
1612 
1615 
1617  ROSE_DLL_API SgScopeStatement* findEnclosingLoop(SgStatement* s, const std::string& fortranLabel = "", bool stopOnSwitches = false);
1618 
1620  ROSE_DLL_API SgFunctionDeclaration * getEnclosingFunctionDeclaration (SgNode * astNode, const bool includingSelf=false);
1621  //roseSupport/utility_functions.h
1623  ROSE_DLL_API SgFile* getEnclosingFileNode (SgNode* astNode );
1624 
1627 
1629  ROSE_DLL_API SgClassDefinition* getEnclosingClassDefinition(SgNode* astnode, const bool includingSelf=false);
1630 
1631 // TODO
1632 #if 0
1633  SgNode * getEnclosingSgNode(SgNode* source,VariantT, SgNode* endNode=NULL);
1634  std::vector<SgNode *> getAllEnclosingSgNode(SgNode* source,VariantT, SgNode* endNode=NULL);
1635  SgVariableDeclaration* findVariableDeclaratin( const string& varname)
1636 
1637  SgClassDeclaration* getEnclosingClassDeclaration( const SgNode* astNode);
1638 
1639  // e.g. for some expression, find its parent statement
1640  SgStatement* getEnclosingStatement(const SgNode* astNode);
1641 
1642  SgSwitchStatement* getEnclosingSwitch(SgStatement* s);
1643  SgModuleStatement* getEnclosingModuleStatement( const SgNode* astNode);
1644 
1645  // used to build a variable reference for compiler generated code in current scope
1646  SgSymbol * findReachingDefinition (SgScopeStatement* startScope, SgName &name);
1647 #endif
1648 
1649 
1650 //------------------------------------------------------------------------
1652 
1655  // Liao, 1/9/2008
1659  ROSE_DLL_API SgGlobal * getFirstGlobalScope(SgProject *project);
1660 
1664  ROSE_DLL_API SgStatement* getLastStatement(SgScopeStatement *scope);
1665 
1667  ROSE_DLL_API SgStatement* getFirstStatement(SgScopeStatement *scope,bool includingCompilerGenerated=false);
1670 
1672  ROSE_DLL_API SgStatement* getNextStatement(SgStatement * currentStmt);
1673 
1675  ROSE_DLL_API SgStatement* getPreviousStatement(SgStatement * currentStmt, bool climbOutScope = true);
1676 #if 0 //TODO
1677  // preorder traversal from current SgNode till find next SgNode of type V_SgXXX
1678  SgNode* getNextSgNode( const SgNode* currentNode, VariantT=V_SgNode);
1679 #endif
1680 
1681 
1682 //------------------------------------------------------------------------
1684 
1687  ROSE_DLL_API bool isEqualToIntConst(SgExpression* e, int value);
1689 
1691 
1694  ROSE_DLL_API bool isSameFunction(SgFunctionDeclaration* func1, SgFunctionDeclaration* func2);
1695 
1697  ROSE_DLL_API bool isLastStatement(SgStatement* stmt);
1698 
1700 
1701 //------------------------------------------------------------------------
1703 
1709 // DQ (2/24/2009): Simple function to delete an AST subtree (used in outlining).
1711 ROSE_DLL_API void deleteAST(SgNode* node);
1712 
1715 
1716 // DQ (2/25/2009): Added new function to support outliner.
1718 ROSE_DLL_API void moveStatementsBetweenBlocks ( SgBasicBlock* sourceBlock, SgBasicBlock* targetBlock );
1719 
1721 ROSE_DLL_API void moveVariableDeclaration(SgVariableDeclaration* decl, SgScopeStatement* target_scope);
1723 ROSE_DLL_API void appendStatement(SgStatement *stmt, SgScopeStatement* scope=NULL);
1724 
1726 ROSE_DLL_API void appendStatement(SgStatement *stmt, SgForInitStatement* for_init_stmt);
1727 
1729 ROSE_DLL_API void appendStatementList(const std::vector<SgStatement*>& stmt, SgScopeStatement* scope=NULL);
1730 
1731 // DQ (2/6/2009): Added function to support outlining into separate file.
1733 ROSE_DLL_API void appendStatementWithDependentDeclaration( SgDeclarationStatement* decl, SgGlobal* scope, SgStatement* original_statement, bool excludeHeaderFiles );
1734 
1737 ROSE_DLL_API void prependStatement(SgStatement *stmt, SgScopeStatement* scope=NULL);
1738 
1740 ROSE_DLL_API void prependStatement(SgStatement *stmt, SgForInitStatement* for_init_stmt);
1741 
1744 ROSE_DLL_API void prependStatementList(const std::vector<SgStatement*>& stmt, SgScopeStatement* scope=NULL);
1745 
1749 ROSE_DLL_API bool hasSimpleChildrenList (SgScopeStatement* scope);
1750 
1752 ROSE_DLL_API void insertStatement(SgStatement *targetStmt, SgStatement* newStmt, bool insertBefore= true, bool autoMovePreprocessingInfo = true);
1753 
1755 //target's scope
1756 ROSE_DLL_API void insertStatementList(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmts, bool insertBefore= true);
1757 
1759 ROSE_DLL_API void insertStatementBefore(SgStatement *targetStmt, SgStatement* newStmt, bool autoMovePreprocessingInfo = true);
1760 
1762 ROSE_DLL_API void insertStatementListBefore(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmts);
1763 
1765 ROSE_DLL_API void insertStatementAfter(SgStatement *targetStmt, SgStatement* newStmt, bool autoMovePreprocessingInfo = true);
1766 
1768 ROSE_DLL_API void insertStatementListAfter(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmt);
1769 
1771 ROSE_DLL_API void insertStatementAfterLastDeclaration(SgStatement* stmt, SgScopeStatement* scope);
1772 
1774 ROSE_DLL_API void insertStatementAfterLastDeclaration(std::vector<SgStatement*> stmt_list, SgScopeStatement* scope);
1775 
1777 // then the statement is inserted at the end of the scope.
1778 ROSE_DLL_API void insertStatementBeforeFirstNonDeclaration(SgStatement *newStmt, SgScopeStatement *scope,
1779  bool movePreprocessingInfo=true);
1780 
1782 //then the new statements are inserted at the end of the scope.
1783 ROSE_DLL_API void insertStatementListBeforeFirstNonDeclaration(const std::vector<SgStatement*> &newStmts,
1784  SgScopeStatement *scope);
1785 
1787 ROSE_DLL_API void removeStatement(SgStatement* stmt, bool autoRelocatePreprocessingInfo = true);
1788 
1790 ROSE_DLL_API void deepDelete(SgNode* root);
1791 
1793 ROSE_DLL_API void replaceStatement(SgStatement* oldStmt, SgStatement* newStmt, bool movePreprocessinInfo = false);
1794 
1796 ROSE_DLL_API SgNode* replaceWithPattern (SgNode * anchor, SgNode* new_pattern);
1797 
1799 // Essentially replace variable a with b.
1800 ROSE_DLL_API void replaceVariableReferences(SgVariableSymbol* old_sym, SgVariableSymbol* new_sym, SgScopeStatement * scope );
1801 
1812 std::pair<SgVariableDeclaration*, SgExpression* > createTempVariableForExpression(SgExpression* expression,
1813  SgScopeStatement* scope, bool initializeInDeclaration, SgAssignOp** reEvaluate = NULL);
1814 
1815 /* This function creates a temporary variable for a given expression in the given scope
1816  This is different from SageInterface::createTempVariableForExpression in that it does not
1817  try to be smart to create pointers to reference types and so on. The tempt is initialized to expression.
1818  The caller is responsible for setting the parent of SgVariableDeclaration since buildVariableDeclaration
1819  may not set_parent() when the scope stack is empty. See programTransformation/extractFunctionArgumentsNormalization/ExtractFunctionArguments.C for sample usage.
1820  @param expression Expression which will be replaced by a variable
1821  @param scope scope in which the temporary variable will be generated
1822 */
1823 
1824 std::pair<SgVariableDeclaration*, SgExpression*> createTempVariableAndReferenceForExpression
1825  (SgExpression* expression, SgScopeStatement* scope);
1826 
1828 
1835 
1837 ROSE_DLL_API void appendExpression(SgExprListExp *, SgExpression*);
1838 
1840 ROSE_DLL_API void appendExpressionList(SgExprListExp *, const std::vector<SgExpression*>&);
1841 
1843 template <class actualFunction>
1844 void setParameterList(actualFunction *func,SgFunctionParameterList *paralist) {
1845 
1846  // TODO consider the difference between C++ and Fortran
1847  // fixup the scope of arguments,no symbols for nondefining function declaration's arguments
1848 
1849  // DQ (11/25/2011): templated function so that we can handle both
1850  // SgFunctionDeclaration and SgTemplateFunctionDeclaration (and their associated member
1851  // function derived classes).
1852 
1853  ROSE_ASSERT(func != NULL);
1854  ROSE_ASSERT(paralist != NULL);
1855 
1856 #if 0
1857  // At this point we don't have cerr and endl defined, so comment this code out.
1858  // Warn to users if a paralist is being shared
1859  if (paralist->get_parent() !=NULL)
1860  {
1861  cerr << "Waring! Setting a used SgFunctionParameterList to function: "
1862  << (func->get_name()).getString()<<endl
1863  << " Sharing parameter lists can corrupt symbol tables!"<<endl
1864  << " Please use deepCopy() to get an exclusive parameter list for each function declaration!"<<endl;
1865  // ROSE_ASSERT(false);
1866  }
1867 #endif
1868 
1869  // Liao,2/5/2008 constructor of SgFunctionDeclaration will automatically generate SgFunctionParameterList, so be cautious when set new paralist!!
1870  if (func->get_parameterList() != NULL)
1871  {
1872  if (func->get_parameterList() != paralist)
1873  {
1874  delete func->get_parameterList();
1875  }
1876  }
1877 
1878  func->set_parameterList(paralist);
1879  paralist->set_parent(func);
1880 
1881  // DQ (5/15/2012): Need to set the declptr in each SgInitializedName IR node.
1882  // This is needed to support the AST Copy mechanism (at least). The files: test2005_150.C,
1883  // test2012_81.C and testcode2012_82.C demonstrate this problem.
1884  SgInitializedNamePtrList & args = paralist->get_args();
1885  for (SgInitializedNamePtrList::iterator i = args.begin(); i != args.end(); i++)
1886  {
1887  (*i)->set_declptr(func);
1888  }
1889  }
1890 
1892 ROSE_DLL_API void setPragma(SgPragmaDeclaration* decl, SgPragma *pragma);
1893 
1895 ROSE_DLL_API void replaceExpression(SgExpression* oldExp, SgExpression* newExp, bool keepOldExp=false);
1896 
1898 ROSE_DLL_API void replaceExpressionWithStatement(SgExpression* from,
1902 ROSE_DLL_API void replaceSubexpressionWithStatement(SgExpression* from,
1904 
1906 ROSE_DLL_API void setOperand(SgExpression* target, SgExpression* operand);
1907 
1909 ROSE_DLL_API void setLhsOperand(SgExpression* target, SgExpression* lhs);
1910 
1912 ROSE_DLL_API void setRhsOperand(SgExpression* target, SgExpression* rhs);
1913 
1915 ROSE_DLL_API void removeAllOriginalExpressionTrees(SgNode* top);
1916 
1917 // DQ (1/25/2010): Added support for directories
1919 ROSE_DLL_API void moveToSubdirectory ( std::string directoryName, SgFile* file );
1920 
1922 ROSE_DLL_API SgStatement* findSurroundingStatementFromSameFile(SgStatement* targetStmt, bool & surroundingStatementPreceedsTargetStatement);
1923 
1925 ROSE_DLL_API void moveCommentsToNewStatement(SgStatement* sourceStatement, const std::vector<int> & indexList, SgStatement* targetStatement, bool surroundingStatementPreceedsTargetStatement);
1926 
1927 // DQ (7/19/2015): This is required to support general unparsing of template instantations for the GNU g++
1928 // compiler which does not permit name qualification to be used to support the expression of the namespace
1929 // where a template instantiatoon would be places. Such name qualification would also sometimes require
1930 // global qualification which is also not allowed by the GNU g++ compiler. These issues appear to be
1931 // specific to the GNU compiler versions, at least versions 4.4 through 4.8.
1933 ROSE_DLL_API void moveDeclarationToAssociatedNamespace ( SgDeclarationStatement* declarationStatement );
1934 
1935 ROSE_DLL_API bool isTemplateInstantiationNode(SgNode* node);
1936 
1938 
1939 // DQ (12/1/2015): Adding support for fixup internal data struuctures that have references to statements (e.g. macro expansions).
1940 ROSE_DLL_API void resetInternalMapsForTargetStatement(SgStatement* sourceStatement);
1941 
1943 //------------------------------------------------------------------------
1945 
1952 
1958 ROSE_DLL_API int fixVariableReferences(SgNode* root);
1959 
1961 
1965 ROSE_DLL_API void fixVariableDeclaration(SgVariableDeclaration* varDecl, SgScopeStatement* scope);
1966 
1968 ROSE_DLL_API void fixStructDeclaration(SgClassDeclaration* structDecl, SgScopeStatement* scope);
1970 ROSE_DLL_API void fixClassDeclaration(SgClassDeclaration* classDecl, SgScopeStatement* scope);
1971 
1973 ROSE_DLL_API void fixNamespaceDeclaration(SgNamespaceDeclarationStatement* structDecl, SgScopeStatement* scope);
1974 
1975 
1977 ROSE_DLL_API void fixLabelStatement(SgLabelStatement* label_stmt, SgScopeStatement* scope);
1978 
1980 ROSE_DLL_API void setFortranNumericLabel(SgStatement* stmt, int label_value);
1981 
1983 ROSE_DLL_API int suggestNextNumericLabel(SgFunctionDefinition* func_def);
1984 
1986 ROSE_DLL_API void fixFunctionDeclaration(SgFunctionDeclaration* stmt, SgScopeStatement* scope);
1987 
1989 ROSE_DLL_API void fixTemplateDeclaration(SgTemplateDeclaration* stmt, SgScopeStatement* scope);
1990 
1992 ROSE_DLL_API void fixStatement(SgStatement* stmt, SgScopeStatement* scope);
1993 
1994 // DQ (6/11/2015): This reports the statements that are marked as transformed (used to debug the token-based unparsing).
1996 ROSE_DLL_API std::set<SgStatement*> collectTransformedStatements( SgNode* node );
1997 
1999 ROSE_DLL_API std::set<SgStatement*> collectModifiedStatements( SgNode* node );
2000 
2002 ROSE_DLL_API std::set<SgLocatedNode*> collectModifiedLocatedNodes( SgNode* node );
2003 
2005 
2007 
2013 
2014 //------------------------------------------------------------------------
2016 
2020 ROSE_DLL_API bool
2022 collectReadWriteRefs(SgStatement* stmt, std::vector<SgNode*>& readRefs, std::vector<SgNode*>& writeRefs, bool useCachedDefUse=false);
2023 
2025 ROSE_DLL_API bool collectReadWriteVariables(SgStatement* stmt, std::set<SgInitializedName*>& readVars, std::set<SgInitializedName*>& writeVars, bool coarseGrain=true);
2026 
2028 ROSE_DLL_API void collectReadOnlyVariables(SgStatement* stmt, std::set<SgInitializedName*>& readOnlyVars, bool coarseGrain=true);
2029 
2031 ROSE_DLL_API void collectReadOnlySymbols(SgStatement* stmt, std::set<SgVariableSymbol*>& readOnlySymbols, bool coarseGrain=true);
2032 
2034 ROSE_DLL_API bool isUseByAddressVariableRef(SgVarRefExp* ref);
2035 
2037 ROSE_DLL_API void collectUseByAddressVariableRefs (const SgStatement* s, std::set<SgVarRefExp* >& varSetB);
2038 
2039 #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
2040 ROSE_DLL_API LivenessAnalysis * call_liveness_analysis(SgProject* project, bool debug=false);
2042 
2044 ROSE_DLL_API void getLiveVariables(LivenessAnalysis * liv, SgForStatement* loop, std::set<SgInitializedName*>& liveIns, std::set<SgInitializedName*> & liveOuts);
2045 #endif
2046 
2048 ROSE_DLL_API void ReductionRecognition(SgForStatement* loop, std::set< std::pair <SgInitializedName*, OmpSupport::omp_construct_enum> > & results);
2049 
2051 
2052 ROSE_DLL_API void constantFolding(SgNode* r);
2053 
2055 
2057 ROSE_DLL_API int instrumentEndOfFunction(SgFunctionDeclaration * func, SgStatement* s);
2058 
2060 ROSE_DLL_API void removeJumpsToNextStatement(SgNode*);
2061 
2063 ROSE_DLL_API void removeUnusedLabels(SgNode* top);
2064 
2066 ROSE_DLL_API void removeConsecutiveLabels(SgNode* top);
2067 
2069 
2075 ROSE_DLL_API bool mergeDeclarationAndAssignment (SgVariableDeclaration* decl, SgExprStatement* assign_stmt, bool removeAssignStmt = true);
2076 
2077 
2079 ROSE_DLL_API bool mergeAssignmentWithDeclaration (SgExprStatement* assign_stmt, SgVariableDeclaration* decl, bool removeAssignStmt = true);
2080 
2082 
2085 ROSE_DLL_API bool mergeDeclarationWithAssignment (SgVariableDeclaration* decl, SgExprStatement* assign_stmt);
2086 
2088 
2093 
2095 ROSE_DLL_API int splitVariableDeclaration (SgScopeStatement* scope, bool topLevelOnly = true);
2096 
2098 
2105  ROSE_DLL_API SgAssignInitializer* splitExpression(SgExpression* from, std::string newName = "");
2106 
2108 ROSE_DLL_API void splitExpressionIntoBasicBlock(SgExpression* expr);
2109 
2111 ROSE_DLL_API void removeLabeledGotos(SgNode* top);
2112 
2114 ROSE_DLL_API void changeBreakStatementsToGotos(SgStatement* loopOrSwitch);
2115 
2118 
2121 
2124 
2127 
2130 
2133 
2136 
2139 
2141 ROSE_DLL_API SgBasicBlock* ensureBasicBlockAsFalseBodyOfIf(SgIfStmt* ifs, bool createEmptyBody = true);
2142 
2145 
2148 
2149 // DQ (1/18/2015): This is added to support better quality token-based unparsing.
2151 ROSE_DLL_API void cleanupNontransformedBasicBlockNode();
2152 
2153 // DQ (1/18/2015): This is added to support better quality token-based unparsing.
2155 ROSE_DLL_API void recordNormalizations(SgStatement* s);
2156 
2159 bool isBodyStatement (SgStatement* s);
2160 
2162 void changeAllBodiesToBlocks(SgNode* top, bool createEmptyBody = true);
2163 
2164 // The same as changeAllBodiesToBlocks(SgNode* top). Phased out.
2165 //void changeAllLoopBodiesToBlocks(SgNode* top);
2166 
2169 
2170 #if 0
2171 
2174 SgLocatedNode* ensureBasicBlockAsParent(SgStatement* s);
2175 #endif
2176 
2179 unsigned long long getIntegerConstantValue(SgValueExp* expr);
2180 
2182 std::vector<SgDeclarationStatement*> getDependentDeclarations (SgStatement* stmt );
2183 
2184 
2187 
2189 SgCommaOpExp *insertAfterUsingCommaOp (SgExpression* new_exp, SgExpression* anchor_exp, SgStatement** temp_decl = NULL, SgVarRefExp** temp_ref = NULL);
2190 
2191 
2221 std::pair<SgStatement*, SgInitializedName*>
2222 wrapFunction(SgFunctionDeclaration& definingDeclaration, SgName newName);
2223 
2229 template <class NameGen>
2230 std::pair<SgStatement*, SgInitializedName*>
2231 wrapFunction(SgFunctionDeclaration& definingDeclaration, NameGen nameGen)
2232 {
2233  return wrapFunction(definingDeclaration, nameGen(definingDeclaration.get_name()));
2234 }
2235 
2239 
2240 
2242 
2243 // DQ (6/7/2012): Unclear where this function should go...
2244  bool hasTemplateSyntax( const SgName & name );
2245 
2246 #if 0
2247 
2248 //------------------------AST dump, stringify-----------------------------
2249 //------------------------------------------------------------------------
2250  std::string buildOperatorString ( SgNode* astNode ); //transformationSupport.h
2251 
2252  // do we need these?
2253  std::string dump_node(const SgNode* astNode);
2254  std::string dump_tree(const SgNode* astNode);
2255 
2256  // or a friendly version of unparseToString(), as a memeber function
2257  std::string SgNode::toString(bool asSubTree=true); // dump node or subtree
2258 
2259 //----------------------------AST comparison------------------------------
2260 //------------------------------------------------------------------------
2261 // How to get generic functions for comparison?
2262  bool isNodeEqual(SgNode* node1, SgNode* node2); //?
2263  bool isTreeEqual(SgNode* tree1, SgNode* tree2);
2264 
2266  bool expressionTreeEqual(SgExpression*, SgExpression*);
2268  bool expressionTreeEqualStar(const SgExpressionPtrList&,
2269  const SgExpressionPtrList&);
2270 
2271 //----------------------AST verfication/repair----------------------------
2272 //------------------------------------------------------------------------
2273 // sanity check of AST subtree, any suggestions?
2274 // TODO
2275  verifySgNode(SgNode* node, bool subTree=true);
2276  //src/midend/astDiagnostics/AstConsistencyTests.h
2277  // AstTests::runAllTests(SgProject * )
2278 
2279  //src/midend/astUtil/astInterface/AstInterface.h.C
2280  //FixSgProject(SgProject &project)
2281  //FixSgTree(SgNode* r)
2282 
2283  //src/frontend/SageIII/astPostProcessing
2284  //AstPostProcessing(SgNode * node)
2285 
2286 //--------------------------AST modification------------------------------
2287 //------------------------------------------------------------------------
2288 // any operations changing AST tree, including
2289 // insert, copy, delete(remove), replace
2290 
2291  // insert before or after some point, argument list is consistent with LowLevelRewrite
2292  void insertAst(SgNode* targetPosition, SgNode* newNode, bool insertBefore=true);
2293 
2294  // previous examples
2295  //void myStatementInsert(SgStatement* target,...)
2296  // void AstInterfaceBase::InsertStmt(AstNodePtr const & orig, AstNodePtr const &n, bool insertbefore, bool extractfromBasicBlock)
2297 
2298  // copy
2299  // copy children of one basic block to another basic block
2300  //void appendStatementCopy (const SgBasicBlock* a, SgBasicBlock* b);
2301  void copyStatements (const SgBasicBlock* src, SgBasicBlock* dst);
2302 
2303  // delete (remove) a node or a whole subtree
2304  void removeSgNode(SgNode* targetNode); // need this?
2305  void removeSgNodeTree(SgNode* subtree); // need this?
2306 
2307  void removeStatement( SgStatement* targetStmt);
2308 
2309  //Move = delete + insert
2310  void moveAst (SgNode* src, SgNode* target); // need this?
2311  // similar to
2312  void moveStatements (SgBasicBlock* src, SgBasicBlock* target);
2313 
2314  // replace= delete old + insert new (via building or copying)
2315 
2316 // DQ (1/25/2010): This does not appear to exist as a definition anywhere in ROSE.
2317 // void replaceAst(SgNode* oldNode, SgNode* newNode);
2318 
2319  //void replaceChild(SgNode* parent, SgNode* from, SgNode* to);
2320  //bool AstInterface::ReplaceAst( const AstNodePtr& orig, const AstNodePtr& n)
2321 
2322 //--------------------------AST transformations---------------------------
2323 //------------------------------------------------------------------------
2324 // Advanced AST modifications through basic AST modifications
2325 // Might not be included in AST utitlity list, but listed here for the record.
2326 
2327  // extract statements/content from a scope
2328  void flattenBlocks(SgNode* n);
2329 
2330  //src/midend/astInlining/inlinerSupport.h
2331  void renameVariables(SgNode* n);
2332  void renameLabels(SgNode* n, SgFunctionDefinition* enclosingFunctionDefinition);
2333 
2334  void simpleCopyAndConstantPropagation(SgNode* top);
2335  void changeAllMembersToPublic(SgNode* n);
2336 
2337  void removeVariableDeclaration(SgInitializedName* initname);
2338 
2340  SgAssignOp* convertInitializerIntoAssignment(SgAssignInitializer* init);
2341 
2346  void pushTestIntoBody(LoopStatement* loopStmt);
2347 
2348  //programTransformation/finiteDifferencing/finiteDifferencing.h
2350  void moveForDeclaredVariables(SgNode* root);
2351 
2352 //------------------------ Is/Has functions ------------------------------
2353 //------------------------------------------------------------------------
2354 // misc. boolean functions
2355 // some of them could moved to SgXXX class as a member function
2356 
2357  bool isOverloaded (SgFunctionDeclaration * functionDeclaration);
2358 
2359  bool isSwitchCond (const SgStatement* s);
2360  bool isIfCond (const SgStatement* s);
2361  bool isWhileCond (const SgStatement* s);
2362  bool isStdNamespace (const SgScopeStatement* scope);
2363  bool isTemplateInst (const SgDeclarationStatement* decl);
2364 
2365 
2366  bool isCtor (const SgFunctionDeclaration* func);
2367  bool isDtor (const SgFunctionDeclaration* func);
2368 
2369  // src/midend/astInlining/typeTraits.h
2370  bool hasTrivialDestructor(SgType* t);
2371  ROSE_DLL_API bool isNonconstReference(SgType* t);
2372  ROSE_DLL_API bool isReferenceType(SgType* t);
2373 
2374  // generic ones, or move to the SgXXX class as a member function
2375 
2376  bool isConst(SgNode* node); // const type, variable, function, etc.
2377  // .... and more
2378 
2379  bool isConstType (const SgType* type);
2380  bool isConstFunction (const SgFunctionDeclaration* decl);
2381 
2382 
2383  bool isMemberVariable(const SgInitializedName & var);
2384  //bool isMemberVariable(const SgNode& in);
2385 
2386  bool isPrototypeInScope (SgScopeStatement * scope,
2387  SgFunctionDeclaration * functionDeclaration,
2388  SgDeclarationStatement * startingAtDeclaration);
2389 
2390  bool MayRedefined(SgExpression* expr, SgNode* root);
2391  // bool isPotentiallyModified(SgExpression* expr, SgNode* root); // inlinderSupport.h
2392  bool hasAddressTaken(SgExpression* expr, SgNode* root);
2393 
2394  //src/midend/astInlining/inlinerSupport.C
2395  // can also classified as topdown search
2396  bool containsVariableReference(SgNode* root, SgInitializedName* var);
2397 
2398  bool isDeclarationOf(SgVariableDeclaration* decl, SgInitializedName* var);
2399  bool isPotentiallyModifiedDuringLifeOf(SgBasicBlock* sc,
2400  SgInitializedName* toCheck,
2401  SgInitializedName* lifetime)
2402  //src/midend/programTransformation/partialRedundancyElimination/pre.h
2403  bool anyOfListPotentiallyModifiedIn(const std::vector<SgVariableSymbol*>& syms, SgNode* n);
2404 
2405 //------------------------ loop handling ---------------------------------
2406 //------------------------------------------------------------------------
2407  //get and set loop control expressions
2408  // 0: init expr, 1: condition expr, 2: stride expr
2409 
2410  SgExpression* getForLoopTripleValues(int valuetype,SgForStatement* forstmt );
2411  int setForLoopTripleValues(int valuetype,SgForStatement* forstmt, SgExpression* exp);
2412 
2413  bool isLoopIndexVarRef(SgForStatement* forstmt, SgVarRefExp *varref);
2414  SgInitializedName * getLoopIndexVar(SgForStatement* forstmt);
2415 
2416 //------------------------expressions-------------------------------------
2417 //------------------------------------------------------------------------
2418  //src/midend/programTransformation/partialRedundancyElimination/pre.h
2419  int countComputationsOfExpressionIn(SgExpression* expr, SgNode* root);
2420 
2421  //src/midend/astInlining/replaceExpressionWithStatement.h
2422  void replaceAssignmentStmtWithStatement(SgExprStatement* from, StatementGenerator* to);
2423 
2425  StatementGenerator* to);
2426  SgExpression* getRootOfExpression(SgExpression* n);
2427 
2428 //--------------------------preprocessing info. -------------------------
2429 //------------------------------------------------------------------------
2431  void cutPreprocInfo (SgBasicBlock* b,
2433  AttachedPreprocessingInfoType& save_buf);
2435  void pastePreprocInfoFront (AttachedPreprocessingInfoType& save_buf,
2436  SgStatement* s);
2438  void pastePreprocInfoBack (AttachedPreprocessingInfoType& save_buf,
2439  SgStatement* s);
2440 
2446  // a generic one for all
2448  void moveBeforePreprocInfo (SgStatement* src, SgStatement* dest);
2449  void moveInsidePreprocInfo (SgBasicBlock* src, SgBasicBlock* dest);
2450  void moveAfterPreprocInfo (SgStatement* src, SgStatement* dest);
2451 
2452 //--------------------------------operator--------------------------------
2453 //------------------------------------------------------------------------
2454  from transformationSupport.h, not sure if they should be included here
2455  /* return enum code for SAGE operators */
2456  operatorCodeType classifyOverloadedOperator(); // transformationSupport.h
2457 
2463  std::string stringifyOperator (std::string name);
2464 
2465 //--------------------------------macro ----------------------------------
2466 //------------------------------------------------------------------------
2467  std::string buildMacro ( std::string s ); //transformationSupport.h
2468 
2469 //--------------------------------access functions---------------------------
2470 //----------------------------------get/set sth.-----------------------------
2471 // several categories:
2472 * get/set a direct child/grandchild node or fields
2473 * get/set a property flag value
2474 * get a descendent child node using preorder searching
2475 * get an ancestor node using bottomup/reverse searching
2476 
2477  // SgName or string?
2478  std::string getFunctionName (SgFunctionCallExp* functionCallExp);
2479  std::string getFunctionTypeName ( SgFunctionCallExp* functionCallExpression );
2480 
2481  // do we need them anymore? or existing member functions are enought?
2482  // a generic one:
2483  std::string get_name (const SgNode* node);
2484  std::string get_name (const SgDeclarationStatement * declaration);
2485 
2486  // get/set some property: should moved to SgXXX as an inherent memeber function?
2487  // access modifier
2488  void setExtern (SgFunctionDeclartion*)
2489  void clearExtern()
2490 
2491  // similarly for other declarations and other properties
2493  void setPublic()
2494  void setPrivate()
2495 
2496 #endif
2497 
2498 // DQ (1/23/2013): Added support for generated a set of source sequence entries.
2499  std::set<unsigned int> collectSourceSequenceNumbers( SgNode* astNode );
2500 
2501 //--------------------------------Type Traits (C++)---------------------------
2502  bool HasNoThrowAssign(const SgType * const inputType);
2503  bool HasNoThrowCopy(const SgType * const inputType);
2504  bool HasNoThrowConstructor(const SgType * const inputType);
2505  bool HasTrivialAssign(const SgType * const inputType);
2506  bool HasTrivialCopy(const SgType * const inputType);
2507  bool HasTrivialConstructor(const SgType * const inputType);
2508  bool HasTrivialDestructor(const SgType * const inputType);
2509  bool HasVirtualDestructor(const SgType * const inputType);
2510  bool IsBaseOf(const SgType * const inputBaseType, const SgType * const inputDerivedType);
2511  bool IsAbstract(const SgType * const inputType);
2512  bool IsClass(const SgType * const inputType);
2513  bool IsEmpty(const SgType * const inputType);
2514  bool IsEnum(const SgType * const inputType);
2515  bool IsPod(const SgType * const inputType);
2516  bool IsPolymorphic(const SgType * const inputType);
2517  bool IsStandardLayout(const SgType * const inputType);
2518  bool IsLiteralType(const SgType * const inputType);
2519  bool IsTrivial(const SgType * const inputType);
2520  bool IsUnion(const SgType * const inputType);
2521  SgType * UnderlyingType(SgType *type);
2522 
2523 // DQ (3/2/2014): Added a new interface function (used in the snippet insertion support).
2524 // void supportForInitializedNameLists ( SgScopeStatement* scope, SgInitializedNamePtrList & variableList );
2525 
2526 // DQ (3/4/2014): Added support for testing two trees for equivalents using the AST iterators.
2527  bool isStructurallyEquivalentAST( SgNode* tree1, SgNode* tree2 );
2528 
2529 // JP (10/14/24): Moved code to evaluate a const integer expression (like in array size definitions) to SageInterface
2532  size_t value_;
2533  bool hasValue_;
2534  };
2537 
2538 // JP (9/17/14): Added function to test whether two SgType* are equivalent or not
2539  bool checkTypesAreEqual(SgType *typeA, SgType *typeB);
2540 
2541 //--------------------------------Java interface functions ---------------------
2542 #ifdef ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
2543  ROSE_DLL_API std::string getTempDirectory(SgProject *project);
2544  ROSE_DLL_API void destroyTempDirectory(std::string);
2545  ROSE_DLL_API SgFile *processFile(SgProject *, std::string, bool unparse = false);
2546  ROSE_DLL_API std::string preprocessPackage(SgProject *, std::string);
2547  ROSE_DLL_API std::string preprocessImport(SgProject *, std::string);
2548  ROSE_DLL_API SgFile* preprocessCompilationUnit(SgProject *, std::string, std::string, bool unparse = true);
2549  ROSE_DLL_API SgClassDefinition *findJavaPackage(SgScopeStatement *, std::string);
2550  ROSE_DLL_API SgClassDefinition *findOrInsertJavaPackage(SgProject *, std::string, bool create_directory = false);
2551  ROSE_DLL_API SgClassDeclaration *findOrImportJavaClass(SgProject *, SgClassDefinition *package_definition, std::string);
2552  ROSE_DLL_API SgClassDeclaration *findOrImportJavaClass(SgProject *, std::string, std::string);
2553  ROSE_DLL_API SgClassDeclaration *findOrImportJavaClass(SgProject *, SgClassType *);
2554  ROSE_DLL_API SgMemberFunctionDeclaration *findJavaMain(SgClassDefinition *);
2555  ROSE_DLL_API SgMemberFunctionDeclaration *findJavaMain(SgClassType *);
2556 #endif // ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
2557 
2558 
2559 
2560 // DQ (8/31/2016): Making this a template function so that we can have it work with user defined filters.
2562 
2568 template < class T >
2570  {
2571  // DQ (9/1/2016): This function is called in the Call graph generation to avoid filtering out EDG normalized
2572  // function template instnatiations (which come from normalized template functions and member functions).
2573  // Note that because of the EDG normailzation the membr function is moved outside of the class, and
2574  // thus marked as compiler generated. However the template instantiations are always marked as compiler
2575  // generated (if not specializations) and so we want to include a template instantiation that is marked
2576  // as compiler generated, but is from a template declaration that satisfyied a specific user defined filter.
2577  // The complexity of this detection is isolated here, but knowing that it must be called is more complex.
2578  // This function is call in the CG.C file of tests/nonsmoke/functional/roseTests/programAnalysisTests/testCallGraphAnalysis.
2579 
2580  bool retval = false;
2581 
2582 #define DEBUG_TEMPLATE_NORMALIZATION_DETECTION 0
2583 
2584 #if DEBUG_TEMPLATE_NORMALIZATION_DETECTION
2585  printf ("In isNormalizedTemplateInstantiation(): function = %p = %s = %s \n",function,function->class_name().c_str(),function->get_name().str());
2586 #endif
2587 
2588  // Test for this to be a template instantation (in which case it was marked as
2589  // compiler generated but we may want to allow it to be used in the call graph,
2590  // if it's template was a part was defined in the current directory).
2591  SgTemplateInstantiationFunctionDecl* templateInstantiationFunction = isSgTemplateInstantiationFunctionDecl(function);
2592  SgTemplateInstantiationMemberFunctionDecl* templateInstantiationMemberFunction = isSgTemplateInstantiationMemberFunctionDecl(function);
2593 
2594  if (templateInstantiationFunction != NULL)
2595  {
2596  // When the defining function has been normalized by EDG, only the non-defining declaration will have a source position.
2597  templateInstantiationFunction = isSgTemplateInstantiationFunctionDecl(templateInstantiationFunction->get_firstNondefiningDeclaration());
2598  SgTemplateFunctionDeclaration* templateFunctionDeclaration = templateInstantiationFunction->get_templateDeclaration();
2599  if (templateFunctionDeclaration != NULL)
2600  {
2601  retval = filter->operator()(templateFunctionDeclaration);
2602  }
2603  else
2604  {
2605  // Assume false.
2606  }
2607 
2608 #if DEBUG_TEMPLATE_NORMALIZATION_DETECTION
2609  printf (" --- case of templateInstantiationFunction: retval = %s \n",retval ? "true" : "false");
2610 #endif
2611  }
2612  else
2613  {
2614  if (templateInstantiationMemberFunction != NULL)
2615  {
2616  // When the defining function has been normalized by EDG, only the non-defining declaration will have a source position.
2617  templateInstantiationMemberFunction = isSgTemplateInstantiationMemberFunctionDecl(templateInstantiationMemberFunction->get_firstNondefiningDeclaration());
2618  SgTemplateMemberFunctionDeclaration* templateMemberFunctionDeclaration = templateInstantiationMemberFunction->get_templateDeclaration();
2619  if (templateMemberFunctionDeclaration != NULL)
2620  {
2621  retval = filter->operator()(templateMemberFunctionDeclaration);
2622  }
2623  else
2624  {
2625  // Assume false.
2626  }
2627 
2628 #if DEBUG_TEMPLATE_NORMALIZATION_DETECTION
2629  printf (" --- case of templateInstantiationMemberFunction: retval = %s \n",retval ? "true" : "false");
2630 #endif
2631  }
2632  }
2633 
2634  return retval;
2635  }
2636 
2637 
2638 
2639 }// end of namespace
2640 
2641 #endif
std::string extractPragmaKeyword(const SgPragmaDeclaration *)
Extract a SgPragmaDeclaration's leading keyword . For example "#pragma omp parallel" has a keyword of...
ROSE_DLL_API void constantFolding(SgNode *r)
Constant folding an AST subtree rooted at 'r' (replacing its children with their constant values...
ROSE_DLL_API SgStatement * findSurroundingStatementFromSameFile(SgStatement *targetStmt, bool &surroundingStatementPreceedsTargetStatement)
Supporting function to comment relocation in insertStatement() and removeStatement().
ROSE_DLL_API SgFunctionDeclaration * findFirstDefiningFunctionDecl(SgScopeStatement *scope)
Find the first defining function declaration statement in a scope.
This class represents the notion of an initializer for a variable declaration or expression in a func...
ROSE_DLL_API bool isCanonicalDoLoop(SgFortranDo *loop, SgInitializedName **ivar, SgExpression **lb, SgExpression **ub, SgExpression **step, SgStatement **body, bool *hasIncrementalIterationSpace, bool *isInclusiveUpperBound)
Check if a Fortran Do loop has a complete canonical form: Do I=1, 10, 1.
ROSE_DLL_API bool is_mixed_Fortran_and_C_and_Cxx_language()
ROSE_DLL_API size_t getUpcSharedBlockSize(SgModifierType *mod_type)
Get the block size of a UPC shared modifier type.
ROSE_DLL_API void prependStatement(SgStatement *stmt, SgScopeStatement *scope=NULL)
Prepend a statement to the beginning of the current scope, handling side effects as appropriate...
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
ROSE_DLL_API void insertStatementListAfter(SgStatement *targetStmt, const std::vector< SgStatement * > &newStmt)
Insert a list of statements after a target statement.
This class represents the concept of an instantiation of member function template or a member functio...
bool getForLoopInformations(SgForStatement *for_loop, SgVariableSymbol *&iterator, SgExpression *&lower_bound, SgExpression *&upper_bound, SgExpression *&stride)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
A persistent attribute to represent a unique name for an expression.
ROSE_DLL_API SgFile * getEnclosingFileNode(SgNode *astNode)
get the SgFile node from current node
This class represents the concept of a class declaration statement. It includes the concept of an ins...
bool declarationPreceedsDefinition(SgDeclarationStatement *nonDefiningDeclaration, SgDeclarationStatement *definingDeclaration)
Check if a defining declaration comes before of after the non-defining declaration.
SgExprListExp * loopCollapsing(SgForStatement *target_loop, size_t collapsing_factor)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsFalseBodyOfIf(SgIfStmt *ifs, bool createEmptyBody=true)
Check if the false body of a 'if' statement is a SgBasicBlock, create one if not when the flag is tru...
ROSE_DLL_API bool isEquivalentType(const SgType *lhs, const SgType *rhs)
Test for equivalence of types independent of access permissions (private or protected modes for membe...
ROSE_DLL_API SgStatement * getEnclosingStatement(SgNode *n)
Find the closest enclosing statement, including the given node.
std::string generateUniqueNameForUseAsIdentifier(SgDeclarationStatement *declaration)
Generate a useful name to support construction of identifiers from declarations.
ROSE_DLL_API SgScopeStatement * getEnclosingScope(SgNode *n, const bool includingSelf=false)
Get the enclosing scope from a node n.
ROSE_DLL_API bool mergeDeclarationAndAssignment(SgVariableDeclaration *decl, SgExprStatement *assign_stmt, bool removeAssignStmt=true)
Merge a variable assignment statement into a matching variable declaration statement. Callers should make sure the merge is semantically correct (by not introducing compilation errors). This function simply does the merge transformation, without eligibility check.
This class represents the concept of a declaration list.
ROSE_DLL_API bool hasMultipleInitStatmentsOrExpressions(SgForStatement *for_loop)
Check if a for loop uses C99 style initialization statement with multiple expressions like for (int i...
ROSE_DLL_API SgVariableSymbol * getFirstVarSym(SgVariableDeclaration *decl)
Get the variable symbol for the first initialized name of a declaration stmt.
ROSE_DLL_API void insertStatementBefore(SgStatement *targetStmt, SgStatement *newStmt, bool autoMovePreprocessingInfo=true)
Insert a statement before a target statement.
void fixupReferencesToSymbols(const SgScopeStatement *this_scope, SgScopeStatement *copy_scope, SgCopyHelp &help)
All the symbol table references in the copied AST need to be reset after rebuilding the copied scope'...
ROSE_DLL_API bool isUpcSharedModifierType(SgModifierType *mod_type)
Check if a modifier type is a UPC shared type.
ROSE_DLL_API std::string mangleType(SgType *type)
Generate a mangled string for a given type based on Itanium C++ ABI.
ROSE_DLL_API SgExprStatement * splitVariableDeclaration(SgVariableDeclaration *decl)
Split a variable declaration with an rhs assignment into two statements: a declaration and an assignm...
SgStatement * findLastDeclarationStatement(SgScopeStatement *scope, bool includePragma=false)
Find the last declaration statement within a scope (if any). This is often useful to decide where to ...
ROSE_DLL_API void insertStatementList(SgStatement *targetStmt, const std::vector< SgStatement * > &newStmts, bool insertBefore=true)
Insert a list of statements before or after the target statement within the.
ROSE_DLL_API bool is_Fortran_language()
ROSE_DLL_API void removeAllOriginalExpressionTrees(SgNode *top)
Set original expression trees to NULL for SgValueExp or SgCastExp expressions, so you can change the ...
ROSE_DLL_API void insertStatementListBefore(SgStatement *targetStmt, const std::vector< SgStatement * > &newStmts)
Insert a list of statements before a target statement.
ROSE_DLL_API bool hasTrivialDestructor(SgType *t)
Does a type have a trivial (built-in) destructor?
ROSE_DLL_API void setOneSourcePositionNull(SgNode *node)
Set current node's source position as NULL.
bool isPostfixOperator(SgExpression *exp)
Is an overloaded operator a postfix operator. (e.g. ).
PreprocessingInfo * attachComment(SgSourceFile *source_file, const std::string &content, PreprocessingInfo::DirectiveType directive_type=PreprocessingInfo::C_StyleComment, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before)
Build and attach comment onto the global scope of a source file.
std::string getMangledNameFromCache(SgNode *astNode)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
ROSE_DLL_API SgFunctionDefinition * getEnclosingFunctionDefinition(SgNode *astNode, const bool includingSelf=false)
Find a node by type using upward traversal.
ROSE_DLL_API 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 void insertStatementAfter(SgStatement *targetStmt, SgStatement *newStmt, bool autoMovePreprocessingInfo=true)
Insert a statement after a target statement, Move around preprocessing info automatically by default...
bool templateDefinitionIsInClass(SgTemplateInstantiationMemberFunctionDecl *memberFunctionDeclaration)
Return true if template definition is in the class, false if outside of class.
ROSE_DLL_API SgMemberFunctionDeclaration * getDefaultConstructor(SgClassDeclaration *classDeclaration)
Get the default constructor from the class declaration.
ROSE_DLL_API bool normalizeForLoopTest(SgForStatement *loop)
Normalize a for loop's test expression ix is normalized to i>= (x...
ROSE_DLL_API void cutPreprocessingInfo(SgLocatedNode *src_node, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType &save_buf)
Cut preprocessing information from a source node and save it into a buffer. Used in combination of pa...
void initializeIfStmt(SgIfStmt *ifstmt, SgStatement *conditional, SgStatement *true_body, SgStatement *false_body)
Support function used for variable declarations in conditionals.
Class for traversing the AST.
bool isTemplateInstantiationFromTemplateDeclarationSatisfyingFilter(SgFunctionDeclaration *function, T *filter)
This function detects template instantiations that are relevant when filters are used.
void guardNode(SgLocatedNode *target, std::string guard)
Add preproccessor guard around a given node.
This class represents the rhs of a variable declaration which includes an optional assignment (e...
ROSE_DLL_API 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...
This class represents the base class for all types.
SgType * removeConst(SgType *t)
Remove const (if present) from a type. stripType() cannot do this because it removes all modifiers...
ROSE_DLL_API SgNode * deepCopyNode(const SgNode *subtree)
Deep copy an arbitrary subtree.
This class represents the concept of a do-while statement.
ROSE_DLL_API bool isUpcStrictSharedModifierType(SgModifierType *mode_type)
Check if a shared UPC type is strict memory consistency or not. Return false if it is relaxed...
struct const_int_expr_t evaluateConstIntegerExpression(SgExpression *expr)
The function tries to evaluate const integer expressions (such as are used in array dimension sizes)...
ROSE_DLL_API void getLiveVariables(LivenessAnalysis *liv, SgForStatement *loop, std::set< SgInitializedName * > &liveIns, std::set< SgInitializedName * > &liveOuts)
get liveIn and liveOut variables for a for loop from liveness analysis result liv.
This class represents the concept of a class name within the compiler.
SgFunctionDeclaration * findFunctionDeclaration(SgNode *root, std::string name, SgScopeStatement *scope, bool isDefining)
Topdown traverse a subtree from root to find the first function declaration matching the given name...
ROSE_DLL_API void moveStatementsBetweenBlocks(SgBasicBlock *sourceBlock, SgBasicBlock *targetBlock)
Move statements in first block to the second block (preserves order and rebuilds the symbol table)...
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsTrueBodyOfIf(SgIfStmt *ifs)
Check if the true body of a 'if' statement is a SgBasicBlock, create one if not.
SgMemberFunctionDeclaration * getDefaultDestructor(SgClassDeclaration *classDeclaration)
Get the default destructor from the class declaration.
ROSE_DLL_API bool isUpcArrayWithThreads(SgArrayType *t)
Is a UPC array with dimension of X*THREADS.
ROSE_DLL_API bool loopInterchange(SgForStatement *loop, size_t depth, size_t lexicoOrder)
Interchange/permutate a n-level perfectly-nested loop rooted at 'loop' using a lexicographical order ...
ROSE_DLL_API void appendExpressionList(SgExprListExp *, const std::vector< SgExpression * > &)
Append an expression list to a SgExprListExp, set the parent pointers also.
ROSE_DLL_API std::string mangleScalarType(SgType *type)
Generate mangled scalar type names according to Itanium C++ ABI, the input type should pass isScalarT...
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.
bool isStructDeclaration(SgNode *node)
Check if a SgNode is a declaration for a structure.
ROSE_DLL_API bool is_mixed_Fortran_and_Cxx_language()
Interface for creating a statement whose computation writes its answer into a given variable...
std::string generateUniqueVariableName(SgScopeStatement *scope, std::string baseName="temp")
Generate a name like temp# that is unique in the current scope and any parent and children scopes...
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
SgType * getBoolType(SgNode *n)
Get the right bool type according to C or C++ language input.
ROSE_DLL_API SgSourceFile * getEnclosingSourceFile(SgNode *n, const bool includingSelf=false)
Find enclosing source file node.
ROSE_DLL_API bool is_Python_language()
bool ROSE_DLL_API isStatic(SgDeclarationStatement *stmt)
Check if a declaration has a "static' modifier.
unsigned long long getIntegerConstantValue(SgValueExp *expr)
Get the constant value from a constant integer expression; abort on everything else.
This class represents the concept of a C and C++ expression list.
void clearScopeNumbers(SgFunctionDefinition *functionDefinition)
Clears the cache of scope,integer pairs for the input function.
ROSE_DLL_API void setStatic(SgDeclarationStatement *stmt)
Set a declaration as static.
ROSE_DLL_API void outputLocalSymbolTables(SgNode *node)
Output the local symbol tables.
ROSE_DLL_API bool isUpcSharedArrayType(SgArrayType *array_type)
Check if an array type is a UPC shared type. ROSE AST represents a UPC shared array as regular array ...
std::string get_name(const SgNode *node)
Generate a useful name to describe the SgNode.
ROSE_DLL_API bool is_binary_executable()
ROSE_DLL_API SgClassSymbol * lookupClassSymbolInParentScopes(const SgName &name, SgScopeStatement *currentScope=NULL, SgTemplateArgumentPtrList *templateArgumentList=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
PreprocessingInfo * insertHeader(SgSourceFile *source_file, const std::string &header_file_name, bool isSystemHeader, bool asLastHeader)
Insert #include "filename" or #include (system header) onto the global scope of a source f...
std::vector< SgBreakStmt * > findBreakStmts(SgStatement *code, const std::string &fortranLabel="")
Find break statements inside a particular statement, stopping at nested loops or switches.
ROSE_DLL_API void setSourcePositionForTransformation(SgNode *root)
Recursively set source position info(Sg_File_Info) as transformation generated.
ROSE_DLL_API void setLoopCondition(SgScopeStatement *loop, SgStatement *cond)
Set the condition statement of a loop, including While-loop, For-loop, and Do-While-loop.
ROSE_DLL_API SgStatement * getLoopBody(SgScopeStatement *loop)
Routines to get and set the body of a loop.
std::vector< SgFile * > generateFileList()
Returns STL vector of SgFile IR node pointers.
std::string generateUniqueNameForUseAsIdentifier_support(SgDeclarationStatement *declaration)
Global map of name collisions to support generateUniqueNameForUseAsIdentifier() function.
ROSE_DLL_API SgStatement * getPreviousStatement(SgStatement *currentStmt, bool climbOutScope=true)
Get previous statement of the current statement. It may return a previous statement of a parent scope...
ROSE_DLL_API int set_name(SgInitializedName *initializedNameNode, SgName new_name)
set_name of symbol in symbol table.
void changeAllBodiesToBlocks(SgNode *top, bool createEmptyBody=true)
Fix up ifs, loops, while, switch, Catch, OmpBodyStatement, etc. to have blocks as body components...
ROSE_DLL_API bool isPointerType(SgType *t)
Is this type a pointer type? (Handles typedefs correctly)
bool isOverloaded(SgFunctionDeclaration *functionDeclaration)
Return true if function is overloaded.
ROSE_DLL_API SgNode * getSgNodeFromAbstractHandleString(const std::string &input_string)
Obtain a matching SgNode from an abstract handle string.
ROSE_DLL_API void fixStatement(SgStatement *stmt, SgScopeStatement *scope)
A wrapper containing fixes (fixVariableDeclaration(),fixStructDeclaration(), fixLabelStatement(), etc) for all kinds statements. Should be used before attaching the statement into AST.
ROSE_DLL_API void deleteExpressionTreeWithOriginalExpressionSubtrees(SgNode *root)
Special purpose function for deleting AST expression tress containing valid original expression trees...
ROSE_DLL_API bool isCopyConstructible(SgType *type)
Is a type copy constructible? This may not quite work properly.
This class represents the base class of a numbr of IR nodes that don't otherwise fit into the existin...
Definition: Cxx_Grammar.h:9613
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)
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 bool isSameFunction(SgFunctionDeclaration *func1, SgFunctionDeclaration *func2)
Check if two function declarations refer to the same one. Two function declarations are the same when...
ROSE_DLL_API void convertAllForsToWhiles(SgNode *top)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
ROSE_DLL_API bool isConstantTrue(SgExpression *e)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
SgDeclarationStatement * getNonInstantiatonDeclarationForClass(SgTemplateInstantiationMemberFunctionDecl *memberFunctionInstantiation)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
ROSE_DLL_API int getDimensionCount(SgType *t)
Get the number of dimensions of an array type.
void visit(SgNode *node)
this method is called at every traversed node.
RelativePositionType
MK: Enum type to store if the directive goes before or after the corresponding line of source code...
void clearMangledNameCache(SgGlobal *globalScope)
Support for faster mangled name generation (caching avoids recomputation).
void whereAmI(SgNode *node)
Diagnostic function for tracing back through the parent list to understand at runtime where in the AS...
ROSE_DLL_API bool isStrictIntegerType(SgType *t)
Check if a type is an integral type, only allowing signed/unsigned short, int, long, long long. /! /! There is another similar function named SgType::isIntegerType(), which allows additional types char, wchar, and bool to be treated as integer types.
ROSE_DLL_API void removeUnusedLabels(SgNode *top)
Remove labels which are not targets of any goto statements.
SgBasicBlock * makeSingleStatementBodyToBlock(SgStatement *singleStmt)
Make a single statement body to be a basic block. Its parent is if, while, catch, or upc_forall etc...
ROSE_DLL_API SgInitializer * getInitializerOfExpression(SgExpression *n)
Get the initializer containing an expression if it is within an initializer.
ROSE_DLL_API void replaceExpression(SgExpression *oldExp, SgExpression *newExp, bool keepOldExp=false)
Replace an expression with another, used for variable reference substitution and others. the old expression can be deleted (default case) or kept.
ROSE_DLL_API bool is_OpenMP_language()
ROSE_DLL_API void moveUpPreprocessingInfo(SgStatement *stmt_dst, SgStatement *stmt_src, PreprocessingInfo::RelativePositionType src_position=PreprocessingInfo::undef, PreprocessingInfo::RelativePositionType dst_position=PreprocessingInfo::undef, bool usePrepend=false)
Identical to movePreprocessingInfo(), except for the stale name and confusing order of parameters...
This class represents the notion of an expression. Expressions are derived from SgLocatedNodes, since similar to statement, expressions have a concrete location within the user's source code.
ROSE_DLL_API 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 void setFortranNumericLabel(SgStatement *stmt, int label_value)
Set a numerical label for a Fortran statement. The statement should have a enclosing function definit...
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.
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:8404
ROSE_DLL_API void setSourcePosition(SgNode *node)
Set the source code positon for the current (input) node.
ROSE_DLL_API bool isPureVirtualClass(SgType *type, const ClassHierarchyWrapper &classHierarchy)
Check if a class type is a pure virtual class.
ROSE_DLL_API void removeStatement(SgStatement *stmt, bool autoRelocatePreprocessingInfo=true)
Remove a statement from its attach point of the AST. Automatically keep its associated preprocessing ...
ROSE_DLL_API bool isUseByAddressVariableRef(SgVarRefExp *ref)
Check if a variable reference is used by its address: including &a expression and foo(a) when type2 f...
ROSE_DLL_API SgGlobal * getFirstGlobalScope(SgProject *project)
return the first global scope under current project
ROSE_DLL_API void replaceExpressionWithStatement(SgExpression *from, SageInterface::StatementGenerator *to)
Replace a given expression with a list of statements produced by a generator.
ROSE_DLL_API void fixStructDeclaration(SgClassDeclaration *structDecl, SgScopeStatement *scope)
Fix symbols, parent and scope pointers. Used internally within appendStatment(), insertStatement() et...
ROSE_DLL_API SgType * getFirstVarType(SgVariableDeclaration *decl)
Get the data type of the first initialized name of a declaration statement.
ROSE_DLL_API bool isUpcSharedType(SgType *t, SgModifierType **mod_type_out=NULL)
Check if a type is a UPC shared type, including shared array, shared pointers etc. Exclude private pointers to shared types. Optionally return the modifier type with the UPC shared property.
ROSE_DLL_API void setLoopBody(SgScopeStatement *loop, SgStatement *body)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
ROSE_DLL_API int collectVariableReferencesInArrayTypes(SgLocatedNode *root, Rose_STL_Container< SgNode * > &currentVarRefList)
Collect variable references in array types. The default NodeQuery::querySubTree() will miss variables...
This class represents the concept of a class definition in C++.
This class represents strings within the IR nodes.
SgCommaOpExp * insertAfterUsingCommaOp(SgExpression *new_exp, SgExpression *anchor_exp, SgStatement **temp_decl=NULL, SgVarRefExp **temp_ref=NULL)
Insert an expression (new_exp ) after another expression (anchor_exp) has possible side effects...
void resetMangledNameCache(SgGlobal *globalScope)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsBodyOfWhile(SgWhileStmt *ws)
Check if the body of a 'while' statement is a SgBasicBlock, create one if not.
ROSE_DLL_API bool collectReadWriteVariables(SgStatement *stmt, std::set< SgInitializedName * > &readVars, std::set< SgInitializedName * > &writeVars, bool coarseGrain=true)
Collect unique variables which are read or written within a statement. Note that a variable can be bo...
ROSE_DLL_API size_t getArrayElementCount(SgArrayType *t)
Calculate the number of elements of an array type: dim1* dim2*... , assume element count is 1 for int...
ROSE_DLL_API void moveCommentsToNewStatement(SgStatement *sourceStatement, const std::vector< int > &indexList, SgStatement *targetStatement, bool surroundingStatementPreceedsTargetStatement)
Relocate comments and CPP directives from one statement to another.
ROSE_DLL_API bool isMain(const SgNode *node)
Check if a SgNode is a main() function declaration.
ROSE_DLL_API void setExtern(SgDeclarationStatement *stmt)
Set a declaration as extern.
ROSE_DLL_API void replaceStatement(SgStatement *oldStmt, SgStatement *newStmt, bool movePreprocessinInfo=false)
Replace a statement with another. Move preprocessing information from oldStmt to newStmt if requested...
std::vector< SgStatement * > getSwitchCases(SgSwitchStatement *sw)
Query a subtree to get all nodes of a given type, with an appropriate downcast.
void setSourcePositionAsTransformation(SgNode *node)
DQ (5/1/2012): New function with improved name.
bool isPrototypeInScope(SgScopeStatement *scope, SgFunctionDeclaration *functionDeclaration, SgDeclarationStatement *startingAtDeclaration)
Assigns unique numbers to each SgScopeStatement of a function.
Functions that are useful when operating on the AST.
Definition: sageBuilder.h:25
ROSE_DLL_API bool doLoopNormalization(SgFortranDo *loop)
Normalize a Fortran Do loop. Make the default increment expression (1) explicit.
ROSE_DLL_API bool isConstantFalse(SgExpression *e)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
ROSE_DLL_API bool isExtern(SgDeclarationStatement *stmt)
Check if a declaration has an "extern" modifier.
ROSE_DLL_API SgFunctionDeclaration * findMain(SgNode *currentNode)
top-down traversal from current node to find the main() function declaration
ROSE_DLL_API SgInitializedName * getFirstInitializedName(SgVariableDeclaration *decl)
Get the first initialized name of a declaration statement.
ROSE_DLL_API SgType * lookupNamedTypeInParentScopes(const std::string &type_name, SgScopeStatement *scope=NULL)
Lookup a named type based on its name, bottomup searching from a specified scope. Note name collison ...
ROSE_DLL_API bool is_UPC_dynamic_threads()
Check if dynamic threads compilation is used for UPC programs.
ROSE_DLL_API void 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.
std::pair< SgVariableDeclaration *, SgExpression * > createTempVariableForExpression(SgExpression *expression, SgScopeStatement *scope, bool initializeInDeclaration, SgAssignOp **reEvaluate=NULL)
Given an expression, generates a temporary variable whose initializer optionally evaluates that expre...
ROSE_DLL_API std::set< SgStatement * > collectModifiedStatements(SgNode *node)
This collects the statements that are marked as modified (a flag automatically set by all set_* gener...
ROSE_DLL_API void ReductionRecognition(SgForStatement *loop, std::set< std::pair< SgInitializedName *, OmpSupport::omp_construct_enum > > &results)
Recognize and collect reduction variables and operations within a C/C++ loop, following OpenMP 3...
ROSE_DLL_API SgStatement * getLoopCondition(SgScopeStatement *loop)
Routines to get the condition of a loop. It recognize While-loop, For-loop, and Do-While-loop.
This class represents the concept of a namespace name within the compiler.
ROSE_DLL_API void fixFunctionDeclaration(SgFunctionDeclaration *stmt, SgScopeStatement *scope)
Fix the symbol table and set scope (only if scope in declaration is not already set).
SgBasicBlock * ensureBasicBlockAsBodyOfCaseOption(SgCaseOptionStmt *cs)
Check if the body of a 'case option' statement is a SgBasicBlock, create one if not.
This class represents the base class for all IR nodes within Sage III.
Definition: Cxx_Grammar.h:8656
This class represents the concept of a catch within a try-catch construct used in C++ exception handl...
uint64_t getAsmConstant(SgAsmValueExpression *e)
Get the unsigned value of a disassembled constant.
This class represents the notion of an value (expression value).
This class represents the concept of a variable name within the compiler (a shared container for the ...
This class represents the concept of an instantiation of function template.
bool isPrefixOperatorName(const SgName &functionName)
Check for proper names of possible prefix operators (used in isPrefixOperator()). ...
bool isUnionDeclaration(SgNode *node)
Check if a SgNode is a declaration for a union.
ROSE_DLL_API std::set< SgStatement * > collectTransformedStatements(SgNode *node)
This collects the statements that are marked as transformed (useful in debugging).
NodeType * getEnclosingNode(const SgNode *astNode, const bool includingSelf=false)
Find a node by type using upward traversal.
ROSE_DLL_API bool is_Jovial_language()
ROSE_DLL_API void collectReadOnlySymbols(SgStatement *stmt, std::set< SgVariableSymbol * > &readOnlySymbols, bool coarseGrain=true)
Collect read only variable symbols within a statement. The statement can be either of a function...
ROSE_DLL_API void moveForStatementIncrementIntoBody(SgForStatement *f)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
SgTemplateMemberFunctionDeclaration * get_templateDeclaration() const
Returns pointer to SgTemplateDeclaration from which instantiation is generated.
std::vector< SgDeclarationStatement * > getDependentDeclarations(SgStatement *stmt)
Get a statement's dependent declarations which declares the types used in the statement. The returned vector of declaration statements are sorted according to their appearance order in the original AST. Any reference to a class or template class from a namespace will treated as a reference to the enclosing namespace.
ROSE_DLL_API void prependStatementList(const std::vector< SgStatement * > &stmt, SgScopeStatement *scope=NULL)
prepend a list of statements to the beginning of the current scope, handling side effects as appropri...
ROSE_DLL_API SgClassDefinition * getEnclosingClassDefinition(SgNode *astnode, const bool includingSelf=false)
Get the closest class definition enclosing the specified AST node,.
std::map< std::string, SgNode * > local_name_to_node_map
Global map of name collisions to support generateUniqueNameForUseAsIdentifier() function.
ROSE_DLL_API void replaceVariableReferences(SgVariableSymbol *old_sym, SgVariableSymbol *new_sym, SgScopeStatement *scope)
Replace all variable references to an old symbol in a scope to being references to a new symbol...
SgStatement * lastStatementOfScopeWithTokenInfo(SgScopeStatement *scope, std::map< SgNode *, TokenStreamSequenceToNodeMapping * > &tokenStreamSequenceMap)
Used to support token unparsing (when the output the trailing token sequence).
ROSE_DLL_API bool unnormalizeForLoopInitDeclaration(SgForStatement *loop)
Undo the normalization of for loop's C99 init declaration. Previous record of normalization is used t...
ROSE_DLL_API bool is_OpenCL_language()
ROSE_DLL_API bool normalizeForLoopInitDeclaration(SgForStatement *loop)
Normalize loop init stmt by promoting the single variable declaration statement outside of the for lo...
ROSE_DLL_API bool isLastStatement(SgStatement *stmt)
Check if a statement is the last statement within its closed scope.
ROSE_DLL_API SgType * getAssociatedTypeFromFunctionTypeList(SgExpression *actual_argument_expression)
Get the type of the associated argument expression from the function type.
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsBodyOfFor(SgForStatement *fs)
Check if the body of a 'for' statement is a SgBasicBlock, create one if not.
std::vector< SgExpression * > get_C_array_dimensions(const SgArrayType &arrtype)
returns the array dimensions in an array as defined for arrtype
This class represents the concept of a block (not a basic block from control flow analysis)...
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()
This class represents the concept of a namespace definition.
This class represents the concept of a for loop.
ROSE_DLL_API SgStatement * getLastStatement(SgScopeStatement *scope)
get the last statement within a scope, return NULL if it does not exit
void clearUnusedVariableSymbols(SgNode *root=NULL)
Clear those variable symbols with unknown type (together with initialized names) which are also not r...
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsBodyOfDoWhile(SgDoWhileStmt *ws)
Check if the body of a 'do .. while' statement is a SgBasicBlock, create one if not.
ROSE_DLL_API void resetInternalMapsForTargetStatement(SgStatement *sourceStatement)
Function to delete AST subtree's nodes only, users must take care of any dangling pointers...
SgDeclarationStatement * get_definingDeclaration() const
This is an access function for the SgDeclarationStatement::p_definingDeclaration data member (see tha...
ROSE_DLL_API void recordNormalizations(SgStatement *s)
Record where normalization have been done so that we can preform denormalizations as required for the...
ROSE_DLL_API SgInitializedName * getLoopIndexVariable(SgNode *loop)
Return the loop index variable for a for loop.
ROSE_DLL_API bool is_X10_language()
This class represents a type for all functions.
void annotateExpressionsWithUniqueNames(SgProject *project)
Generate unique names for expressions and attach the names as persistent attributes ("UniqueNameAttri...
SgInitializedName & getFirstVariable(SgVariableDeclaration &vardecl)
convenience function that returns the first initialized name in a list of variable declarations...
ROSE_DLL_API bool isCallToParticularFunction(SgFunctionDeclaration *decl, SgExpression *e)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
This class represents the concept of a namespace definition.
ROSE_DLL_API void moveVariableDeclaration(SgVariableDeclaration *decl, SgScopeStatement *target_scope)
Move a variable declaration to a new scope, handle symbol, special scopes like For loop...
ROSE_DLL_API SgStatement * copyStatement(SgStatement *s)
Deep copy a statement.
void addMessageStatement(SgStatement *stmt, std::string message)
Function to add "C" style comment to statement.
ROSE_DLL_API SgBasicBlock * ensureBasicBlockAsBodyOfCatch(SgCatchOptionStmt *cos)
Check if the body of a 'catch' statement is a SgBasicBlock, create one if not.
ROSE_DLL_API bool isScalarType(SgType *t)
Is this a scalar type?
This class represents the concept of a C Assembler statement (untested).
ROSE_DLL_API void appendExpression(SgExprListExp *, SgExpression *)
Append an expression to a SgExprListExp, set the parent pointer also.
ROSE_DLL_API void updateDefiningNondefiningLinks(SgFunctionDeclaration *func, SgScopeStatement *scope)
Update defining and nondefining links due to a newly introduced function declaration. Should be used after inserting the function into a scope.
ROSE_DLL_API bool hasUpcSharedType(SgType *t, SgModifierType **mod_type_out=NULL)
Has a UPC shared type of any kinds (shared-to-shared, private-to-shared, shared-to-private, shared scalar/array)? An optional parameter, mod_type_out, stores the first SgModifierType with UPC access information.
bool isIndexOperator(SgExpression *exp)
Is an overloaded operator an index operator (also referred to as call or subscript operators)...
ROSE_DLL_API bool hasSimpleChildrenList(SgScopeStatement *scope)
Check if a scope statement has a simple children statement list so insert additional statements under...
ROSE_DLL_API bool isNonconstReference(SgType *t)
Is this type a non-constant reference type? (Handles typedefs correctly)
This class represents the concept of a C or C++ default case within a switch statement.
ROSE_DLL_API bool templateArgumentEquivalence(SgTemplateArgument *arg1, SgTemplateArgument *arg2)
Verify that 2 SgTemplateArgument are equivalent (same type, same expression, or same template declara...
This class represents the concept of an "if" construct.
ROSE_DLL_API SgSymbol * lookupSymbolInParentScopes(const SgName &name, SgScopeStatement *currentScope=NULL, SgTemplateParameterPtrList *templateParameterList=NULL, SgTemplateArgumentPtrList *templateArgumentList=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
to specify a construct using a specifier Can be used alone or with parent handles when relative speci...
ROSE_DLL_API void fixVariableDeclaration(SgVariableDeclaration *varDecl, SgScopeStatement *scope)
Patch up symbol, scope, and parent information when a SgVariableDeclaration's scope is known...
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 int fixVariableReferences(SgNode *root)
Connect variable reference to the right variable symbols when feasible, return the number of referenc...
ROSE_DLL_API bool forLoopNormalization(SgForStatement *loop, bool foldConstant=true)
Normalize a for loop, return true if successful.
ROSE_DLL_API SgNamespaceSymbol * lookupNamespaceSymbolInParentScopes(const SgName &name, SgScopeStatement *currentScope=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
ROSE_DLL_API SgScopeStatement * findEnclosingLoop(SgStatement *s, const std::string &fortranLabel="", bool stopOnSwitches=false)
Find the closest loop outside the given statement; if fortranLabel is not empty, the Fortran label of...
This class represents the notion of an expression or statement which has a position within the source...
ROSE_DLL_API bool isReferenceType(SgType *t)
Is this type a const or non-const reference type? (Handles typedefs correctly)
This class represents template argument within the use of a template to build an instantiation.
ROSE_DLL_API void appendStatement(SgStatement *stmt, SgScopeStatement *scope=NULL)
Append a statement to the end of the current scope, handle side effect of appending statements...
This class represents the variable refernece in expressions.
ROSE_DLL_API void insertStatementAfterLastDeclaration(SgStatement *stmt, SgScopeStatement *scope)
Insert a statement after the last declaration within a scope. The statement will be prepended to the ...
This class represents the concept of a do-while statement.
ROSE_DLL_API std::vector< SgNode * > astIntersection(SgNode *original, SgNode *copy, SgCopyHelp *help=NULL)
Compute the intersection set for two ASTs.
ROSE_DLL_API bool isUpcPrivateToSharedType(SgType *t)
Is a UPC private-to-shared pointer? SgPointerType comes first compared to SgModifierType with UPC inf...
void initializeSwitchStatement(SgSwitchStatement *switchStatement, SgStatement *item_selector, SgStatement *body)
Support function used for variable declarations in conditionals.
std::map< std::string, int > local_name_collision_map
Global map of name collisions to support generateUniqueNameForUseAsIdentifier() function.
ROSE_DLL_API void setLoopUpperBound(SgNode *loop, SgExpression *ub)
Set the upper bound of a loop header,regardless the condition expression type. for (i=lb; i op up...
ROSE_DLL_API SgEnumSymbol * lookupEnumSymbolInParentScopes(const SgName &name, SgScopeStatement *currentScope=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
ROSE_DLL_API std::set< SgLocatedNode * > collectModifiedLocatedNodes(SgNode *node)
This collects the SgLocatedNodes that are marked as modified (a flag automatically set by all set_* g...
ROSE_DLL_API bool isDefaultConstructible(SgType *type)
Is a type default constructible? This may not quite work properly.
ROSE_DLL_API void wrapAllTemplateInstantiationsInAssociatedNamespaces(SgProject *root)
Function to delete AST subtree's nodes only, users must take care of any dangling pointers...
ROSE_DLL_API void convertForToWhile(SgForStatement *f)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
ROSE_DLL_API SgTypedefSymbol * lookupTypedefSymbolInParentScopes(const SgName &name, SgScopeStatement *currentScope=NULL)
Find a symbol in current and ancestor scopes for a given variable name, starting from top of ScopeSta...
ROSE_DLL_API bool loopTiling(SgForStatement *loopNest, size_t targetLevel, size_t tileSize)
Tile the n-level (starting from 1) loop of a perfectly nested loop nest using tiling size s...
Base class for values.
SgTemplateInstantiationMemberFunctionDecl * buildForwardFunctionDeclaration(SgTemplateInstantiationMemberFunctionDecl *memberFunctionInstantiation)
Generate a non-defining (forward) declaration from a defining function declaration.
ROSE_DLL_API bool mergeDeclarationWithAssignment(SgVariableDeclaration *decl, SgExprStatement *assign_stmt)
Merge a declaration statement into a matching followed variable assignment. Callers should make sure ...
void computeUniqueNameForUseAsIdentifier(SgNode *astNode)
Traversal to set the global map of names to node and node to names.collisions to support generateUniq...
ROSE_DLL_API bool isAssignable(SgType *type)
Is a type assignable? This may not quite work properly.
ROSE_DLL_API void setLoopLowerBound(SgNode *loop, SgExpression *lb)
Set the lower bound of a loop header for (i=lb; ...)
ROSE_DLL_API SgProject * getProject()
Get the current SgProject IR Node.
ROSE_DLL_API bool is_PHP_language()
ROSE_DLL_API bool normalizeForLoopIncrement(SgForStatement *loop)
Add a step statement to the end of a loop body Add a new label to the end of the loop, with the step statement after it; then change all continue statements in the old loop body into jumps to the label.
ROSE_DLL_API void splitExpressionIntoBasicBlock(SgExpression *expr)
Split long expressions into blocks of statements.
void initializeWhileStatement(SgWhileStmt *whileStatement, SgStatement *condition, SgStatement *body, SgStatement *else_body)
Support function used for variable declarations in conditionals.
void addVarRefExpFromArrayDimInfo(SgNode *astNode, Rose_STL_Container< SgNode * > &NodeList_t)
Find all SgPntrArrRefExp under astNode, then add SgVarRefExp (if any) of SgPntrArrRefExp's dim_info i...
ROSE_DLL_API void removeConsecutiveLabels(SgNode *top)
Remove consecutive labels.
ROSE_DLL_API void setOneSourcePositionForTransformation(SgNode *root)
Set current node's source position as transformation generated.
ROSE_DLL_API void moveDeclarationToAssociatedNamespace(SgDeclarationStatement *declarationStatement)
Relocate the declaration to be explicitly represented in its associated namespace (required for some ...
ROSE_DLL_API void setRhsOperand(SgExpression *target, SgExpression *rhs)
set left hand operand for binary expression
SgNode * get_parent() const
Access function for parent node.
ROSE_DLL_API void myRemoveStatement(SgStatement *stmt)
A special purpose statement removal function, originally from inlinerSupport.h, Need Jeremiah's atten...
bool functionCallExpressionPreceedsDeclarationWhichAssociatesScope(SgFunctionCallExp *functionCall)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
ROSE_DLL_API int suggestNextNumericLabel(SgFunctionDefinition *func_def)
Suggest next usable (non-conflicting) numeric label value for a Fortran function definition scope...
ROSE_DLL_API int gensym_counter
An internal counter for generating unique SgName.
ROSE_DLL_API bool isEqualToIntConst(SgExpression *e, int value)
Check if a SgIntVal node has a given value.
ROSE_DLL_API void setLoopStride(SgNode *loop, SgExpression *stride)
Set the stride(step) of a loop 's incremental expression, regardless the expression types (i+=s; i= i...
ROSE_DLL_API SgStatement * getFirstStatement(SgScopeStatement *scope, bool includingCompilerGenerated=false)
Get the first statement within a scope, return NULL if it does not exist. Skip compiler-generated sta...
ROSE_DLL_API void changeContinuesToGotos(SgStatement *stmt, SgLabelStatement *label)
Change continue statements in a given block of code to gotos to a label.
ROSE_DLL_API SgSwitchStatement * findEnclosingSwitch(SgStatement *s)
Find the closest switch outside a given statement (normally used for case and default statements) ...
ROSE_DLL_API bool is_Cxx_language()
void rebuildSymbolTable(SgScopeStatement *scope)
Regenerate the symbol table.
ROSE_DLL_API void collectUseByAddressVariableRefs(const SgStatement *s, std::set< SgVarRefExp * > &varSetB)
Collect variable references involving use by address: including &a expression and foo(a) when type2 f...
ROSE_DLL_API bool isConstType(SgType *t)
Is this a const type?
ROSE_DLL_API LivenessAnalysis * call_liveness_analysis(SgProject *project, bool debug=false)
Call liveness analysis on an entire project.
SgFunctionDeclaration * getDeclarationOfNamedFunction(SgExpression *func)
Given a SgExpression that represents a named function (or bound member function), return the mentione...
ROSE_DLL_API bool isRestrictType(SgType *t)
Is this a restrict type?
ROSE_DLL_API bool is_C99_language()
This class represents a source project, with a list of SgFile objects and global information about th...
ROSE_DLL_API SgStatement * getNextStatement(SgStatement *currentStmt)
Get next statement within the same scope of current statement.
ROSE_DLL_API SgType * getElementType(SgType *t)
Get the element type of an array, pointer or string, or NULL if not applicable. This function only ch...
ROSE_DLL_API void fixLabelStatement(SgLabelStatement *label_stmt, SgScopeStatement *scope)
Fix symbol table for SgLabelStatement. Used Internally when the label is built without knowing its ta...
ROSE_DLL_API void movePreprocessingInfo(SgStatement *stmt_src, SgStatement *stmt_dst, PreprocessingInfo::RelativePositionType src_position=PreprocessingInfo::undef, PreprocessingInfo::RelativePositionType dst_position=PreprocessingInfo::undef, bool usePrepend=false)
Move preprocessing information of stmt_src to stmt_dst, Only move preprocessing information from the ...
ROSE_DLL_API void appendStatementWithDependentDeclaration(SgDeclarationStatement *decl, SgGlobal *scope, SgStatement *original_statement, bool excludeHeaderFiles)
Append a copy ('decl') of a function ('original_statement') into a 'scope', include any referenced de...
virtual std::string class_name() const ROSE_OVERRIDE
returns a string representing the class name
ROSE_DLL_API SgVariableSymbol * appendArg(SgFunctionParameterList *, SgInitializedName *)
Append an argument to SgFunctionParameterList, transparently set parent,scope, and symbols for argume...
ROSE_DLL_API bool isTemplateInstantiationNode(SgNode *node)
Function to delete AST subtree's nodes only, users must take care of any dangling pointers...
ROSE_DLL_API bool is_mixed_Fortran_and_C_language()
SgNamespaceDefinitionStatement * enclosingNamespaceScope(SgDeclarationStatement *declaration)
Find the enclosing namespace of a declaration.
ROSE_DLL_API bool is_CAF_language()
ROSE_DLL_API void removeJumpsToNextStatement(SgNode *)
Remove jumps whose label is immediately after the jump. Used to clean up inlined code fragments...
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.
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 bool loopUnrolling(SgForStatement *loop, size_t unrolling_factor)
Unroll a target loop with a specified unrolling factor. It handles steps larger than 1 and adds a fri...
std::string addMangledNameToCache(SgNode *astNode, const std::string &mangledName)
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST wi...
bool ROSE_DLL_API isAncestor(SgNode *node1, SgNode *node2)
check if node1 is a strict ancestor of node 2. (a node is not considered its own ancestor) ...
This class represents the concept of a declaration statement.
virtual SgName get_name() const =0
Access function for getting name from declarations or types internally.
This class represents the concept of a switch.
ROSE_DLL_API SgExpression * copyExpression(SgExpression *e)
Deep copy an expression.
int64_t getAsmSignedConstant(SgAsmValueExpression *e)
Get the signed value of a disassembled constant.
ROSE_DLL_API bool isUpcPhaseLessSharedType(SgType *t)
Is UPC phase-less shared type? Phase-less means block size of the first SgModifierType with UPC infor...
ROSE_DLL_API SgType * getArrayElementType(SgType *t)
Get the element type of an array. It recursively find the base type for multi-dimension array types...
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...