Skip to content

Functions

Name Description
AddConst
int AddConst( int a, int b);
AnalyzeConditionRefs
bool AnalyzeConditionRefs( AstInterface& fa, AstNodePtr const& n, CollectObject<AstNodePtr>& wRefs, CollectObject<AstNodePtr>& rRefs);
AnalyzeEquation
template< class CoeffVec, class BoundVec, class BoundOp, class Dep> bool AnalyzeEquation( CoeffVec const& vec, BoundVec const& bounds, BoundOp& boundop, Dep& result, DepRel const& rel);
AnalyzeStmtRefs
bool AnalyzeStmtRefs( AstInterface& fa, AstNodePtr const& n, CollectObject<AstNodePtr>& wRefs, CollectObject<AstNodePtr>& rRefs);
ApplyBinOP
SymbolicVal ApplyBinOP( SymOpType t, SymbolicVal const& v1, SymbolicVal const& v2);
ApplyLoopSplitting
void ApplyLoopSplitting(LoopTreeNode* r);
ApplyUnaryOP
SymbolicVal ApplyUnaryOP( SymOpType t, SymbolicVal const& v);
AstPostProcessing
[[visibility("default")]] void AstPostProcessing(SgNode* node);
Clone
DepInfoImpl* Clone(DepInfoImpl const& that);
Closure
DepInfoSet Closure(DepInfoSet d);
CompareVal
CompareRel CompareVal( SymbolicVal const& v1, SymbolicVal const& v2, MapObject<SymbolicVal, SymbolicBound>* f = 0);
ComputeLoopDep
template<class Result> void ComputeLoopDep( AstNodePtr const& exp, DepRel const& rel, Result& r);
CopyArrayOpt2String
std::string CopyArrayOpt2String(CopyArrayOpt opt);
CopyNodeEdge
template< class Graph, class Node> void CopyNodeEdge( Graph* graph, Node* orig, Node* des);
CopySplitNodeEdge
template< class Graph, class Node> void CopySplitNodeEdge( Graph* graph, Node* orig, Node* split, DomainCond const& splitCond);
CountEnclosedStmts
unsigned int CountEnclosedStmts(LoopTreeNode* root);
CountIteratorSize
template<class Iter> unsigned int CountIteratorSize(Iter iter);
DebugAnnot
extern bool DebugAnnot();
DecomposeAffineExpression
template< class VarVec, class CoeffVec> SymbolicVal DecomposeAffineExpression( SymbolicVal const& exp, VarVec const& vars, CoeffVec& vec, int size);
DepGraphInsertLoop
template< class Graph, class SelectNode> void DepGraphInsertLoop( Graph* graph, SelectNode nodes, int level);
DepGraphNodeAlignLoop
template< class Graph, class Node> void DepGraphNodeAlignLoop( Graph* graph, Node* node, int level, int align);
DepGraphNodeInsertLoop
template< class Graph, class Node> void DepGraphNodeInsertLoop( Graph* graph, Node* n, int level);
DepGraphNodeMergeLoop
template< class Graph, class Node> void DepGraphNodeMergeLoop( Graph* graph, Node* node, int desc, int src);
DepGraphNodeRemoveLoop
template< class Graph, class Node> void DepGraphNodeRemoveLoop( Graph* graph, Node* node, int level);
DepGraphNodeRestrictDomain
template< class Graph, class Node> void DepGraphNodeRestrictDomain( Graph* graph, Node* node, DomainCond const& cond);
DepGraphNodeSwapLoop
template< class Graph, class Node> void DepGraphNodeSwapLoop( Graph* graph, Node* node, int level1, int level2);
DepType2String
std::string DepType2String(DepType t);
DoubleToString
std::string DoubleToString(double d);
EdgeDir2DepDir
DepDirection EdgeDir2DepDir(GraphAccess::EdgeDirection dir);
Equal
bool Equal( SymbolicVal const& v1, SymbolicVal const& v2);
FindFirst
template< class Iter, class Update> bool FindFirst( Iter& iter, Update T);
FindVal
bool FindVal( SymbolicVal const& v, SymbolicVal const& sub);
FuseDepGraphNode
template< class Graph, class Node> void FuseDepGraphNode( Graph* graph, Node* orig, Node* split);
FuseSliceNests
void FuseSliceNests( CompSliceNest& g1, CompSliceNest& g2, DepInfo const& info);
GetCommonLoop
template< class Stmt, class Interface> Stmt GetCommonLoop( Interface& ast_interface, Stmt b1, Stmt b2, int* level = 0);
GetEnclosingLoop
template< class Stmt, class Interface> Stmt GetEnclosingLoop( Stmt n, Interface& ast_interface);
GetExprVal
SymbolicVal GetExprVal(SymbolicExpr* exp);
GetFirstOperand
SgExpression* GetFirstOperand(SgExpression* expr);
GetFusionInfo
FusionInfo GetFusionInfo( DepInfo const& info, int index1, int index2);
GetImplicitConversionObject
SgExpression* GetImplicitConversionObject(SgFunctionCallExp* call);
GetLoopLevel
template< class Stmt, class Interface> int GetLoopLevel( Stmt s, Interface& ast_interface);
GetOperatorVariant
int GetOperatorVariant(SgExpression* expr);
GetValBound
SymbolicBound GetValBound( SymbolicVal val, MapObject<SymbolicVal, SymbolicBound>& f);
GetValLB
SymbolicVal GetValLB( SymbolicVal const& val, MapObject<SymbolicVal, SymbolicBound>& f);
GetValUB
SymbolicVal GetValUB( SymbolicVal const& val, MapObject<SymbolicVal, SymbolicBound>& f);
GraphNodeToString
template< class Graph, class Node> std::string GraphNodeToString( Graph const& g, Node const* n);
GraphToString
template<class Graph> std::string GraphToString(Graph const& g);
HasFraction
bool HasFraction( SymbolicVal const& v, SymbolicVal* integral = 0, SymbolicVal* frac = 0);
IncreaseAlign
DepRel IncreaseAlign( DepRel const& r, int a);
IsImportantForSliceSgFilter
[[visibility("default")]] bool IsImportantForSliceSgFilter(SgNode* n);
IsNIL
bool IsNIL(DepInfo const& info);
IsOne
bool IsOne(SymbolicTerm const& t);
IsSimpleStmt
bool IsSimpleStmt(LoopTreeNode const* node);
IsValidDep
bool IsValidDep( DepInfo const& info, int commLevel);
IsZero
bool IsZero(SymbolicTerm const& t);
IteratorToString1
template<class Iter> std::string IteratorToString1(Iter iter);
IteratorToString2
template<class Iter> std::string IteratorToString2(Iter iter);
LessThan
bool LessThan( DepRel const& e1, DepRel const& e2);
Max
SymbolicVal Max( SymbolicVal const& v1, SymbolicVal const& v2, MapObject<SymbolicVal, SymbolicBound>* f = 0);
Min
SymbolicVal Min( SymbolicVal const& v1, SymbolicVal const& v2, MapObject<SymbolicVal, SymbolicBound>* f = 0);
MoveNodeEdge
template< class Graph, class Node> void MoveNodeEdge( Graph* graph, Node* orig, Node* des);
New_File_Info
Sg_File_Info* New_File_Info(SgLocatedNode* p);
NormalizeForLoop
void NormalizeForLoop( AstInterface& fa, AstNodePtr const& head);
NormalizeMatrix
template<class Mat> bool NormalizeMatrix( Mat& analMatrix, int rows, int cols);
OptimizeLoopTree
void OptimizeLoopTree(LoopTreeNode* r);
PrintResults
void PrintResults(std::string const buffer);
PropagateDefUseChainUpdate
template<class Node> void PropagateDefUseChainUpdate( DefUseChain<Node>* graph, UpdateDefUseChainNode<Node>& update);
ReadAstTraverse
bool ReadAstTraverse( AstInterface& fa, AstNodePtr const& root, ProcessAstNode<AstNodePtr>& op, AstInterface::TraversalOrderType t = AstInterface::PreOrder);
Traverse an entire AST, where (op) is invoked on each AST node to gather information.
RelToString
std::string RelToString(CompareRel r);
ReplaceVal
SymbolicVal ReplaceVal( SymbolicVal const& v, MapObject<SymbolicVal, SymbolicVal>& valmap);
RestrictDepDomain
void RestrictDepDomain( DepInfo& dep, DomainInfo const& domain, DepDirection dir);
Reverse
CompareRel Reverse(CompareRel rel);
SelectDepLevel
bool SelectDepLevel( DepInfo const& d, int level);
SelectDepType
bool SelectDepType( DepInfo const& info, DepType const& sel);
SelfSpatialReuse
float SelfSpatialReuse( AstNodePtr const& r, SymbolicVar const& induction, unsigned int linesize);
SetDepDirection
template<class Collect> int SetDepDirection( DepInfo& edd, int commLevel, Collect& result);
SgExpr2Var
varID SgExpr2Var(SgExpression const* expr);
SgTreeTraversal_inFileToTraverse
[[visibility("default")]] bool SgTreeTraversal_inFileToTraverse( SgNode* node, bool traversalConstraint, SgFile* fileToVisit);
Sg_options
Sg_Options& Sg_options();
SliceLoopIvar
SymbolicVar SliceLoopIvar( AstInterface& fa, CompSlice const* slice);
SliceLoopRange
SymbolicBound SliceLoopRange( CompSlice const* slice, LoopTreeNode* root);
SliceLoopStep
LoopStepInfo SliceLoopStep(CompSlice const* slice);
SliceNestReverseTypedFusion
void SliceNestReverseTypedFusion( CompSliceLocalityRegistry* anal, CompSliceDepGraphCreate& t, LoopNestFusion const& fuse);
SliceNestTypedFusion
void SliceNestTypedFusion( CompSliceLocalityRegistry* anal, CompSliceDepGraphCreate& t, LoopNestFusion const& fuse);
SplitEquation
template< class CoeffVec, class BoundVec, class BoundOp> bool SplitEquation( CoeffVec& cur, SymbolicVal const& cut, BoundVec const& bounds, BoundOp& boundop, CoeffVec& split);
StatementListInsertChild
template<class Elemtype> bool StatementListInsertChild( SgStatement* parent, std::vector<Elemtype*>& statement_or_declaration_container, SgStatement* target, SgStatement* n, bool inFront, bool extractFromBasicBlock, bool removeCurrent);
StatementReplace
template<class Elemtype> bool StatementReplace( SgStatement* parent, Elemtype*& cur, SgStatement* target, SgStatement* newstmt);
TemporaryReuseRefs
DepType TemporaryReuseRefs( DepInfoConstIterator ep, Map2Object<AstNodePtr, DepDirection, int>& loopmap, CollectObject<AstNodePtr>& refCollect, int* dist = 0);
ToString
std::string ToString(std::vector<std::vector<SymbolicVal>>& analMatrix);
TransformAstTraverse
AstNodePtr TransformAstTraverse( AstInterface& fa, AstNodePtr const& r, TransformAstTree& op, AstInterface::TraversalVisitType t = AstInterface::PreVisit);
Traverse and transform an entire AST, where (op) is invoked to transform each sub-Tree.
UnwrapVarCond
SymbolicVal UnwrapVarCond( SymbolicCond const& valCond, SymbolicVar const& pivot, SymbolicBound& pivotBound);
UpdateEach
template< class Iter, class Update> void UpdateEach( Iter iter, Update T);
UpdateEachNodeEdge
template< class Graph, class SelectNode, class EdgeOp> void UpdateEachNodeEdge( Graph* graph, SelectNode nodes, EdgeOp op);
UpdateMatrix
template< class Mat, class ElemOp> bool UpdateMatrix( Mat& d1, Mat const& d2, ElemOp op);
UpdateNodeEdge
template< class Graph, class EdgeOp, class Node> void UpdateNodeEdge( Graph* graph, Node* orig, EdgeOp op);
XOMP_barrier
extern void XOMP_barrier();
XOMP_static_even_divide
extern void XOMP_static_even_divide( long start, long orig_size, int chunk_count, int chunk_id, long* chunk_offset, long* chunk_size);
XOMP_task
extern void XOMP_task( void(*)(void*), void*, void(*)(void*, void*), long, long, bool, unsigned int);
XOMP_taskwait
extern void XOMP_taskwait();
addPredefinedVars
void addPredefinedVars(varIDSet& vars);
attachPreprocessingInfo
void attachPreprocessingInfo( SgSourceFile* sageFile, std::string const& new_filename = "", bool attach_to_ast = true);
backend
[[visibility("default")]] int backend( SgProject* project, UnparseFormatHelp* unparseFormatHelp = NULL, UnparseDelegate* unparseDelegate = NULL);
backendCompilesUsingOriginalInputFile
[[visibility("default")]] int backendCompilesUsingOriginalInputFile( SgProject* project, bool compile_with_USE_ROSE_macro = false);
backendGeneratesSourceCodeButCompilesUsingOriginalInputFile
[[visibility("default")]] int backendGeneratesSourceCodeButCompilesUsingOriginalInputFile(SgProject* project);
buildArtificialFrontier
void buildArtificialFrontier( SgSourceFile* sourceFile, bool traverseHeaderFiles, TokenUnparseFrontierFileContext& frontierContext);
buildClangTemplateInstantiationNameForFrontend
std::string buildClangTemplateInstantiationNameForFrontend( std::string const& baseName, llvm::ArrayRef<clang::TemplateArgument> templateArguments, clang::LangOptions const& languageOptions);
buildIntegralTemplateArgExpr
SgValueExp* buildIntegralTemplateArgExpr( llvm::APSInt const& value, SgType* type);
buildSourceFileForHeaderFile
SgSourceFile* buildSourceFileForHeaderFile( SgProject* project, std::string originalFileName);
buildTokenStreamMapping
void buildTokenStreamMapping( SgSourceFile* sourceFile, std::vector<stream_element*>& tokenVector);
buildTokenStreamMappingForRoot
void buildTokenStreamMappingForRoot( SgSourceFile* sourceFile, SgNode* traversalRoot, std::vector<stream_element*>& tokenVector);
buildVariableList
void buildVariableList(SgOmpVariablesClause* current_omp_clause);
callGraphDeclHasIndependentCallableIdentity
[[visibility("default")]] bool callGraphDeclHasIndependentCallableIdentity(SgFunctionDeclaration* fdecl);
callGraphFunctionHasUserSourceOwnership
[[visibility("default")]] std::optional<bool> callGraphFunctionHasUserSourceOwnership(SgFunctionDeclaration* declaration);
call_graph_traversal_includes_function_decl
bool call_graph_traversal_includes_function_decl(SgFunctionDeclaration* decl);
checkOpenMPIR
bool checkOpenMPIR(OpenMPDirective*);
checkPhysicalSourcePosition
void checkPhysicalSourcePosition(SgNode* ast);
clangDeclHasBuiltinAttr
bool clangDeclHasBuiltinAttr(clang::Decl const* decl);
clangFrontendDeclarationHasExactCompletedSourceSurfaceOwnership
bool clangFrontendDeclarationHasExactCompletedSourceSurfaceOwnership(SgDeclarationStatement* declaration);
clangFrontendImportedNamespaceModule
clang::Module const* clangFrontendImportedNamespaceModule(clang::NamespaceDecl const* namespace_decl);
clangFunctionDeclIsBuiltinSupportForFrontend
bool clangFunctionDeclIsBuiltinSupportForFrontend( clang::FunctionDecl const* decl, clang::CompilerInstance const* ci, SagePreprocessorRecord const* preprocessor_record);
clangTemplateParameterSpelling
std::string clangTemplateParameterSpelling(clang::NamedDecl const* parameter);
clang_main
int clang_main( int argc, char* argv[], SgSourceFile& sageFile, char const* driver_argv0);
cleanupInlinedCode
[[visibility("default")]] void cleanupInlinedCode(SgNode* n);
Combined procedure for cleaning up code after inlining. Does not do variable renaming or block flattening, however.
clearAnalysis
void clearAnalysis();
collectTemplateParameterLevelsFromDeclContext
std::vector<clang::TemplateParameterList const*> collectTemplateParameterLevelsFromDeclContext( clang::DeclContext const* start_context, bool use_defining_record_contexts = false);
constructorInitializerAssociatedClassUnknown
bool constructorInitializerAssociatedClassUnknown(SgType* expression_type);
convertAdjustArgsClause
SgOmpAdjustArgsClause* convertAdjustArgsClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertAffinityClause
SgOmpAffinityClause* convertAffinityClause( SgStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertAllocatorClause
SgOmpAllocatorClause* convertAllocatorClause( SgOmpClauseStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertAppendArgsClause
SgOmpAppendArgsClause* convertAppendArgsClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertAtomicDefaultMemOrderClause
SgOmpAtomicDefaultMemOrderClause* convertAtomicDefaultMemOrderClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertBindClause
SgOmpBindClause* convertBindClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertBodyDirective
SgStatement* convertBodyDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>);
convertClause
SgOmpVariablesClause* convertClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertCombinedBodyDirective
SgOmpBodyStatement* convertCombinedBodyDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>);
convertDefaultClause
SgOmpDefaultClause* convertDefaultClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertDefaultmapClause
SgOmpDefaultmapClause* convertDefaultmapClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertDependClause
SgOmpDependClause* convertDependClause( SgStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertDepobjUpdateClause
SgOmpDepobjUpdateClause* convertDepobjUpdateClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertDirective
SgStatement* convertDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>);
convertDistScheduleClause
SgOmpDistScheduleClause* convertDistScheduleClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertExpressionClause
SgOmpExpressionClause* convertExpressionClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertExtImplementationDefinedRequirementClause
SgOmpExtImplementationDefinedRequirementClause* convertExtImplementationDefinedRequirementClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertFromClause
SgOmpFromClause* convertFromClause( SgStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertInitializerIntoAssignment
SgAssignOp* convertInitializerIntoAssignment(SgAssignInitializer* init);
Convert something like "int a = foo();" into "int a; a = foo();"
convertMapClause
SgOmpMapClause* convertMapClause( SgStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertMatchClause
SgOmpMatchClause* convertMatchClause( SgStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertNonBodyDirective
SgStatement* convertNonBodyDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII);
convertOmpAllocateDirective
SgStatement* convertOmpAllocateDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>);
convertOmpBeginDeclareVariantDirective
SgStatement* convertOmpBeginDeclareVariantDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>);
convertOmpDeclareSimdDirective
SgStatement* convertOmpDeclareSimdDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>);
convertOmpDeclareTargetDirective
SgStatement* convertOmpDeclareTargetDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>);
convertOmpDeclareVariantDirective
SgStatement* convertOmpDeclareVariantDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>);
convertOmpEndDeclareTargetDirective
SgStatement* convertOmpEndDeclareTargetDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>);
convertOmpEndDeclareVariantDirective
SgStatement* convertOmpEndDeclareVariantDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>);
convertOmpFlushDirective
SgStatement* convertOmpFlushDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>);
convertOmpParallelStatementFromCombinedDirectives
SgOmpParallelStatement* convertOmpParallelStatementFromCombinedDirectives(std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII);
convertOmpRequiresDirective
SgStatement* convertOmpRequiresDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII);
convertOmpTaskwaitDirective
SgStatement* convertOmpTaskwaitDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII);
convertOmpThreadprivateStatement
SgStatement* convertOmpThreadprivateStatement(std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII);
convertOpenACCDirective
SgStatement* convertOpenACCDirective( SgPragmaDeclaration*, openacc::Directive const&);
convertOrderClause
SgOmpOrderClause* convertOrderClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertProcBindClause
SgOmpProcBindClause* convertProcBindClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertScheduleClause
SgOmpScheduleClause* convertScheduleClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertSizesClause
SgOmpSizesClause* convertSizesClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertToClause
SgOmpToClause* convertToClause( SgStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertUsesAllocatorsClause
SgOmpUsesAllocatorsClause* convertUsesAllocatorsClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
convertVariantBodyDirective
SgStatement* convertVariantBodyDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>);
convertVariantDirective
SgStatement* convertVariantDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>);
convertWhenClause
SgOmpWhenClause* convertWhenClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause);
copyClangFunctionArgumentTypes
void copyClangFunctionArgumentTypes( SgFunctionType const* source, SgFunctionParameterTypeList* destination, char const* context);
copy_mapped_variable
extern void copy_mapped_variable( XOMP_mapped_variable* desc, XOMP_mapped_variable* src);
A helper function to copy a mapped variable from src to desc
cxxRecordDeclFromQualTypeWithoutDefinitionLookup
clang::CXXRecordDecl const* cxxRecordDeclFromQualTypeWithoutDefinitionLookup(clang::QualType type);
debug_cfg
bool debug_cfg();
defaultArgumentParameterForLambda
clang::ParmVarDecl const* defaultArgumentParameterForLambda(clang::CXXRecordDecl const* declaration);
dependenceDiagnosticNodeText
std::string dependenceDiagnosticNodeText(SgNode const* node);
destructorCallAnnotator
[[visibility("default")]] void destructorCallAnnotator(SgProject* prj);
detachTokenMappingForRemovedNode
void detachTokenMappingForRemovedNode( SgSourceFile* sourceFile, SgNode* node);
detectMacroExpansionsToBeUnparsedAsAstTransformations
void detectMacroExpansionsToBeUnparsedAsAstTransformations( SgSourceFile* sourceFile, TokenUnparseFrontierFileContext& frontierContext);
detectMacroOrIncludeFileExpansions
void detectMacroOrIncludeFileExpansions(SgSourceFile* sourceFile);
detectTransformations
void detectTransformations(SgNode* node);
determineFileType
SgSourceFile* determineFileType( std::vector<std::string> argv, SgProject* project, SgFileList* owner, SgSourceFile::source_origin_enum origin = SgSourceFile::e_parsed_source);
doInline
[[visibility("default")]] bool doInline( SgFunctionCallExp* funcall, bool allowRecursion = false);
Main inliner code. Accepts a function call as a parameter, and inlines only that single function call. Returns true if it succeeded, and false otherwise. The function call must be to a named function, static member function, or non-virtual non-static member function, and the function must be known (not through a function pointer or member function pointer). Also, the body of the function must already be visible. Recursive procedures are handled properly (when allowRecursion is set), by inlining one copy of the procedure into itself. Any other restrictions on what can be inlined are bugs in the inliner code.
doRTI
template<typename T> void doRTI( char const* fieldNameBase, T* fieldPtr, void* thisPtr, char const* className, char const* typeString, char const* fieldName, RTIValueDescriptor const& fieldContents, RTIMemberData& memberData);
edgePointerReplacement
void edgePointerReplacement(replacement_map_t const& replacements);
enforceTokenUnparseContract
[[visibility("default")]] void enforceTokenUnparseContract(SgProject* project);
enumValueFromClang
long long enumValueFromClang(llvm::APSInt const& value);
escapeString
[[visibility("default")]] std::string escapeString(std::string const& s);
escape_double_quotes
std::string escape_double_quotes(std::string const& input);
exactQualificationUseSiteForEmission
SgStatement* exactQualificationUseSiteForEmission( SgNode const* node, SgStatement* emissionStatement);
expressionTreeEqual
bool expressionTreeEqual( SgExpression*, SgExpression*);
Are two expressions equal (using a deep comparison)?
expressionTreeEqualStar
bool expressionTreeEqualStar( SgExpressionPtrList const&, SgExpressionPtrList const&);
Are corresponding expressions in two lists equal (using a deep comparison)?
failSourceQualification
[[noreturn]] void failSourceQualification( char const* context, char const* detail); [noreturn]
filterGraph
template< typename Graph, typename Predicate> void filterGraph( Graph& graph, Predicate predicate);
Filter nodes from a graph.
findBasicBlockForStmt
std::pair<SgBasicBlock*, SgNode*> findBasicBlockForStmt(SgStatement* stmt);
findFollowingPositions
stmt_pos_list findFollowingPositions(SgInitializedName* in);
findInitializedNamesInScope
[[visibility("default")]] SgInitializedNamePtrList findInitializedNamesInScope(SgScopeStatement* scope);
Get all variable names declared within a scope, in the correct order for destruction
findNearestParentOfType
template< typename T, T* isT(SgNode*)> std::pair<T*, SgNode*> findNearestParentOfType(SgNode* node);
findPosition
stmt_pos findPosition(SgNode* n);
findRootFunc
SgFunctionDefinition const* findRootFunc(SgScopeStatement const* scope);
Returns the function definition containing the specified statement.
findRoseSupportPathFromBuild
[[visibility("default")]] std::string findRoseSupportPathFromBuild( std::string const& buildTreeLocation, std::string const& installTreeLocation);
Find the path of a ROSE support file from the build tree.
findRoseSupportPathFromSource
[[visibility("default")]] std::string findRoseSupportPathFromSource( std::string const& sourceTreeLocation, std::string const& installTreeLocation);
Find the path of a ROSE support file from the source tree.
findStatementForExpression
SgStatement* findStatementForExpression(SgExpression* expr);
findVariablesUsedInRegion
[[visibility("default")]] std::set<SgInitializedName*> findVariablesUsedInRegion(SgNode* e);
Find all variables referenced in a region
finishSageAST
void finishSageAST(ClangToSageTranslator& translator);
flattenBlocks
[[visibility("default")]] void flattenBlocks(SgNode* n);
Flatten nested blocks while preserving declaration lifetimes and semantic auxiliary scopes.
floatingValueFromClang
Rose::FloatingValue floatingValueFromClang(llvm::APFloat const& value);
formatRTIField
template<typename T> static std::string formatRTIField(void const* fieldPtr);
fortranAttributeStatementOwnsArrayShape
bool fortranAttributeStatementOwnsArrayShape(SgInitializedName const* initializedName);
frontend
[[visibility("default")]] SgProject* frontend( std::vector<std::string> const& argv, bool frontendConstantFolding);
Simple APIs for ROSE (error codes are in SgProject.frontendErrorCode(), backendErrorCode()). @{
frontendExitStatus
[[visibility("default")]] int frontendExitStatus(SgProject const* project);
@}
frontendShell
[[visibility("default")]] SgProject* frontendShell(std::vector<std::string> const& argv);
frontierDetectionForTokenStreamMapping
void frontierDetectionForTokenStreamMapping( SgSourceFile* sourceFile, bool traverseHeaderFiles, TokenUnparseFrontierContext& context, SgNode* traversalRoot = nullptr);
generateAstGraph
[[visibility("default")]] void generateAstGraph( SgProject const* project, int maxSize = 2000, std::string filenameSuffix = "");
generateDOT
[[visibility("default")]] void generateDOT( SgNode* node, std::string filename);
generateDOT_withIncludes
[[visibility("default")]] void generateDOT_withIncludes( SgProject const& project, std::string filenamePostfix = "");
generateDOTforMultipleFile
[[visibility("default")]] void generateDOTforMultipleFile( SgProject const& project, std::string filenamePostfix = "");
generateGraphOfAST
[[visibility("default")]] void generateGraphOfAST( SgProject* project, std::string filename);
generateGraphOfIncludeFiles
[[visibility("default")]] void generateGraphOfIncludeFiles( SgProject* project, std::string filename);
generateModFile
extern void generateModFile(SgFile* sfile);
generateNameQualificationSupport
void generateNameQualificationSupport( SgNode* node, SgUnorderedNodeSet& referencedNameSet, NameQualificationContext& nameQualifications, bool useInputFileTraversalOptimization = true, SgStatement* explicitEmissionStatement = nullptr, SgNode* explicitReferenceNode = nullptr, SgType* explicitSemanticTypeUse = nullptr, SgDeclarationStatement* explicitTypeDefinition = nullptr);
generatePDF
[[visibility("default")]] void generatePDF(SgProject const& project);
generateWholeGraphOfAST
[[visibility("default")]] void generateWholeGraphOfAST(std::string filename);
generateWholeGraphOfAST overloads
getAlgebraicRules
[[visibility("default")]] RewriteRule* getAlgebraicRules();
A standard set of algebraic rules for simple optimizations
getAllNodes
std::set<SgNode*> getAllNodes(SgNode* node);
getCallGraph
SgIncidenceDirectedGraph* getCallGraph();
getClangTranslationUnitSourceOrder
std::optional<unsigned int> getClangTranslationUnitSourceOrder( SgDeclarationStatement const* declaration, char const* context);
getLiveOutVarsAt
LiveVarsLattice* getLiveOutVarsAt( LiveDeadVarsAnalysis* ldva, SgNode* n, unsigned int index = 0);
getOpenMPBlockBody
SgStatement* getOpenMPBlockBody(std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII);
getOperatorFunctionName
bool getOperatorFunctionName( SgExpression* expr, std::string& func_name);
getParmVarDeclDefaultArgExpr
clang::Expr const* getParmVarDeclDefaultArgExpr(clang::ParmVarDecl const* param_var_decl);
getPreprocessorDirectives
ROSEAttributesList* getPreprocessorDirectives( std::string fileName, std::string new_filename = "");
getReadVarRefsInSubtree
varIDSet getReadVarRefsInSubtree(SgNode* root);
getRootOfExpression
SgExpression* getRootOfExpression(SgExpression* n);
Get the topmost enclosing expression of a given expression.
getStatementOfExpression
SgStatement* getStatementOfExpression(SgNode* n);
Get the statement of an expression.
getTokenStream
std::vector<stream_element*> getTokenStream(SgSourceFile* file);
getVarRefsInSubtree
varIDSet getVarRefsInSubtree(SgNode* root);
getVariantName
[[visibility("default")]] std::string getVariantName(VariantT v);
A global function for getting the string associated with an enum (which is defined in global scope)
getWriteVarRefsInSubtree
varIDSet getWriteVarRefsInSubtree(SgNode* root);
globalUnparseToString
[[visibility("default")]] std::string globalUnparseToString( SgNode const* astNode, SgUnparse_Info* inputUnparseInfoPointer = nullptr);
graphNodesAfterCopy
void graphNodesAfterCopy( std::set<SgNode*> const& nodesBeforeCopy, std::string filename);
graph_trim_trailing_spaces
std::string graph_trim_trailing_spaces(std::string text);
hasAddressTaken
[[visibility("default")]] bool hasAddressTaken( SgExpression* expr, SgNode* root);
Does expression expr potentially have its address taken somewhere in the tree pointed to by root?
initAnalysis
void initAnalysis(SgProject* p);
integer128ValueFromClang
Rose::Integer128Value integer128ValueFromClang(llvm::APSInt const& value);
isExactCLexicalRecordTagSourceSurface
bool isExactCLexicalRecordTagSourceSurface( SgDeclarationStatement const* declaration, SgScopeStatement const* structuralScope);
isExactEmptyTranslationUnitTokenMapping
bool isExactEmptyTranslationUnitTokenMapping( SgSourceFile* sourceFile, SgStatement* statement, TokenStreamSequenceToNodeMapping* mapping);
isFortranPairedDirective
extern bool isFortranPairedDirective(OpenMPDirective* node);
isInstantiatedConversionOperatorDecl
bool isInstantiatedConversionOperatorDecl(clang::CXXConversionDecl const* decl);
isMemberVariable
[[visibility("default")]] bool isMemberVariable(SgNode const& in);
Internal routine to check whether a given variable declaration is a member variable.
isNonFriendMemberFunctionDeclaration
bool isNonFriendMemberFunctionDeclaration(SgFunctionDeclaration const* decl);
isPotentiallyModified
[[visibility("default")]] bool isPotentiallyModified( SgExpression* expr, SgNode* root);
Is the expression or variable symbol potentially modified (assigned to, address taken, passed by non-const reference) within root?
isSgAccAsyncClause
[[visibility("default")]] SgAccAsyncClause* isSgAccAsyncClause(SgNode* node);
isSgAccAsyncClause overloads
isSgAccAtomicStatement
[[visibility("default")]] SgAccAtomicStatement* isSgAccAtomicStatement(SgNode* node);
isSgAccAtomicStatement overloads
isSgAccBodyStatement
[[visibility("default")]] SgAccBodyStatement* isSgAccBodyStatement(SgNode* node);
isSgAccBodyStatement overloads
isSgAccCacheStatement
[[visibility("default")]] SgAccCacheStatement* isSgAccCacheStatement(SgNode* node);
isSgAccCacheStatement overloads
isSgAccCaptureClause
[[visibility("default")]] SgAccCaptureClause* isSgAccCaptureClause(SgNode* node);
isSgAccCaptureClause overloads
isSgAccClause
[[visibility("default")]] SgAccClause* isSgAccClause(SgNode* node);
isSgAccClause overloads
isSgAccClauseBodyStatement
[[visibility("default")]] SgAccClauseBodyStatement* isSgAccClauseBodyStatement(SgNode* node);
isSgAccClauseBodyStatement overloads
isSgAccClauseStatement
[[visibility("default")]] SgAccClauseStatement* isSgAccClauseStatement(SgNode* node);
isSgAccClauseStatement overloads
isSgAccCollapseClause
[[visibility("default")]] SgAccCollapseClause* isSgAccCollapseClause(SgNode* node);
isSgAccCollapseClause overloads
isSgAccCopyClause
[[visibility("default")]] SgAccCopyClause* isSgAccCopyClause(SgNode* node);
isSgAccCopyClause overloads
isSgAccCopyinClause
[[visibility("default")]] SgAccCopyinClause* isSgAccCopyinClause(SgNode* node);
isSgAccCopyinClause overloads
isSgAccCopyoutClause
[[visibility("default")]] SgAccCopyoutClause* isSgAccCopyoutClause(SgNode* node);
isSgAccCopyoutClause overloads
isSgAccCreateClause
[[visibility("default")]] SgAccCreateClause* isSgAccCreateClause(SgNode* node);
isSgAccCreateClause overloads
isSgAccDataStatement
[[visibility("default")]] SgAccDataStatement* isSgAccDataStatement(SgNode* node);
isSgAccDataStatement overloads
isSgAccDefaultClause
[[visibility("default")]] SgAccDefaultClause* isSgAccDefaultClause(SgNode* node);
isSgAccDefaultClause overloads
isSgAccDeleteClause
[[visibility("default")]] SgAccDeleteClause* isSgAccDeleteClause(SgNode* node);
isSgAccDeleteClause overloads
isSgAccDeviceptrClause
[[visibility("default")]] SgAccDeviceptrClause* isSgAccDeviceptrClause(SgNode* node);
isSgAccDeviceptrClause overloads
isSgAccEnterDataStatement
[[visibility("default")]] SgAccEnterDataStatement* isSgAccEnterDataStatement(SgNode* node);
isSgAccEnterDataStatement overloads
isSgAccExitDataStatement
[[visibility("default")]] SgAccExitDataStatement* isSgAccExitDataStatement(SgNode* node);
isSgAccExitDataStatement overloads
isSgAccExpressionClause
[[visibility("default")]] SgAccExpressionClause* isSgAccExpressionClause(SgNode* node);
isSgAccExpressionClause overloads
isSgAccGangClause
[[visibility("default")]] SgAccGangClause* isSgAccGangClause(SgNode* node);
isSgAccGangClause overloads
isSgAccIfClause
[[visibility("default")]] SgAccIfClause* isSgAccIfClause(SgNode* node);
isSgAccIfClause overloads
isSgAccKernelsStatement
[[visibility("default")]] SgAccKernelsStatement* isSgAccKernelsStatement(SgNode* node);
isSgAccKernelsStatement overloads
isSgAccNumGangsClause
[[visibility("default")]] SgAccNumGangsClause* isSgAccNumGangsClause(SgNode* node);
isSgAccNumGangsClause overloads
isSgAccNumWorkersClause
[[visibility("default")]] SgAccNumWorkersClause* isSgAccNumWorkersClause(SgNode* node);
isSgAccNumWorkersClause overloads
isSgAccParallelLoopStatement
[[visibility("default")]] SgAccParallelLoopStatement* isSgAccParallelLoopStatement(SgNode* node);
isSgAccParallelLoopStatement overloads
isSgAccParallelStatement
[[visibility("default")]] SgAccParallelStatement* isSgAccParallelStatement(SgNode* node);
isSgAccParallelStatement overloads
isSgAccPresentClause
[[visibility("default")]] SgAccPresentClause* isSgAccPresentClause(SgNode* node);
isSgAccPresentClause overloads
isSgAccPrivateClause
[[visibility("default")]] SgAccPrivateClause* isSgAccPrivateClause(SgNode* node);
isSgAccPrivateClause overloads
isSgAccReadClause
[[visibility("default")]] SgAccReadClause* isSgAccReadClause(SgNode* node);
isSgAccReadClause overloads
isSgAccReductionClause
[[visibility("default")]] SgAccReductionClause* isSgAccReductionClause(SgNode* node);
isSgAccReductionClause overloads
isSgAccRoutineStatement
[[visibility("default")]] SgAccRoutineStatement* isSgAccRoutineStatement(SgNode* node);
isSgAccRoutineStatement overloads
isSgAccSeqClause
[[visibility("default")]] SgAccSeqClause* isSgAccSeqClause(SgNode* node);
isSgAccSeqClause overloads
isSgAccUpdateClause
[[visibility("default")]] SgAccUpdateClause* isSgAccUpdateClause(SgNode* node);
isSgAccUpdateClause overloads
isSgAccVariablesClause
[[visibility("default")]] SgAccVariablesClause* isSgAccVariablesClause(SgNode* node);
isSgAccVariablesClause overloads
isSgAccVectorClause
[[visibility("default")]] SgAccVectorClause* isSgAccVectorClause(SgNode* node);
isSgAccVectorClause overloads
isSgAccVectorLengthClause
[[visibility("default")]] SgAccVectorLengthClause* isSgAccVectorLengthClause(SgNode* node);
isSgAccVectorLengthClause overloads
isSgAccWaitStatement
[[visibility("default")]] SgAccWaitStatement* isSgAccWaitStatement(SgNode* node);
isSgAccWaitStatement overloads
isSgAccWriteClause
[[visibility("default")]] SgAccWriteClause* isSgAccWriteClause(SgNode* node);
isSgAccWriteClause overloads
isSgAccessLabelStatement
[[visibility("default")]] SgAccessLabelStatement* isSgAccessLabelStatement(SgNode* node);
isSgAccessLabelStatement overloads
isSgAccessModifier
[[visibility("default")]] SgAccessModifier* isSgAccessModifier(SgNode* node);
isSgAccessModifier overloads
isSgActualArgumentExpression
[[visibility("default")]] SgActualArgumentExpression* isSgActualArgumentExpression(SgNode* node);
isSgActualArgumentExpression overloads
isSgAddOp
[[visibility("default")]] SgAddOp* isSgAddOp(SgNode* node);
isSgAddOp overloads
isSgAddressOfOp
[[visibility("default")]] SgAddressOfOp* isSgAddressOfOp(SgNode* node);
isSgAddressOfOp overloads
isSgAggregateInitializer
[[visibility("default")]] SgAggregateInitializer* isSgAggregateInitializer(SgNode* node);
isSgAggregateInitializer overloads
isSgAliasSymbol
[[visibility("default")]] SgAliasSymbol* isSgAliasSymbol(SgNode* node);
isSgAliasSymbol overloads
isSgAlignOfOp
[[visibility("default")]] SgAlignOfOp* isSgAlignOfOp(SgNode* node);
isSgAlignOfOp overloads
isSgAlignmentSpecifier
[[visibility("default")]] SgAlignmentSpecifier* isSgAlignmentSpecifier(SgNode* node);
isSgAlignmentSpecifier overloads
isSgAllocateStatement
[[visibility("default")]] SgAllocateStatement* isSgAllocateStatement(SgNode* node);
isSgAllocateStatement overloads
isSgAndAssignOp
[[visibility("default")]] SgAndAssignOp* isSgAndAssignOp(SgNode* node);
isSgAndAssignOp overloads
isSgAndOp
[[visibility("default")]] SgAndOp* isSgAndOp(SgNode* node);
isSgAndOp overloads
isSgArithmeticIfStatement
[[visibility("default")]] SgArithmeticIfStatement* isSgArithmeticIfStatement(SgNode* node);
isSgArithmeticIfStatement overloads
isSgArrayType
[[visibility("default")]] SgArrayType* isSgArrayType(SgNode* node);
isSgArrayType overloads
isSgArrowExp
[[visibility("default")]] SgArrowExp* isSgArrowExp(SgNode* node);
isSgArrowExp overloads
isSgArrowStarOp
[[visibility("default")]] SgArrowStarOp* isSgArrowStarOp(SgNode* node);
isSgArrowStarOp overloads
isSgAsmOp
[[visibility("default")]] SgAsmOp* isSgAsmOp(SgNode* node);
isSgAsmOp overloads
isSgAsmStmt
[[visibility("default")]] SgAsmStmt* isSgAsmStmt(SgNode* node);
isSgAsmStmt overloads
isSgAssignInitializer
[[visibility("default")]] SgAssignInitializer* isSgAssignInitializer(SgNode* node);
isSgAssignInitializer overloads
isSgAssignOp
[[visibility("default")]] SgAssignOp* isSgAssignOp(SgNode* node);
isSgAssignOp overloads
isSgAssignStatement
[[visibility("default")]] SgAssignStatement* isSgAssignStatement(SgNode* node);
isSgAssignStatement overloads
isSgAssignedGotoStatement
[[visibility("default")]] SgAssignedGotoStatement* isSgAssignedGotoStatement(SgNode* node);
isSgAssignedGotoStatement overloads
isSgAssociateStatement
[[visibility("default")]] SgAssociateStatement* isSgAssociateStatement(SgNode* node);
isSgAssociateStatement overloads
isSgAssumedRankExp
[[visibility("default")]] SgAssumedRankExp* isSgAssumedRankExp(SgNode* node);
isSgAssumedRankExp overloads
isSgAsteriskShapeExp
[[visibility("default")]] SgAsteriskShapeExp* isSgAsteriskShapeExp(SgNode* node);
isSgAsteriskShapeExp overloads
isSgAttribute
[[visibility("default")]] SgAttribute* isSgAttribute(SgNode* node);
isSgAttribute overloads
isSgAttributeSpecificationStatement
[[visibility("default")]] SgAttributeSpecificationStatement* isSgAttributeSpecificationStatement(SgNode* node);
isSgAttributeSpecificationStatement overloads
isSgAttributedStatement
[[visibility("default")]] SgAttributedStatement* isSgAttributedStatement(SgNode* node);
isSgAttributedStatement overloads
isSgAutoType
[[visibility("default")]] SgAutoType* isSgAutoType(SgNode* node);
isSgAutoType overloads
isSgAuxiliaryDeclarationList
[[visibility("default")]] SgAuxiliaryDeclarationList* isSgAuxiliaryDeclarationList(SgNode* node);
isSgAuxiliaryDeclarationList overloads
isSgAwaitExpression
[[visibility("default")]] SgAwaitExpression* isSgAwaitExpression(SgNode* node);
isSgAwaitExpression overloads
isSgBFloat16Val
[[visibility("default")]] SgBFloat16Val* isSgBFloat16Val(SgNode* node);
isSgBFloat16Val overloads
isSgBackspaceStatement
[[visibility("default")]] SgBackspaceStatement* isSgBackspaceStatement(SgNode* node);
isSgBackspaceStatement overloads
isSgBaseClass
[[visibility("default")]] SgBaseClass* isSgBaseClass(SgNode* node);
isSgBaseClass overloads
isSgBaseClassModifier
[[visibility("default")]] SgBaseClassModifier* isSgBaseClassModifier(SgNode* node);
isSgBaseClassModifier overloads
isSgBasicBlock
[[visibility("default")]] SgBasicBlock* isSgBasicBlock(SgNode* node);
isSgBasicBlock overloads
isSgBidirectionalGraph
[[visibility("default")]] SgBidirectionalGraph* isSgBidirectionalGraph(SgNode* node);
isSgBidirectionalGraph overloads
isSgBinaryOp
[[visibility("default")]] SgBinaryOp* isSgBinaryOp(SgNode* node);
isSgBinaryOp overloads
isSgBitAndOp
[[visibility("default")]] SgBitAndOp* isSgBitAndOp(SgNode* node);
isSgBitAndOp overloads
isSgBitAttribute
[[visibility("default")]] SgBitAttribute* isSgBitAttribute(SgNode* node);
isSgBitAttribute overloads
isSgBitComplementOp
[[visibility("default")]] SgBitComplementOp* isSgBitComplementOp(SgNode* node);
isSgBitComplementOp overloads
isSgBitEqvOp
[[visibility("default")]] SgBitEqvOp* isSgBitEqvOp(SgNode* node);
isSgBitEqvOp overloads
isSgBitOrOp
[[visibility("default")]] SgBitOrOp* isSgBitOrOp(SgNode* node);
isSgBitOrOp overloads
isSgBitXorOp
[[visibility("default")]] SgBitXorOp* isSgBitXorOp(SgNode* node);
isSgBitXorOp overloads
isSgBoolValExp
[[visibility("default")]] SgBoolValExp* isSgBoolValExp(SgNode* node);
isSgBoolValExp overloads
isSgBracedInitializer
[[visibility("default")]] SgBracedInitializer* isSgBracedInitializer(SgNode* node);
isSgBracedInitializer overloads
isSgBreakStmt
[[visibility("default")]] SgBreakStmt* isSgBreakStmt(SgNode* node);
isSgBreakStmt overloads
isSgCAFCoExpression
[[visibility("default")]] SgCAFCoExpression* isSgCAFCoExpression(SgNode* node);
isSgCAFCoExpression overloads
isSgCAFImageSelectorExp
[[visibility("default")]] SgCAFImageSelectorExp* isSgCAFImageSelectorExp(SgNode* node);
isSgCAFImageSelectorExp overloads
isSgC_PreprocessorDirectiveStatement
[[visibility("default")]] SgC_PreprocessorDirectiveStatement* isSgC_PreprocessorDirectiveStatement(SgNode* node);
isSgC_PreprocessorDirectiveStatement overloads
isSgCallExpression
[[visibility("default")]] SgCallExpression* isSgCallExpression(SgNode* node);
isSgCallExpression overloads
isSgCaseOptionStmt
[[visibility("default")]] SgCaseOptionStmt* isSgCaseOptionStmt(SgNode* node);
isSgCaseOptionStmt overloads
isSgCastExp
[[visibility("default")]] SgCastExp* isSgCastExp(SgNode* node);
isSgCastExp overloads
isSgCatchOptionStmt
[[visibility("default")]] SgCatchOptionStmt* isSgCatchOptionStmt(SgNode* node);
isSgCatchOptionStmt overloads
isSgCatchStatementSeq
[[visibility("default")]] SgCatchStatementSeq* isSgCatchStatementSeq(SgNode* node);
isSgCatchStatementSeq overloads
isSgChar16Val
[[visibility("default")]] SgChar16Val* isSgChar16Val(SgNode* node);
isSgChar16Val overloads
isSgChar32Val
[[visibility("default")]] SgChar32Val* isSgChar32Val(SgNode* node);
isSgChar32Val overloads
isSgCharVal
[[visibility("default")]] SgCharVal* isSgCharVal(SgNode* node);
isSgCharVal overloads
isSgChooseExpression
[[visibility("default")]] SgChooseExpression* isSgChooseExpression(SgNode* node);
isSgChooseExpression overloads
isSgClassDecl_attr
[[visibility("default")]] SgClassDecl_attr* isSgClassDecl_attr(SgNode* node);
isSgClassDecl_attr overloads
isSgClassDeclaration
[[visibility("default")]] SgClassDeclaration* isSgClassDeclaration(SgNode* node);
isSgClassDeclaration overloads
isSgClassDefinition
[[visibility("default")]] SgClassDefinition* isSgClassDefinition(SgNode* node);
isSgClassDefinition overloads
isSgClassNameRefExp
[[visibility("default")]] SgClassNameRefExp* isSgClassNameRefExp(SgNode* node);
isSgClassNameRefExp overloads
isSgClassSymbol
[[visibility("default")]] SgClassSymbol* isSgClassSymbol(SgNode* node);
isSgClassSymbol overloads
isSgClassType
[[visibility("default")]] SgClassType* isSgClassType(SgNode* node);
isSgClassType overloads
isSgClinkageDeclarationStatement
[[visibility("default")]] SgClinkageDeclarationStatement* isSgClinkageDeclarationStatement(SgNode* node);
isSgClinkageDeclarationStatement overloads
isSgClinkageEndStatement
[[visibility("default")]] SgClinkageEndStatement* isSgClinkageEndStatement(SgNode* node);
isSgClinkageEndStatement overloads
isSgClinkageStartStatement
[[visibility("default")]] SgClinkageStartStatement* isSgClinkageStartStatement(SgNode* node);
isSgClinkageStartStatement overloads
isSgCloseStatement
[[visibility("default")]] SgCloseStatement* isSgCloseStatement(SgNode* node);
isSgCloseStatement overloads
isSgColonShapeExp
[[visibility("default")]] SgColonShapeExp* isSgColonShapeExp(SgNode* node);
isSgColonShapeExp overloads
isSgCommaOpExp
[[visibility("default")]] SgCommaOpExp* isSgCommaOpExp(SgNode* node);
isSgCommaOpExp overloads
isSgCommonBlock
[[visibility("default")]] SgCommonBlock* isSgCommonBlock(SgNode* node);
isSgCommonBlock overloads
isSgCommonBlockObject
[[visibility("default")]] SgCommonBlockObject* isSgCommonBlockObject(SgNode* node);
isSgCommonBlockObject overloads
isSgCommonSymbol
[[visibility("default")]] SgCommonSymbol* isSgCommonSymbol(SgNode* node);
isSgCommonSymbol overloads
isSgComplexVal
[[visibility("default")]] SgComplexVal* isSgComplexVal(SgNode* node);
isSgComplexVal overloads
isSgCompoundAssignOp
[[visibility("default")]] SgCompoundAssignOp* isSgCompoundAssignOp(SgNode* node);
isSgCompoundAssignOp overloads
isSgCompoundLiteralExp
[[visibility("default")]] SgCompoundLiteralExp* isSgCompoundLiteralExp(SgNode* node);
isSgCompoundLiteralExp overloads
isSgCompoundRequirement
[[visibility("default")]] SgCompoundRequirement* isSgCompoundRequirement(SgNode* node);
isSgCompoundRequirement overloads
isSgComputedGotoStatement
[[visibility("default")]] SgComputedGotoStatement* isSgComputedGotoStatement(SgNode* node);
isSgComputedGotoStatement overloads
isSgConcatenationOp
[[visibility("default")]] SgConcatenationOp* isSgConcatenationOp(SgNode* node);
isSgConcatenationOp overloads
isSgConditionalExp
[[visibility("default")]] SgConditionalExp* isSgConditionalExp(SgNode* node);
isSgConditionalExp overloads
isSgConjugateOp
[[visibility("default")]] SgConjugateOp* isSgConjugateOp(SgNode* node);
isSgConjugateOp overloads
isSgConstVolatileModifier
[[visibility("default")]] SgConstVolatileModifier* isSgConstVolatileModifier(SgNode* node);
isSgConstVolatileModifier overloads
isSgConstructorInitializer
[[visibility("default")]] SgConstructorInitializer* isSgConstructorInitializer(SgNode* node);
isSgConstructorInitializer overloads
isSgContainsStatement
[[visibility("default")]] SgContainsStatement* isSgContainsStatement(SgNode* node);
isSgContainsStatement overloads
isSgContinueStmt
[[visibility("default")]] SgContinueStmt* isSgContinueStmt(SgNode* node);
isSgContinueStmt overloads
isSgCtorInitializerList
[[visibility("default")]] SgCtorInitializerList* isSgCtorInitializerList(SgNode* node);
isSgCtorInitializerList overloads
isSgCudaKernelCallExp
[[visibility("default")]] SgCudaKernelCallExp* isSgCudaKernelCallExp(SgNode* node);
isSgCudaKernelCallExp overloads
isSgCudaKernelExecConfig
[[visibility("default")]] SgCudaKernelExecConfig* isSgCudaKernelExecConfig(SgNode* node);
isSgCudaKernelExecConfig overloads
isSgCxxArrayInitBinding
[[visibility("default")]] SgCxxArrayInitBinding* isSgCxxArrayInitBinding(SgNode* node);
isSgCxxArrayInitBinding overloads
isSgCxxArrayInitLoop
[[visibility("default")]] SgCxxArrayInitLoop* isSgCxxArrayInitLoop(SgNode* node);
isSgCxxArrayInitLoop overloads
isSgCxxArrayInitReference
[[visibility("default")]] SgCxxArrayInitReference* isSgCxxArrayInitReference(SgNode* node);
isSgCxxArrayInitReference overloads
isSgCxxDecompositionRefExp
[[visibility("default")]] SgCxxDecompositionRefExp* isSgCxxDecompositionRefExp(SgNode* node);
isSgCxxDecompositionRefExp overloads
isSgCxxDefaultInitExp
[[visibility("default")]] SgCxxDefaultInitExp* isSgCxxDefaultInitExp(SgNode* node);
isSgCxxDefaultInitExp overloads
isSgCxxLiteralToken
[[visibility("default")]] SgCxxLiteralToken* isSgCxxLiteralToken(SgNode* node);
isSgCxxLiteralToken overloads
isSgCxxLiteralTokenList
[[visibility("default")]] SgCxxLiteralTokenList* isSgCxxLiteralTokenList(SgNode* node);
isSgCxxLiteralTokenList overloads
isSgCxxSubobjectDestruction
[[visibility("default")]] SgCxxSubobjectDestruction* isSgCxxSubobjectDestruction(SgNode* node);
isSgCxxSubobjectDestruction overloads
isSgDataStatementGroup
[[visibility("default")]] SgDataStatementGroup* isSgDataStatementGroup(SgNode* node);
isSgDataStatementGroup overloads
isSgDataStatementObject
[[visibility("default")]] SgDataStatementObject* isSgDataStatementObject(SgNode* node);
isSgDataStatementObject overloads
isSgDataStatementValue
[[visibility("default")]] SgDataStatementValue* isSgDataStatementValue(SgNode* node);
isSgDataStatementValue overloads
isSgDeadIfDirectiveStatement
[[visibility("default")]] SgDeadIfDirectiveStatement* isSgDeadIfDirectiveStatement(SgNode* node);
isSgDeadIfDirectiveStatement overloads
isSgDeallocateStatement
[[visibility("default")]] SgDeallocateStatement* isSgDeallocateStatement(SgNode* node);
isSgDeallocateStatement overloads
isSgDeclType
[[visibility("default")]] SgDeclType* isSgDeclType(SgNode* node);
isSgDeclType overloads
isSgDeclarationGroupStatement
[[visibility("default")]] SgDeclarationGroupStatement* isSgDeclarationGroupStatement(SgNode* node);
isSgDeclarationGroupStatement overloads
isSgDeclarationModifier
[[visibility("default")]] SgDeclarationModifier* isSgDeclarationModifier(SgNode* node);
isSgDeclarationModifier overloads
isSgDeclarationScope
[[visibility("default")]] SgDeclarationScope* isSgDeclarationScope(SgNode* node);
isSgDeclarationScope overloads
isSgDeclarationScopeList
[[visibility("default")]] SgDeclarationScopeList* isSgDeclarationScopeList(SgNode* node);
isSgDeclarationScopeList overloads
isSgDeclarationStatement
[[visibility("default")]] SgDeclarationStatement* isSgDeclarationStatement(SgNode* node);
isSgDeclarationStatement overloads
isSgDefaultOptionStmt
[[visibility("default")]] SgDefaultOptionStmt* isSgDefaultOptionStmt(SgNode* node);
isSgDefaultOptionStmt overloads
isSgDefaultSymbol
[[visibility("default")]] SgDefaultSymbol* isSgDefaultSymbol(SgNode* node);
isSgDefaultSymbol overloads
isSgDefineDirectiveStatement
[[visibility("default")]] SgDefineDirectiveStatement* isSgDefineDirectiveStatement(SgNode* node);
isSgDefineDirectiveStatement overloads
isSgDeleteExp
[[visibility("default")]] SgDeleteExp* isSgDeleteExp(SgNode* node);
isSgDeleteExp overloads
isSgDerivedTypeStatement
[[visibility("default")]] SgDerivedTypeStatement* isSgDerivedTypeStatement(SgNode* node);
isSgDerivedTypeStatement overloads
isSgDesignatedInitializer
[[visibility("default")]] SgDesignatedInitializer* isSgDesignatedInitializer(SgNode* node);
isSgDesignatedInitializer overloads
isSgDesignator
[[visibility("default")]] SgDesignator* isSgDesignator(SgNode* node);
isSgDesignator overloads
isSgDimensionObject
[[visibility("default")]] SgDimensionObject* isSgDimensionObject(SgNode* node);
isSgDimensionObject overloads
isSgDirectedGraphEdge
[[visibility("default")]] SgDirectedGraphEdge* isSgDirectedGraphEdge(SgNode* node);
isSgDirectedGraphEdge overloads
isSgDirectory
[[visibility("default")]] SgDirectory* isSgDirectory(SgNode* node);
isSgDirectory overloads
isSgDirectoryList
[[visibility("default")]] SgDirectoryList* isSgDirectoryList(SgNode* node);
isSgDirectoryList overloads
isSgDivAssignOp
[[visibility("default")]] SgDivAssignOp* isSgDivAssignOp(SgNode* node);
isSgDivAssignOp overloads
isSgDivideOp
[[visibility("default")]] SgDivideOp* isSgDivideOp(SgNode* node);
isSgDivideOp overloads
isSgDoWhileStmt
[[visibility("default")]] SgDoWhileStmt* isSgDoWhileStmt(SgNode* node);
isSgDoWhileStmt overloads
isSgDotExp
[[visibility("default")]] SgDotExp* isSgDotExp(SgNode* node);
isSgDotExp overloads
isSgDotStarOp
[[visibility("default")]] SgDotStarOp* isSgDotStarOp(SgNode* node);
isSgDotStarOp overloads
isSgDoubleVal
[[visibility("default")]] SgDoubleVal* isSgDoubleVal(SgNode* node);
isSgDoubleVal overloads
isSgElaboratedTypeModifier
[[visibility("default")]] SgElaboratedTypeModifier* isSgElaboratedTypeModifier(SgNode* node);
isSgElaboratedTypeModifier overloads
isSgElseDirectiveStatement
[[visibility("default")]] SgElseDirectiveStatement* isSgElseDirectiveStatement(SgNode* node);
isSgElseDirectiveStatement overloads
isSgElseWhereStatement
[[visibility("default")]] SgElseWhereStatement* isSgElseWhereStatement(SgNode* node);
isSgElseWhereStatement overloads
isSgElseifDirectiveStatement
[[visibility("default")]] SgElseifDirectiveStatement* isSgElseifDirectiveStatement(SgNode* node);
isSgElseifDirectiveStatement overloads
isSgEmptyDeclaration
[[visibility("default")]] SgEmptyDeclaration* isSgEmptyDeclaration(SgNode* node);
isSgEmptyDeclaration overloads
isSgEmptyDirectiveStatement
[[visibility("default")]] SgEmptyDirectiveStatement* isSgEmptyDirectiveStatement(SgNode* node);
isSgEmptyDirectiveStatement overloads
isSgEndfileStatement
[[visibility("default")]] SgEndfileStatement* isSgEndfileStatement(SgNode* node);
isSgEndfileStatement overloads
isSgEndifDirectiveStatement
[[visibility("default")]] SgEndifDirectiveStatement* isSgEndifDirectiveStatement(SgNode* node);
isSgEndifDirectiveStatement overloads
isSgEntryStatement
[[visibility("default")]] SgEntryStatement* isSgEntryStatement(SgNode* node);
isSgEntryStatement overloads
isSgEnumDeclaration
[[visibility("default")]] SgEnumDeclaration* isSgEnumDeclaration(SgNode* node);
isSgEnumDeclaration overloads
isSgEnumFieldSymbol
[[visibility("default")]] SgEnumFieldSymbol* isSgEnumFieldSymbol(SgNode* node);
isSgEnumFieldSymbol overloads
isSgEnumSymbol
[[visibility("default")]] SgEnumSymbol* isSgEnumSymbol(SgNode* node);
isSgEnumSymbol overloads
isSgEnumType
[[visibility("default")]] SgEnumType* isSgEnumType(SgNode* node);
isSgEnumType overloads
isSgEnumVal
[[visibility("default")]] SgEnumVal* isSgEnumVal(SgNode* node);
isSgEnumVal overloads
isSgEqualityOp
[[visibility("default")]] SgEqualityOp* isSgEqualityOp(SgNode* node);
isSgEqualityOp overloads
isSgEquivalenceStatement
[[visibility("default")]] SgEquivalenceStatement* isSgEquivalenceStatement(SgNode* node);
isSgEquivalenceStatement overloads
isSgErrorDirectiveStatement
[[visibility("default")]] SgErrorDirectiveStatement* isSgErrorDirectiveStatement(SgNode* node);
isSgErrorDirectiveStatement overloads
isSgExpBaseClass
[[visibility("default")]] SgExpBaseClass* isSgExpBaseClass(SgNode* node);
isSgExpBaseClass overloads
isSgExponentiationAssignOp
[[visibility("default")]] SgExponentiationAssignOp* isSgExponentiationAssignOp(SgNode* node);
isSgExponentiationAssignOp overloads
isSgExponentiationOp
[[visibility("default")]] SgExponentiationOp* isSgExponentiationOp(SgNode* node);
isSgExponentiationOp overloads
isSgExprListExp
[[visibility("default")]] SgExprListExp* isSgExprListExp(SgNode* node);
isSgExprListExp overloads
isSgExprStatement
[[visibility("default")]] SgExprStatement* isSgExprStatement(SgNode* node);
isSgExprStatement overloads
isSgExpression
[[visibility("default")]] SgExpression* isSgExpression(SgNode* node);
isSgExpression overloads
isSgExpressionRoot
[[visibility("default")]] SgExpressionRoot* isSgExpressionRoot(SgNode* node);
isSgExpressionRoot overloads
isSgFile
[[visibility("default")]] SgFile* isSgFile(SgNode* node);
isSgFile overloads
isSgFileList
[[visibility("default")]] SgFileList* isSgFileList(SgNode* node);
isSgFileList overloads
isSgFloat128Val
[[visibility("default")]] SgFloat128Val* isSgFloat128Val(SgNode* node);
isSgFloat128Val overloads
isSgFloat16Val
[[visibility("default")]] SgFloat16Val* isSgFloat16Val(SgNode* node);
isSgFloat16Val overloads
isSgFloat32Val
[[visibility("default")]] SgFloat32Val* isSgFloat32Val(SgNode* node);
isSgFloat32Val overloads
isSgFloat64Val
[[visibility("default")]] SgFloat64Val* isSgFloat64Val(SgNode* node);
isSgFloat64Val overloads
isSgFloat80Val
[[visibility("default")]] SgFloat80Val* isSgFloat80Val(SgNode* node);
isSgFloat80Val overloads
isSgFloatVal
[[visibility("default")]] SgFloatVal* isSgFloatVal(SgNode* node);
isSgFloatVal overloads
isSgFloatingPointType
[[visibility("default")]] SgFloatingPointType* isSgFloatingPointType(SgNode* node);
isSgFloatingPointType overloads
isSgFlushStatement
[[visibility("default")]] SgFlushStatement* isSgFlushStatement(SgNode* node);
isSgFlushStatement overloads
isSgFoldExpression
[[visibility("default")]] SgFoldExpression* isSgFoldExpression(SgNode* node);
isSgFoldExpression overloads
isSgForAllStatement
[[visibility("default")]] SgForAllStatement* isSgForAllStatement(SgNode* node);
isSgForAllStatement overloads
isSgForInitStatement
[[visibility("default")]] SgForInitStatement* isSgForInitStatement(SgNode* node);
isSgForInitStatement overloads
isSgForStatement
[[visibility("default")]] SgForStatement* isSgForStatement(SgNode* node);
isSgForStatement overloads
isSgFormTeamStatement
[[visibility("default")]] SgFormTeamStatement* isSgFormTeamStatement(SgNode* node);
isSgFormTeamStatement overloads
isSgFormatItem
[[visibility("default")]] SgFormatItem* isSgFormatItem(SgNode* node);
isSgFormatItem overloads
isSgFormatItemList
[[visibility("default")]] SgFormatItemList* isSgFormatItemList(SgNode* node);
isSgFormatItemList overloads
isSgFormatStatement
[[visibility("default")]] SgFormatStatement* isSgFormatStatement(SgNode* node);
isSgFormatStatement overloads
isSgFortranBOZVal
[[visibility("default")]] SgFortranBOZVal* isSgFortranBOZVal(SgNode* node);
isSgFortranBOZVal overloads
isSgFortranCommonBlockRefExp
[[visibility("default")]] SgFortranCommonBlockRefExp* isSgFortranCommonBlockRefExp(SgNode* node);
isSgFortranCommonBlockRefExp overloads
isSgFortranContinueStmt
[[visibility("default")]] SgFortranContinueStmt* isSgFortranContinueStmt(SgNode* node);
isSgFortranContinueStmt overloads
isSgFortranDataInitializer
[[visibility("default")]] SgFortranDataInitializer* isSgFortranDataInitializer(SgNode* node);
isSgFortranDataInitializer overloads
isSgFortranDo
[[visibility("default")]] SgFortranDo* isSgFortranDo(SgNode* node);
isSgFortranDo overloads
isSgFortranImplicitRange
[[visibility("default")]] SgFortranImplicitRange* isSgFortranImplicitRange(SgNode* node);
isSgFortranImplicitRange overloads
isSgFortranIncludeLine
[[visibility("default")]] SgFortranIncludeLine* isSgFortranIncludeLine(SgNode* node);
isSgFortranIncludeLine overloads
isSgFriendTypeDeclaration
[[visibility("default")]] SgFriendTypeDeclaration* isSgFriendTypeDeclaration(SgNode* node);
isSgFriendTypeDeclaration overloads
isSgFuncDecl_attr
[[visibility("default")]] SgFuncDecl_attr* isSgFuncDecl_attr(SgNode* node);
isSgFuncDecl_attr overloads
isSgFunctionCallExp
[[visibility("default")]] SgFunctionCallExp* isSgFunctionCallExp(SgNode* node);
isSgFunctionCallExp overloads
isSgFunctionDeclaration
[[visibility("default")]] SgFunctionDeclaration* isSgFunctionDeclaration(SgNode* node);
isSgFunctionDeclaration overloads
isSgFunctionDefinition
[[visibility("default")]] SgFunctionDefinition* isSgFunctionDefinition(SgNode* node);
isSgFunctionDefinition overloads
isSgFunctionModifier
[[visibility("default")]] SgFunctionModifier* isSgFunctionModifier(SgNode* node);
isSgFunctionModifier overloads
isSgFunctionParameterList
[[visibility("default")]] SgFunctionParameterList* isSgFunctionParameterList(SgNode* node);
isSgFunctionParameterList overloads
isSgFunctionParameterRefExp
[[visibility("default")]] SgFunctionParameterRefExp* isSgFunctionParameterRefExp(SgNode* node);
isSgFunctionParameterRefExp overloads
isSgFunctionParameterScope
[[visibility("default")]] SgFunctionParameterScope* isSgFunctionParameterScope(SgNode* node);
isSgFunctionParameterScope overloads
isSgFunctionParameterTypeList
[[visibility("default")]] SgFunctionParameterTypeList* isSgFunctionParameterTypeList(SgNode* node);
isSgFunctionParameterTypeList overloads
isSgFunctionRefExp
[[visibility("default")]] SgFunctionRefExp* isSgFunctionRefExp(SgNode* node);
isSgFunctionRefExp overloads
isSgFunctionSymbol
[[visibility("default")]] SgFunctionSymbol* isSgFunctionSymbol(SgNode* node);
isSgFunctionSymbol overloads
isSgFunctionType
[[visibility("default")]] SgFunctionType* isSgFunctionType(SgNode* node);
isSgFunctionType overloads
isSgFunctionTypeArgument
[[visibility("default")]] SgFunctionTypeArgument* isSgFunctionTypeArgument(SgNode* node);
isSgFunctionTypeArgument overloads
isSgFunctionTypeSymbol
[[visibility("default")]] SgFunctionTypeSymbol* isSgFunctionTypeSymbol(SgNode* node);
isSgFunctionTypeSymbol overloads
isSgFunctionTypeTable
[[visibility("default")]] SgFunctionTypeTable* isSgFunctionTypeTable(SgNode* node);
isSgFunctionTypeTable overloads
isSgGlobal
[[visibility("default")]] SgGlobal* isSgGlobal(SgNode* node);
isSgGlobal overloads
isSgGotoStatement
[[visibility("default")]] SgGotoStatement* isSgGotoStatement(SgNode* node);
isSgGotoStatement overloads
isSgGraph
[[visibility("default")]] SgGraph* isSgGraph(SgNode* node);
isSgGraph overloads
isSgGraphEdge
[[visibility("default")]] SgGraphEdge* isSgGraphEdge(SgNode* node);
isSgGraphEdge overloads
isSgGraphEdgeList
[[visibility("default")]] SgGraphEdgeList* isSgGraphEdgeList(SgNode* node);
isSgGraphEdgeList overloads
isSgGraphNode
[[visibility("default")]] SgGraphNode* isSgGraphNode(SgNode* node);
isSgGraphNode overloads
isSgGraphNodeList
[[visibility("default")]] SgGraphNodeList* isSgGraphNodeList(SgNode* node);
isSgGraphNodeList overloads
isSgGreaterOrEqualOp
[[visibility("default")]] SgGreaterOrEqualOp* isSgGreaterOrEqualOp(SgNode* node);
isSgGreaterOrEqualOp overloads
isSgGreaterThanOp
[[visibility("default")]] SgGreaterThanOp* isSgGreaterThanOp(SgNode* node);
isSgGreaterThanOp overloads
isSgHeaderFileBody
[[visibility("default")]] SgHeaderFileBody* isSgHeaderFileBody(SgNode* node);
isSgHeaderFileBody overloads
isSgIOStatement
[[visibility("default")]] SgIOStatement* isSgIOStatement(SgNode* node);
isSgIOStatement overloads
isSgIdentDirectiveStatement
[[visibility("default")]] SgIdentDirectiveStatement* isSgIdentDirectiveStatement(SgNode* node);
isSgIdentDirectiveStatement overloads
isSgIfDirectiveStatement
[[visibility("default")]] SgIfDirectiveStatement* isSgIfDirectiveStatement(SgNode* node);
isSgIfDirectiveStatement overloads
isSgIfStmt
[[visibility("default")]] SgIfStmt* isSgIfStmt(SgNode* node);
isSgIfStmt overloads
isSgIfdefDirectiveStatement
[[visibility("default")]] SgIfdefDirectiveStatement* isSgIfdefDirectiveStatement(SgNode* node);
isSgIfdefDirectiveStatement overloads
isSgIfndefDirectiveStatement
[[visibility("default")]] SgIfndefDirectiveStatement* isSgIfndefDirectiveStatement(SgNode* node);
isSgIfndefDirectiveStatement overloads
isSgImagPartOp
[[visibility("default")]] SgImagPartOp* isSgImagPartOp(SgNode* node);
isSgImagPartOp overloads
isSgImageControlStatement
[[visibility("default")]] SgImageControlStatement* isSgImageControlStatement(SgNode* node);
isSgImageControlStatement overloads
isSgImplicitStatement
[[visibility("default")]] SgImplicitStatement* isSgImplicitStatement(SgNode* node);
isSgImplicitStatement overloads
isSgImpliedDo
[[visibility("default")]] SgImpliedDo* isSgImpliedDo(SgNode* node);
isSgImpliedDo overloads
isSgImportStatement
[[visibility("default")]] SgImportStatement* isSgImportStatement(SgNode* node);
isSgImportStatement overloads
isSgIncidenceDirectedGraph
[[visibility("default")]] SgIncidenceDirectedGraph* isSgIncidenceDirectedGraph(SgNode* node);
isSgIncidenceDirectedGraph overloads
isSgIncidenceUndirectedGraph
[[visibility("default")]] SgIncidenceUndirectedGraph* isSgIncidenceUndirectedGraph(SgNode* node);
isSgIncidenceUndirectedGraph overloads
isSgIncludeDirectiveStatement
[[visibility("default")]] SgIncludeDirectiveStatement* isSgIncludeDirectiveStatement(SgNode* node);
isSgIncludeDirectiveStatement overloads
isSgIncludeFile
[[visibility("default")]] SgIncludeFile* isSgIncludeFile(SgNode* node);
isSgIncludeFile overloads
isSgIncludeNextDirectiveStatement
[[visibility("default")]] SgIncludeNextDirectiveStatement* isSgIncludeNextDirectiveStatement(SgNode* node);
isSgIncludeNextDirectiveStatement overloads
isSgInitializedName
[[visibility("default")]] SgInitializedName* isSgInitializedName(SgNode* node);
isSgInitializedName overloads
isSgInitializer
[[visibility("default")]] SgInitializer* isSgInitializer(SgNode* node);
isSgInitializer overloads
isSgInquireStatement
[[visibility("default")]] SgInquireStatement* isSgInquireStatement(SgNode* node);
isSgInquireStatement overloads
isSgIntKeyedBidirectionalGraph
[[visibility("default")]] SgIntKeyedBidirectionalGraph* isSgIntKeyedBidirectionalGraph(SgNode* node);
isSgIntKeyedBidirectionalGraph overloads
isSgIntVal
[[visibility("default")]] SgIntVal* isSgIntVal(SgNode* node);
isSgIntVal overloads
isSgInteger128Val
[[visibility("default")]] SgInteger128Val* isSgInteger128Val(SgNode* node);
isSgInteger128Val overloads
isSgIntegerDivideAssignOp
[[visibility("default")]] SgIntegerDivideAssignOp* isSgIntegerDivideAssignOp(SgNode* node);
isSgIntegerDivideAssignOp overloads
isSgIntegerDivideOp
[[visibility("default")]] SgIntegerDivideOp* isSgIntegerDivideOp(SgNode* node);
isSgIntegerDivideOp overloads
isSgIntegralType
[[visibility("default")]] SgIntegralType* isSgIntegralType(SgNode* node);
isSgIntegralType overloads
isSgInterfaceBody
[[visibility("default")]] SgInterfaceBody* isSgInterfaceBody(SgNode* node);
isSgInterfaceBody overloads
isSgInterfaceStatement
[[visibility("default")]] SgInterfaceStatement* isSgInterfaceStatement(SgNode* node);
isSgInterfaceStatement overloads
isSgInterfaceSymbol
[[visibility("default")]] SgInterfaceSymbol* isSgInterfaceSymbol(SgNode* node);
isSgInterfaceSymbol overloads
isSgIntrinsicSymbol
[[visibility("default")]] SgIntrinsicSymbol* isSgIntrinsicSymbol(SgNode* node);
isSgIntrinsicSymbol overloads
isSgIorAssignOp
[[visibility("default")]] SgIorAssignOp* isSgIorAssignOp(SgNode* node);
isSgIorAssignOp overloads
isSgLabelRefExp
[[visibility("default")]] SgLabelRefExp* isSgLabelRefExp(SgNode* node);
isSgLabelRefExp overloads
isSgLabelStatement
[[visibility("default")]] SgLabelStatement* isSgLabelStatement(SgNode* node);
isSgLabelStatement overloads
isSgLabelSymbol
[[visibility("default")]] SgLabelSymbol* isSgLabelSymbol(SgNode* node);
isSgLabelSymbol overloads
isSgLambdaCapture
[[visibility("default")]] SgLambdaCapture* isSgLambdaCapture(SgNode* node);
isSgLambdaCapture overloads
isSgLambdaCaptureList
[[visibility("default")]] SgLambdaCaptureList* isSgLambdaCaptureList(SgNode* node);
isSgLambdaCaptureList overloads
isSgLambdaExp
[[visibility("default")]] SgLambdaExp* isSgLambdaExp(SgNode* node);
isSgLambdaExp overloads
isSgLessOrEqualOp
[[visibility("default")]] SgLessOrEqualOp* isSgLessOrEqualOp(SgNode* node);
isSgLessOrEqualOp overloads
isSgLessThanOp
[[visibility("default")]] SgLessThanOp* isSgLessThanOp(SgNode* node);
isSgLessThanOp overloads
isSgLineDirectiveStatement
[[visibility("default")]] SgLineDirectiveStatement* isSgLineDirectiveStatement(SgNode* node);
isSgLineDirectiveStatement overloads
isSgLinemarkerDirectiveStatement
[[visibility("default")]] SgLinemarkerDirectiveStatement* isSgLinemarkerDirectiveStatement(SgNode* node);
isSgLinemarkerDirectiveStatement overloads
isSgLinkageModifier
[[visibility("default")]] SgLinkageModifier* isSgLinkageModifier(SgNode* node);
isSgLinkageModifier overloads
isSgLocatedNode
[[visibility("default")]] SgLocatedNode* isSgLocatedNode(SgNode* node);
isSgLocatedNode overloads
isSgLocatedNodeSupport
[[visibility("default")]] SgLocatedNodeSupport* isSgLocatedNodeSupport(SgNode* node);
isSgLocatedNodeSupport overloads
isSgLockStatement
[[visibility("default")]] SgLockStatement* isSgLockStatement(SgNode* node);
isSgLockStatement overloads
isSgLongDoubleVal
[[visibility("default")]] SgLongDoubleVal* isSgLongDoubleVal(SgNode* node);
isSgLongDoubleVal overloads
isSgLongIntVal
[[visibility("default")]] SgLongIntVal* isSgLongIntVal(SgNode* node);
isSgLongIntVal overloads
isSgLongLongIntVal
[[visibility("default")]] SgLongLongIntVal* isSgLongLongIntVal(SgNode* node);
isSgLongLongIntVal overloads
isSgLshiftAssignOp
[[visibility("default")]] SgLshiftAssignOp* isSgLshiftAssignOp(SgNode* node);
isSgLshiftAssignOp overloads
isSgLshiftOp
[[visibility("default")]] SgLshiftOp* isSgLshiftOp(SgNode* node);
isSgLshiftOp overloads
isSgMacroExpansionExp
[[visibility("default")]] SgMacroExpansionExp* isSgMacroExpansionExp(SgNode* node);
isSgMacroExpansionExp overloads
isSgMemberAccessExp
[[visibility("default")]] SgMemberAccessExp* isSgMemberAccessExp(SgNode* node);
isSgMemberAccessExp overloads
isSgMemberFunctionDeclaration
[[visibility("default")]] SgMemberFunctionDeclaration* isSgMemberFunctionDeclaration(SgNode* node);
isSgMemberFunctionDeclaration overloads
isSgMemberFunctionRefExp
[[visibility("default")]] SgMemberFunctionRefExp* isSgMemberFunctionRefExp(SgNode* node);
isSgMemberFunctionRefExp overloads
isSgMemberFunctionSymbol
[[visibility("default")]] SgMemberFunctionSymbol* isSgMemberFunctionSymbol(SgNode* node);
isSgMemberFunctionSymbol overloads
isSgMemberFunctionType
[[visibility("default")]] SgMemberFunctionType* isSgMemberFunctionType(SgNode* node);
isSgMemberFunctionType overloads
isSgMinusAssignOp
[[visibility("default")]] SgMinusAssignOp* isSgMinusAssignOp(SgNode* node);
isSgMinusAssignOp overloads
isSgMinusMinusOp
[[visibility("default")]] SgMinusMinusOp* isSgMinusMinusOp(SgNode* node);
isSgMinusMinusOp overloads
isSgMinusOp
[[visibility("default")]] SgMinusOp* isSgMinusOp(SgNode* node);
isSgMinusOp overloads
isSgModAssignOp
[[visibility("default")]] SgModAssignOp* isSgModAssignOp(SgNode* node);
isSgModAssignOp overloads
isSgModOp
[[visibility("default")]] SgModOp* isSgModOp(SgNode* node);
isSgModOp overloads
isSgModifier
[[visibility("default")]] SgModifier* isSgModifier(SgNode* node);
isSgModifier overloads
isSgModifierNodes
[[visibility("default")]] SgModifierNodes* isSgModifierNodes(SgNode* node);
isSgModifierNodes overloads
isSgModifierType
[[visibility("default")]] SgModifierType* isSgModifierType(SgNode* node);
isSgModifierType overloads
isSgModuleStatement
[[visibility("default")]] SgModuleStatement* isSgModuleStatement(SgNode* node);
isSgModuleStatement overloads
isSgModuleSymbol
[[visibility("default")]] SgModuleSymbol* isSgModuleSymbol(SgNode* node);
isSgModuleSymbol overloads
isSgMultAssignOp
[[visibility("default")]] SgMultAssignOp* isSgMultAssignOp(SgNode* node);
isSgMultAssignOp overloads
isSgMultiplyOp
[[visibility("default")]] SgMultiplyOp* isSgMultiplyOp(SgNode* node);
isSgMultiplyOp overloads
isSgName
[[visibility("default")]] SgName* isSgName(SgNode* node);
isSgName overloads
isSgNameGroup
[[visibility("default")]] SgNameGroup* isSgNameGroup(SgNode* node);
isSgNameGroup overloads
isSgNamedType
[[visibility("default")]] SgNamedType* isSgNamedType(SgNode* node);
isSgNamedType overloads
isSgNamelistStatement
[[visibility("default")]] SgNamelistStatement* isSgNamelistStatement(SgNode* node);
isSgNamelistStatement overloads
isSgNamelistSymbol
[[visibility("default")]] SgNamelistSymbol* isSgNamelistSymbol(SgNode* node);
isSgNamelistSymbol overloads
isSgNamespaceAliasDeclarationStatement
[[visibility("default")]] SgNamespaceAliasDeclarationStatement* isSgNamespaceAliasDeclarationStatement(SgNode* node);
isSgNamespaceAliasDeclarationStatement overloads
isSgNamespaceDeclarationStatement
[[visibility("default")]] SgNamespaceDeclarationStatement* isSgNamespaceDeclarationStatement(SgNode* node);
isSgNamespaceDeclarationStatement overloads
isSgNamespaceDefinitionStatement
[[visibility("default")]] SgNamespaceDefinitionStatement* isSgNamespaceDefinitionStatement(SgNode* node);
isSgNamespaceDefinitionStatement overloads
isSgNamespaceSourceFragment
[[visibility("default")]] SgNamespaceSourceFragment* isSgNamespaceSourceFragment(SgNode* node);
isSgNamespaceSourceFragment overloads
isSgNamespaceSymbol
[[visibility("default")]] SgNamespaceSymbol* isSgNamespaceSymbol(SgNode* node);
isSgNamespaceSymbol overloads
isSgNestedRequirement
[[visibility("default")]] SgNestedRequirement* isSgNestedRequirement(SgNode* node);
isSgNestedRequirement overloads
isSgNewExp
[[visibility("default")]] SgNewExp* isSgNewExp(SgNode* node);
isSgNewExp overloads
isSgNode
[[visibility("default")]] SgNode* isSgNode(SgNode* node);
isSgNode overloads
isSgNoexceptOp
[[visibility("default")]] SgNoexceptOp* isSgNoexceptOp(SgNode* node);
isSgNoexceptOp overloads
isSgNonrealBaseClass
[[visibility("default")]] SgNonrealBaseClass* isSgNonrealBaseClass(SgNode* node);
isSgNonrealBaseClass overloads
isSgNonrealDecl
[[visibility("default")]] SgNonrealDecl* isSgNonrealDecl(SgNode* node);
isSgNonrealDecl overloads
isSgNonrealRefExp
[[visibility("default")]] SgNonrealRefExp* isSgNonrealRefExp(SgNode* node);
isSgNonrealRefExp overloads
isSgNonrealSymbol
[[visibility("default")]] SgNonrealSymbol* isSgNonrealSymbol(SgNode* node);
isSgNonrealSymbol overloads
isSgNonrealType
[[visibility("default")]] SgNonrealType* isSgNonrealType(SgNode* node);
isSgNonrealType overloads
isSgNotEqualOp
[[visibility("default")]] SgNotEqualOp* isSgNotEqualOp(SgNode* node);
isSgNotEqualOp overloads
isSgNotOp
[[visibility("default")]] SgNotOp* isSgNotOp(SgNode* node);
isSgNotOp overloads
isSgNullExpression
[[visibility("default")]] SgNullExpression* isSgNullExpression(SgNode* node);
isSgNullExpression overloads
isSgNullStatement
[[visibility("default")]] SgNullStatement* isSgNullStatement(SgNode* node);
isSgNullStatement overloads
isSgNullifyStatement
[[visibility("default")]] SgNullifyStatement* isSgNullifyStatement(SgNode* node);
isSgNullifyStatement overloads
isSgNullptrValExp
[[visibility("default")]] SgNullptrValExp* isSgNullptrValExp(SgNode* node);
isSgNullptrValExp overloads
isSgOmpAbsentClause
[[visibility("default")]] SgOmpAbsentClause* isSgOmpAbsentClause(SgNode* node);
isSgOmpAbsentClause overloads
isSgOmpAcqRelClause
[[visibility("default")]] SgOmpAcqRelClause* isSgOmpAcqRelClause(SgNode* node);
isSgOmpAcqRelClause overloads
isSgOmpAcquireClause
[[visibility("default")]] SgOmpAcquireClause* isSgOmpAcquireClause(SgNode* node);
isSgOmpAcquireClause overloads
isSgOmpAdjustArgsClause
[[visibility("default")]] SgOmpAdjustArgsClause* isSgOmpAdjustArgsClause(SgNode* node);
isSgOmpAdjustArgsClause overloads
isSgOmpAffinityClause
[[visibility("default")]] SgOmpAffinityClause* isSgOmpAffinityClause(SgNode* node);
isSgOmpAffinityClause overloads
isSgOmpAlignClause
[[visibility("default")]] SgOmpAlignClause* isSgOmpAlignClause(SgNode* node);
isSgOmpAlignClause overloads
isSgOmpAlignedClause
[[visibility("default")]] SgOmpAlignedClause* isSgOmpAlignedClause(SgNode* node);
isSgOmpAlignedClause overloads
isSgOmpAllocateClause
[[visibility("default")]] SgOmpAllocateClause* isSgOmpAllocateClause(SgNode* node);
isSgOmpAllocateClause overloads
isSgOmpAllocateStatement
[[visibility("default")]] SgOmpAllocateStatement* isSgOmpAllocateStatement(SgNode* node);
isSgOmpAllocateStatement overloads
isSgOmpAllocatorClause
[[visibility("default")]] SgOmpAllocatorClause* isSgOmpAllocatorClause(SgNode* node);
isSgOmpAllocatorClause overloads
isSgOmpAppendArgsClause
[[visibility("default")]] SgOmpAppendArgsClause* isSgOmpAppendArgsClause(SgNode* node);
isSgOmpAppendArgsClause overloads
isSgOmpAppendArgsOperation
[[visibility("default")]] SgOmpAppendArgsOperation* isSgOmpAppendArgsOperation(SgNode* node);
isSgOmpAppendArgsOperation overloads
isSgOmpApplyClause
[[visibility("default")]] SgOmpApplyClause* isSgOmpApplyClause(SgNode* node);
isSgOmpApplyClause overloads
isSgOmpApplyTransformation
[[visibility("default")]] SgOmpApplyTransformation* isSgOmpApplyTransformation(SgNode* node);
isSgOmpApplyTransformation overloads
isSgOmpAssumeStatement
[[visibility("default")]] SgOmpAssumeStatement* isSgOmpAssumeStatement(SgNode* node);
isSgOmpAssumeStatement overloads
isSgOmpAssumesStatement
[[visibility("default")]] SgOmpAssumesStatement* isSgOmpAssumesStatement(SgNode* node);
isSgOmpAssumesStatement overloads
isSgOmpAtClause
[[visibility("default")]] SgOmpAtClause* isSgOmpAtClause(SgNode* node);
isSgOmpAtClause overloads
isSgOmpAtomicClause
[[visibility("default")]] SgOmpAtomicClause* isSgOmpAtomicClause(SgNode* node);
isSgOmpAtomicClause overloads
isSgOmpAtomicDefaultMemOrderClause
[[visibility("default")]] SgOmpAtomicDefaultMemOrderClause* isSgOmpAtomicDefaultMemOrderClause(SgNode* node);
isSgOmpAtomicDefaultMemOrderClause overloads
isSgOmpAtomicStatement
[[visibility("default")]] SgOmpAtomicStatement* isSgOmpAtomicStatement(SgNode* node);
isSgOmpAtomicStatement overloads
isSgOmpBarrierStatement
[[visibility("default")]] SgOmpBarrierStatement* isSgOmpBarrierStatement(SgNode* node);
isSgOmpBarrierStatement overloads
isSgOmpBeginAssumesStatement
[[visibility("default")]] SgOmpBeginAssumesStatement* isSgOmpBeginAssumesStatement(SgNode* node);
isSgOmpBeginAssumesStatement overloads
isSgOmpBeginClause
[[visibility("default")]] SgOmpBeginClause* isSgOmpBeginClause(SgNode* node);
isSgOmpBeginClause overloads
isSgOmpBeginDeclareTargetStatement
[[visibility("default")]] SgOmpBeginDeclareTargetStatement* isSgOmpBeginDeclareTargetStatement(SgNode* node);
isSgOmpBeginDeclareTargetStatement overloads
isSgOmpBeginDeclareVariantStatement
[[visibility("default")]] SgOmpBeginDeclareVariantStatement* isSgOmpBeginDeclareVariantStatement(SgNode* node);
isSgOmpBeginDeclareVariantStatement overloads
isSgOmpBindClause
[[visibility("default")]] SgOmpBindClause* isSgOmpBindClause(SgNode* node);
isSgOmpBindClause overloads
isSgOmpBodyStatement
[[visibility("default")]] SgOmpBodyStatement* isSgOmpBodyStatement(SgNode* node);
isSgOmpBodyStatement overloads
isSgOmpCancelStatement
[[visibility("default")]] SgOmpCancelStatement* isSgOmpCancelStatement(SgNode* node);
isSgOmpCancelStatement overloads
isSgOmpCancellationPointStatement
[[visibility("default")]] SgOmpCancellationPointStatement* isSgOmpCancellationPointStatement(SgNode* node);
isSgOmpCancellationPointStatement overloads
isSgOmpCaptureClause
[[visibility("default")]] SgOmpCaptureClause* isSgOmpCaptureClause(SgNode* node);
isSgOmpCaptureClause overloads
isSgOmpClause
[[visibility("default")]] SgOmpClause* isSgOmpClause(SgNode* node);
isSgOmpClause overloads
isSgOmpClauseBodyStatement
[[visibility("default")]] SgOmpClauseBodyStatement* isSgOmpClauseBodyStatement(SgNode* node);
isSgOmpClauseBodyStatement overloads
isSgOmpClauseList
[[visibility("default")]] SgOmpClauseList* isSgOmpClauseList(SgNode* node);
isSgOmpClauseList overloads
isSgOmpClauseStatement
[[visibility("default")]] SgOmpClauseStatement* isSgOmpClauseStatement(SgNode* node);
isSgOmpClauseStatement overloads
isSgOmpCollapseClause
[[visibility("default")]] SgOmpCollapseClause* isSgOmpCollapseClause(SgNode* node);
isSgOmpCollapseClause overloads
isSgOmpCompareClause
[[visibility("default")]] SgOmpCompareClause* isSgOmpCompareClause(SgNode* node);
isSgOmpCompareClause overloads
isSgOmpContainsClause
[[visibility("default")]] SgOmpContainsClause* isSgOmpContainsClause(SgNode* node);
isSgOmpContainsClause overloads
isSgOmpContextSelector
[[visibility("default")]] SgOmpContextSelector* isSgOmpContextSelector(SgNode* node);
isSgOmpContextSelector overloads
isSgOmpContextSelectorProperty
[[visibility("default")]] SgOmpContextSelectorProperty* isSgOmpContextSelectorProperty(SgNode* node);
isSgOmpContextSelectorProperty overloads
isSgOmpContextSelectorSet
[[visibility("default")]] SgOmpContextSelectorSet* isSgOmpContextSelectorSet(SgNode* node);
isSgOmpContextSelectorSet overloads
isSgOmpCopyinClause
[[visibility("default")]] SgOmpCopyinClause* isSgOmpCopyinClause(SgNode* node);
isSgOmpCopyinClause overloads
isSgOmpCopyprivateClause
[[visibility("default")]] SgOmpCopyprivateClause* isSgOmpCopyprivateClause(SgNode* node);
isSgOmpCopyprivateClause overloads
isSgOmpCriticalStatement
[[visibility("default")]] SgOmpCriticalStatement* isSgOmpCriticalStatement(SgNode* node);
isSgOmpCriticalStatement overloads
isSgOmpDeclareMapperStatement
[[visibility("default")]] SgOmpDeclareMapperStatement* isSgOmpDeclareMapperStatement(SgNode* node);
isSgOmpDeclareMapperStatement overloads
isSgOmpDeclareSimdStatement
[[visibility("default")]] SgOmpDeclareSimdStatement* isSgOmpDeclareSimdStatement(SgNode* node);
isSgOmpDeclareSimdStatement overloads
isSgOmpDeclareTargetStatement
[[visibility("default")]] SgOmpDeclareTargetStatement* isSgOmpDeclareTargetStatement(SgNode* node);
isSgOmpDeclareTargetStatement overloads
isSgOmpDeclareVariantStatement
[[visibility("default")]] SgOmpDeclareVariantStatement* isSgOmpDeclareVariantStatement(SgNode* node);
isSgOmpDeclareVariantStatement overloads
isSgOmpDefaultClause
[[visibility("default")]] SgOmpDefaultClause* isSgOmpDefaultClause(SgNode* node);
isSgOmpDefaultClause overloads
isSgOmpDefaultmapClause
[[visibility("default")]] SgOmpDefaultmapClause* isSgOmpDefaultmapClause(SgNode* node);
isSgOmpDefaultmapClause overloads
isSgOmpDependClause
[[visibility("default")]] SgOmpDependClause* isSgOmpDependClause(SgNode* node);
isSgOmpDependClause overloads
isSgOmpDepobjStatement
[[visibility("default")]] SgOmpDepobjStatement* isSgOmpDepobjStatement(SgNode* node);
isSgOmpDepobjStatement overloads
isSgOmpDepobjUpdateClause
[[visibility("default")]] SgOmpDepobjUpdateClause* isSgOmpDepobjUpdateClause(SgNode* node);
isSgOmpDepobjUpdateClause overloads
isSgOmpDestroyClause
[[visibility("default")]] SgOmpDestroyClause* isSgOmpDestroyClause(SgNode* node);
isSgOmpDestroyClause overloads
isSgOmpDetachClause
[[visibility("default")]] SgOmpDetachClause* isSgOmpDetachClause(SgNode* node);
isSgOmpDetachClause overloads
isSgOmpDeviceClause
[[visibility("default")]] SgOmpDeviceClause* isSgOmpDeviceClause(SgNode* node);
isSgOmpDeviceClause overloads
isSgOmpDirectiveKindClause
[[visibility("default")]] SgOmpDirectiveKindClause* isSgOmpDirectiveKindClause(SgNode* node);
isSgOmpDirectiveKindClause overloads
isSgOmpDirectiveLocalRefExp
[[visibility("default")]] SgOmpDirectiveLocalRefExp* isSgOmpDirectiveLocalRefExp(SgNode* node);
isSgOmpDirectiveLocalRefExp overloads
isSgOmpDispatchStatement
[[visibility("default")]] SgOmpDispatchStatement* isSgOmpDispatchStatement(SgNode* node);
isSgOmpDispatchStatement overloads
isSgOmpDistScheduleClause
[[visibility("default")]] SgOmpDistScheduleClause* isSgOmpDistScheduleClause(SgNode* node);
isSgOmpDistScheduleClause overloads
isSgOmpDistributeParallelForSimdStatement
[[visibility("default")]] SgOmpDistributeParallelForSimdStatement* isSgOmpDistributeParallelForSimdStatement(SgNode* node);
isSgOmpDistributeParallelForSimdStatement overloads
isSgOmpDistributeParallelForStatement
[[visibility("default")]] SgOmpDistributeParallelForStatement* isSgOmpDistributeParallelForStatement(SgNode* node);
isSgOmpDistributeParallelForStatement overloads
isSgOmpDistributeSimdStatement
[[visibility("default")]] SgOmpDistributeSimdStatement* isSgOmpDistributeSimdStatement(SgNode* node);
isSgOmpDistributeSimdStatement overloads
isSgOmpDistributeStatement
[[visibility("default")]] SgOmpDistributeStatement* isSgOmpDistributeStatement(SgNode* node);
isSgOmpDistributeStatement overloads
isSgOmpDoStatement
[[visibility("default")]] SgOmpDoStatement* isSgOmpDoStatement(SgNode* node);
isSgOmpDoStatement overloads
isSgOmpDoacrossClause
[[visibility("default")]] SgOmpDoacrossClause* isSgOmpDoacrossClause(SgNode* node);
isSgOmpDoacrossClause overloads
isSgOmpDynamicAllocatorsClause
[[visibility("default")]] SgOmpDynamicAllocatorsClause* isSgOmpDynamicAllocatorsClause(SgNode* node);
isSgOmpDynamicAllocatorsClause overloads
isSgOmpEndAssumeStatement
[[visibility("default")]] SgOmpEndAssumeStatement* isSgOmpEndAssumeStatement(SgNode* node);
isSgOmpEndAssumeStatement overloads
isSgOmpEndAssumesStatement
[[visibility("default")]] SgOmpEndAssumesStatement* isSgOmpEndAssumesStatement(SgNode* node);
isSgOmpEndAssumesStatement overloads
isSgOmpEndClause
[[visibility("default")]] SgOmpEndClause* isSgOmpEndClause(SgNode* node);
isSgOmpEndClause overloads
isSgOmpEndDeclareTargetStatement
[[visibility("default")]] SgOmpEndDeclareTargetStatement* isSgOmpEndDeclareTargetStatement(SgNode* node);
isSgOmpEndDeclareTargetStatement overloads
isSgOmpEndDeclareVariantStatement
[[visibility("default")]] SgOmpEndDeclareVariantStatement* isSgOmpEndDeclareVariantStatement(SgNode* node);
isSgOmpEndDeclareVariantStatement overloads
isSgOmpEnterClause
[[visibility("default")]] SgOmpEnterClause* isSgOmpEnterClause(SgNode* node);
isSgOmpEnterClause overloads
isSgOmpErrorStatement
[[visibility("default")]] SgOmpErrorStatement* isSgOmpErrorStatement(SgNode* node);
isSgOmpErrorStatement overloads
isSgOmpExclusiveClause
[[visibility("default")]] SgOmpExclusiveClause* isSgOmpExclusiveClause(SgNode* node);
isSgOmpExclusiveClause overloads
isSgOmpExecStatement
[[visibility("default")]] SgOmpExecStatement* isSgOmpExecStatement(SgNode* node);
isSgOmpExecStatement overloads
isSgOmpExpressionClause
[[visibility("default")]] SgOmpExpressionClause* isSgOmpExpressionClause(SgNode* node);
isSgOmpExpressionClause overloads
isSgOmpExtImplementationDefinedRequirementClause
[[visibility("default")]] SgOmpExtImplementationDefinedRequirementClause* isSgOmpExtImplementationDefinedRequirementClause(SgNode* node);
isSgOmpExtImplementationDefinedRequirementClause overloads
isSgOmpFailClause
[[visibility("default")]] SgOmpFailClause* isSgOmpFailClause(SgNode* node);
isSgOmpFailClause overloads
isSgOmpFilterClause
[[visibility("default")]] SgOmpFilterClause* isSgOmpFilterClause(SgNode* node);
isSgOmpFilterClause overloads
isSgOmpFinalClause
[[visibility("default")]] SgOmpFinalClause* isSgOmpFinalClause(SgNode* node);
isSgOmpFinalClause overloads
isSgOmpFirstprivateClause
[[visibility("default")]] SgOmpFirstprivateClause* isSgOmpFirstprivateClause(SgNode* node);
isSgOmpFirstprivateClause overloads
isSgOmpFlushStatement
[[visibility("default")]] SgOmpFlushStatement* isSgOmpFlushStatement(SgNode* node);
isSgOmpFlushStatement overloads
isSgOmpForClause
[[visibility("default")]] SgOmpForClause* isSgOmpForClause(SgNode* node);
isSgOmpForClause overloads
isSgOmpForSimdStatement
[[visibility("default")]] SgOmpForSimdStatement* isSgOmpForSimdStatement(SgNode* node);
isSgOmpForSimdStatement overloads
isSgOmpForStatement
[[visibility("default")]] SgOmpForStatement* isSgOmpForStatement(SgNode* node);
isSgOmpForStatement overloads
isSgOmpFromClause
[[visibility("default")]] SgOmpFromClause* isSgOmpFromClause(SgNode* node);
isSgOmpFromClause overloads
isSgOmpFullClause
[[visibility("default")]] SgOmpFullClause* isSgOmpFullClause(SgNode* node);
isSgOmpFullClause overloads
isSgOmpFuseStatement
[[visibility("default")]] SgOmpFuseStatement* isSgOmpFuseStatement(SgNode* node);
isSgOmpFuseStatement overloads
isSgOmpGrainsizeClause
[[visibility("default")]] SgOmpGrainsizeClause* isSgOmpGrainsizeClause(SgNode* node);
isSgOmpGrainsizeClause overloads
isSgOmpGraphIdClause
[[visibility("default")]] SgOmpGraphIdClause* isSgOmpGraphIdClause(SgNode* node);
isSgOmpGraphIdClause overloads
isSgOmpGraphResetClause
[[visibility("default")]] SgOmpGraphResetClause* isSgOmpGraphResetClause(SgNode* node);
isSgOmpGraphResetClause overloads
isSgOmpGroupprivateStatement
[[visibility("default")]] SgOmpGroupprivateStatement* isSgOmpGroupprivateStatement(SgNode* node);
isSgOmpGroupprivateStatement overloads
isSgOmpHasDeviceAddrClause
[[visibility("default")]] SgOmpHasDeviceAddrClause* isSgOmpHasDeviceAddrClause(SgNode* node);
isSgOmpHasDeviceAddrClause overloads
isSgOmpHintClause
[[visibility("default")]] SgOmpHintClause* isSgOmpHintClause(SgNode* node);
isSgOmpHintClause overloads
isSgOmpHoldsClause
[[visibility("default")]] SgOmpHoldsClause* isSgOmpHoldsClause(SgNode* node);
isSgOmpHoldsClause overloads
isSgOmpIfClause
[[visibility("default")]] SgOmpIfClause* isSgOmpIfClause(SgNode* node);
isSgOmpIfClause overloads
isSgOmpInReductionClause
[[visibility("default")]] SgOmpInReductionClause* isSgOmpInReductionClause(SgNode* node);
isSgOmpInReductionClause overloads
isSgOmpInbranchClause
[[visibility("default")]] SgOmpInbranchClause* isSgOmpInbranchClause(SgNode* node);
isSgOmpInbranchClause overloads
isSgOmpInclusiveClause
[[visibility("default")]] SgOmpInclusiveClause* isSgOmpInclusiveClause(SgNode* node);
isSgOmpInclusiveClause overloads
isSgOmpIndirectClause
[[visibility("default")]] SgOmpIndirectClause* isSgOmpIndirectClause(SgNode* node);
isSgOmpIndirectClause overloads
isSgOmpInductionClause
[[visibility("default")]] SgOmpInductionClause* isSgOmpInductionClause(SgNode* node);
isSgOmpInductionClause overloads
isSgOmpInductionItem
[[visibility("default")]] SgOmpInductionItem* isSgOmpInductionItem(SgNode* node);
isSgOmpInductionItem overloads
isSgOmpInitClause
[[visibility("default")]] SgOmpInitClause* isSgOmpInitClause(SgNode* node);
isSgOmpInitClause overloads
isSgOmpInitModifier
[[visibility("default")]] SgOmpInitModifier* isSgOmpInitModifier(SgNode* node);
isSgOmpInitModifier overloads
isSgOmpInitModifierList
[[visibility("default")]] SgOmpInitModifierList* isSgOmpInitModifierList(SgNode* node);
isSgOmpInitModifierList overloads
isSgOmpInterchangeStatement
[[visibility("default")]] SgOmpInterchangeStatement* isSgOmpInterchangeStatement(SgNode* node);
isSgOmpInterchangeStatement overloads
isSgOmpInteropStatement
[[visibility("default")]] SgOmpInteropStatement* isSgOmpInteropStatement(SgNode* node);
isSgOmpInteropStatement overloads
isSgOmpIsDevicePtrClause
[[visibility("default")]] SgOmpIsDevicePtrClause* isSgOmpIsDevicePtrClause(SgNode* node);
isSgOmpIsDevicePtrClause overloads
isSgOmpIteratorDefinition
[[visibility("default")]] SgOmpIteratorDefinition* isSgOmpIteratorDefinition(SgNode* node);
isSgOmpIteratorDefinition overloads
isSgOmpLastprivateClause
[[visibility("default")]] SgOmpLastprivateClause* isSgOmpLastprivateClause(SgNode* node);
isSgOmpLastprivateClause overloads
isSgOmpLinearClause
[[visibility("default")]] SgOmpLinearClause* isSgOmpLinearClause(SgNode* node);
isSgOmpLinearClause overloads
isSgOmpLinkClause
[[visibility("default")]] SgOmpLinkClause* isSgOmpLinkClause(SgNode* node);
isSgOmpLinkClause overloads
isSgOmpLocalClause
[[visibility("default")]] SgOmpLocalClause* isSgOmpLocalClause(SgNode* node);
isSgOmpLocalClause overloads
isSgOmpLoopStatement
[[visibility("default")]] SgOmpLoopStatement* isSgOmpLoopStatement(SgNode* node);
isSgOmpLoopStatement overloads
isSgOmpLooprangeClause
[[visibility("default")]] SgOmpLooprangeClause* isSgOmpLooprangeClause(SgNode* node);
isSgOmpLooprangeClause overloads
isSgOmpMapClause
[[visibility("default")]] SgOmpMapClause* isSgOmpMapClause(SgNode* node);
isSgOmpMapClause overloads
isSgOmpMapDistDataPolicy
[[visibility("default")]] SgOmpMapDistDataPolicy* isSgOmpMapDistDataPolicy(SgNode* node);
isSgOmpMapDistDataPolicy overloads
isSgOmpMapItem
[[visibility("default")]] SgOmpMapItem* isSgOmpMapItem(SgNode* node);
isSgOmpMapItem overloads
isSgOmpMaskedStatement
[[visibility("default")]] SgOmpMaskedStatement* isSgOmpMaskedStatement(SgNode* node);
isSgOmpMaskedStatement overloads
isSgOmpMaskedTaskloopSimdStatement
[[visibility("default")]] SgOmpMaskedTaskloopSimdStatement* isSgOmpMaskedTaskloopSimdStatement(SgNode* node);
isSgOmpMaskedTaskloopSimdStatement overloads
isSgOmpMaskedTaskloopStatement
[[visibility("default")]] SgOmpMaskedTaskloopStatement* isSgOmpMaskedTaskloopStatement(SgNode* node);
isSgOmpMaskedTaskloopStatement overloads
isSgOmpMasterStatement
[[visibility("default")]] SgOmpMasterStatement* isSgOmpMasterStatement(SgNode* node);
isSgOmpMasterStatement overloads
isSgOmpMasterTaskloopSimdStatement
[[visibility("default")]] SgOmpMasterTaskloopSimdStatement* isSgOmpMasterTaskloopSimdStatement(SgNode* node);
isSgOmpMasterTaskloopSimdStatement overloads
isSgOmpMasterTaskloopStatement
[[visibility("default")]] SgOmpMasterTaskloopStatement* isSgOmpMasterTaskloopStatement(SgNode* node);
isSgOmpMasterTaskloopStatement overloads
isSgOmpMatchClause
[[visibility("default")]] SgOmpMatchClause* isSgOmpMatchClause(SgNode* node);
isSgOmpMatchClause overloads
isSgOmpMergeableClause
[[visibility("default")]] SgOmpMergeableClause* isSgOmpMergeableClause(SgNode* node);
isSgOmpMergeableClause overloads
isSgOmpMessageClause
[[visibility("default")]] SgOmpMessageClause* isSgOmpMessageClause(SgNode* node);
isSgOmpMessageClause overloads
isSgOmpMetadirectiveStatement
[[visibility("default")]] SgOmpMetadirectiveStatement* isSgOmpMetadirectiveStatement(SgNode* node);
isSgOmpMetadirectiveStatement overloads
isSgOmpNameExpression
[[visibility("default")]] SgOmpNameExpression* isSgOmpNameExpression(SgNode* node);
isSgOmpNameExpression overloads
isSgOmpNoOpenmpClause
[[visibility("default")]] SgOmpNoOpenmpClause* isSgOmpNoOpenmpClause(SgNode* node);
isSgOmpNoOpenmpClause overloads
isSgOmpNoOpenmpConstructsClause
[[visibility("default")]] SgOmpNoOpenmpConstructsClause* isSgOmpNoOpenmpConstructsClause(SgNode* node);
isSgOmpNoOpenmpConstructsClause overloads
isSgOmpNoOpenmpRoutinesClause
[[visibility("default")]] SgOmpNoOpenmpRoutinesClause* isSgOmpNoOpenmpRoutinesClause(SgNode* node);
isSgOmpNoOpenmpRoutinesClause overloads
isSgOmpNoParallelismClause
[[visibility("default")]] SgOmpNoParallelismClause* isSgOmpNoParallelismClause(SgNode* node);
isSgOmpNoParallelismClause overloads
isSgOmpNocontextClause
[[visibility("default")]] SgOmpNocontextClause* isSgOmpNocontextClause(SgNode* node);
isSgOmpNocontextClause overloads
isSgOmpNogroupClause
[[visibility("default")]] SgOmpNogroupClause* isSgOmpNogroupClause(SgNode* node);
isSgOmpNogroupClause overloads
isSgOmpNontemporalClause
[[visibility("default")]] SgOmpNontemporalClause* isSgOmpNontemporalClause(SgNode* node);
isSgOmpNontemporalClause overloads
isSgOmpNothingStatement
[[visibility("default")]] SgOmpNothingStatement* isSgOmpNothingStatement(SgNode* node);
isSgOmpNothingStatement overloads
isSgOmpNotinbranchClause
[[visibility("default")]] SgOmpNotinbranchClause* isSgOmpNotinbranchClause(SgNode* node);
isSgOmpNotinbranchClause overloads
isSgOmpNovariantsClause
[[visibility("default")]] SgOmpNovariantsClause* isSgOmpNovariantsClause(SgNode* node);
isSgOmpNovariantsClause overloads
isSgOmpNowaitClause
[[visibility("default")]] SgOmpNowaitClause* isSgOmpNowaitClause(SgNode* node);
isSgOmpNowaitClause overloads
isSgOmpNumTasksClause
[[visibility("default")]] SgOmpNumTasksClause* isSgOmpNumTasksClause(SgNode* node);
isSgOmpNumTasksClause overloads
isSgOmpNumTeamsClause
[[visibility("default")]] SgOmpNumTeamsClause* isSgOmpNumTeamsClause(SgNode* node);
isSgOmpNumTeamsClause overloads
isSgOmpNumThreadsClause
[[visibility("default")]] SgOmpNumThreadsClause* isSgOmpNumThreadsClause(SgNode* node);
isSgOmpNumThreadsClause overloads
isSgOmpOrderClause
[[visibility("default")]] SgOmpOrderClause* isSgOmpOrderClause(SgNode* node);
isSgOmpOrderClause overloads
isSgOmpOrderedClause
[[visibility("default")]] SgOmpOrderedClause* isSgOmpOrderedClause(SgNode* node);
isSgOmpOrderedClause overloads
isSgOmpOrderedDependStatement
[[visibility("default")]] SgOmpOrderedDependStatement* isSgOmpOrderedDependStatement(SgNode* node);
isSgOmpOrderedDependStatement overloads
isSgOmpOrderedStatement
[[visibility("default")]] SgOmpOrderedStatement* isSgOmpOrderedStatement(SgNode* node);
isSgOmpOrderedStatement overloads
isSgOmpOtherwiseClause
[[visibility("default")]] SgOmpOtherwiseClause* isSgOmpOtherwiseClause(SgNode* node);
isSgOmpOtherwiseClause overloads
isSgOmpParallelClause
[[visibility("default")]] SgOmpParallelClause* isSgOmpParallelClause(SgNode* node);
isSgOmpParallelClause overloads
isSgOmpParallelLoopStatement
[[visibility("default")]] SgOmpParallelLoopStatement* isSgOmpParallelLoopStatement(SgNode* node);
isSgOmpParallelLoopStatement overloads
isSgOmpParallelMaskedStatement
[[visibility("default")]] SgOmpParallelMaskedStatement* isSgOmpParallelMaskedStatement(SgNode* node);
isSgOmpParallelMaskedStatement overloads
isSgOmpParallelMasterStatement
[[visibility("default")]] SgOmpParallelMasterStatement* isSgOmpParallelMasterStatement(SgNode* node);
isSgOmpParallelMasterStatement overloads
isSgOmpParallelMasterTaskloopSimdStatement
[[visibility("default")]] SgOmpParallelMasterTaskloopSimdStatement* isSgOmpParallelMasterTaskloopSimdStatement(SgNode* node);
isSgOmpParallelMasterTaskloopSimdStatement overloads
isSgOmpParallelMasterTaskloopStatement
[[visibility("default")]] SgOmpParallelMasterTaskloopStatement* isSgOmpParallelMasterTaskloopStatement(SgNode* node);
isSgOmpParallelMasterTaskloopStatement overloads
isSgOmpParallelStatement
[[visibility("default")]] SgOmpParallelStatement* isSgOmpParallelStatement(SgNode* node);
isSgOmpParallelStatement overloads
isSgOmpPartialClause
[[visibility("default")]] SgOmpPartialClause* isSgOmpPartialClause(SgNode* node);
isSgOmpPartialClause overloads
isSgOmpPriorityClause
[[visibility("default")]] SgOmpPriorityClause* isSgOmpPriorityClause(SgNode* node);
isSgOmpPriorityClause overloads
isSgOmpPrivateClause
[[visibility("default")]] SgOmpPrivateClause* isSgOmpPrivateClause(SgNode* node);
isSgOmpPrivateClause overloads
isSgOmpProcBindClause
[[visibility("default")]] SgOmpProcBindClause* isSgOmpProcBindClause(SgNode* node);
isSgOmpProcBindClause overloads
isSgOmpReadClause
[[visibility("default")]] SgOmpReadClause* isSgOmpReadClause(SgNode* node);
isSgOmpReadClause overloads
isSgOmpReductionClause
[[visibility("default")]] SgOmpReductionClause* isSgOmpReductionClause(SgNode* node);
isSgOmpReductionClause overloads
isSgOmpRelaxedClause
[[visibility("default")]] SgOmpRelaxedClause* isSgOmpRelaxedClause(SgNode* node);
isSgOmpRelaxedClause overloads
isSgOmpReleaseClause
[[visibility("default")]] SgOmpReleaseClause* isSgOmpReleaseClause(SgNode* node);
isSgOmpReleaseClause overloads
isSgOmpRequiresStatement
[[visibility("default")]] SgOmpRequiresStatement* isSgOmpRequiresStatement(SgNode* node);
isSgOmpRequiresStatement overloads
isSgOmpReverseOffloadClause
[[visibility("default")]] SgOmpReverseOffloadClause* isSgOmpReverseOffloadClause(SgNode* node);
isSgOmpReverseOffloadClause overloads
isSgOmpReverseStatement
[[visibility("default")]] SgOmpReverseStatement* isSgOmpReverseStatement(SgNode* node);
isSgOmpReverseStatement overloads
isSgOmpSafelenClause
[[visibility("default")]] SgOmpSafelenClause* isSgOmpSafelenClause(SgNode* node);
isSgOmpSafelenClause overloads
isSgOmpSafesyncClause
[[visibility("default")]] SgOmpSafesyncClause* isSgOmpSafesyncClause(SgNode* node);
isSgOmpSafesyncClause overloads
isSgOmpScanStatement
[[visibility("default")]] SgOmpScanStatement* isSgOmpScanStatement(SgNode* node);
isSgOmpScanStatement overloads
isSgOmpScheduleClause
[[visibility("default")]] SgOmpScheduleClause* isSgOmpScheduleClause(SgNode* node);
isSgOmpScheduleClause overloads
isSgOmpScopeStatement
[[visibility("default")]] SgOmpScopeStatement* isSgOmpScopeStatement(SgNode* node);
isSgOmpScopeStatement overloads
isSgOmpSectionStatement
[[visibility("default")]] SgOmpSectionStatement* isSgOmpSectionStatement(SgNode* node);
isSgOmpSectionStatement overloads
isSgOmpSectionsClause
[[visibility("default")]] SgOmpSectionsClause* isSgOmpSectionsClause(SgNode* node);
isSgOmpSectionsClause overloads
isSgOmpSectionsStatement
[[visibility("default")]] SgOmpSectionsStatement* isSgOmpSectionsStatement(SgNode* node);
isSgOmpSectionsStatement overloads
isSgOmpSelfMapsClause
[[visibility("default")]] SgOmpSelfMapsClause* isSgOmpSelfMapsClause(SgNode* node);
isSgOmpSelfMapsClause overloads
isSgOmpSeqCstClause
[[visibility("default")]] SgOmpSeqCstClause* isSgOmpSeqCstClause(SgNode* node);
isSgOmpSeqCstClause overloads
isSgOmpSeverityClause
[[visibility("default")]] SgOmpSeverityClause* isSgOmpSeverityClause(SgNode* node);
isSgOmpSeverityClause overloads
isSgOmpSharedClause
[[visibility("default")]] SgOmpSharedClause* isSgOmpSharedClause(SgNode* node);
isSgOmpSharedClause overloads
isSgOmpSimdClause
[[visibility("default")]] SgOmpSimdClause* isSgOmpSimdClause(SgNode* node);
isSgOmpSimdClause overloads
isSgOmpSimdStatement
[[visibility("default")]] SgOmpSimdStatement* isSgOmpSimdStatement(SgNode* node);
isSgOmpSimdStatement overloads
isSgOmpSimdlenClause
[[visibility("default")]] SgOmpSimdlenClause* isSgOmpSimdlenClause(SgNode* node);
isSgOmpSimdlenClause overloads
isSgOmpSingleStatement
[[visibility("default")]] SgOmpSingleStatement* isSgOmpSingleStatement(SgNode* node);
isSgOmpSingleStatement overloads
isSgOmpSizesClause
[[visibility("default")]] SgOmpSizesClause* isSgOmpSizesClause(SgNode* node);
isSgOmpSizesClause overloads
isSgOmpSourceExpression
[[visibility("default")]] SgOmpSourceExpression* isSgOmpSourceExpression(SgNode* node);
isSgOmpSourceExpression overloads
isSgOmpTargetDataCompositeStatement
[[visibility("default")]] SgOmpTargetDataCompositeStatement* isSgOmpTargetDataCompositeStatement(SgNode* node);
isSgOmpTargetDataCompositeStatement overloads
isSgOmpTargetDataStatement
[[visibility("default")]] SgOmpTargetDataStatement* isSgOmpTargetDataStatement(SgNode* node);
isSgOmpTargetDataStatement overloads
isSgOmpTargetEnterDataStatement
[[visibility("default")]] SgOmpTargetEnterDataStatement* isSgOmpTargetEnterDataStatement(SgNode* node);
isSgOmpTargetEnterDataStatement overloads
isSgOmpTargetExitDataStatement
[[visibility("default")]] SgOmpTargetExitDataStatement* isSgOmpTargetExitDataStatement(SgNode* node);
isSgOmpTargetExitDataStatement overloads
isSgOmpTargetParallelForSimdStatement
[[visibility("default")]] SgOmpTargetParallelForSimdStatement* isSgOmpTargetParallelForSimdStatement(SgNode* node);
isSgOmpTargetParallelForSimdStatement overloads
isSgOmpTargetParallelForStatement
[[visibility("default")]] SgOmpTargetParallelForStatement* isSgOmpTargetParallelForStatement(SgNode* node);
isSgOmpTargetParallelForStatement overloads
isSgOmpTargetParallelLoopStatement
[[visibility("default")]] SgOmpTargetParallelLoopStatement* isSgOmpTargetParallelLoopStatement(SgNode* node);
isSgOmpTargetParallelLoopStatement overloads
isSgOmpTargetParallelStatement
[[visibility("default")]] SgOmpTargetParallelStatement* isSgOmpTargetParallelStatement(SgNode* node);
isSgOmpTargetParallelStatement overloads
isSgOmpTargetSimdStatement
[[visibility("default")]] SgOmpTargetSimdStatement* isSgOmpTargetSimdStatement(SgNode* node);
isSgOmpTargetSimdStatement overloads
isSgOmpTargetStatement
[[visibility("default")]] SgOmpTargetStatement* isSgOmpTargetStatement(SgNode* node);
isSgOmpTargetStatement overloads
isSgOmpTargetTeamsDistributeParallelForSimdStatement
[[visibility("default")]] SgOmpTargetTeamsDistributeParallelForSimdStatement* isSgOmpTargetTeamsDistributeParallelForSimdStatement(SgNode* node);
isSgOmpTargetTeamsDistributeParallelForSimdStatement overloads
isSgOmpTargetTeamsDistributeParallelForStatement
[[visibility("default")]] SgOmpTargetTeamsDistributeParallelForStatement* isSgOmpTargetTeamsDistributeParallelForStatement(SgNode* node);
isSgOmpTargetTeamsDistributeParallelForStatement overloads
isSgOmpTargetTeamsDistributeSimdStatement
[[visibility("default")]] SgOmpTargetTeamsDistributeSimdStatement* isSgOmpTargetTeamsDistributeSimdStatement(SgNode* node);
isSgOmpTargetTeamsDistributeSimdStatement overloads
isSgOmpTargetTeamsDistributeStatement
[[visibility("default")]] SgOmpTargetTeamsDistributeStatement* isSgOmpTargetTeamsDistributeStatement(SgNode* node);
isSgOmpTargetTeamsDistributeStatement overloads
isSgOmpTargetTeamsLoopStatement
[[visibility("default")]] SgOmpTargetTeamsLoopStatement* isSgOmpTargetTeamsLoopStatement(SgNode* node);
isSgOmpTargetTeamsLoopStatement overloads
isSgOmpTargetTeamsStatement
[[visibility("default")]] SgOmpTargetTeamsStatement* isSgOmpTargetTeamsStatement(SgNode* node);
isSgOmpTargetTeamsStatement overloads
isSgOmpTargetTeamsWorkdistributeStatement
[[visibility("default")]] SgOmpTargetTeamsWorkdistributeStatement* isSgOmpTargetTeamsWorkdistributeStatement(SgNode* node);
isSgOmpTargetTeamsWorkdistributeStatement overloads
isSgOmpTargetUpdateStatement
[[visibility("default")]] SgOmpTargetUpdateStatement* isSgOmpTargetUpdateStatement(SgNode* node);
isSgOmpTargetUpdateStatement overloads
isSgOmpTaskReductionClause
[[visibility("default")]] SgOmpTaskReductionClause* isSgOmpTaskReductionClause(SgNode* node);
isSgOmpTaskReductionClause overloads
isSgOmpTaskStatement
[[visibility("default")]] SgOmpTaskStatement* isSgOmpTaskStatement(SgNode* node);
isSgOmpTaskStatement overloads
isSgOmpTaskgraphStatement
[[visibility("default")]] SgOmpTaskgraphStatement* isSgOmpTaskgraphStatement(SgNode* node);
isSgOmpTaskgraphStatement overloads
isSgOmpTaskgroupClause
[[visibility("default")]] SgOmpTaskgroupClause* isSgOmpTaskgroupClause(SgNode* node);
isSgOmpTaskgroupClause overloads
isSgOmpTaskgroupStatement
[[visibility("default")]] SgOmpTaskgroupStatement* isSgOmpTaskgroupStatement(SgNode* node);
isSgOmpTaskgroupStatement overloads
isSgOmpTaskloopSimdStatement
[[visibility("default")]] SgOmpTaskloopSimdStatement* isSgOmpTaskloopSimdStatement(SgNode* node);
isSgOmpTaskloopSimdStatement overloads
isSgOmpTaskloopStatement
[[visibility("default")]] SgOmpTaskloopStatement* isSgOmpTaskloopStatement(SgNode* node);
isSgOmpTaskloopStatement overloads
isSgOmpTaskwaitStatement
[[visibility("default")]] SgOmpTaskwaitStatement* isSgOmpTaskwaitStatement(SgNode* node);
isSgOmpTaskwaitStatement overloads
isSgOmpTaskyieldStatement
[[visibility("default")]] SgOmpTaskyieldStatement* isSgOmpTaskyieldStatement(SgNode* node);
isSgOmpTaskyieldStatement overloads
isSgOmpTeamsDistributeParallelForSimdStatement
[[visibility("default")]] SgOmpTeamsDistributeParallelForSimdStatement* isSgOmpTeamsDistributeParallelForSimdStatement(SgNode* node);
isSgOmpTeamsDistributeParallelForSimdStatement overloads
isSgOmpTeamsDistributeParallelForStatement
[[visibility("default")]] SgOmpTeamsDistributeParallelForStatement* isSgOmpTeamsDistributeParallelForStatement(SgNode* node);
isSgOmpTeamsDistributeParallelForStatement overloads
isSgOmpTeamsDistributeSimdStatement
[[visibility("default")]] SgOmpTeamsDistributeSimdStatement* isSgOmpTeamsDistributeSimdStatement(SgNode* node);
isSgOmpTeamsDistributeSimdStatement overloads
isSgOmpTeamsDistributeStatement
[[visibility("default")]] SgOmpTeamsDistributeStatement* isSgOmpTeamsDistributeStatement(SgNode* node);
isSgOmpTeamsDistributeStatement overloads
isSgOmpTeamsLoopStatement
[[visibility("default")]] SgOmpTeamsLoopStatement* isSgOmpTeamsLoopStatement(SgNode* node);
isSgOmpTeamsLoopStatement overloads
isSgOmpTeamsStatement
[[visibility("default")]] SgOmpTeamsStatement* isSgOmpTeamsStatement(SgNode* node);
isSgOmpTeamsStatement overloads
isSgOmpThreadLimitClause
[[visibility("default")]] SgOmpThreadLimitClause* isSgOmpThreadLimitClause(SgNode* node);
isSgOmpThreadLimitClause overloads
isSgOmpThreadprivateStatement
[[visibility("default")]] SgOmpThreadprivateStatement* isSgOmpThreadprivateStatement(SgNode* node);
isSgOmpThreadprivateStatement overloads
isSgOmpThreadsClause
[[visibility("default")]] SgOmpThreadsClause* isSgOmpThreadsClause(SgNode* node);
isSgOmpThreadsClause overloads
isSgOmpThreadsetClause
[[visibility("default")]] SgOmpThreadsetClause* isSgOmpThreadsetClause(SgNode* node);
isSgOmpThreadsetClause overloads
isSgOmpTileStatement
[[visibility("default")]] SgOmpTileStatement* isSgOmpTileStatement(SgNode* node);
isSgOmpTileStatement overloads
isSgOmpToClause
[[visibility("default")]] SgOmpToClause* isSgOmpToClause(SgNode* node);
isSgOmpToClause overloads
isSgOmpTransparentClause
[[visibility("default")]] SgOmpTransparentClause* isSgOmpTransparentClause(SgNode* node);
isSgOmpTransparentClause overloads
isSgOmpUnifiedAddressClause
[[visibility("default")]] SgOmpUnifiedAddressClause* isSgOmpUnifiedAddressClause(SgNode* node);
isSgOmpUnifiedAddressClause overloads
isSgOmpUnifiedSharedMemoryClause
[[visibility("default")]] SgOmpUnifiedSharedMemoryClause* isSgOmpUnifiedSharedMemoryClause(SgNode* node);
isSgOmpUnifiedSharedMemoryClause overloads
isSgOmpUniformClause
[[visibility("default")]] SgOmpUniformClause* isSgOmpUniformClause(SgNode* node);
isSgOmpUniformClause overloads
isSgOmpUnrollStatement
[[visibility("default")]] SgOmpUnrollStatement* isSgOmpUnrollStatement(SgNode* node);
isSgOmpUnrollStatement overloads
isSgOmpUntiedClause
[[visibility("default")]] SgOmpUntiedClause* isSgOmpUntiedClause(SgNode* node);
isSgOmpUntiedClause overloads
isSgOmpUpdateClause
[[visibility("default")]] SgOmpUpdateClause* isSgOmpUpdateClause(SgNode* node);
isSgOmpUpdateClause overloads
isSgOmpUseClause
[[visibility("default")]] SgOmpUseClause* isSgOmpUseClause(SgNode* node);
isSgOmpUseClause overloads
isSgOmpUseDeviceAddrClause
[[visibility("default")]] SgOmpUseDeviceAddrClause* isSgOmpUseDeviceAddrClause(SgNode* node);
isSgOmpUseDeviceAddrClause overloads
isSgOmpUseDevicePtrClause
[[visibility("default")]] SgOmpUseDevicePtrClause* isSgOmpUseDevicePtrClause(SgNode* node);
isSgOmpUseDevicePtrClause overloads
isSgOmpUsesAllocatorsClause
[[visibility("default")]] SgOmpUsesAllocatorsClause* isSgOmpUsesAllocatorsClause(SgNode* node);
isSgOmpUsesAllocatorsClause overloads
isSgOmpUsesAllocatorsDefination
[[visibility("default")]] SgOmpUsesAllocatorsDefination* isSgOmpUsesAllocatorsDefination(SgNode* node);
isSgOmpUsesAllocatorsDefination overloads
isSgOmpVariablesClause
[[visibility("default")]] SgOmpVariablesClause* isSgOmpVariablesClause(SgNode* node);
isSgOmpVariablesClause overloads
isSgOmpWeakClause
[[visibility("default")]] SgOmpWeakClause* isSgOmpWeakClause(SgNode* node);
isSgOmpWeakClause overloads
isSgOmpWhenClause
[[visibility("default")]] SgOmpWhenClause* isSgOmpWhenClause(SgNode* node);
isSgOmpWhenClause overloads
isSgOmpWorkdistributeStatement
[[visibility("default")]] SgOmpWorkdistributeStatement* isSgOmpWorkdistributeStatement(SgNode* node);
isSgOmpWorkdistributeStatement overloads
isSgOmpWorkshareStatement
[[visibility("default")]] SgOmpWorkshareStatement* isSgOmpWorkshareStatement(SgNode* node);
isSgOmpWorkshareStatement overloads
isSgOmpWriteClause
[[visibility("default")]] SgOmpWriteClause* isSgOmpWriteClause(SgNode* node);
isSgOmpWriteClause overloads
isSgOpaqueValueBinding
[[visibility("default")]] SgOpaqueValueBinding* isSgOpaqueValueBinding(SgNode* node);
isSgOpaqueValueBinding overloads
isSgOpaqueValueReference
[[visibility("default")]] SgOpaqueValueReference* isSgOpaqueValueReference(SgNode* node);
isSgOpaqueValueReference overloads
isSgOpenStatement
[[visibility("default")]] SgOpenStatement* isSgOpenStatement(SgNode* node);
isSgOpenStatement overloads
isSgOpenclAccessModeModifier
[[visibility("default")]] SgOpenclAccessModeModifier* isSgOpenclAccessModeModifier(SgNode* node);
isSgOpenclAccessModeModifier overloads
isSgOptions
[[visibility("default")]] SgOptions* isSgOptions(SgNode* node);
isSgOptions overloads
isSgOrOp
[[visibility("default")]] SgOrOp* isSgOrOp(SgNode* node);
isSgOrOp overloads
isSgPackExpansionExpr
[[visibility("default")]] SgPackExpansionExpr* isSgPackExpansionExpr(SgNode* node);
isSgPackExpansionExpr overloads
isSgPlusAssignOp
[[visibility("default")]] SgPlusAssignOp* isSgPlusAssignOp(SgNode* node);
isSgPlusAssignOp overloads
isSgPlusPlusOp
[[visibility("default")]] SgPlusPlusOp* isSgPlusPlusOp(SgNode* node);
isSgPlusPlusOp overloads
isSgPntrArrRefExp
[[visibility("default")]] SgPntrArrRefExp* isSgPntrArrRefExp(SgNode* node);
isSgPntrArrRefExp overloads
isSgPointerAssignOp
[[visibility("default")]] SgPointerAssignOp* isSgPointerAssignOp(SgNode* node);
isSgPointerAssignOp overloads
isSgPointerDerefExp
[[visibility("default")]] SgPointerDerefExp* isSgPointerDerefExp(SgNode* node);
isSgPointerDerefExp overloads
isSgPointerMemberType
[[visibility("default")]] SgPointerMemberType* isSgPointerMemberType(SgNode* node);
isSgPointerMemberType overloads
isSgPointerType
[[visibility("default")]] SgPointerType* isSgPointerType(SgNode* node);
isSgPointerType overloads
isSgPragma
[[visibility("default")]] SgPragma* isSgPragma(SgNode* node);
isSgPragma overloads
isSgPragmaDeclaration
[[visibility("default")]] SgPragmaDeclaration* isSgPragmaDeclaration(SgNode* node);
isSgPragmaDeclaration overloads
isSgPrintStatement
[[visibility("default")]] SgPrintStatement* isSgPrintStatement(SgNode* node);
isSgPrintStatement overloads
isSgProcedureHeaderStatement
[[visibility("default")]] SgProcedureHeaderStatement* isSgProcedureHeaderStatement(SgNode* node);
isSgProcedureHeaderStatement overloads
isSgProcessControlStatement
[[visibility("default")]] SgProcessControlStatement* isSgProcessControlStatement(SgNode* node);
isSgProcessControlStatement overloads
isSgProgramHeaderStatement
[[visibility("default")]] SgProgramHeaderStatement* isSgProgramHeaderStatement(SgNode* node);
isSgProgramHeaderStatement overloads
isSgProject
[[visibility("default")]] SgProject* isSgProject(SgNode* node);
isSgProject overloads
isSgPseudoDestructorRefExp
[[visibility("default")]] SgPseudoDestructorRefExp* isSgPseudoDestructorRefExp(SgNode* node);
isSgPseudoDestructorRefExp overloads
isSgPseudoObjectExp
[[visibility("default")]] SgPseudoObjectExp* isSgPseudoObjectExp(SgNode* node);
isSgPseudoObjectExp overloads
isSgRangeBasedForStatement
[[visibility("default")]] SgRangeBasedForStatement* isSgRangeBasedForStatement(SgNode* node);
isSgRangeBasedForStatement overloads
isSgRangeExp
[[visibility("default")]] SgRangeExp* isSgRangeExp(SgNode* node);
isSgRangeExp overloads
isSgReadStatement
[[visibility("default")]] SgReadStatement* isSgReadStatement(SgNode* node);
isSgReadStatement overloads
isSgRealPartOp
[[visibility("default")]] SgRealPartOp* isSgRealPartOp(SgNode* node);
isSgRealPartOp overloads
isSgRefExp
[[visibility("default")]] SgRefExp* isSgRefExp(SgNode* node);
isSgRefExp overloads
isSgReferenceType
[[visibility("default")]] SgReferenceType* isSgReferenceType(SgNode* node);
isSgReferenceType overloads
isSgRenamePair
[[visibility("default")]] SgRenamePair* isSgRenamePair(SgNode* node);
isSgRenamePair overloads
isSgRenameSymbol
[[visibility("default")]] SgRenameSymbol* isSgRenameSymbol(SgNode* node);
isSgRenameSymbol overloads
isSgRequirementSubstitutionFailure
[[visibility("default")]] SgRequirementSubstitutionFailure* isSgRequirementSubstitutionFailure(SgNode* node);
isSgRequirementSubstitutionFailure overloads
isSgRequiresExpr
[[visibility("default")]] SgRequiresExpr* isSgRequiresExpr(SgNode* node);
isSgRequiresExpr overloads
isSgReturnStmt
[[visibility("default")]] SgReturnStmt* isSgReturnStmt(SgNode* node);
isSgReturnStmt overloads
isSgRewindStatement
[[visibility("default")]] SgRewindStatement* isSgRewindStatement(SgNode* node);
isSgRewindStatement overloads
isSgRshiftAssignOp
[[visibility("default")]] SgRshiftAssignOp* isSgRshiftAssignOp(SgNode* node);
isSgRshiftAssignOp overloads
isSgRshiftOp
[[visibility("default")]] SgRshiftOp* isSgRshiftOp(SgNode* node);
isSgRshiftOp overloads
isSgRvalueReferenceType
[[visibility("default")]] SgRvalueReferenceType* isSgRvalueReferenceType(SgNode* node);
isSgRvalueReferenceType overloads
isSgSIMDAddOp
[[visibility("default")]] SgSIMDAddOp* isSgSIMDAddOp(SgNode* node);
isSgSIMDAddOp overloads
isSgSIMDBinaryOp
[[visibility("default")]] SgSIMDBinaryOp* isSgSIMDBinaryOp(SgNode* node);
isSgSIMDBinaryOp overloads
isSgSIMDBroadcast
[[visibility("default")]] SgSIMDBroadcast* isSgSIMDBroadcast(SgNode* node);
isSgSIMDBroadcast overloads
isSgSIMDDivOp
[[visibility("default")]] SgSIMDDivOp* isSgSIMDDivOp(SgNode* node);
isSgSIMDDivOp overloads
isSgSIMDExplicitGather
[[visibility("default")]] SgSIMDExplicitGather* isSgSIMDExplicitGather(SgNode* node);
isSgSIMDExplicitGather overloads
isSgSIMDFmaOp
[[visibility("default")]] SgSIMDFmaOp* isSgSIMDFmaOp(SgNode* node);
isSgSIMDFmaOp overloads
isSgSIMDGather
[[visibility("default")]] SgSIMDGather* isSgSIMDGather(SgNode* node);
isSgSIMDGather overloads
isSgSIMDLoad
[[visibility("default")]] SgSIMDLoad* isSgSIMDLoad(SgNode* node);
isSgSIMDLoad overloads
isSgSIMDMulOp
[[visibility("default")]] SgSIMDMulOp* isSgSIMDMulOp(SgNode* node);
isSgSIMDMulOp overloads
isSgSIMDPartialStore
[[visibility("default")]] SgSIMDPartialStore* isSgSIMDPartialStore(SgNode* node);
isSgSIMDPartialStore overloads
isSgSIMDScalarStore
[[visibility("default")]] SgSIMDScalarStore* isSgSIMDScalarStore(SgNode* node);
isSgSIMDScalarStore overloads
isSgSIMDScatter
[[visibility("default")]] SgSIMDScatter* isSgSIMDScatter(SgNode* node);
isSgSIMDScatter overloads
isSgSIMDStore
[[visibility("default")]] SgSIMDStore* isSgSIMDStore(SgNode* node);
isSgSIMDStore overloads
isSgSIMDSubOp
[[visibility("default")]] SgSIMDSubOp* isSgSIMDSubOp(SgNode* node);
isSgSIMDSubOp overloads
isSgScopeOp
[[visibility("default")]] SgScopeOp* isSgScopeOp(SgNode* node);
isSgScopeOp overloads
isSgScopeStatement
[[visibility("default")]] SgScopeStatement* isSgScopeStatement(SgNode* node);
isSgScopeStatement overloads
isSgShortVal
[[visibility("default")]] SgShortVal* isSgShortVal(SgNode* node);
isSgShortVal overloads
isSgSignedCharVal
[[visibility("default")]] SgSignedCharVal* isSgSignedCharVal(SgNode* node);
isSgSignedCharVal overloads
isSgSignedIntegralType
[[visibility("default")]] SgSignedIntegralType* isSgSignedIntegralType(SgNode* node);
isSgSignedIntegralType overloads
isSgSimpleRequirement
[[visibility("default")]] SgSimpleRequirement* isSgSimpleRequirement(SgNode* node);
isSgSimpleRequirement overloads
isSgSizeOfOp
[[visibility("default")]] SgSizeOfOp* isSgSizeOfOp(SgNode* node);
isSgSizeOfOp overloads
isSgSourceFile
[[visibility("default")]] SgSourceFile* isSgSourceFile(SgNode* node);
isSgSourceFile overloads
isSgSourceLocationBuiltinExp
[[visibility("default")]] SgSourceLocationBuiltinExp* isSgSourceLocationBuiltinExp(SgNode* node);
isSgSourceLocationBuiltinExp overloads
isSgSpaceshipOp
[[visibility("default")]] SgSpaceshipOp* isSgSpaceshipOp(SgNode* node);
isSgSpaceshipOp overloads
isSgSpecialFunctionModifier
[[visibility("default")]] SgSpecialFunctionModifier* isSgSpecialFunctionModifier(SgNode* node);
isSgSpecialFunctionModifier overloads
isSgStatement
[[visibility("default")]] SgStatement* isSgStatement(SgNode* node);
isSgStatement overloads
isSgStatementAttribute
[[visibility("default")]] SgStatementAttribute* isSgStatementAttribute(SgNode* node);
isSgStatementAttribute overloads
isSgStatementAttributeList
[[visibility("default")]] SgStatementAttributeList* isSgStatementAttributeList(SgNode* node);
isSgStatementAttributeList overloads
isSgStatementExpression
[[visibility("default")]] SgStatementExpression* isSgStatementExpression(SgNode* node);
isSgStatementExpression overloads
isSgStatementFunctionStatement
[[visibility("default")]] SgStatementFunctionStatement* isSgStatementFunctionStatement(SgNode* node);
isSgStatementFunctionStatement overloads
isSgStaticAssertionDeclaration
[[visibility("default")]] SgStaticAssertionDeclaration* isSgStaticAssertionDeclaration(SgNode* node);
isSgStaticAssertionDeclaration overloads
isSgStorageModifier
[[visibility("default")]] SgStorageModifier* isSgStorageModifier(SgNode* node);
isSgStorageModifier overloads
isSgStringKeyedBidirectionalGraph
[[visibility("default")]] SgStringKeyedBidirectionalGraph* isSgStringKeyedBidirectionalGraph(SgNode* node);
isSgStringKeyedBidirectionalGraph overloads
isSgStringVal
[[visibility("default")]] SgStringVal* isSgStringVal(SgNode* node);
isSgStringVal overloads
isSgSubscriptExpression
[[visibility("default")]] SgSubscriptExpression* isSgSubscriptExpression(SgNode* node);
isSgSubscriptExpression overloads
isSgSubtractOp
[[visibility("default")]] SgSubtractOp* isSgSubtractOp(SgNode* node);
isSgSubtractOp overloads
isSgSupport
[[visibility("default")]] SgSupport* isSgSupport(SgNode* node);
isSgSupport overloads
isSgSwitchStatement
[[visibility("default")]] SgSwitchStatement* isSgSwitchStatement(SgNode* node);
isSgSwitchStatement overloads
isSgSymbol
[[visibility("default")]] SgSymbol* isSgSymbol(SgNode* node);
isSgSymbol overloads
isSgSymbolTable
[[visibility("default")]] SgSymbolTable* isSgSymbolTable(SgNode* node);
isSgSymbolTable overloads
isSgSyncAllStatement
[[visibility("default")]] SgSyncAllStatement* isSgSyncAllStatement(SgNode* node);
isSgSyncAllStatement overloads
isSgSyncImagesStatement
[[visibility("default")]] SgSyncImagesStatement* isSgSyncImagesStatement(SgNode* node);
isSgSyncImagesStatement overloads
isSgSyncMemoryStatement
[[visibility("default")]] SgSyncMemoryStatement* isSgSyncMemoryStatement(SgNode* node);
isSgSyncMemoryStatement overloads
isSgSyncTeamStatement
[[visibility("default")]] SgSyncTeamStatement* isSgSyncTeamStatement(SgNode* node);
isSgSyncTeamStatement overloads
isSgTemplateArgument
[[visibility("default")]] SgTemplateArgument* isSgTemplateArgument(SgNode* node);
isSgTemplateArgument overloads
isSgTemplateClassDeclaration
[[visibility("default")]] SgTemplateClassDeclaration* isSgTemplateClassDeclaration(SgNode* node);
isSgTemplateClassDeclaration overloads
isSgTemplateClassDefinition
[[visibility("default")]] SgTemplateClassDefinition* isSgTemplateClassDefinition(SgNode* node);
isSgTemplateClassDefinition overloads
isSgTemplateClassSymbol
[[visibility("default")]] SgTemplateClassSymbol* isSgTemplateClassSymbol(SgNode* node);
isSgTemplateClassSymbol overloads
isSgTemplateDeclaration
[[visibility("default")]] SgTemplateDeclaration* isSgTemplateDeclaration(SgNode* node);
isSgTemplateDeclaration overloads
isSgTemplateFunctionDeclaration
[[visibility("default")]] SgTemplateFunctionDeclaration* isSgTemplateFunctionDeclaration(SgNode* node);
isSgTemplateFunctionDeclaration overloads
isSgTemplateFunctionDefinition
[[visibility("default")]] SgTemplateFunctionDefinition* isSgTemplateFunctionDefinition(SgNode* node);
isSgTemplateFunctionDefinition overloads
isSgTemplateFunctionRefExp
[[visibility("default")]] SgTemplateFunctionRefExp* isSgTemplateFunctionRefExp(SgNode* node);
isSgTemplateFunctionRefExp overloads
isSgTemplateFunctionSymbol
[[visibility("default")]] SgTemplateFunctionSymbol* isSgTemplateFunctionSymbol(SgNode* node);
isSgTemplateFunctionSymbol overloads
isSgTemplateInstantiationDecl
[[visibility("default")]] SgTemplateInstantiationDecl* isSgTemplateInstantiationDecl(SgNode* node);
isSgTemplateInstantiationDecl overloads
isSgTemplateInstantiationDefn
[[visibility("default")]] SgTemplateInstantiationDefn* isSgTemplateInstantiationDefn(SgNode* node);
isSgTemplateInstantiationDefn overloads
isSgTemplateInstantiationDirectiveStatement
[[visibility("default")]] SgTemplateInstantiationDirectiveStatement* isSgTemplateInstantiationDirectiveStatement(SgNode* node);
isSgTemplateInstantiationDirectiveStatement overloads
isSgTemplateInstantiationFunctionDecl
[[visibility("default")]] SgTemplateInstantiationFunctionDecl* isSgTemplateInstantiationFunctionDecl(SgNode* node);
isSgTemplateInstantiationFunctionDecl overloads
isSgTemplateInstantiationMemberFunctionDecl
[[visibility("default")]] SgTemplateInstantiationMemberFunctionDecl* isSgTemplateInstantiationMemberFunctionDecl(SgNode* node);
isSgTemplateInstantiationMemberFunctionDecl overloads
isSgTemplateInstantiationTypedefDeclaration
[[visibility("default")]] SgTemplateInstantiationTypedefDeclaration* isSgTemplateInstantiationTypedefDeclaration(SgNode* node);
isSgTemplateInstantiationTypedefDeclaration overloads
isSgTemplateMemberFunctionDeclaration
[[visibility("default")]] SgTemplateMemberFunctionDeclaration* isSgTemplateMemberFunctionDeclaration(SgNode* node);
isSgTemplateMemberFunctionDeclaration overloads
isSgTemplateMemberFunctionRefExp
[[visibility("default")]] SgTemplateMemberFunctionRefExp* isSgTemplateMemberFunctionRefExp(SgNode* node);
isSgTemplateMemberFunctionRefExp overloads
isSgTemplateMemberFunctionSymbol
[[visibility("default")]] SgTemplateMemberFunctionSymbol* isSgTemplateMemberFunctionSymbol(SgNode* node);
isSgTemplateMemberFunctionSymbol overloads
isSgTemplateParameter
[[visibility("default")]] SgTemplateParameter* isSgTemplateParameter(SgNode* node);
isSgTemplateParameter overloads
isSgTemplateParameterList
[[visibility("default")]] SgTemplateParameterList* isSgTemplateParameterList(SgNode* node);
isSgTemplateParameterList overloads
isSgTemplateParameterVal
[[visibility("default")]] SgTemplateParameterVal* isSgTemplateParameterVal(SgNode* node);
isSgTemplateParameterVal overloads
isSgTemplateSymbol
[[visibility("default")]] SgTemplateSymbol* isSgTemplateSymbol(SgNode* node);
isSgTemplateSymbol overloads
isSgTemplateType
[[visibility("default")]] SgTemplateType* isSgTemplateType(SgNode* node);
isSgTemplateType overloads
isSgTemplateTypedefDeclaration
[[visibility("default")]] SgTemplateTypedefDeclaration* isSgTemplateTypedefDeclaration(SgNode* node);
isSgTemplateTypedefDeclaration overloads
isSgTemplateTypedefSymbol
[[visibility("default")]] SgTemplateTypedefSymbol* isSgTemplateTypedefSymbol(SgNode* node);
isSgTemplateTypedefSymbol overloads
isSgTemplateVariableDeclaration
[[visibility("default")]] SgTemplateVariableDeclaration* isSgTemplateVariableDeclaration(SgNode* node);
isSgTemplateVariableDeclaration overloads
isSgTemplateVariableSymbol
[[visibility("default")]] SgTemplateVariableSymbol* isSgTemplateVariableSymbol(SgNode* node);
isSgTemplateVariableSymbol overloads
isSgThisExp
[[visibility("default")]] SgThisExp* isSgThisExp(SgNode* node);
isSgThisExp overloads
isSgThrowOp
[[visibility("default")]] SgThrowOp* isSgThrowOp(SgNode* node);
isSgThrowOp overloads
isSgToken
[[visibility("default")]] SgToken* isSgToken(SgNode* node);
isSgToken overloads
isSgTryStmt
[[visibility("default")]] SgTryStmt* isSgTryStmt(SgNode* node);
isSgTryStmt overloads
isSgType
[[visibility("default")]] SgType* isSgType(SgNode* node);
isSgType overloads
isSgTypeBFloat16
[[visibility("default")]] SgTypeBFloat16* isSgTypeBFloat16(SgNode* node);
isSgTypeBFloat16 overloads
isSgTypeBool
[[visibility("default")]] SgTypeBool* isSgTypeBool(SgNode* node);
isSgTypeBool overloads
isSgTypeChar
[[visibility("default")]] SgTypeChar* isSgTypeChar(SgNode* node);
isSgTypeChar overloads
isSgTypeChar16
[[visibility("default")]] SgTypeChar16* isSgTypeChar16(SgNode* node);
isSgTypeChar16 overloads
isSgTypeChar32
[[visibility("default")]] SgTypeChar32* isSgTypeChar32(SgNode* node);
isSgTypeChar32 overloads
isSgTypeChar8
[[visibility("default")]] SgTypeChar8* isSgTypeChar8(SgNode* node);
isSgTypeChar8 overloads
isSgTypeComplex
[[visibility("default")]] SgTypeComplex* isSgTypeComplex(SgNode* node);
isSgTypeComplex overloads
isSgTypeCrayPointer
[[visibility("default")]] SgTypeCrayPointer* isSgTypeCrayPointer(SgNode* node);
isSgTypeCrayPointer overloads
isSgTypeDefault
[[visibility("default")]] SgTypeDefault* isSgTypeDefault(SgNode* node);
isSgTypeDefault overloads
isSgTypeDependent
[[visibility("default")]] SgTypeDependent* isSgTypeDependent(SgNode* node);
isSgTypeDependent overloads
isSgTypeDouble
[[visibility("default")]] SgTypeDouble* isSgTypeDouble(SgNode* node);
isSgTypeDouble overloads
isSgTypeEllipse
[[visibility("default")]] SgTypeEllipse* isSgTypeEllipse(SgNode* node);
isSgTypeEllipse overloads
isSgTypeExpression
[[visibility("default")]] SgTypeExpression* isSgTypeExpression(SgNode* node);
isSgTypeExpression overloads
isSgTypeFloat
[[visibility("default")]] SgTypeFloat* isSgTypeFloat(SgNode* node);
isSgTypeFloat overloads
isSgTypeFloat128
[[visibility("default")]] SgTypeFloat128* isSgTypeFloat128(SgNode* node);
isSgTypeFloat128 overloads
isSgTypeFloat16
[[visibility("default")]] SgTypeFloat16* isSgTypeFloat16(SgNode* node);
isSgTypeFloat16 overloads
isSgTypeFloat32
[[visibility("default")]] SgTypeFloat32* isSgTypeFloat32(SgNode* node);
isSgTypeFloat32 overloads
isSgTypeFloat32x
[[visibility("default")]] SgTypeFloat32x* isSgTypeFloat32x(SgNode* node);
isSgTypeFloat32x overloads
isSgTypeFloat64
[[visibility("default")]] SgTypeFloat64* isSgTypeFloat64(SgNode* node);
isSgTypeFloat64 overloads
isSgTypeFloat64x
[[visibility("default")]] SgTypeFloat64x* isSgTypeFloat64x(SgNode* node);
isSgTypeFloat64x overloads
isSgTypeFloat80
[[visibility("default")]] SgTypeFloat80* isSgTypeFloat80(SgNode* node);
isSgTypeFloat80 overloads
isSgTypeFortranAssumed
[[visibility("default")]] SgTypeFortranAssumed* isSgTypeFortranAssumed(SgNode* node);
isSgTypeFortranAssumed overloads
isSgTypeFortranBOZ
[[visibility("default")]] SgTypeFortranBOZ* isSgTypeFortranBOZ(SgNode* node);
isSgTypeFortranBOZ overloads
isSgTypeFortranUnlimitedPolymorphic
[[visibility("default")]] SgTypeFortranUnlimitedPolymorphic* isSgTypeFortranUnlimitedPolymorphic(SgNode* node);
isSgTypeFortranUnlimitedPolymorphic overloads
isSgTypeFp16
[[visibility("default")]] SgTypeFp16* isSgTypeFp16(SgNode* node);
isSgTypeFp16 overloads
isSgTypeGlobalVoid
[[visibility("default")]] SgTypeGlobalVoid* isSgTypeGlobalVoid(SgNode* node);
isSgTypeGlobalVoid overloads
isSgTypeIdOp
[[visibility("default")]] SgTypeIdOp* isSgTypeIdOp(SgNode* node);
isSgTypeIdOp overloads
isSgTypeImaginary
[[visibility("default")]] SgTypeImaginary* isSgTypeImaginary(SgNode* node);
isSgTypeImaginary overloads
isSgTypeInt
[[visibility("default")]] SgTypeInt* isSgTypeInt(SgNode* node);
isSgTypeInt overloads
isSgTypeLabel
[[visibility("default")]] SgTypeLabel* isSgTypeLabel(SgNode* node);
isSgTypeLabel overloads
isSgTypeLong
[[visibility("default")]] SgTypeLong* isSgTypeLong(SgNode* node);
isSgTypeLong overloads
isSgTypeLongDouble
[[visibility("default")]] SgTypeLongDouble* isSgTypeLongDouble(SgNode* node);
isSgTypeLongDouble overloads
isSgTypeLongLong
[[visibility("default")]] SgTypeLongLong* isSgTypeLongLong(SgNode* node);
isSgTypeLongLong overloads
isSgTypeModifier
[[visibility("default")]] SgTypeModifier* isSgTypeModifier(SgNode* node);
isSgTypeModifier overloads
isSgTypeNullptr
[[visibility("default")]] SgTypeNullptr* isSgTypeNullptr(SgNode* node);
isSgTypeNullptr overloads
isSgTypeOfType
[[visibility("default")]] SgTypeOfType* isSgTypeOfType(SgNode* node);
isSgTypeOfType overloads
isSgTypeRequirement
[[visibility("default")]] SgTypeRequirement* isSgTypeRequirement(SgNode* node);
isSgTypeRequirement overloads
isSgTypeShort
[[visibility("default")]] SgTypeShort* isSgTypeShort(SgNode* node);
isSgTypeShort overloads
isSgTypeSigned128bitInteger
[[visibility("default")]] SgTypeSigned128bitInteger* isSgTypeSigned128bitInteger(SgNode* node);
isSgTypeSigned128bitInteger overloads
isSgTypeSignedChar
[[visibility("default")]] SgTypeSignedChar* isSgTypeSignedChar(SgNode* node);
isSgTypeSignedChar overloads
isSgTypeSignedInt
[[visibility("default")]] SgTypeSignedInt* isSgTypeSignedInt(SgNode* node);
isSgTypeSignedInt overloads
isSgTypeSignedLong
[[visibility("default")]] SgTypeSignedLong* isSgTypeSignedLong(SgNode* node);
isSgTypeSignedLong overloads
isSgTypeSignedLongLong
[[visibility("default")]] SgTypeSignedLongLong* isSgTypeSignedLongLong(SgNode* node);
isSgTypeSignedLongLong overloads
isSgTypeSignedShort
[[visibility("default")]] SgTypeSignedShort* isSgTypeSignedShort(SgNode* node);
isSgTypeSignedShort overloads
isSgTypeString
[[visibility("default")]] SgTypeString* isSgTypeString(SgNode* node);
isSgTypeString overloads
isSgTypeTable
[[visibility("default")]] SgTypeTable* isSgTypeTable(SgNode* node);
isSgTypeTable overloads
isSgTypeTargetBuiltin
[[visibility("default")]] SgTypeTargetBuiltin* isSgTypeTargetBuiltin(SgNode* node);
isSgTypeTargetBuiltin overloads
isSgTypeTraitBuiltinOperator
[[visibility("default")]] SgTypeTraitBuiltinOperator* isSgTypeTraitBuiltinOperator(SgNode* node);
isSgTypeTraitBuiltinOperator overloads
isSgTypeUnknown
[[visibility("default")]] SgTypeUnknown* isSgTypeUnknown(SgNode* node);
isSgTypeUnknown overloads
isSgTypeUnsigned128bitInteger
[[visibility("default")]] SgTypeUnsigned128bitInteger* isSgTypeUnsigned128bitInteger(SgNode* node);
isSgTypeUnsigned128bitInteger overloads
isSgTypeUnsignedChar
[[visibility("default")]] SgTypeUnsignedChar* isSgTypeUnsignedChar(SgNode* node);
isSgTypeUnsignedChar overloads
isSgTypeUnsignedInt
[[visibility("default")]] SgTypeUnsignedInt* isSgTypeUnsignedInt(SgNode* node);
isSgTypeUnsignedInt overloads
isSgTypeUnsignedLong
[[visibility("default")]] SgTypeUnsignedLong* isSgTypeUnsignedLong(SgNode* node);
isSgTypeUnsignedLong overloads
isSgTypeUnsignedLongLong
[[visibility("default")]] SgTypeUnsignedLongLong* isSgTypeUnsignedLongLong(SgNode* node);
isSgTypeUnsignedLongLong overloads
isSgTypeUnsignedShort
[[visibility("default")]] SgTypeUnsignedShort* isSgTypeUnsignedShort(SgNode* node);
isSgTypeUnsignedShort overloads
isSgTypeVoid
[[visibility("default")]] SgTypeVoid* isSgTypeVoid(SgNode* node);
isSgTypeVoid overloads
isSgTypeWchar
[[visibility("default")]] SgTypeWchar* isSgTypeWchar(SgNode* node);
isSgTypeWchar overloads
isSgTypedefDeclaration
[[visibility("default")]] SgTypedefDeclaration* isSgTypedefDeclaration(SgNode* node);
isSgTypedefDeclaration overloads
isSgTypedefSymbol
[[visibility("default")]] SgTypedefSymbol* isSgTypedefSymbol(SgNode* node);
isSgTypedefSymbol overloads
isSgTypedefType
[[visibility("default")]] SgTypedefType* isSgTypedefType(SgNode* node);
isSgTypedefType overloads
isSgUnaryAddOp
[[visibility("default")]] SgUnaryAddOp* isSgUnaryAddOp(SgNode* node);
isSgUnaryAddOp overloads
isSgUnaryOp
[[visibility("default")]] SgUnaryOp* isSgUnaryOp(SgNode* node);
isSgUnaryOp overloads
isSgUnaryTransformType
[[visibility("default")]] SgUnaryTransformType* isSgUnaryTransformType(SgNode* node);
isSgUnaryTransformType overloads
isSgUndefDirectiveStatement
[[visibility("default")]] SgUndefDirectiveStatement* isSgUndefDirectiveStatement(SgNode* node);
isSgUndefDirectiveStatement overloads
isSgUndirectedGraphEdge
[[visibility("default")]] SgUndirectedGraphEdge* isSgUndirectedGraphEdge(SgNode* node);
isSgUndirectedGraphEdge overloads
isSgUnlockStatement
[[visibility("default")]] SgUnlockStatement* isSgUnlockStatement(SgNode* node);
isSgUnlockStatement overloads
isSgUnparse_Info
[[visibility("default")]] SgUnparse_Info* isSgUnparse_Info(SgNode* node);
isSgUnparse_Info overloads
isSgUnsignedCharVal
[[visibility("default")]] SgUnsignedCharVal* isSgUnsignedCharVal(SgNode* node);
isSgUnsignedCharVal overloads
isSgUnsignedIntVal
[[visibility("default")]] SgUnsignedIntVal* isSgUnsignedIntVal(SgNode* node);
isSgUnsignedIntVal overloads
isSgUnsignedIntegralType
[[visibility("default")]] SgUnsignedIntegralType* isSgUnsignedIntegralType(SgNode* node);
isSgUnsignedIntegralType overloads
isSgUnsignedLongLongIntVal
[[visibility("default")]] SgUnsignedLongLongIntVal* isSgUnsignedLongLongIntVal(SgNode* node);
isSgUnsignedLongLongIntVal overloads
isSgUnsignedLongVal
[[visibility("default")]] SgUnsignedLongVal* isSgUnsignedLongVal(SgNode* node);
isSgUnsignedLongVal overloads
isSgUnsignedShortVal
[[visibility("default")]] SgUnsignedShortVal* isSgUnsignedShortVal(SgNode* node);
isSgUnsignedShortVal overloads
isSgUseStatement
[[visibility("default")]] SgUseStatement* isSgUseStatement(SgNode* node);
isSgUseStatement overloads
isSgUserDefinedBinaryOp
[[visibility("default")]] SgUserDefinedBinaryOp* isSgUserDefinedBinaryOp(SgNode* node);
isSgUserDefinedBinaryOp overloads
isSgUserDefinedUnaryOp
[[visibility("default")]] SgUserDefinedUnaryOp* isSgUserDefinedUnaryOp(SgNode* node);
isSgUserDefinedUnaryOp overloads
isSgUsingDeclarationStatement
[[visibility("default")]] SgUsingDeclarationStatement* isSgUsingDeclarationStatement(SgNode* node);
isSgUsingDeclarationStatement overloads
isSgUsingDirectiveStatement
[[visibility("default")]] SgUsingDirectiveStatement* isSgUsingDirectiveStatement(SgNode* node);
isSgUsingDirectiveStatement overloads
isSgValueExp
[[visibility("default")]] SgValueExp* isSgValueExp(SgNode* node);
isSgValueExp overloads
isSgVarArgCopyOp
[[visibility("default")]] SgVarArgCopyOp* isSgVarArgCopyOp(SgNode* node);
isSgVarArgCopyOp overloads
isSgVarArgEndOp
[[visibility("default")]] SgVarArgEndOp* isSgVarArgEndOp(SgNode* node);
isSgVarArgEndOp overloads
isSgVarArgOp
[[visibility("default")]] SgVarArgOp* isSgVarArgOp(SgNode* node);
isSgVarArgOp overloads
isSgVarArgStartOneOperandOp
[[visibility("default")]] SgVarArgStartOneOperandOp* isSgVarArgStartOneOperandOp(SgNode* node);
isSgVarArgStartOneOperandOp overloads
isSgVarArgStartOp
[[visibility("default")]] SgVarArgStartOp* isSgVarArgStartOp(SgNode* node);
isSgVarArgStartOp overloads
isSgVarRefExp
[[visibility("default")]] SgVarRefExp* isSgVarRefExp(SgNode* node);
isSgVarRefExp overloads
isSgVariableDeclaration
[[visibility("default")]] SgVariableDeclaration* isSgVariableDeclaration(SgNode* node);
isSgVariableDeclaration overloads
isSgVariableDefinition
[[visibility("default")]] SgVariableDefinition* isSgVariableDefinition(SgNode* node);
isSgVariableDefinition overloads
isSgVariableSymbol
[[visibility("default")]] SgVariableSymbol* isSgVariableSymbol(SgNode* node);
isSgVariableSymbol overloads
isSgVariantExpression
[[visibility("default")]] SgVariantExpression* isSgVariantExpression(SgNode* node);
isSgVariantExpression overloads
isSgVectorElementExp
[[visibility("default")]] SgVectorElementExp* isSgVectorElementExp(SgNode* node);
isSgVectorElementExp overloads
isSgVoidVal
[[visibility("default")]] SgVoidVal* isSgVoidVal(SgNode* node);
isSgVoidVal overloads
isSgWaitStatement
[[visibility("default")]] SgWaitStatement* isSgWaitStatement(SgNode* node);
isSgWaitStatement overloads
isSgWarningDirectiveStatement
[[visibility("default")]] SgWarningDirectiveStatement* isSgWarningDirectiveStatement(SgNode* node);
isSgWarningDirectiveStatement overloads
isSgWcharVal
[[visibility("default")]] SgWcharVal* isSgWcharVal(SgNode* node);
isSgWcharVal overloads
isSgWhereStatement
[[visibility("default")]] SgWhereStatement* isSgWhereStatement(SgNode* node);
isSgWhereStatement overloads
isSgWhileStmt
[[visibility("default")]] SgWhileStmt* isSgWhileStmt(SgNode* node);
isSgWhileStmt overloads
isSgWriteStatement
[[visibility("default")]] SgWriteStatement* isSgWriteStatement(SgNode* node);
isSgWriteStatement overloads
isSgXorAssignOp
[[visibility("default")]] SgXorAssignOp* isSgXorAssignOp(SgNode* node);
isSgXorAssignOp overloads
isSg_File_Info
[[visibility("default")]] Sg_File_Info* isSg_File_Info(SgNode* node);
isSg_File_Info overloads
isVarExpr
bool isVarExpr(SgExpression* expr);
is_id
bool is_id(char c);
is_num
bool is_num(char c);
is_operator
int is_operator(char c);
is_space
bool is_space(char c);
joinMangledQualifiers
SgName joinMangledQualifiers( SgName const& base, SgName const& name);
Joins two sets of mangled qualifiers to form a new mangled qualifier.
joinMangledQualifiersToString
std::string joinMangledQualifiersToString( std::string const& base, std::string const& name);
Joins two sets of mangled qualifiers to form a new mangled qualifier.
linearize_subtree
std::vector<SgNode*> linearize_subtree(SgNode* node);
makeEdge
template< class NodeT1, class NodeT2, class EdgeT> void makeEdge( NodeT1 from, NodeT2 to, std::vector<EdgeT>& result);
Utility function to make CFG Edges
makeRTIValueDescriptor
template<typename T> static RTIValueDescriptor makeRTIValueDescriptor(T const& field);
mangleExpression
std::string mangleExpression(SgExpression const* expr);
Mangles a constant expression, needed for template arguments.
mangleFunctionName
SgName mangleFunctionName( SgName const& n, SgName const& ret_type_name = SgName(""));
Returns a mangled form of a C++ function name, as an SgName object.
mangleFunctionNameToString
std::string mangleFunctionNameToString( std::string const& s, std::string const& ret_type_name = std::string(""));
Returns a mangled form of special C++ function names (excl. qualifiers).
mangleLocalScopeToString
std::string mangleLocalScopeToString(SgScopeStatement const* scope);
Produces a mangled name for a scope statement.
mangleQualifiers
SgName mangleQualifiers(SgScopeStatement const* scope);
Mangles a chain of qualifiers, returning an SgName object.
mangleQualifiersToString
std::string mangleQualifiersToString(SgScopeStatement const* scope);
Mangles a chain of qualifiers followed from a given scope.
mangleTemplate
SgName mangleTemplate( SgName const& templ_name, SgTemplateArgumentPtrList const& templ_args, SgScopeStatement const* scope);
mangleTemplate overloads
mangleTemplateArgsToString
std::string mangleTemplateArgsToString( SgTemplateArgumentPtrList::const_iterator const b, SgTemplateArgumentPtrList::const_iterator const e);
mangleTemplateArgsToString overloads
mangleTemplateFunction
SgName mangleTemplateFunction( std::string const& templ_name, SgTemplateArgumentPtrList const& templ_args, SgFunctionType const* func_type, SgScopeStatement const* scope);
Mangles an instantiated template function or member function, returning a SgName object.
mangleTemplateFunctionToString
std::string mangleTemplateFunctionToString( std::string const& templ_name, SgTemplateArgumentPtrList const& templ_args, SgFunctionType const* func_type, SgScopeStatement const* scope);
Mangles an instantiated template function or template member function.
mangleTemplateToString
std::string mangleTemplateToString( std::string const& templ_name, SgTemplateArgumentPtrList const& templ_args, SgScopeStatement const* scope);
mangleTemplateToString overloads
mangleTranslationUnitQualifiers
std::string mangleTranslationUnitQualifiers(SgDeclarationStatement const* decl);
If the declaration has translation unit scope (as opposed to program scope), mangle the translation unit name.
mangleTypes
SgName mangleTypes( SgTypePtrList::const_iterator const b, SgTypePtrList::const_iterator const e);
Mangles a list of types, returning an SgName object.
mangleTypesToString
std::string mangleTypesToString( SgTypePtrList::const_iterator const b, SgTypePtrList::const_iterator const e);
Mangles a container of types, returning an STL std::string object.
mangleValueExp
std::string mangleValueExp(SgValueExp const* expr);
Mangles a value expression, as used in a template argument.
mark_compiler_generated_frontend_specific
void mark_compiler_generated_frontend_specific(SgNode* node);
memoryUsage
[[visibility("default")]] size_t memoryUsage();
mlogAssertFail_C
void mlogAssertFail_C( char const* subject, char const* expr, char const* file, int line, char const* funcname, std::string const& message);
mlogLevelToString_CXX
extern std::string mlogLevelToString_CXX(MLOG_LEVEL_t level);
mlogMore_C
extern void mlogMore_C(char const* format, ...);
mlogNullStream_CXX
extern std::ostream& mlogNullStream_CXX();
mlog_C
extern void mlog_C( MLOG_LEVEL_t level, char const* subject, char const* file, int line, char const* funcname, char const* format, ...);
myStatementInsert
void myStatementInsert( SgStatement* target, SgStatement* newstmt, bool before, bool allowForInit = false);
Insert a new statement before or after a target statement. If allowForInit is true, the new statement can be inserted into the initializer of a for statement.
nestedNameSpecifierHasGlobal
bool nestedNameSpecifierHasGlobal(clang::NestedNameSpecifier qualifier);
nestedNameSpecifierHasTemplateKeyword
bool nestedNameSpecifierHasTemplateKeyword(clang::NestedNameSpecifier nns);
nestedNameSpecifierLocHasExplicitGlobal
bool nestedNameSpecifierLocHasExplicitGlobal(clang::NestedNameSpecifierLoc qualifier_loc);
nestedNameSpecifierLocPrefix
clang::NestedNameSpecifierLoc nestedNameSpecifierLocPrefix(clang::NestedNameSpecifierLoc current);
nestedNameSpecifierNamespace
clang::NamespaceDecl const* nestedNameSpecifierNamespace(clang::NestedNameSpecifier nns);
nestedNameSpecifierNamespaceBase
clang::NamespaceBaseDecl const* nestedNameSpecifierNamespaceBase(clang::NestedNameSpecifier nns);
nestedNameSpecifierPrefix
clang::NestedNameSpecifier nestedNameSpecifierPrefix(clang::NestedNameSpecifier nns);
numberOfNodes
[[visibility("default")]] size_t numberOfNodes();
omp_simd_write_arm
void omp_simd_write_arm( SgOmpSimdStatement* target, SgForStatement* for_loop, std::vector<SgNode*>* ir_block, OmpSimdCompiler const& compiler);
omp_simd_write_intel
void omp_simd_write_intel( SgOmpSimdStatement* target, SgForStatement* for_loop, std::vector<SgNode*>* ir_block, unsigned int simd_length, OmpSimdCompiler const& compiler);
operator&
DepInfo operator&( DepInfo const& d1, DepInfo const& d2);
Bitwise conjunction operators
operator&=
bool operator&=( DepRel& e1, DepRel const& that);
Bitwise conjunction assignment operators
operator*
DepInfo operator*( DepInfo const& d1, DepInfo const& d2);
Multiplication operators
operator+
[[visibility("default")]] VariantVector operator+( VariantT lhs, VariantT rhs);
Addition operators
operator-
DepRel operator-(DepRel const& e);
Unary minus operators
operator/
SymbolicVal operator/( SymbolicVal const& v1, SymbolicVal const& v2);
operator|
DepInfo operator|( DepInfo const& d1, DepInfo const& d2);
Bitwise disjunction operators
operator|=
bool operator|=( DepRel& e1, DepRel const& that);
Bitwise disjunction assignment operators
p_AddOp
Pattern* p_AddOp( Pattern* lhs, Pattern* rhs);
Match an addition operation
p_CommaOp
Pattern* p_CommaOp( Pattern* lhs, Pattern* rhs);
Match a comma operation
p_MultiplyOp
Pattern* p_MultiplyOp( Pattern* lhs, Pattern* rhs);
Match a multiplication operation
p_PlusAssignOp
Pattern* p_PlusAssignOp( Pattern* lhs, Pattern* rhs);
Match an add-assign operation
p_int
Pattern* p_int(int x);
Match a particular integer
p_var
Pattern* p_var(std::string name);
Match anything into a variable
parallelBottomUpProcessingThread
template<class S> void* parallelBottomUpProcessingThread(void* p);
parallelTopDownBottomUpProcessingThread
template< class I, class S> void* parallelTopDownBottomUpProcessingThread(void* p);
parallelTopDownProcessingThread
template<class I> void* parallelTopDownProcessingThread(void* p);
parseArraySectionExpression
extern SgExpression* parseArraySectionExpression( SgNode*, char const*);
parseExpression
extern SgExpression* parseExpression( SgNode*, char const*);
parseOmpArraySection
SgExpression* parseOmpArraySection( SgPragmaDeclaration* directive, OpenMPClauseKind clause_kind, std::string expression);
parseOmpExpression
SgExpression* parseOmpExpression( SgPragmaDeclaration* directive, OpenMPClauseKind clause_kind, std::string expression);
parseOmpVariable
void parseOmpVariable( std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClauseKind clause_kind, std::string expression);
patact
PatternActionRule* patact( Pattern* pattern, Pattern* action);
Create a PatternActionRule
peek_ch
char peek_ch(std::istream& in);
peek_id
std::string peek_id(std::istream& in);
peek_next
char peek_next(std::istream& in);
preventConstructionOnStack
void preventConstructionOnStack(SgNode* n);
printDivAnalysisStates
void printDivAnalysisStates( DivAnalysis* da, std::string indent = "");
publishClangTranslationUnitSourceOrder
void publishClangTranslationUnitSourceOrder( SgDeclarationStatement* declaration, unsigned int order);
pushTestIntoBody
void pushTestIntoBody(SgScopeStatement* loopStmt);
Rewrites a loop so that the official test is changed to "true" and what had previously been the test is now an if-break combination at the beginning of a while/for body or the end of a do-while body.
qualifiedTypeHasQualifier
bool qualifiedTypeHasQualifier(clang::Type const* type);
qualifiedTypeQualifier
clang::NestedNameSpecifier qualifiedTypeQualifier(clang::Type const* type);
queryIsImportantForSliceType
NodeQuerySynthesizedAttributeType queryIsImportantForSliceType(SgNode* astNode);
queryIsImportantForSliceTypeWithCalls
NodeQuerySynthesizedAttributeType queryIsImportantForSliceTypeWithCalls(SgNode* astNode);
read_ch
char read_ch(std::istream& in);
read_graph
template<class Graph> void read_graph( Graph& g, std::istream& in, std::string const& hint);
read_id
std::string read_id(std::istream& in);
read_list
template<class ItemGen> bool read_list( std::istream& in, ItemGen& op, char sep);
read_num
std::string read_num(std::istream& in);
read_operator
std::string read_operator(std::istream& in);
removeNullStatements
[[visibility("default")]] void removeNullStatements(SgNode* n);
Remove all null statements (those with only an integer constant or a null expression)
removeUnusedVariables
[[visibility("default")]] void removeUnusedVariables( SgNode* top, std::set<SgFunctionDeclaration*> const& safeFunctions = std::set<SgFunctionDeclaration *>());
Remove unused variables in a scope
removeVariableDeclaration
[[visibility("default")]] void removeVariableDeclaration(SgInitializedName* initname);
Remove the declaration of a given variable
renameLabels
[[visibility("default")]] void renameLabels( SgNode* n, SgFunctionDefinition* enclosingFunctionDefinition);
Rename all labels in a block of code.
renameVariables
[[visibility("default")]] void renameVariables(SgNode* n);
Rename all variables in a block of code, and ensure that all variable references point to the correct declarations.
replaceExpressionWithExpression
void replaceExpressionWithExpression( SgExpression* from, SgExpression* to);
Replace the expression "from" with another expression "to", wherever it appears in the AST. The expression "from" is not deleted, and may be reused elsewhere in the AST.
replaceNonAlphaNum
std::string replaceNonAlphaNum(std::string const& s);
requireClangFunctionDeclSourceProvenanceForFrontend
void requireClangFunctionDeclSourceProvenanceForFrontend( clang::FunctionDecl const* decl, clang::CompilerInstance const* ci, SagePreprocessorRecord const* preprocessor_record);
requireClangOrderedDeclarationProvenanceForFrontend
ClangOrderedDeclarationProvenance requireClangOrderedDeclarationProvenanceForFrontend( SgDeclarationStatement const* declaration, char const* context);
requireFortranSourceDerivedTypeName
SgName requireFortranSourceDerivedTypeName( SgClassType* classType, SgUnparse_Info& info);
resolveNameQualificationProject
SgProject* resolveNameQualificationProject( SgNode* node, SgStatement* explicitEmissionStatement, SgNode* explicitReferenceNode);
resolveRosePaths
[[visibility("default")]] RosePathRoots resolveRosePaths(char const* argv0);
resolveTemplateNameDeclaration
clang::TemplateDecl* resolveTemplateNameDeclaration(clang::TemplateName template_name);
rewrite
[[visibility("default")]] void rewrite( RewriteRule* rule, SgNode*& top);
Rewrite a node and its children recursively using a rule. Iterate until no more changes can be made.
roseInstallPrefix
[[visibility("default")]] bool roseInstallPrefix(std::string& result);
Find the path of the ROSE install prefix.
rosePathIsWithinTree
[[visibility("default")]] bool rosePathIsWithinTree( std::string const& root, std::string const& candidate);
roseResolveTestOutputPath
std::string roseResolveTestOutputPath(std::string const& filename);
shortCircuitingTransformation
[[visibility("default")]] void shortCircuitingTransformation(SgProject* prj);
simpleCopyAndConstantPropagation
[[visibility("default")]] void simpleCopyAndConstantPropagation(SgNode* top);
In code with declarations such as "int foo = bar", where foo and bar are not modified, replace "foo" with "bar" and remove the declaration
simpleFrontierDetectionForTokenStreamMapping
void simpleFrontierDetectionForTokenStreamMapping( SgSourceFile* sourceFile, bool traverseHeaderFiles, TokenUnparseFrontierFileContext& frontierContext, SgNode* traversalRoot = nullptr);
simpleIndexFiniteDifferencing
[[visibility("default")]] void simpleIndexFiniteDifferencing(SgNode* root);
Do a simple form of finite differencing on all functions contained within root (which should be a project, file, or function definition).
sla
[[visibility("default")]] int sla( std::vector<std::string>& argv, std::string const& flind, std::string const& assop, std::string const& pname, int argd = 0);
sla_set_debug
[[visibility("default")]] void sla_set_debug(int d);
sourceQualificationFileLoc
clang::SourceLocation sourceQualificationFileLoc( clang::SourceManager& source_manager, clang::SourceLocation location, bool expansion_end = false);
sourceQualificationFromNestedNameSpecifierLoc
SourceQualification sourceQualificationFromNestedNameSpecifierLoc( clang::NestedNameSpecifierLoc qualifier_loc, clang::CompilerInstance* compiler_instance, char const* context, clang::SourceLocation exact_source_begin = clang::SourceLocation());
sourceQualificationIsSemanticMacroExpansionFragment
bool sourceQualificationIsSemanticMacroExpansionFragment( clang::NestedNameSpecifierLoc qualifier_loc, clang::SourceManager& source_manager, clang::LangOptions const& lang_options);
sourceQualificationIsSemanticMacroFragment
bool sourceQualificationIsSemanticMacroFragment(SourceQualification const& qualification);
sourceQualificationMatchesSemanticIdentity
bool sourceQualificationMatchesSemanticIdentity( SourceQualification const& qualification, clang::NestedNameSpecifier semantic_identity, bool global, std::size_t named_component_count);
systemFromVector
[[visibility("default")]] int systemFromVector(std::vector<std::string> const& argv);
templateClassMatchesPattern
bool templateClassMatchesPattern( SgTemplateClassDeclaration const* declaration, SgTemplateClassDeclaration const* pattern);
templateInstantiationPatternDefinition
template<typename Decl> Decl* templateInstantiationPatternDefinition(Decl* pattern);
templateParametersForDeclContext
clang::TemplateParameterList const* templateParametersForDeclContext(clang::DeclContext const* context);
templateParametersForSageDeclarationShared
SgTemplateParameterPtrList const* templateParametersForSageDeclarationShared(SgDeclarationStatement const* decl);
testAstForUniqueNodes
void testAstForUniqueNodes(SgNode* node);
toStringForRTI
template<typename T> static std::string toStringForRTI(T const& x);
traverseMemoryPoolNodes
[[visibility("default")]] void traverseMemoryPoolNodes(ROSE_VisitTraversal& traversal);
traverseMemoryPoolVisitorPattern
[[visibility("default")]] void traverseMemoryPoolVisitorPattern(ROSE_VisitorPattern& visitor);
traverseRepresentativeNodes
[[visibility("default")]] void traverseRepresentativeNodes(ROSE_VisitTraversal& traversal);
trimSpaces
std::string trimSpaces(std::string const& s);
Returns the input std::string stripped of leading and trailing spaces.
typedefDeclarationReferenceShared
SgDeclarationStatement* typedefDeclarationReferenceShared(SgTypedefDeclaration* typedef_decl);
unparseDirectory
void unparseDirectory( SgDirectory* directory, UnparseFormatHelp* unparseHelp = nullptr, UnparseDelegate* delegate = nullptr, UnparsePreprocessingInfoRewriteMap const* preprocessingInfoRewrites = nullptr, NameQualificationContext* nameQualifications = nullptr, TokenUnparseFrontierContext* tokenFrontiers = nullptr);
Support for handling directories of files in ROSE (useful for code generation).
unparseFile
[[visibility("default")]] void unparseFile( SgFile* file, UnparseFormatHelp* unparseHelp = nullptr, UnparseDelegate* delegate = nullptr, SgScopeStatement* unparseScope = nullptr, UnparsePreprocessingInfoRewriteMap const* preprocessingInfoRewrites = nullptr, std::string const* outputFilenameOverride = nullptr, NameQualificationContext* nameQualifications = nullptr, TokenUnparseFrontierContext* tokenFrontiers = nullptr, unsigned int physicalFileOccurrence = 0);
User callable function available if compilation using the backend compiler is not required.
unparseFileList
void unparseFileList( SgFileList* fileList, UnparseFormatHelp* unparseFormatHelp = nullptr, UnparseDelegate* unparseDelegate = nullptr, UnparsePreprocessingInfoRewriteMap const* preprocessingInfoRewrites = nullptr, NameQualificationContext* nameQualifications = nullptr, std::string const* outputDirectoryOverride = nullptr, TokenUnparseFrontierContext* tokenFrontiers = nullptr);
Support for refactored handling directories of files.
unparseIncludedFiles
[[visibility("default")]] void unparseIncludedFiles( SgProject* project, UnparseFormatHelp* unparseHelp = nullptr, UnparseDelegate* delegate = nullptr, UnparsePreprocessingInfoRewriteMap* preprocessingInfoRewrites = nullptr, NameQualificationContext* nameQualifications = nullptr, TokenUnparseFrontierContext* tokenFrontiers = nullptr);
User callable function available if compilation using the backend compiler is not required.
unparseProject
[[visibility("default")]] void unparseProject( SgProject* project, UnparseFormatHelp* unparseHelp = nullptr, UnparseDelegate* delegate = nullptr);
User callable function available if compilation using the backend compiler is not required.
unparse_asm_clobber_name
std::string unparse_asm_clobber_name(std::string const& register_name);
unparse_asm_label_name
std::string unparse_asm_label_name(std::string const& label_name);
validateFreshSubtreeOwnership
void validateFreshSubtreeOwnership( SgNode* node, SgNode* boundary);
Validate a fresh subtree already owned by the supplied detached boundary.
validateOpenACCDirectiveForSage
void validateOpenACCDirectiveForSage(openacc::Directive const&);
validateTypedefDeclarationReferenceShared
void validateTypedefDeclarationReferenceShared(SgTypedefDeclaration* typedef_decl);
version_message
std::string version_message();
version_number
std::string version_number();
writeClangAstGraph
void writeClangAstGraph( clang::CompilerInstance& compiler, std::string const& filename);
writeList
template<class T> void writeList( DoublyLinkedListWrap<T> const& list, std::ostream& out);
write_graph
template< class Graph, class OUTPUT> void write_graph( Graph const& g, OUTPUT& out, std::string const& hint);
write_graph2
template< class Graph, class OUTPUT> void write_graph2( Graph const& g, OUTPUT& out, std::string const& hint);
write_graph_node_edge
template< class Graph, class Node> void write_graph_node_edge( Graph& g, Node const* curnode, std::ostream& out, std::string const& hint, GraphAccess::EdgeDirection dir);
xomp_acc_init
extern void xomp_acc_init();
xomp_beyond_block_reduction_double
double xomp_beyond_block_reduction_double( double* per_block_results, int numBlocks, int reduction_op);
xomp_beyond_block_reduction_float
float xomp_beyond_block_reduction_float( float* per_block_results, int numBlocks, int reduction_op);
xomp_beyond_block_reduction_int
int xomp_beyond_block_reduction_int( int* per_block_results, int numBlocks, int reduction_op);
xomp_deviceDataEnvironmentAddVariable
extern void xomp_deviceDataEnvironmentAddVariable( int devID, void* var_addr, int* var_size, int* var_offset, int* var_dim, int nDim, int typeSize, void* dev_addr, bool copyTo, bool copyFrom);
xomp_deviceDataEnvironmentEnter
extern void xomp_deviceDataEnvironmentEnter(int devID);
xomp_deviceDataEnvironmentExit
extern void xomp_deviceDataEnvironmentExit(int devID);
xomp_deviceDataEnvironmentGetInheritedVariable
extern void* xomp_deviceDataEnvironmentGetInheritedVariable( int devID, void* original_variable_address, int typeSize, int* size);
xomp_deviceDataEnvironmentPrepareVariable
extern void* xomp_deviceDataEnvironmentPrepareVariable( int devID, void* original_variable_address, int nDim, int typeSize, int* size, int* offset, int* vDimSize, bool copyTo, bool copyFrom);
xomp_deviceMalloc
extern void* xomp_deviceMalloc(size_t size);
xomp_freeArrayPointer
extern void xomp_freeArrayPointer( void* array, int* dimensions, size_t dimension_num);
xomp_freeDevice
extern bool xomp_freeDevice(void* devPtr);
xomp_freeHost
extern bool xomp_freeHost(void* hostPtr);
xomp_get_max1DBlock
extern size_t xomp_get_max1DBlock( int devID, size_t ss);
xomp_get_maxSegmentsPerDimensionOf2DBlock
extern size_t xomp_get_maxSegmentsPerDimensionOf2DBlock( int devID, size_t dimension_size);
xomp_get_maxThreadsPerBlock
extern size_t xomp_get_maxThreadsPerBlock(int devID);
xomp_get_max_devices
extern int xomp_get_max_devices();
xomp_get_max_threads_per_dimesion_2D
extern size_t xomp_get_max_threads_per_dimesion_2D(int devID);
xomp_get_num_devices
extern int xomp_get_num_devices();
xomp_hostMalloc
extern void* xomp_hostMalloc(size_t size);
xomp_mallocArray
extern void* xomp_mallocArray( int* dimensions, size_t dimension_num, size_t esize);
xomp_memcpyDeviceToDevice
extern void* xomp_memcpyDeviceToDevice( void* dest, void const* src, size_t n_n);
xomp_memcpyDeviceToHost
extern void* xomp_memcpyDeviceToHost( void* dest, void const* src, size_t n_n);
xomp_memcpyDynamicDeviceToHost
extern void* xomp_memcpyDynamicDeviceToHost( void* dest, int* dimensions, size_t dimension_size, void const* src, size_t element_size, size_t* bytes_copied);
xomp_memcpyDynamicHostToDevice
extern void* xomp_memcpyDynamicHostToDevice( void* dest, void const* src, int* dimensions, size_t dimension_size, size_t element_size, size_t* bytes_copied);
xomp_memcpyHostToDevice
extern void* xomp_memcpyHostToDevice( void* dest, void const* src, size_t n_n);
xomp_memcpyHostToHost
extern void* xomp_memcpyHostToHost( void* dest, void const* src, size_t n_n);
xomp_set_default_device
extern void xomp_set_default_device(int devID);
operator<<
std::ostream& operator<<( std::ostream& os, std::vector<SgDimensionObject*> const& value);
Stream insertion operators
operator==
bool operator==( SgSpecialFunctionModifier const& lhs, SgSpecialFunctionModifier const& rhs);
Equality operators
operator!=
bool operator!=( Sg_File_Info const& X, Sg_File_Info const& Y);
Inequality operators
operator<
bool operator<( Sg_File_Info const& X, Sg_File_Info const& Y);
Less-than operators
operator<=
bool operator<=( Sg_File_Info const& X, Sg_File_Info const& Y);
Less-than-or-equal operators
operator>
bool operator>( Sg_File_Info const& X, Sg_File_Info const& Y);
Greater-than operators
operator>=
bool operator>=( Sg_File_Info const& X, Sg_File_Info const& Y);
Greater-than-or-equal operators

ASTMemoryPool

Name
validNodeMarker
SgNode* validNodeMarker();

AST_Graph

Name
writeGraphOfAstSubGraphToFile
[[visibility("default")]] void writeGraphOfAstSubGraphToFile( std::string filename, SgNode* node, AST_Graph::pointerHandling graphNullPointers, int depth = -1);
writeGraphOfMemoryPoolToFile
[[visibility("default")]] void writeGraphOfMemoryPoolToFile( std::string filename, AST_Graph::pointerHandling);

ASTtools

Name Description
attachComment
void attachComment( std::string const& comment, SgStatement* s);
Attaches a string as a new C++-style comment to the given statement.
canonicalFunctionFamilyDeclaration
[[visibility("default")]] SgFunctionDeclaration* canonicalFunctionFamilyDeclaration(SgFunctionDeclaration* declaration);
Return the canonical declaration that identifies a function family.
collectDefdVarSyms
[[visibility("default")]] void collectDefdVarSyms( SgNode const* s, VarSymSet_t& syms);
Collect var syms for all local variable declarations at 's'.
collectLocalVisibleVarSyms
[[visibility("default")]] void collectLocalVisibleVarSyms( SgStatement const* root, SgStatement const* target, VarSymSet_t& syms);
Collect var syms declared at 'root' or below that are visible to 'target'.
collectNonLocalGotos
void collectNonLocalGotos( SgStatement const* root, JumpMap_t& jumps);
Collect non-local "goto" statements.
collectNonLocalJumps
void collectNonLocalJumps( SgStatement const* root, JumpMap_t& jumps);
Collect non-local "jumps" within a statement.
collectPointerDereferencingVarSyms
[[visibility("default")]] void collectPointerDereferencingVarSyms( SgStatement const* s, VarSymSet_t& pdSyms);
Collect variables suitable for using pointer dereferencing
collectRefdVarSyms
[[visibility("default")]] void collectRefdVarSyms( SgNode const* s, VarSymSet_t& syms);
Collect var syms for all variable references at 's'.
collectThisExpressions
void collectThisExpressions( SgStatement const* root, ThisExprSet_t& exprs);
Collect 'this' expressions.
collectVarRefsOfTypeWithoutAssignmentSupport
[[visibility("default")]] void collectVarRefsOfTypeWithoutAssignmentSupport( SgStatement const* s, std::set<SgVarRefExp*>& varSetB);
Collect variable references with a type which does not support =operator or copy construction. Those two support is essential for temp variables used to copy and restore parameters
collectVarRefsUsingAddress
[[visibility("default")]] void collectVarRefsUsingAddress( SgStatement const* s, std::set<SgVarRefExp*>& varSetB);
Collect variable references using addresses for s
cutPreprocInfo
void cutPreprocInfo( SgBasicBlock* b, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType& save_buf);
Removes all preprocessing information at a given position.
deepCopy
[[visibility("default")]] SgNode* deepCopy(SgNode const* n);
Create a deep-copy of an SgNode
findFirstFuncDef
[[visibility("default")]] SgFunctionDefinition const* findFirstFuncDef(SgStatement const* s);
Search for the first surrounding function definition.
functionOwningHiddenNamedType
[[visibility("default")]] SgFunctionDeclaration* functionOwningHiddenNamedType(SgType* type);
Return the function that lexically owns a function-local named type.
insertHeader
void insertHeader( std::string const& filename, SgProject* proj);
Inserts an '#include' into every source file, including an empty file.
isConstObj
bool isConstObj(SgType const* type);
Returns 'true' if the specified type is a 'const' object.
isIfCond
bool isIfCond(SgStatement const* s);
Returns 'true' <==> 's' is the condition of some 'if' statement.
isIfDirectiveBegin
bool isIfDirectiveBegin(PreprocessingInfo const* info);
Returns true if the info is an '#if', '#ifdef', or '#ifndef'.
isIfDirectiveEnd
bool isIfDirectiveEnd(PreprocessingInfo const* info);
isIfDirectiveMiddle
bool isIfDirectiveMiddle(PreprocessingInfo const* info);
Returns true if the info is an '#elif' or '#else'.
isPositionAfter
bool isPositionAfter(PreprocessingInfo const* info);
Returns true if info is positioned after its statement.
isPositionBefore
bool isPositionBefore(PreprocessingInfo const* info);
Returns true if info is positioned before its statement.
isPositionInside
bool isPositionInside(PreprocessingInfo const* info);
Returns true if info is positioned inside its statement.
isSwitchCond
bool isSwitchCond(SgStatement const* s);
Returns 'true' <==> 's' is the conditional selector of some 'switch' statement.
isWhileCond
bool isWhileCond(SgStatement const* s);
Returns 'true' <==> 's' is the condition of some 'while' or 'do ... while' statement.
moveAfterPreprocInfo
void moveAfterPreprocInfo( SgStatement* src, SgStatement* dest);
Moves 'after' preprocessing information.
moveBeforePreprocInfo
void moveBeforePreprocInfo( SgStatement* src, SgStatement* dest);
Moves 'before' preprocessing information.
moveInsidePreprocInfo
void moveInsidePreprocInfo( SgBasicBlock* src, SgBasicBlock* dest);
Moves 'inside' preprocessing information.
moveUpPreprocInfo
void moveUpPreprocInfo( SgStatement* stmt1, SgStatement* stmt2);
Moves preprocessingInfo of stmt2 to stmt1.
pastePreprocInfoBack
void pastePreprocInfoBack( AttachedPreprocessingInfoType& save_buf, SgStatement* s);
Pastes preprocessing information at the back of a statement.
pastePreprocInfoFront
void pastePreprocInfoFront( AttachedPreprocessingInfoType& save_buf, SgStatement* s);
Pastes preprocessing information at the front of a statement.
publishTemplateParameterPackExpansion
[[visibility("default")]] void publishTemplateParameterPackExpansion( SgTemplateParameter const* parameter, SgTemplateArgument* argument);
Publish the exact use-site pack-expansion surface for an argument that references a template parameter. A type parameter's SgTemplateType owns the ellipsis in its declaration; the SgTemplateArgument owns the ellipsis in a generated template-id use.
requiresVariableCapture
[[visibility("default")]] bool requiresVariableCapture(SgVarRefExp const* reference);
sameFunctionFamily
[[visibility("default")]] bool sameFunctionFamily( SgFunctionDeclaration* lhs, SgFunctionDeclaration* rhs);
Return true when two declarations belong to the same function family.
toStringFileLoc
std::string toStringFileLoc(SgLocatedNode const* n);
Convert a node's location to a string-friendly form.
transformToBlockShell
SgBasicBlock* transformToBlockShell(SgBasicBlock* b_orig);
Create an SgBasicBlock shell around an existing SgBasicBlock.

AliasAnalysisDetail

Name
deleteOwnedGraph
[[visibility("default")]] void deleteOwnedGraph(SgIncidenceDirectedGraph* graph);
virtualFunctionReference
[[visibility("default")]] SgMemberFunctionRefExp* virtualFunctionReference(SgFunctionCallExp* call);

AstQueryNamespace

Name
Merge
template<typename ResultType> void Merge( std::vector<ResultType>& mergeWith, std::vector<ResultType> const& mergeTo);
queryMemoryPool
template<typename NodeFunctional> detail::invoke_result_t<NodeFunctional&, SgNode*> queryMemoryPool( NodeFunctional nodeFunc, VariantVector* targetVariantVector = NULL);
queryRange
template<class _Result> _Result queryRange( _Result::iterator begin, _Result::iterator end, _Result(* __x)(SgNode*));
querySubTree
template<class _Result> _Result querySubTree( SgNode* subTree, _Result(* __x)(SgNode*), AstQueryNamespace::QueryDepth defineQueryType = AstQueryNamespace::AllNodes);

AstQueryNamespace::detail

Name
invoke
template< typename F, typename... Args> invoke_result_t<F&&, Args&&...> invoke( F&& f, Args&&... args) requires std::is_member_pointer<typename std::decay<F>::type>::value;

AstUtilInterface

Name Description
AddOperatorSideEffectAnnotation
void AddOperatorSideEffectAnnotation( SgNode* op_ast, AstNodePtr const& var, OperatorSideEffect relation);
CollectSideEffectVariables
void CollectSideEffectVariables( SgNode* ast, std::vector<AstNodePtr>* writeVars = 0, std::vector<AstNodePtr>* readVars = 0, std::vector<AstNodePtr>* callVars = 0);
Collect non-local variables that are read and written within the given ast. This is a wrapper of the ComputeAstSideEffects function to provide a more convenient user interface. Returns true if the returned variables are guaranteed to be complete; returns false otherwise.
ComputeAstSideEffects
void ComputeAstSideEffects( SgNode* ast, std::function<bool(AstNodePtr const&, AstNodePtr const&, OperatorSideEffect)>* collect = 0, SaveOperatorSideEffectInterface* add_to_dep_table = 0);
Returns the collection of memory references modified, read, and invoked (as function calls) as potential side effects of running the given ast, inside the given scope.
GetVariableSignature
std::string GetVariableSignature(AstNodePtr const& variable);
Returns a string that uniquely identifies the given variable. When enabled, save file, line, and expression type metadata for the signature.
IsLocalRef
bool IsLocalRef( SgNode* ref, SgNode* scope, bool* has_ptr_deref = 0);
OperatorSideEffectName
std::string OperatorSideEffectName(OperatorSideEffect what);
OutputOperatorSideEffectAnnotations
void OutputOperatorSideEffectAnnotations( std::ostream& output, DependenceTable* use_dep_analysis = 0);
OutputSignatureDictionary
void OutputSignatureDictionary(std::ostream& output);
ReadAnnotations
void ReadAnnotations( std::istream& input, DependenceTable* use_dep_table = 0);
RegisterOperatorSideEffectAnnotation
void RegisterOperatorSideEffectAnnotation();
SetFunctionNameMangling
void SetFunctionNameMangling(std::string(*)(SgFunctionDeclaration const*));
SetSaveVariableDictionary
void SetSaveVariableDictionary(bool doit);
operator<<
std::ostream& operator<<( std::ostream& output, DependenceEntry const& e);
Stream insertion operator

CPreproc

Name Description
dump
void dump(Ifs_t const ifs);
dump overloads
extractIfDirectives
void extractIfDirectives( SgNode* root, Ifs_t& ifs);
Extracts the '#if' directive structure from a project.
findIfDirectiveContext
void findIfDirectiveContext( SgLocatedNode const* target, Ifs_t& ifs, If::Case*& top, If::Case*& bottom);
Locate the '#if' directive context at a node.

CallTargetSet

Name Description
getDeclarationsForExpression
void getDeclarationsForExpression( SgExpression* exp, ClassHierarchyWrapper* classHierarchy, std::vector<SgFunctionDeclaration*>& calleeList, bool includePureVirtualFunc = false);
Populates functionList with declarations of all functions that may get called. This is basically a wrapper around getPropertiesForExpression.
getDefinitionsForExpression
void getDefinitionsForExpression( SgExpression* exp, ClassHierarchyWrapper* classHierarchy, std::vector<SgFunctionDefinition*>& calleeList);
Populates functionList with definitions of all functions that may get called. This is basically a wrapper around getPropertiesForExpression that extracts the SgFunctionDefinition from the Properties object. This returns only callees that have definitions - to get all possible callees, use getDeclarationsForExpression
getExpressionsForDefinition
void getExpressionsForDefinition( SgFunctionDefinition* targetDef, ClassHierarchyWrapper* classHierarchy, std::vector<SgExpression*>& exps);
getFirstVirtualFunctionDefinitionFromAncestors
SgFunctionDeclaration* getFirstVirtualFunctionDefinitionFromAncestors( SgClassType* crtClass, SgMemberFunctionDeclaration* memberFunctionDeclaration, ClassHierarchyWrapper* classHierarchy);
getPropertiesForExpression
[[visibility("default")]] void getPropertiesForExpression( SgExpression* exp, ClassHierarchyWrapper* classHierarchy, std::vector<SgFunctionDeclaration*>& propList, bool includePureVirtualFunc = false);
Append possible callees using canonicalFunctionDeclForCallGraph identity; preserve entries already present in propList.
isNonExecutableCallExpression
bool isNonExecutableCallExpression(SgExpression* expression);
solveConstructorInitializer
std::vector<SgFunctionDeclaration*> solveConstructorInitializer(SgConstructorInitializer* sgCtorInit);
Return the selected constructor's canonical declaration.
solveFunctionPointerCall
std::vector<SgFunctionDeclaration*> solveFunctionPointerCall(SgPointerDerefExp* pointerDerefExp);
Return signature-compatible functions in the dereference's exact project.
solveFunctionPointerCallsFunctional
std::vector<SgFunctionDeclaration*> solveFunctionPointerCallsFunctional( SgNode* node, SgFunctionType* functionType);
Return the canonical declaration if its callable signature matches.
solveMemberFunctionCall
std::vector<SgFunctionDeclaration*> solveMemberFunctionCall( SgClassType*, ClassHierarchyWrapper*, SgMemberFunctionDeclaration*, bool, bool includePureVirtualFunc = false);
solveMemberFunctionPointerCall
std::vector<SgFunctionDeclaration*> solveMemberFunctionPointerCall( SgExpression*, ClassHierarchyWrapper*);
unwrapExactImplicitCalleeConversions
[[visibility("default")]] SgExpression* unwrapExactImplicitCalleeConversions(SgExpression* functionExpression);
Return the source expression that denotes a callee after validating and traversing only compiler-synthesized implicit callee conversions. Explicit casts and all non-conversion call surfaces remain in the returned syntax.

CommandlineProcessing

Name Description
addCppSourceFileSuffix
[[visibility("default")]] void addCppSourceFileSuffix(std::string const& suffix);
Add another valid C++ source file extension without a leading dot.
addListToCommandLine
[[visibility("default")]] void addListToCommandLine( std::vector<std::string>& argv, std::string prefix, std::vector<std::string> argList);
Add the strings in argList to the command line.
clangLanguageSelectionForSource
[[visibility("default")]] ClangLanguageSelection clangLanguageSelectionForSource( std::vector<std::string> const& argv, std::string const& source);
Return the ordered -x state active at one exact source operand.
clangLanguageSelectionForSuffix
[[visibility("default")]] ClangLanguageSelection clangLanguageSelectionForSuffix(std::string const& source);
Return the exact Clang driver language selected by a supported suffix.
generateArgListFromArgcArgv
[[visibility("default")]] std::vector<std::string> generateArgListFromArgcArgv( int argc, char const const* argv[]);
Convert an argc-argv pair into a string vector.
generateSourceFilenames
[[visibility("default")]] std::vector<std::string> generateSourceFilenames(std::vector<std::string> const& argList);
Build the list of isolated file names from the command line.
generateStringFromArgList
[[visibility("default")]] std::string generateStringFromArgList(std::vector<std::string> const& argList);
Convert a vector of string to a single string.
isAssemblerFileNameSuffix
[[visibility("default")]] bool isAssemblerFileNameSuffix(std::string const& suffix);
isCFileNameSuffix
[[visibility("default")]] bool isCFileNameSuffix(std::string const& suffix);
isCoArrayFortranFileNameSuffix
[[visibility("default")]] bool isCoArrayFortranFileNameSuffix(std::string const& suffix);
isCppFileNameSuffix
[[visibility("default")]] bool isCppFileNameSuffix(std::string const& suffix);
isCudaFileNameSuffix
[[visibility("default")]] bool isCudaFileNameSuffix(std::string const& suffix);
isFortran2003FileNameSuffix
[[visibility("default")]] bool isFortran2003FileNameSuffix(std::string const& suffix);
isFortran2008FileNameSuffix
[[visibility("default")]] bool isFortran2008FileNameSuffix(std::string const& suffix);
isFortran77FileNameSuffix
[[visibility("default")]] bool isFortran77FileNameSuffix(std::string const& suffix);
isFortran90FileNameSuffix
[[visibility("default")]] bool isFortran90FileNameSuffix(std::string const& suffix);
isFortran95FileNameSuffix
[[visibility("default")]] bool isFortran95FileNameSuffix(std::string const& suffix);
isFortranFileNameSuffix
[[visibility("default")]] bool isFortranFileNameSuffix(std::string const& suffix);
isFortranFileNameSuffixRequiringCPP
[[visibility("default")]] bool isFortranFileNameSuffixRequiringCPP(std::string const& suffix);
isObjectFilename
[[visibility("default")]] bool isObjectFilename(std::string name);
isOpenCLFileNameSuffix
[[visibility("default")]] bool isOpenCLFileNameSuffix(std::string const& suffix);
isOption
[[visibility("default")]] bool isOption( std::vector<std::string>& argv, std::string optionPrefix, std::string Option, bool removeOption);
Search 'argv' for an option like optionPrefixOption.
isOptionTakingSecondParameter
[[visibility("default")]] bool isOptionTakingSecondParameter(std::string argument);
isOptionTakingThirdParameter
[[visibility("default")]] bool isOptionTakingThirdParameter(std::string argument);
isOptionWithParameter
[[visibility("default")]] bool isOptionWithParameter( std::vector<std::string>& argv, std::string optionPrefix, std::string Option, float& optionParameter, bool removeOption);
isOptionWithParameter overloads
isSourceFilename
[[visibility("default")]] bool isSourceFilename(std::string name);
removeAllFileNamesExcept
[[visibility("default")]] void removeAllFileNamesExcept( std::vector<std::string>& argv, std::vector<std::string> filenameList, std::string exceptFilename);
Remove file names specified in filenameList from argv.
removeArgs
[[visibility("default")]] void removeArgs( std::vector<std::string>& argv, std::string prefix);
Remove all options matching a specified prefix.
removeArgsWithParameters
[[visibility("default")]] void removeArgsWithParameters( std::vector<std::string>& argv, std::string prefix);
Remove all options matching a specified prefix along with their values.
sliceCommandLineForSource
[[visibility("default")]] std::vector<std::string> sliceCommandLineForSource( std::vector<std::string> const& argv, std::vector<std::string> const& sourceFiles, std::string const& source);
Build a per-translation-unit argv without changing ordered option state.
validateBackendCompileOnlyCommandLine
[[visibility("default")]] void validateBackendCompileOnlyCommandLine( std::vector<std::string> const& argList, std::string const& expectedSource);
Enforce the final per-translation-unit backend compile contract.
validateClangLanguageOptions
[[visibility("default")]] void validateClangLanguageOptions(std::vector<std::string> const& argv);
Validate every split or joined Clang -x option in argument order.

ConstantFolding

Name Description
buildPredicateResult
SgValueExp* buildPredicateResult( SgBinaryOp* op, bool value);
buildResultValueExp_float_t
template< typename T1, typename T2> static SgValueExp* buildResultValueExp_float_t( SgBinaryOp* binaryOperator, SgValueExp* lhsValue, SgValueExp* rhsValue);
buildResultValueExp_t
template< typename T1, typename T2> static SgValueExp* buildResultValueExp_t( SgBinaryOp* binaryOperator, SgValueExp* lhsValue, SgValueExp* rhsValue);
buildResultValueExp_u_t
template< typename T1, typename T2> static SgValueExp* buildResultValueExp_u_t( SgUnaryOp* unaryOperator, SgValueExp* theValue);
calculateIntegral
template<typename T> std::optional<T> calculateIntegral( SgBinaryOp* op, T lhs, T rhs);
calculate_float_t
template<typename T> T calculate_float_t( SgBinaryOp* binaryOperator, T lhsValue, T rhsValue);
Calculate the result of a binary operation on two constant float-kind values,
calculate_u_t
template<typename T> T calculate_u_t( SgUnaryOp* unaryOperator, T theValue);
cf_get_value_t
template< typename T1, typename T2> T1 cf_get_value_t(T2* sg_value_exp);
checkedIntegralProduct
template<typename T> bool checkedIntegralProduct( T lhs, T rhs, T& result);
constantFoldingOptimization
[[visibility("default")]] void constantFoldingOptimization(SgNode* n);
constantUnFoldingTest
[[visibility("default")]] void constantUnFoldingTest(SgNode* n);
isPredicateBinaryOperator
bool isPredicateBinaryOperator(VariantT kind);
returnConstantFoldedValueExpression
[[visibility("default")]] SgValueExp* returnConstantFoldedValueExpression(SgNode* n);

DUVariableAnalysisExt

Name
getNextParentInterstingNode
SgNode* getNextParentInterstingNode(SgNode* node);
isDef
bool isDef(SgNode* node);
isIDef
bool isIDef(SgNode* node);
isIUse
bool isIUse(SgNode* node);
isUse
bool isUse(SgNode* node);

Dbg

Name Description
addDOT
std::string addDOT(std::string dot);
addDOTStr
std::string addDOTStr(dottable& obj);
addImage
std::string addImage(std::string ext = "gif");
diagnosticNodeText
std::string diagnosticNodeText(SgNode const* node);
dotGraphGenerator
void dotGraphGenerator(Analysis* a);
Generate dot graphs for an analysis: it handles intra-procedural analysis for now.
enterFunc
void enterFunc(std::string funcName);
escape
std::string escape(std::string s);
exitFunc
void exitFunc(std::string funcName);
init
void init( std::string title, std::string workDir, std::string fName = "debug");

IncludeFileGraph

Name
graph_include_files
void graph_include_files(SgIncludeFile* includeFile);
insertGraphNode
void insertGraphNode(void* node);

IntegerOps

Name Description
bitmask_subset
template<typename T> bool bitmask_subset( T m1, T m2);
Determines if one bitmask is a subset of another. Returns true if the bits set in the first argument form a subset of the bits set in the second argument.
countClear
template<typename T> size_t countClear(T val);
Counts how many bits are clear (zero).
countSet
template<typename T> size_t countSet(T val);
Counts how many bits are set (one).
extract
template< size_t lobit, size_t hibit, typename T> T extract(T bits);
Extract bits from a value. Bits lobit through hibit, inclusive, are right shifted into the result and higher-order bits of the result are cleared.
extract2
template<typename T> T extract2( size_t lobit, size_t hibit, T bits);
genMask
template<typename T> T genMask(size_t n);
genMask overloads
isPowerOfTwo
template<typename T> bool isPowerOfTwo(T value);
Returns true if the value is a power of two. Zero is considered a power of two.
log2
template<typename T> T log2(T a);
log2max
template<typename T> T log2max(T value);
Returns the base-2 logorithm of value. If value is not a power of two then the return value is rounded up to the next integer. The value is treated as an unsigned value. Returns zero if value is zero.
msb_set
template<typename T> std::optional<size_t> msb_set(T val);
Optionally returns the zero-origin position of the most significant set bit. Returns nothing if no bits are set.
rotateLeft
template< size_t NBits, typename T> T rotateLeft( T value, size_t count);
Rotate the bits of the value left by count bits.
rotateLeft2
template<typename T> T rotateLeft2( T value, size_t count, size_t width = 8 * sizeof(T));
rotateRight
template< size_t NBits, typename T> T rotateRight( T value, size_t count);
Rotate bits of the value right by count bits.
rotateRight2
template<typename T> T rotateRight2( T value, size_t count, size_t width = 8 * sizeof(T));
shiftLeft
template< size_t NBits, typename T> T shiftLeft( T value, size_t count);
Shifts bits of value left by count bits.
shiftLeft2
template<typename T> T shiftLeft2( T value, size_t count, size_t width = 8 * sizeof(T));
shiftRightArithmetic
template< size_t NBits, typename T> T shiftRightArithmetic( T value, size_t count);
Shifts bits of value right by count bits with sign extension.
shiftRightArithmetic2
template<typename T> T shiftRightArithmetic2( T value, size_t count, size_t width = 8 * sizeof(T));
shiftRightLogical
template< size_t NBits, typename T> T shiftRightLogical( T value, size_t count);
Shifts bits of value right by count bits without sign extension.
shiftRightLogical2
template<typename T> T shiftRightLogical2( T value, size_t count, size_t width = 8 * sizeof(T));
shift_to
template< size_t lobit, size_t hibit, typename T> T shift_to(T value);
Create a shifted value. The return value is created by shifting value to the specified position in the result. Other bits of the return value are clear. The hibit is specified so that we can check at run-time that a valid value was specified (i.e., the value isn't too wide).
shift_to2
template<typename T> T shift_to2( size_t lobit, size_t hibit, T value);
shl1
template<typename T> T shl1(size_t n);
Bitmask with bit n set. Handles the case where n is greater than the width of type T.
signBit
template< size_t NBits, typename T> bool signBit(T value);
Returns true if the sign bit is set, false if clear.
signBit2
template<typename T> bool signBit2( T value, size_t width = 8 * sizeof(T));
signExtend
template< size_t FromBits, size_t ToBits, typename T> T signExtend(T value);
Sign extend value. If the bit FromBits-1 is set set for value, then the result will have bits FromBits through ToBits-1 also set (other bits are unchanged). If ToBits is less than or equal to FromBits then nothing happens.
signExtend2
template<typename T> T signExtend2( T value, size_t from_width, size_t to_width);

MaxSourceExtents

Name
computeMaxSourceExtents
void computeMaxSourceExtents( SgSourceFile* sourceFile, SgNode* n, int& start_line, int& start_column, int& end_line, int& end_column);

NameQuery

Name
getFunction
std::function<std::vector<std::string>(SgNode*)> getFunction(TypeOfQueryTypeOneParameter oneParam);
queryMemoryPool
NameQuerySynthesizedAttributeType queryMemoryPool( TypeOfQueryTypeOneParameter elementReturnType, VariantVector* targetVariantVector = NULL);
queryNameArgumentNames
NameQuerySynthesizedAttributeType queryNameArgumentNames(SgNode* astNode);
queryNameClassDeclarationNames
NameQuerySynthesizedAttributeType queryNameClassDeclarationNames(SgNode* astNode);
queryNameClassFieldNames
NameQuerySynthesizedAttributeType queryNameClassFieldNames(SgNode* astNode);
queryNameFunctionDeclarationNames
NameQuerySynthesizedAttributeType queryNameFunctionDeclarationNames(SgNode* astNode);
queryNameFunctionReferenceNames
NameQuerySynthesizedAttributeType queryNameFunctionReferenceNames(SgNode* astNode);
queryNameMemberFunctionDeclarationNames
NameQuerySynthesizedAttributeType queryNameMemberFunctionDeclarationNames(SgNode* astNode);
queryNameStructFieldNames
NameQuerySynthesizedAttributeType queryNameStructFieldNames(SgNode* astNode);
queryNameStructNames
NameQuerySynthesizedAttributeType queryNameStructNames(SgNode* astNode);
queryNameTypeName
NameQuerySynthesizedAttributeType queryNameTypeName(SgNode* astNode);
queryNameTypedefDeclarationNames
NameQuerySynthesizedAttributeType queryNameTypedefDeclarationNames(SgNode* astNode);
queryNameUnionFieldNames
NameQuerySynthesizedAttributeType queryNameUnionFieldNames(SgNode* astNode);
queryNameUnionNames
NameQuerySynthesizedAttributeType queryNameUnionNames(SgNode* astNode);
queryNameVariableNames
NameQuerySynthesizedAttributeType queryNameVariableNames(SgNode* astNode);
queryNameVariableTypeNames
NameQuerySynthesizedAttributeType queryNameVariableTypeNames(SgNode* astNode);
queryNodeList
[[visibility("default")]] NameQuerySynthesizedAttributeType queryNodeList( std::vector<SgNode*> nodeList, TypeOfQueryTypeOneParameter elementReturnType);
querySubTree
[[visibility("default")]] NameQuerySynthesizedAttributeType querySubTree( SgNode* subTree, TypeOfQueryTypeOneParameter elementReturnType, AstQueryNamespace::QueryDepth defineQueryType = AstQueryNamespace::AllNodes);

NewCallGraph

Name
buildCallGraph
int buildCallGraph(SgProject* project);
generateCallGraphFile
void generateCallGraphFile( SgProject* project, CallGraph& cg);
getLock
int getLock();
readCallGraphFile
std::vector<CallGraphFileStructure>* readCallGraphFile(std::string binaryFilename);
releaseLock
void releaseLock(int fd);

NodeQuery

Name
generateListOfTypes
std::vector<SgNode*> generateListOfTypes(SgNode* astNode);
getFunction
std::function<std::vector<SgNode*>(SgNode*)> getFunction(TypeOfQueryTypeOneParameter oneParam);
queryMemoryPool
[[visibility("default")]] NodeQuerySynthesizedAttributeType queryMemoryPool(VariantVector& targetVariantVector);
queryNodeAnonymousTypedef
NodeQuerySynthesizedAttributeType queryNodeAnonymousTypedef(SgNode* node);
queryNodeAnonymousTypedefClassDeclaration
NodeQuerySynthesizedAttributeType queryNodeAnonymousTypedefClassDeclaration(SgNode* node);
queryNodeList
[[visibility("default")]] NodeQuerySynthesizedAttributeType queryNodeList( NodeQuerySynthesizedAttributeType, VariantT targetVariant);
queryNodePragmaDeclarationFromName
std::vector<SgNode*> queryNodePragmaDeclarationFromName( SgNode* node, SgNode* nameNode);
querySolverArguments
NodeQuerySynthesizedAttributeType querySolverArguments(SgNode* astNode);
querySolverClassDeclarations
NodeQuerySynthesizedAttributeType querySolverClassDeclarations(SgNode* astNode);
querySolverClassFields
NodeQuerySynthesizedAttributeType querySolverClassFields(SgNode* astNode);
querySolverFunctionDeclarations
NodeQuerySynthesizedAttributeType querySolverFunctionDeclarations(SgNode* astNode);
querySolverMemberFunctionDeclarations
NodeQuerySynthesizedAttributeType querySolverMemberFunctionDeclarations(SgNode* astNode);
querySolverStructDeclarations
NodeQuerySynthesizedAttributeType querySolverStructDeclarations(SgNode* astNode);
querySolverStructDefinitions
NodeQuerySynthesizedAttributeType querySolverStructDefinitions(SgNode* astNode);
querySolverStructFields
NodeQuerySynthesizedAttributeType querySolverStructFields(SgNode* astNode);
querySolverTypedefDeclarations
NodeQuerySynthesizedAttributeType querySolverTypedefDeclarations(SgNode* astNode);
querySolverUnionDeclarations
NodeQuerySynthesizedAttributeType querySolverUnionDeclarations(SgNode* astNode);
querySolverUnionFields
NodeQuerySynthesizedAttributeType querySolverUnionFields(SgNode* astNode);
querySolverVariableDeclarations
NodeQuerySynthesizedAttributeType querySolverVariableDeclarations(SgNode* astNode);
querySolverVariableTypes
NodeQuerySynthesizedAttributeType querySolverVariableTypes(SgNode* astNode);
querySubTree
[[visibility("default")]] NodeQuerySynthesizedAttributeType querySubTree( SgNode* subTree, TypeOfQueryTypeOneParameter elementReturnType, AstQueryNamespace::QueryDepth defineQueryType = AstQueryNamespace::AllNodes);

NumberQuery

Name
getFunction
std::function<NumberQuerySynthesizedAttributeType(SgNode*)> getFunction(TypeOfQueryTypeOneParameter oneParam);
queryMemoryPool
[[visibility("default")]] NumberQuerySynthesizedAttributeType queryMemoryPool( TypeOfQueryTypeOneParameter elementReturnType, VariantVector* targetVariantVector = NULL);
queryNodeList
[[visibility("default")]] NumberQuerySynthesizedAttributeType queryNodeList( std::vector<SgNode*> nodeList, TypeOfQueryTypeOneParameter elementReturnType);
queryNumberOfArgsInConstructor
NumberQuerySynthesizedAttributeType queryNumberOfArgsInConstructor(SgNode* astNode);
queryNumberOfArgsInParenthesisOperator
NumberQuerySynthesizedAttributeType queryNumberOfArgsInParenthesisOperator( SgNode* astNode, SgType* returnType);
queryNumberOfArgsInScalarIndexingOperator
NumberQuerySynthesizedAttributeType queryNumberOfArgsInScalarIndexingOperator(SgNode* astNode);
queryNumberOfOperands
NumberQuerySynthesizedAttributeType queryNumberOfOperands(SgNode* astNode);
querySubTree
[[visibility("default")]] NumberQuerySynthesizedAttributeType querySubTree( SgNode* subTree, TypeOfQueryTypeOneParameter elementReturnType, AstQueryNamespace::QueryDepth defineQueryType = AstQueryNamespace::AllNodes);

OmpSupport

Name Description
addClauseVariable
[[visibility("default")]] void addClauseVariable( SgInitializedName* var, SgOmpClauseBodyStatement* clause_stmt, VariantT const& vt);
Add a variable into a non-reduction clause of an OpenMP statement, create the clause transparently if it does not exist
addGeneratedOmpClause
void addGeneratedOmpClause( SgStatement* node, SgOmpClause* clause);
Attach a transformation-generated OpenMP clause, assigning exact source-order provenance when the directive came from combined syntax.
addOmpClause
void addOmpClause( SgStatement* node, SgOmpClause* clause);
Attach an OpenMP clause to directive
analyze_omp
void analyze_omp(SgSourceFile*);
beginOpenACCCxxExactSemanticConsumption
void beginOpenACCCxxExactSemanticConsumption(SgPragmaDeclaration* pragma);
beginOpenACCCxxExactSemanticExpression
void beginOpenACCCxxExactSemanticExpression( SgPragmaDeclaration* pragma, std::string const& expression, OpenMPExprParseMode parse_mode);
beginOpenACCFortranExactSemanticConsumption
void beginOpenACCFortranExactSemanticConsumption(SgPragmaDeclaration* pragma);
beginOpenACCFortranExactSemanticExpression
void beginOpenACCFortranExactSemanticExpression( SgPragmaDeclaration* pragma, std::string const& expression);
buildAndInsertDeclarationForOmp
SgVariableDeclaration* buildAndInsertDeclarationForOmp( std::string const& name, SgType* type, SgInitializer* varInit, SgBasicBlock* orig_scope);
Special handling when trying to build and insert a variable declaration into a BB within Fortran OpenMP code
buildFortranOutlinedFunctionRef
SgFunctionRefExp* buildFortranOutlinedFunctionRef(SgFunctionDeclaration* declaration);
Build a reference to a generated Fortran outlined procedure through its exact semantic-only publication.
buildOmpVariableClause
[[visibility("default")]] SgOmpVariablesClause* buildOmpVariableClause( SgOmpClauseBodyStatement* clause_stmt, VariantT const& vt);
Build a non-reduction variable clause for a given OpenMP directive. It directly returns the clause if the clause already exists
clearImplicitTargetMapVariables
[[visibility("default")]] void clearImplicitTargetMapVariables();
collectAllClauseVariables
[[visibility("default")]] SgInitializedNamePtrList collectAllClauseVariables(SgStatement* clause_stmt);
Collect all variables from OpenMP clauses associated with an omp statement: private, reduction, etc
collectClauseVariables
[[visibility("default")]] SgInitializedNamePtrList collectClauseVariables( SgStatement* clause_stmt, VariantT const& vt);
collectClauseVariables overloads
collectThreadprivateVariables
std::set<SgInitializedName*> collectThreadprivateVariables();
Collect threadprivate variables within the current project, return a set to avoid duplicated elements. No input parameters are needed since it finds match from memory pools
commandLineProcessing
void commandLineProcessing(std::vector<std::string>& argvList);
consumeOpenACCFortranExactSemanticEnd
void consumeOpenACCFortranExactSemanticEnd(SgPragmaDeclaration* pragma);
consumeOpenACCFortranExactSemanticSyntax
void consumeOpenACCFortranExactSemanticSyntax( SgPragmaDeclaration* pragma, std::string const& spelling);
createInitialValueExp
[[visibility("default")]] SgExpression* createInitialValueExp(SgOmpClause::omp_reduction_identifier_enum r_operator);
Create an initial value according to reduction operator type
createOmpStatementTree
void createOmpStatementTree(SgSourceFile* file);
Analysis helpers
discardOpenMPProducerSemanticRecords
void discardOpenMPProducerSemanticRecords(SgSourceFile* source_file);
endOpenACCCxxExactSemanticExpression
void endOpenACCCxxExactSemanticExpression(SgPragmaDeclaration* pragma);
endOpenACCFortranExactSemanticExpression
void endOpenACCFortranExactSemanticExpression(SgPragmaDeclaration* pragma);
finishOpenACCCxxExactSemanticConsumption
void finishOpenACCCxxExactSemanticConsumption(SgPragmaDeclaration* pragma);
finishOpenACCFortranExactSemanticConsumption
void finishOpenACCFortranExactSemanticConsumption(SgPragmaDeclaration* pragma);
generateOutlinedTask
SgFunctionDeclaration* generateOutlinedTask( SgNode* node, std::string& wrapper_name, ASTtools::VarSymSet_t& syms, ASTtools::VarSymSet_t& pdSyms3, bool insert_runtime_ids = true);
A helper function to generate implicit or explicit task for either omp parallel or omp task
getClause
[[visibility("default")]] std::vector<SgOmpClause*> getClause( SgStatement* clause_stmt, VariantT const& vt);
Get OpenMP clauses from an eligible OpenMP statement
getClauseExpression
[[visibility("default")]] SgExpression* getClauseExpression( SgStatement* clause_stmt, VariantVector const& vvt);
Collect expression from given types of OpenMP clauses associated with an omp statement: private, reduction, etc
getDataSharingAttribute
[[visibility("default")]] omp_construct_enum getDataSharingAttribute(SgVarRefExp* varRef);
getDataSharingAttribute overloads
getEnclosingRegionOrFuncDefinition
SgBasicBlock* getEnclosingRegionOrFuncDefinition(SgNode*);
Find an enclosing parallel region or function definition's body
getKmpcRuntimeFunctionName
std::string getKmpcRuntimeFunctionName(std::string const& abiName);
Return the exact source-language identifier for one LLVM OpenMP runtime entry point. C/C++ use the ABI spelling directly; Fortran uses the standards-conforming REX adapter spelling exported by kmpc_fortran_wrappers.c. Non-__kmpc names are contract violations.
getOmpClauseList
SgOmpClauseList* getOmpClauseList(SgStatement* node);
getOmpParent
SgStatement* getOmpParent(SgStatement* node);
getOpenMPMergedEndClauseSource
std::string const& getOpenMPMergedEndClauseSource(OpenMPClause const* clause);
getReductionOperationType
[[visibility("default")]] SgOmpClause::omp_reduction_identifier_enum getReductionOperationType( SgInitializedName* init_name, SgOmpClauseBodyStatement* clause_stmt);
Return a reduction variable's reduction operation type
hasClause
[[visibility("default")]] bool hasClause( SgStatement* clause_stmt, VariantT const& vt);
Check if an OpenMP statement has a clause of type vt
initializeTaskDataEnvironment
void initializeTaskDataEnvironment( SgOmpTaskStatement* task, SgOmpClauseBodyStatement* source_context, std::vector<SgInitializedName*> const& generated_firstprivate, std::vector<SgInitializedName*> const& generated_private);
insertAcceleratorInit
void insertAcceleratorInit(SgSourceFile*);
insertRTLHeaders
void insertRTLHeaders(SgSourceFile*);
Insert #include "xxx.h", the interface of a runtime library to the compiler
isClause
bool isClause(omp_construct_enum omp_type);
Check if an OpenMP construct is a clause
isDependenceType
bool isDependenceType(omp_construct_enum omp_type);
Check if an OpenMP construct is a dependence type for omp task depend
isDirective
bool isDirective(omp_construct_enum omp_type);
Check if an OpenMP construct is a directive
isDirectiveWithBody
bool isDirectiveWithBody(omp_construct_enum omp_type);
Check if an OpenMP directive has a structured body
isFortranBeginDirective
bool isFortranBeginDirective(omp_construct_enum omp_type);
Check if the construct is a Fortran directive which can (optionally) have a corresponding END directive
isFortranEndDirective
bool isFortranEndDirective(omp_construct_enum omp_type);
Check if the construct is a Fortran END ... directive
isImplicitTargetMapVariable
[[visibility("default")]] bool isImplicitTargetMapVariable( SgOmpClauseBodyStatement const* target, SgSymbol const* sym);
isInClauseVariableList
[[visibility("default")]] bool isInClauseVariableList( SgInitializedName* var, SgOmpClauseBodyStatement* clause_stmt, VariantT const& vt);
isInClauseVariableList overloads
isInOmpTargetRegion
bool isInOmpTargetRegion(SgStatement* node);
Check whether a SgNode is inside omp target
isOmpContextSelectorMetadataDirective
bool isOmpContextSelectorMetadataDirective(SgNode const*);
Return true when an OpenMP statement is a syntax-only construct selector owned by a MATCH/WHEN clause rather than an executable AST statement.
isOpenMPMergedEndClause
bool isOpenMPMergedEndClause(OpenMPClause const* clause);
isReductionOperator
bool isReductionOperator(omp_construct_enum omp_type);
Check if an OpenMP construct is a reduction operator
isSharedAccess
[[visibility("default")]] bool isSharedAccess(SgVarRefExp* varRef);
Check if a variable access is a shared access , assuming it is already within an OpenMP region.
isThreadprivate
[[visibility("default")]] bool isThreadprivate(SgSymbol* var);
Check if a variable is a threadprivate variable. It will search for all threadprivate directives to find the answer.
lower_omp
void lower_omp(SgSourceFile*);
The top level interface to translate OpenMP directives
markImplicitTargetMapVariable
[[visibility("default")]] void markImplicitTargetMapVariable( SgOmpClauseBodyStatement* target, SgInitializedName* var);
markOpenMPMergedEndClause
void markOpenMPMergedEndClause( OpenMPClause* clause, std::string const& source_text);
mergeSgNodeList
std::vector<SgNode*> mergeSgNodeList( std::vector<SgNode*> node_list1, std::vector<SgNode*> node_list2);
openMPExpressionVariables
std::vector<SgNode*>& openMPExpressionVariables();
patchUpPrivateVariables
[[visibility("default")]] int patchUpPrivateVariables(SgFile*);
patchUpPrivateVariables overloads
prepareSourceForOpenMPTransformation
void prepareSourceForOpenMPTransformation(SgNode*);
Prepare the exact written directive/body surfaces before an actual lowering operation changes them. Direct transformation APIs use the same boundary as the lowering driver; unrelated source inclusions remain retained.
processOpenMP
void processOpenMP(SgSourceFile*& sageFilePtr);
registerOpenACCCxxExactSemanticBindings
void registerOpenACCCxxExactSemanticBindings( SgSourceFile* source_file, SgPragmaDeclaration* pragma, OpenACCCxxExactSemanticBindings bindings);
registerOpenMPFortranExactSemanticBindings
void registerOpenMPFortranExactSemanticBindings( SgSourceFile* source_file, SgPragmaDeclaration* pragma, OmpFortranExactSemanticBindings bindings);
registerOpenMPProducerSemanticRecords
void registerOpenMPProducerSemanticRecords( SgSourceFile* source_file, SgPragmaDeclaration* pragma, OpenMPProducerSemanticRecords records);
removeClause
[[visibility("default")]] int removeClause( SgStatement* clause_stmt, VariantT const& vt);
Remove one or more clauses of type vt
replaceVariableReferences
[[visibility("default")]] int replaceVariableReferences( SgNode* root, VariableSymbolMap_t varRemap);
replaceVariableReferences overloads
replaceVariablesWithPointerDereference
int replaceVariablesWithPointerDereference( SgNode* root, std::set<SgVariableSymbol*>& vars);
Replace all variable references in a set by pointers to the variable
requireExactAssociatedForLoop
SgForStatement* requireExactAssociatedForLoop( SgOmpBodyStatement* directive, SgStatement* expected_root, AssociatedLoopPathContract path_contract, char const* contract);
requireExactAssociatedLoop
SgStatement* requireExactAssociatedLoop( SgOmpBodyStatement* directive, SgStatement* expected_root, AssociatedLoopPathContract path_contract, char const* contract);
Return the one exact loop owned by directive through expected_root. Every structural edge must be unique and parent-consistent, and every wrapper must be admitted by path_contract. Malformed, ambiguous, cyclic, attributed, or semantically different wrapper paths are hard errors.
requireExactClauseVariableCopyIdentity
[[visibility("default")]] ClauseVariableCopyIdentity requireExactClauseVariableCopyIdentity( SgCopyHelp::copiedNodeMapType const& identityMap, SgOmpExecStatement* originalDirective, SgInitializedName* originalClauseVariable, SgVariableSymbol* originalBackingSymbol);
Resolve one original directive, all of the clause variable's exact expression identities, and its pointer-backing symbol through the deep-copy identity map. The copied clause expressions must agree on exactly one symbol/declaration. Missing, identity, ambiguous, or wrongly typed mappings are hard errors; spelling and scope lookup are never used.
requireExactIntegralConstantExpression
void requireExactIntegralConstantExpression( SgExpression* expression, char const* contract);
Require expression to be one language-valid target-ABI integral constant expression. This is a proof-only API: every runtime expression is a hard contract violation.
requireExactPositiveIntegralConstant
unsigned long long requireExactPositiveIntegralConstant( SgExpression* expression, unsigned long long maximum, char const* contract);
Evaluate a language-valid, target-ABI integral constant and require it to be in [1, maximum]. Unsupported, malformed, volatile, cyclic, or undefined constant expressions are hard errors; no textual parsing or fallback value is permitted.
requireFortranDirectiveSemanticProducer
void requireFortranDirectiveSemanticProducer( SgPragmaDeclaration* pragma, OmpFortranExactSemanticBindings::Producer producer, char const* operation, SgPragmaDeclaration::fortran_directive_family_enum expected_family = SgPragmaDeclaration::e_fortran_directive_none);
requireOpenMPConversionSession
void requireOpenMPConversionSession();
retireConsumedOmpDirective
void retireConsumedOmpDirective(SgStatement* directive);
setOmpRelationship
void setOmpRelationship( SgStatement* parent, SgStatement* child);
snapshotOpenMPProducerSemanticRecords
OpenMPProducerSemanticRecords snapshotOpenMPProducerSemanticRecords(SgPragmaDeclaration* pragma);
toString
std::string toString(omp_construct_enum omp_type);
toString overloads
transOmpAtomic
void transOmpAtomic(SgNode* node);
Translate omp atomic
transOmpBarrier
void transOmpBarrier(SgNode* node);
Translate omp barrier
transOmpCollapse
void transOmpCollapse(SgStatement* node);
transOmpCritical
void transOmpCritical(SgNode* node);
Translate omp critical
transOmpFlush
void transOmpFlush(SgNode* node);
Translate omp flush
transOmpLoop
void transOmpLoop(SgNode* node);
Translate omp for or omp do loops
transOmpMaster
void transOmpMaster(SgNode* node);
Translate omp master
transOmpMetadirective
void transOmpMetadirective(SgNode* node);
Translate omp metadirective
transOmpOrdered
void transOmpOrdered(SgNode* node);
Translate the ordered directive (not the ordered clause)
transOmpParallel
void transOmpParallel(SgNode* node);
Translate omp parallel
transOmpSections
void transOmpSections(SgNode* node);
Translate omp sections
transOmpSimd
void transOmpSimd(SgNode* node);
Translate omp simd
transOmpSingle
void transOmpSingle(SgNode* node);
Translate omp single
transOmpTarget
void transOmpTarget(SgNode* node);
Translate "omp target"
transOmpTargetData
void transOmpTargetData(SgNode* node);
Translate "omp target data"
transOmpTargetParallel
void transOmpTargetParallel(SgNode* node);
Translate omp parallel under "omp target"
transOmpTask
void transOmpTask(SgNode* node);
Translate omp task
transOmpTaskgroup
void transOmpTaskgroup(SgNode* node);
transOmpTaskloop
void transOmpTaskloop(SgNode* node);
transOmpTaskwait
void transOmpTaskwait(SgNode* node);
Translate omp taskwait
transOmpThreadprivate
void transOmpThreadprivate(SgNode* node);
Translate omp threadprivate
transOmpTile
void transOmpTile(SgNode* node);
Translate omp tile
transOmpUnroll
void transOmpUnroll(SgNode* node);
Translate omp unroll
transOmpVariables
[[visibility("default")]] void transOmpVariables( SgStatement* ompStmt, SgBasicBlock* bb1, SgExpression* orig_loop_upper = NULL, bool withinAcceleratorModel = false);
Translate OpenMP variables associated with an OpenMP pragma, such as private, firstprivate, lastprivate, reduction, etc. bb1 is the translation generated code block in which the variable handling statements will be inserted. Original loop upper bound is needed for implementing lastprivate (check if it is the last iteration). withinAcceleratorModel means if we only translate private() variables, used to support accelerator model
useStaticSchedule
[[visibility("default")]] bool useStaticSchedule(SgOmpClauseBodyStatement* omp_loop);
Check if an omp for/do loop use static schedule or not, including: default schedule, or schedule(static[,chunk_size])

Outliner

Name Description
appendIndividualFunctionCallArgs
void appendIndividualFunctionCallArgs( ASTtools::VarSymSet_t const& syms, std::set<SgInitializedName*> const varUsingOriginalType, SgExprListExp* e_list);
Generates a function call parameter list using a set of symbols
captureValueType
[[visibility("default")]] SgType* captureValueType(SgType* type);
collectVars
void collectVars( SgNode const* root, SgStatement const* outline_site, ASTtools::VarSymSet_t& syms);
Computes the set of variables in 's' that need to be passed to the outlined routine (semantically equivalent to shared variables in OpenMP)
commandLineProcessing
[[visibility("default")]] void commandLineProcessing(std::vector<std::string>& argvList);
Accept a set of command line options to adjust internal behaviors
ensureDlopenSupportHeaderInCallSite
void ensureDlopenSupportHeaderInCallSite(SgScopeStatement* scope);
Establish the runtime-header dependency required by a generated dlopen call. Source directives for a separately compiled outlined-function library must be captured first so this call-site-only dependency cannot leak into it.
generateCall
SgStatement* generateCall( SgFunctionDeclaration* source_call_declaration, ASTtools::VarSymSet_t const& syms, std::set<SgInitializedName*> const readOnlyVars, std::string wrapper_arg_name, SgScopeStatement* scope, OutlinedLocalTypeTemplatePlan const& local_type_template_plan);
Generates a call to an outlined function.
generateFuncArgName
std::string generateFuncArgName(SgStatement const* stmt);
Create a unique outlined-function's wrapper argument name for the specified statement.
generateFuncName
std::string generateFuncName(SgStatement const* stmt);
Create a unique outlined-function name for the specified statement.
generateFunction
[[visibility("default")]] SgFunctionDeclaration* generateFunction( SgBasicBlock* s, std::string const& func_name_str, ASTtools::VarSymSet_t const& syms, ASTtools::VarSymSet_t const& pdSyms, std::set<SgInitializedName*> const& restoreVars, SgClassDeclaration* struct_decl, SgScopeStatement* scope, OutlinedLocalTypeTemplatePlan& local_type_template_plan, OutlinedFunctionParameterBindings& parameter_bindings, SgFunctionParameterList* leading_parameters = nullptr);
Returns a new outlined function containing a deep-copy of s.
generateLibSourceFileName
[[visibility("default")]] std::string generateLibSourceFileName(SgBasicBlock* target);
the lib source file's name convention is rose_input_lib.[c|cxx].
generateNewSourceFile
[[visibility("default")]] SgSourceFile* generateNewSourceFile( SgBasicBlock* target, std::string const& file_name);
Generate a new source file under the same SgProject as target, the file's base name is file_name_str. Suffix is automatically generated according to the file suffix of s
generatePackingStatements
[[visibility("default")]] std::string generatePackingStatements( SgStatement* target, ASTtools::VarSymSet_t& syms, ASTtools::VarSymSet_t& pdsyms, SgClassDeclaration* struct_decl = NULL);
Generate packing (wrapping) statements for the variables to be passed
generateParameterStructureDeclaration
[[visibility("default")]] SgClassDeclaration* generateParameterStructureDeclaration( SgBasicBlock* s, std::string const& func_name_str, ASTtools::VarSymSet_t const& syms, ASTtools::VarSymSet_t& pdSyms, SgScopeStatement* func_scope);
Generate a struct declaration to wrap all variables to be passed to the outlined function There are two ways to wrap a variable: Using its value vs. Using its address (pointer type)
getLibSourceFile
[[visibility("default")]] SgSourceFile* getLibSourceFile(SgBasicBlock* target);
Obtain the file handle to the separated source file storing outlined functions. In dlopen mode, the outliner leaves this source enabled for unparsing and excludes it from the main program's compile/link step; the caller compiles it separately as a shared library. target is the input code block for outlining. It provides SgProject and input file name info. the lib source file's name convention is rose_input_lib.[c|cxx].
insert
[[visibility("default")]] SageInterface::DeferredTransformation insert( SgFunctionDeclaration* func, SgScopeStatement* scope, SgBasicBlock* outlining_target, SgFunctionDeclaration*& source_call_declaration);
isFortranModuleDefinitionScope
bool isFortranModuleDefinitionScope(SgScopeStatement const* scope);
isOutlineDirective
[[visibility("default")]] bool isOutlineDirective(SgPragmaDeclaration const*);
Return whether a pragma is the outliner's consumed control directive.
isOutlineable
[[visibility("default")]] bool isOutlineable( SgStatement const* s, bool verbose = false);
Returns true iff the statement is "outlineable."
isValidOutliningScope
bool isValidOutliningScope(SgScopeStatement const* scope);
outline
Result outline(SgPragmaDeclaration* s);
outline overloads
outlineAll
[[visibility("default")]] size_t outlineAll(SgProject*);
Outlines all regions marked by outlining pragmas.
outlineBlock
Result outlineBlock( SgBasicBlock* b, std::string const& name, std::vector<PreprocessingInfo> const& original_directives);
Outlines the given basic block into a function named 'name'.
preprocess
[[visibility("default")]] SgBasicBlock* preprocess(SgPragmaDeclaration* s);
preprocessAll
[[visibility("default")]] size_t preprocessAll(SgProject*);
validateSettings
[[visibility("default")]] void validateSettings();
Validate and adjust analysis settings.

Outliner::Preprocess

Name Description
checkAndPatchUpOptions
void checkAndPatchUpOptions();
Sanity check and patch up outliner options
copyNonLocalFunctionDeclaration
SgFunctionDeclaration* copyNonLocalFunctionDeclaration( SgFunctionDeclaration* source, SgScopeStatement* scope, SgStatement* insertionAnchor);
createBlock
SgBasicBlock* createBlock(SgStatement* s);
Convert the "plain-old" statement into an SgBasicBlock. This normalization simplifies outlining of single statements.
gatherNonLocalDecls
void gatherNonLocalDecls(SgBasicBlock* b);
Gathers non-local declarations into the local scope.
moveLeadingPreprocessorPrefixForPrototype
void moveLeadingPreprocessorPrefixForPrototype( SgStatement* source, SgStatement* destination);
preparePrototypeParameterDeclarations
void preparePrototypeParameterDeclarations( SgFunctionDeclaration const* prototype, SgGlobal* scope, SgDeclarationStatement* boundary);
preprocessOutlineTarget
SgBasicBlock* preprocessOutlineTarget(SgStatement* s);
Preprocesses the outline target and returns an equivalent SgBasicBlock to outline.
transformNonLocalControlFlow
SgBasicBlock* transformNonLocalControlFlow(SgBasicBlock* b_orig);
Preprocess non-local control flow for outlining.
transformPreprocIfs
SgBasicBlock* transformPreprocIfs(SgBasicBlock* b);
Transform '#if' directive structure. It is possible that certain preprocessor directives may straddle the boundaries of a basic block. This routine attempts to detect and transform these instances so that the block may be safely outlined.
transformThisExprs
SgBasicBlock* transformThisExprs(SgBasicBlock* b);
Canonicalize references to 'this'.

ProcessExpression

Name
processLHS
void processLHS( SgNode* node, AliasRelationNode& arNode);
processRHS
void processRHS( SgNode* node, AliasRelationNode& arNode);

ROSE_Analysis

Name
BuildCFG
template<class Node> void BuildCFG( AstInterface& fa, AstInterface::AstNodeList const& head, BuildCFGConfig<Node>& g);

Rose

Name Description
getNextStatement
SgStatement* getNextStatement(SgStatement* targetStatement);
getPathFromFileName
[[visibility("default")]] std::string getPathFromFileName(std::string fileNameWithPath);
get the filename from the full filename
getPreviousStatement
SgStatement* getPreviousStatement( SgStatement* targetStatement, bool climbOutScope = true);
getWorkingDirectory
[[visibility("default")]] std::string getWorkingDirectory();
make_range
template<typename T> iterator_range<T> make_range(std::pair<T, T> p);
Convenience function for iterating over sub-ranges.
obtainAndExecuteActions
int obtainAndExecuteActions(SgProject* n);
operator*
FloatingValue operator*( FloatingValue lhs, FloatingValue rhs);
operator+
FloatingValue operator+( FloatingValue lhs, FloatingValue rhs);
operator-
FloatingValue operator-( FloatingValue lhs, FloatingValue rhs);
operator/
FloatingValue operator/( FloatingValue lhs, FloatingValue rhs);
processPluginCommandLine
void processPluginCommandLine(std::vector<std::string>& input_argv);
usage
[[visibility("default")]] void usage();
get the path from the full filename
utility_stripPathFromFileName
[[visibility("default")]] std::string utility_stripPathFromFileName(std::string const& fileNameWithPath);
operator<<
std::ostream& operator<<( std::ostream& out, Integer128Value value);
Stream insertion operators
operator==
bool operator==( FloatingValue lhs, FloatingValue rhs);
Equality operator
operator!=
bool operator!=( FloatingValue lhs, FloatingValue rhs);
Inequality operator
operator<
bool operator<( FloatingValue lhs, FloatingValue rhs);
Less-than operator
operator<=
bool operator<=( FloatingValue lhs, FloatingValue rhs);
Less-than-or-equal operator
operator>
bool operator>( FloatingValue lhs, FloatingValue rhs);
Greater-than operator
operator>=
bool operator>=( FloatingValue lhs, FloatingValue rhs);
Greater-than-or-equal operator

Rose::AST

Name
expressionHasSemanticValueType
bool expressionHasSemanticValueType( VariantT kind, bool unevaluated_string);
namedTypeScopeHasCrossTranslationUnitIdentity
bool namedTypeScopeHasCrossTranslationUnitIdentity(SgScopeStatement* scope);
resolvedClassType
SgClassType* resolvedClassType( SgType* type, bool strip_indirection = false);
selectedDestructorClass
SgClassType* selectedDestructorClass(SgMemberFunctionDeclaration* destructor);
temporaryStorageMatchesOwner
bool temporaryStorageMatchesOwner( SgExpression::temporary_storage_duration_enum storage, VariantT scope, bool static_storage, bool thread_storage);

Rose::AstJson

Name Description
addExpressionQualificationFields
void addExpressionQualificationFields( std::vector<std::string>& fields, SgExpression* expr);
addExpressionType
void addExpressionType( std::vector<std::string>& fields, SgExpression* expr, std::unordered_map<SgNode const*, uint64_t> const& ids);
addLocatedPreprocessing
void addLocatedPreprocessing( std::vector<std::string>& fields, SgLocatedNode const* node);
aggregateConstructionFieldsFromJson
AggregateConstructionFields aggregateConstructionFieldsFromJson( JsonValue const& properties, NodeMap const& nodes, SgUnsignedCharList source_roles);
aggregateSourceElementRolesFromJson
SgUnsignedCharList aggregateSourceElementRolesFromJson(JsonValue const& properties);
alignmentSpecifierFromProperties
SgAlignmentSpecifier* alignmentSpecifierFromProperties( JsonValue const& properties, SgExpression* operand);
alignmentSpellingFromProperties
SgAlignmentSpecifier::spelling_enum alignmentSpellingFromProperties( JsonValue const& properties, bool has_operand);
appendCanonicalJson
void appendCanonicalJson( std::ostream& out, JsonValue const& value);
appendRawExternalDeclarationStatementFields
void appendRawExternalDeclarationStatementFields( std::vector<std::string>& fields, SgDeclarationStatement* decl, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& context);
appendRawTypeModifierFields
void appendRawTypeModifierFields( std::vector<std::string>& fields, SgTypeModifier const& modifier, std::string const& prefix = "declaration_type");
applyFunctionCallSourceFields
void applyFunctionCallSourceFields( SgFunctionCallExp* call, FunctionCallSourceFields const& fields);
argumentSelectsCheckpoint
bool argumentSelectsCheckpoint( std::string const& value, Checkpoint checkpoint);
arrayInitBindingCategoryFromJson
SgCastExp::value_category_enum arrayInitBindingCategoryFromJson(JsonValue const& json);
arrayInitReferenceFieldsFromJson
ArrayInitReferenceFields arrayInitReferenceFieldsFromJson(JsonValue const& json);
asmOperandFieldsFromJson
AsmOperandConstructionFields asmOperandFieldsFromJson(JsonValue const& properties);
asmStatementFieldsFromJson
AsmStatementConstructionFields asmStatementFieldsFromJson(JsonValue const& properties);
assignmentInitializerSourceFieldsFromJson
AssignmentInitializerSourceFields assignmentInitializerSourceFieldsFromJson(JsonValue const& properties);
attachAstAttributes
void attachAstAttributes( SgNode* node, PreparedAstAttributes attributes);
attachJsonNodeId
void attachJsonNodeId( SgNode* node, uint64_t id);
attachPointerMemberJsonIdentity
void attachPointerMemberJsonIdentity( SgPointerMemberType* type, uint64_t identity);
attachPreprocessingInfo
void attachPreprocessingInfo( SgNode* node, PreparedPreprocessingInfo entries);
attachSemanticArrayJsonIdentity
void attachSemanticArrayJsonIdentity( SgArrayType* type, uint64_t identity);
attachSourceTypeJsonIdentity
void attachSourceTypeJsonIdentity( SgType* type, uint64_t identity);
binaryEmissionRoleFromJson
std::optional<SgArrowExp::emission_role_enum> binaryEmissionRoleFromJson( JsonValue const& properties, std::string const& kind);
binaryStorageSizeFromJson
std::optional<long long> binaryStorageSizeFromJson( JsonValue const& properties, std::string const& kind);
binarySubscriptStridesFromJson
std::vector<std::optional<long long>> binarySubscriptStridesFromJson( JsonValue const& properties, std::string const& kind);
bitVectorFromJson
SgBitVector bitVectorFromJson( JsonValue const& json, std::string const& context, std::size_t expected_size);
buildCachedJsonPointerType
SgPointerType* buildCachedJsonPointerType(SgType* base);
buildFileInfo
Sg_File_Info* buildFileInfo( JsonValue const& json, SgNode* parent);
buildJson
std::string buildJson( SgNode* root, Checkpoint checkpoint, SgSourceFile* file, SgFileList* project_files = nullptr, NodeMap* serialized_nodes = nullptr);
canonicalSourceIdentityFromJson
std::optional<SgTemplateParameter::canonical_source_identity> canonicalSourceIdentityFromJson( JsonValue const& object, char const* owner);
canonicalSubtreeSignature
std::string canonicalSubtreeSignature(SgNode* root);
canonicalTypedefDeclarationId
uint64_t canonicalTypedefDeclarationId( std::unordered_map<SgNode const*, uint64_t> const& ids, SgTypedefDeclaration const* decl);
castConstructionFieldsFromJson
CastConstructionFields castConstructionFieldsFromJson(JsonValue const& properties);
castExpressionFromProperties
SgCastExp* castExpressionFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpression* operand, SgType* type, CastConstructionFields const& fields);
checkpointEnabled
bool checkpointEnabled( SgSourceFile const* file, Checkpoint checkpoint);
checkpointName
char const* checkpointName(Checkpoint checkpoint);
checkpointPath
std::filesystem::path checkpointPath( SgSourceFile* file, Checkpoint checkpoint, Options const& options);
chooseSelectionFromJson
SgChooseExpression::selection_kind_enum chooseSelectionFromJson(JsonValue const& properties);
classDeclarationHasDefinition
bool classDeclarationHasDefinition(SgClassDeclaration* decl);
classDeclarationIsFirstNondefining
bool classDeclarationIsFirstNondefining(SgClassDeclaration* decl);
classSymbolForDeclaration
SgClassSymbol* classSymbolForDeclaration(SgClassDeclaration* decl);
classTypeForDeclaration
SgClassType* classTypeForDeclaration(SgClassDeclaration* decl);
collectDelayedDeclarations
std::vector<NodeRecord const*> collectDelayedDeclarations( AstFileRecord const& ast, NodeMap const& nodes);
collectExternalFunctionConstructionDependencies
void collectExternalFunctionConstructionDependencies( JsonValue const& json, std::unordered_set<uint64_t>& ids);
collectNodes
std::vector<SgNode*> collectNodes(SgNode* root);
collectTypeDependencyIds
void collectTypeDependencyIds( JsonValue const& json, std::unordered_set<uint64_t>& ids, std::unordered_set<uint64_t>& symbol_ids, std::unordered_set<uint64_t>& type_ids);
commandLine
std::vector<std::string> commandLine(SgSourceFile const* file);
commandLineFromJson
std::vector<std::string> commandLineFromJson(JsonValue const& properties);
commandLineValue
std::string commandLineValue( SgSourceFile const* file, std::string const& option);
complexValueFromProperties
SgComplexVal* complexValueFromProperties( JsonValue const& properties, NodeMap const& nodes);
compoundLiteralFromProperties
SgCompoundLiteralExp* compoundLiteralFromProperties( JsonValue const& properties, NodeMap const& nodes);
conditionalFromProperties
SgConditionalExp* conditionalFromProperties( JsonValue const& properties, NodeMap const& nodes, SgConditionalExp::conditional_operator_kind_enum kind, SgExpression* condition, SgExpression* true_expression, SgExpression* false_expression);
conditionalOperatorKindFromJson
SgConditionalExp::conditional_operator_kind_enum conditionalOperatorKindFromJson(JsonValue const& properties);
constructAggregateInitializer
SgAggregateInitializer* constructAggregateInitializer( AggregateConstructionFields const& fields, SgExprListExp* initializers, SgExpressionPtrList const& elements);
constructAsmOperand
SgAsmOp* constructAsmOperand( AsmOperandConstructionFields const& fields, SgExpression* expression);
constructAsmStatement
SgAsmStmt* constructAsmStatement( AsmStatementConstructionFields const& fields, SgExpressionPtrList const& operands);
constructBinaryOp
SgBinaryOp* constructBinaryOp( std::string const& kind, SgExpression* lhs, SgExpression* rhs, SgType* result_type, std::optional<SgArrowExp::emission_role_enum> arrow_role, std::optional<long long> result_storage_size_bytes, std::vector<std::optional<long long>> const& strides);
constructChooseExpression
SgChooseExpression* constructChooseExpression( SgType* type, SgChooseExpression::selection_kind_enum selection, SgExpression* condition, SgExpression* true_expression, SgExpression* false_expression);
constructClassTypeForDeclaration
SgClassType* constructClassTypeForDeclaration(SgClassDeclaration* decl);
constructExternalFunctionOwnedAttributes
void constructExternalFunctionOwnedAttributes( SgFunctionDeclaration* declaration, JsonValue const& json, NodeMap const& nodes);
constructExternalFunctionParameterScopeDeclarationsFromJson
void constructExternalFunctionParameterScopeDeclarationsFromJson( JsonValue const& json, NodeMap const& nodes, SgFunctionParameterScope* scope, SgInitializedNamePtrList const& parameters, std::string const& function_name, std::optional<SourcePositions> positions);
constructExternalFunctionParameterScopeSymbols
bool constructExternalFunctionParameterScopeSymbols( AstFileRecord const& ast, NodeMap const& nodes, bool require_complete);
constructExternalFunctionParameterScopeSymbolsFromJson
void constructExternalFunctionParameterScopeSymbolsFromJson( JsonValue const& json, NodeMap const& nodes, SgFunctionParameterScope* scope, SgInitializedNamePtrList const& parameters, std::string const& function_name);
constructExternalInitializedName
SgInitializedName* constructExternalInitializedName( JsonValue const& json, NodeMap const& nodes, ExternalInitializedNameFields const& fields, SgDeclarationStatement* decl, SgNode* parent, SgScopeStatement* scope, std::string const& context);
constructFileInfo
Sg_File_Info* constructFileInfo( std::optional<FileInfoFields> const& fields, SgNode* parent);
constructFortranImplicitRange
SgFortranImplicitRange* constructFortranImplicitRange( char first, std::optional<char> last, SgFortranImplicitRange::type_spec_enum type_spec, JsonValue const& properties, NodeMap const& nodes);
constructFunctionCall
SgFunctionCallExp* constructFunctionCall( FunctionCallSourceFields const& fields, SgExpression* function, SgExprListExp* arguments, SgType* type, SgCxxLiteralTokenList* literal_tokens);
constructInitializedName
SgInitializedName* constructInitializedName( SgName const& name, SgType* type);
constructNewExpression
SgNewExp* constructNewExpression( NewConstructionFields const& fields, SgExpression* array_bound, SgExprListExp* placement, SgConstructorInitializer* constructor, SgExpression* builtin, SgFunctionDeclaration* operator_declaration, SgExpressionPtrList const& placement_elements);
constructOperandRequirement
SgExpression* constructOperandRequirement( OperandRequirementKind kind, SgExpression* operand, SgExpression* type_constraint, bool noexcept_required);
constructPendingSerializedSymbols
bool constructPendingSerializedSymbols( SerializedSymbolTableConstruction& construction, NodeMap const& nodes, bool require_complete);
constructPreprocessingInfo
PreparedPreprocessingInfo constructPreprocessingInfo(std::vector<PreprocessingInfoFields> const& fields);
constructSourcePositions
SourcePositions constructSourcePositions(SourcePositionFields const& fields);
constructTypedefDeclaration
SgTypedefDeclaration* constructTypedefDeclaration( SgName const& name, SgType* base_type, SgDeclarationStatement* base_declaration, bool owns_base_declaration, VariantT kind, SgTemplateTypedefDeclaration* template_declaration, SgTemplateArgumentPtrList const& arguments, SgTemplateArgumentPtrList const& deduced_arguments, TypedefMetadata const& metadata);
constructUnaryOp
SgUnaryOp* constructUnaryOp( std::string const& kind, SgExpression* operand, UnaryConstructionFields const& fields, SgType* result_type);
constructVisibilitySymbol
std::unique_ptr<SgSymbol> constructVisibilitySymbol( VisibilitySymbolFields const& fields, NodeMap const& nodes, SgNodePtrList causes);
constructorArgumentSourceFromProperties
SgConstructorInitializer::argument_source_enum constructorArgumentSourceFromProperties(JsonValue const& properties);
constructorElisionFromProperties
bool constructorElisionFromProperties(JsonValue const& properties);
constructorInitializerFromProperties
SgConstructorInitializer* constructorInitializerFromProperties( JsonValue const& properties, SgMemberFunctionDeclaration* declaration, SgExprListExp* arguments, SgExpressionPtrList const& elements, SgType* type);
contextPropertyFieldsFromRecord
OmpContextPropertyFields contextPropertyFieldsFromRecord(NodeRecord const& record);
contextSelectorFieldsFromJson
OmpContextSelectorFields contextSelectorFieldsFromJson(JsonValue const& properties);
contextSelectorSetKindFromJson
SgOmpClause::omp_context_selector_set_kind_enum contextSelectorSetKindFromJson(JsonValue const& properties);
coroutineKeywordKindFromJson
SgAwaitExpression::coroutine_keyword_kind_enum coroutineKeywordKindFromJson(JsonValue const& properties);
createExternalSymbolFromJson
SgSymbol* createExternalSymbolFromJson( JsonValue const& json, NodeMap const& nodes, SgSymbolTable* owner_table);
createNodeFromRecord
SgNode* createNodeFromRecord( NodeRecord const& record, SgProject* project, NodeMap const& dependencies);
createSourceFileFromRecord
SgSourceFile* createSourceFileFromRecord( NodeRecord const& record, SgProject* project, SgFileList* owner, NodeMap const& dependencies = {});
createSymbolForKindAndBasis
SgSymbol* createSymbolForKindAndBasis( VariantT kind, SgNode* basis, JsonValue const& properties);
createUseStatementFromRecord
SgNode* createUseStatementFromRecord( NodeRecord const& record, SgProject* project, SgModuleStatement* module);
currentDeserializationSourceFiles
std::vector<SgSourceFile*> currentDeserializationSourceFiles();
declarationConstructionDependencyReady
bool declarationConstructionDependencyReady( AstFileRecord const& ast, NodeMap const& nodes, uint64_t id, bool needs_symbol, bool needs_type_identity, VariantT symbol_kind = V_SgSymbol);
declarationFieldsFromJson
DeclarationFields declarationFieldsFromJson( JsonValue const& properties, VariantT kind, std::string const& context, std::string const& qualifier_context = "declaration source qualifier");
declarationNameQualificationFieldsFromJson
DeclarationNameQualificationFields declarationNameQualificationFieldsFromJson(JsonValue const& properties);
declarationNeedsExternalReferenceRecord
bool declarationNeedsExternalReferenceRecord( SgDeclarationStatement* decl, std::unordered_map<SgNode const*, uint64_t> const& ids);
declarationSourceFieldsFromJson
DeclarationSourceFields declarationSourceFieldsFromJson( JsonValue const& properties, std::string const& context, std::string const& qualifier_context = "declaration source qualifier", bool variable = false);
decodeExternalClassDeclaration
std::function<SgClassDeclaration*()> decodeExternalClassDeclaration(JsonValue const& json);
decodeExternalFunction
std::function<SgFunctionDeclaration*()> decodeExternalFunction( JsonValue const& json, NodeMap const& nodes);
decodeExternalModule
std::function<SgModuleStatement*()> decodeExternalModule(JsonValue const& json);
defaultInitializerDeclarationFromJson
SgInitializedName* defaultInitializerDeclarationFromJson( JsonValue const& json, NodeMap const& nodes);
defaultInitializerDeclarationNodeFromJson
uint64_t defaultInitializerDeclarationNodeFromJson(JsonValue const& json);
defaultInitializerKindFromJson
SgCxxDefaultInitExp::source_kind_enum defaultInitializerKindFromJson(JsonValue const& properties);
defaultOutputDirectory
std::string defaultOutputDirectory(SgSourceFile const* file);
drainDelayedDeclarations
void drainDelayedDeclarations( AstFileRecord const& ast, std::vector<NodeRecord const*>& pending, NodeMap& nodes, bool require_complete, SymbolConstructionAdvance const& symbols = {});
edgeTargetIsInParentChain
bool edgeTargetIsInParentChain( SgNode const* node, SgNode const* target);
edgesFor
std::vector<EdgeRecord> edgesFor( NodeRecord const& record, std::string const& field);
enforceSymbolTablePreferences
void enforceSymbolTablePreferences(std::vector<ExpectedSymbolTablePreference> const& entries);
enumValueFromProperties
SgEnumVal* enumValueFromProperties( JsonValue const& properties, NodeMap const& nodes);
exactBoundSymbolFromJson
SgSymbol* exactBoundSymbolFromJson( JsonValue const& json, NodeMap const& nodes, SgSymbolTable* local_table = nullptr);
exactInitializedNameType
SgType* exactInitializedNameType( JsonValue const& properties, NodeMap const& nodes);
exactJsonValueHash
uint64_t exactJsonValueHash(JsonValue const& value);
exactSerializedPointerTarget
uint64_t exactSerializedPointerTarget( NodeRecord const& record, std::string const& property, std::string const& edge);
exactSymbolBindingDependenciesReady
bool exactSymbolBindingDependenciesReady( JsonValue const& json, NodeMap const& nodes);
exactSymbolBindingEntryIndex
size_t exactSymbolBindingEntryIndex( JsonValue const& binding, JsonValue const& entries);
exactTypedefBaseType
SgType* exactTypedefBaseType( JsonValue const& properties, NodeMap const& nodes);
exprListExpFromTypeJson
SgExprListExp* exprListExpFromTypeJson( JsonValue const& json, NodeMap const& nodes);
expressionCarriesSemanticType
bool expressionCarriesSemanticType(SgExpression const* expression);
expressionConstructionFieldsFromJson
ExpressionConstructionFields expressionConstructionFieldsFromJson(JsonValue const& properties);
expressionFromRef
SgExpression* expressionFromRef( JsonValue const& json, NodeMap const& nodes);
expressionQualificationFieldsFromJson
std::optional<ExpressionQualificationFields> expressionQualificationFieldsFromJson( std::string const& kind, JsonValue const& properties);
expressionSourceFieldsFromJson
ExpressionSourceFields expressionSourceFieldsFromJson( std::string const& kind, JsonValue const& properties);
extendedFloatingValueFromJson
Rose::FloatingValue extendedFloatingValueFromJson(JsonValue const& json);
externalClassDeclarationFromJson
SgClassDeclaration* externalClassDeclarationFromJson(JsonValue const& json);
externalDeclarationFieldsFromJson
ExternalDeclarationFields externalDeclarationFieldsFromJson( JsonValue const& json, VariantT kind, std::string const& context);
externalDeclarationReferenceFromJson
SgDeclarationStatement* externalDeclarationReferenceFromJson( JsonValue const& json, NodeMap const& nodes, std::string const& context);
externalFunctionFromJson
SgFunctionDeclaration* externalFunctionFromJson( JsonValue const& json, NodeMap const& nodes);
externalFunctionParameterScopeOwner
SgFunctionDeclaration* externalFunctionParameterScopeOwner( SgFunctionDeclaration* decl, std::unordered_map<SgNode const*, uint64_t> const& ids);
externalInitializedNameFieldsFromJson
ExternalInitializedNameFields externalInitializedNameFieldsFromJson( JsonValue const& json, NodeMap const& nodes, std::string const& context);
externalInitializedNameFromJson
SgInitializedName* externalInitializedNameFromJson( JsonValue const& json, NodeMap const& nodes, SgDeclarationStatement* decl, SgNode* parent, SgScopeStatement* scope, std::string const& context);
externalModuleFromJson
SgModuleStatement* externalModuleFromJson(JsonValue const& json);
externalParameterScopeDeclarationFromJson
SgDeclarationStatement* externalParameterScopeDeclarationFromJson( JsonValue const& json, NodeMap const& nodes, SgFunctionParameterScope* scope, std::string const& function_name);
fileInfoFieldsFromJson
std::optional<FileInfoFields> fileInfoFieldsFromJson(JsonValue const& json);
fileLanguageFromJson
SgFile::languageOption_enum fileLanguageFromJson( JsonValue const& properties, std::string const& key);
fileOutputFormatFromJson
SgFile::outputFormatOption_enum fileOutputFormatFromJson( JsonValue const& properties, std::string const& key);
filenameForFileId
std::string filenameForFileId( int id, std::string const& context);
floatingValueFromJson
template<typename Float> Float floatingValueFromJson(JsonValue const& json);
fnv1a64
uint64_t fnv1a64(std::string const& value);
foldConstructionFieldsFromJson
FoldConstructionFields foldConstructionFieldsFromJson(JsonValue const& properties);
formatItemFieldsFromJson
FormatItemFields formatItemFieldsFromJson(JsonValue const& properties);
fortranCArgumentPassingFromJson
SgInitializedName::fortran_c_argument_passing_enum fortranCArgumentPassingFromJson(JsonValue const& properties);
fortranInterfaceFieldsFromJson
FortranInterfaceFields fortranInterfaceFieldsFromJson(JsonValue const& properties);
fortranProcedureComponentBindingFromJson
std::optional<SgInitializedName::FortranProcedureComponentBinding> fortranProcedureComponentBindingFromJson(JsonValue const& properties);
fortranSourceContextFromJson
SgSourceFile::fortran_source_context fortranSourceContextFromJson(JsonValue const& properties);
functionCallSourceFieldsFromJson
FunctionCallSourceFields functionCallSourceFieldsFromJson(JsonValue const& properties);
functionConstexprSpecifierFromJson
SgFunctionDeclaration::constexpr_specifier_enum functionConstexprSpecifierFromJson( JsonValue const& properties, std::string const& kind);
functionModifierFieldsFromJson
FunctionModifierFields functionModifierFieldsFromJson(NodeRecord const& record);
functionParameterReferenceFromProperties
SgFunctionParameterRefExp* functionParameterReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes);
functionParameterScopeNeedsExternalReferenceRecord
bool functionParameterScopeNeedsExternalReferenceRecord( SgFunctionDeclaration* decl, std::unordered_map<SgNode const*, uint64_t> const& ids);
functionReferenceFromProperties
SgFunctionRefExp* functionReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes);
functionReturnTypeSourceFieldsFromJson
FunctionReturnTypeSourceFields functionReturnTypeSourceFieldsFromJson(JsonValue const& properties);
groupSymbolTablePreferences
SymbolTablePreferenceGroups groupSymbolTablePreferences( std::vector<ExpectedSymbolTablePreference> const& entries, std::optional<bool> case_insensitive = std::nullopt);
hasCheckpointArgument
bool hasCheckpointArgument( SgSourceFile const* file, Checkpoint checkpoint);
hasExternalMarkerAncestor
bool hasExternalMarkerAncestor(SgNode* node);
hex64
std::string hex64(uint64_t value);
idFor
uint64_t idFor( std::unordered_map<SgNode const*, uint64_t> const& ids, SgNode const* node);
ifStatementKindFromJson
SgIfStmt::if_statement_kind_enum ifStatementKindFromJson(JsonValue const& properties);
indent
void indent( std::ostream& out, int level);
initModifierKindFromJson
SgOmpClause::omp_init_modifier_kind_enum initModifierKindFromJson(JsonValue const& properties);
initializeScalarLiteralType
void initializeScalarLiteralType( SgValueExp* value, JsonValue const& properties, NodeMap const& nodes);
initializeTemplateParameterTypes
void initializeTemplateParameterTypes( SgTemplateParameter* parameter, NodeRecord const& record, NodeMap const& nodes);
initializedNameMetadataFromJson
InitializedNameMetadata initializedNameMetadataFromJson(JsonValue const& properties);
initializedNameRolesFromJson
InitializedNameRoles initializedNameRolesFromJson(JsonValue const& properties);
insideCollectionBoundary
bool insideCollectionBoundary(SgNode* node);
installSourcePositions
void installSourcePositions( SgNode* node, SourcePositions positions, std::string const& context);
installTransformationSourcePosition
void installTransformationSourcePosition(SgLocatedNode* node);
integer128ValueFromJson
Rose::Integer128Value integer128ValueFromJson(JsonValue const& json);
isAnonymousDataMemberReference
bool isAnonymousDataMemberReference(SgVarRefExp* ref);
isAstJsonExternalClassDeclaration
bool isAstJsonExternalClassDeclaration(SgClassDeclaration* decl);
isAstJsonExternalFunction
bool isAstJsonExternalFunction(SgFunctionDeclaration* decl);
isAstJsonExternalModule
bool isAstJsonExternalModule(SgModuleStatement* module);
isExternalUseModuleEdge
bool isExternalUseModuleEdge( SgNode* source, SgNode* target, std::string const& field, std::unordered_map<SgNode const*, uint64_t> const& ids);
isJsonBinaryOpKind
bool isJsonBinaryOpKind(std::string const& kind);
isJsonScalarLiteralKind
bool isJsonScalarLiteralKind(std::string const& kind);
isJsonUnaryOpKind
bool isJsonUnaryOpKind(std::string const& kind);
isJsonValueExpressionKind
bool isJsonValueExpressionKind(std::string const& kind);
isRightHandSideOfMemberAccess
bool isRightHandSideOfMemberAccess(SgNode const* node);
isStructuralAstChildOfParent
bool isStructuralAstChildOfParent(SgNode* node);
isTypedefOwnedSourceType
bool isTypedefOwnedSourceType(SgType* base);
jsonString
std::string jsonString(std::string const& input);
kindInVariants
bool kindInVariants( std::string const& kind, VariantVector const& variants);
labelReferenceFromProperties
SgLabelRefExp* labelReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes);
labelSymbolBasisKind
LabelSymbolBasisKind labelSymbolBasisKind(SgLabelSymbol const* symbol);
labelSymbolFieldsFromJson
LabelSymbolFields labelSymbolFieldsFromJson(JsonValue const& json);
labelSymbolScopeForBasis
SgScopeStatement* labelSymbolScopeForBasis(SgNode* basis);
linkDeclarationGroupEdges
void linkDeclarationGroupEdges( AstFileRecord const& ast, NodeMap const& nodes);
linkNodeEdges
void linkNodeEdges( NodeRecord const& record, NodeMap const& nodes);
literalSpellingFormFromJson
SgValueExp::literal_spelling_form_enum literalSpellingFormFromJson(JsonValue const& properties);
literalTokenFieldsFromJson
LiteralTokenFields literalTokenFieldsFromJson(JsonValue const& properties);
mappedNodePointers
NodeIds mappedNodePointers(NodeMap const& nodes);
markAstJsonExternalClassDeclaration
void markAstJsonExternalClassDeclaration( SgClassDeclaration* decl, std::string const& source_file);
markAstJsonExternalFunction
void markAstJsonExternalFunction( SgFunctionDeclaration* decl, std::string const& source_file);
markAstJsonExternalModule
void markAstJsonExternalModule( SgModuleStatement* module, std::string const& source_file);
memberFunctionReferenceFromProperties
SgMemberFunctionRefExp* memberFunctionReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes, SgTypeExpression* type_id);
moduleNameForNode
std::string moduleNameForNode(SgNode* node);
nearestScope
SgScopeStatement* nearestScope(SgNode* node);
newArrayBoundSourceFormFromJson
SgNewExp::array_bound_source_form_enum newArrayBoundSourceFormFromJson(JsonValue const& properties);
newConstructionFieldsFromJson
NewConstructionFields newConstructionFieldsFromJson( JsonValue const& properties, NodeMap const& nodes);
nodeById
SgNode* nodeById( NodeMap const& nodes, uint64_t id);
nodeByIdAs
template<typename T> T* nodeByIdAs( NodeMap const& nodes, uint64_t id);
noexceptFromProperties
SgNoexceptOp* noexceptFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpression* operand);
nonrealReferenceFromProperties
SgNonrealRefExp* nonrealReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes, SgTypeExpression* type_id);
nonrealSymbolForDeclaration
SgNonrealSymbol* nonrealSymbolForDeclaration(SgNonrealDecl* decl);
nullableCxxSourceTypeFromJson
SgType* nullableCxxSourceTypeFromJson( JsonValue const& json, NodeMap const& nodes);
nullableDeclaredExceptionSignatureFromJson
SgFunctionType* nullableDeclaredExceptionSignatureFromJson( JsonValue const& json, NodeMap const& nodes);
nullableFunctionSyntaxTypeFromJson
SgFunctionType* nullableFunctionSyntaxTypeFromJson( JsonValue const& json, NodeMap const& nodes);
nullableTypeFromJson
SgType* nullableTypeFromJson( JsonValue const& json, NodeMap const& nodes);
nullptrValueFromProperties
SgNullptrValExp* nullptrValueFromProperties( JsonValue const& properties, NodeMap const& nodes);
ompClauseFieldsFromJson
OmpClauseFields ompClauseFieldsFromJson(NodeRecord const& record);
ompContextHierarchyVariant
std::optional<VariantT> ompContextHierarchyVariant(std::string const& kind);
ompContextSelectorIdentity
OmpContextSelectorIdentity ompContextSelectorIdentity( SgOmpClause::omp_context_trait_selector_kind_enum kind, SgName const& implementation_name, std::optional<VariantT> construct_kind);
ompDefaultOptionFromJson
SgOmpClause::omp_default_option_enum ompDefaultOptionFromJson(JsonValue const& properties);
ompDeviceTypeKindFromJson
SgOmpClause::omp_when_context_kind_enum ompDeviceTypeKindFromJson( JsonValue const& properties, std::string const& node_kind);
ompDoacrossKindFromJson
SgOmpClause::omp_doacross_kind_enum ompDoacrossKindFromJson(JsonValue const& properties);
opaqueValueFieldsFromJson
OpaqueValueFields opaqueValueFieldsFromJson(JsonValue const& json);
optionsFromCommandLine
Options optionsFromCommandLine(SgSourceFile const* file);
ordinaryOmpVariablesClauseVariant
std::optional<VariantT> ordinaryOmpVariablesClauseVariant(std::string const& kind);
owningProject
SgProject* owningProject(SgSourceFile* file);
parseAstFileJson
AstFileRecord parseAstFileJson( std::string const& json, std::string const& expected_checkpoint);
parseJson
JsonValue parseJson(std::string const& json);
pointerMemberJsonIdentity
uint64_t pointerMemberJsonIdentity(SgPointerMemberType* type);
populateExternalFunctionParameterScopeFromJson
void populateExternalFunctionParameterScopeFromJson( JsonValue const& json, NodeMap const& nodes, SgFunctionParameterScope* scope, SgInitializedNamePtrList const& parameters, std::string const& function_name);
prepareAstAttributes
PreparedAstAttributes prepareAstAttributes(NodeRecord const& record);
prepareExternalSymbolFromJson
std::function<SgSymbol*()> prepareExternalSymbolFromJson( JsonValue const& json, NodeMap const& nodes, SgSymbolTable* owner_table);
preparePreprocessingInfo
PreparedPreprocessingInfo preparePreprocessingInfo(NodeRecord const& record);
prepareSymbolForKindAndBasis
std::function<SgSymbol*()> prepareSymbolForKindAndBasis( VariantT kind, SgNode* basis, JsonValue const& properties);
preprocessingInfoFieldsFromJson
std::vector<PreprocessingInfoFields> preprocessingInfoFieldsFromJson(NodeRecord const& record);
preservedJsonNodeId
uint64_t preservedJsonNodeId(SgNode* node);
preservedPointerMemberJsonIdentity
uint64_t preservedPointerMemberJsonIdentity(SgPointerMemberType const* type);
preservedSemanticArrayJsonIdentity
uint64_t preservedSemanticArrayJsonIdentity(SgArrayType const* type);
preservedSourceTypeJsonIdentity
uint64_t preservedSourceTypeJsonIdentity(SgType const* type);
processId
uint64_t processId();
rawAlignmentSpecifiersJson
std::string rawAlignmentSpecifiersJson( SgAlignmentSpecifierPtrList const& specifiers, SgNode* owner, std::unordered_map<SgNode const*, uint64_t> const& ids);
rawAstAttributesJson
std::string rawAstAttributesJson(SgNode* node);
rawBitVectorJson
std::string rawBitVectorJson(SgBitVector const& bits);
rawBoolField
std::string rawBoolField( std::string const& name, bool value);
rawCanonicalSourceIdentityJson
std::string rawCanonicalSourceIdentityJson( std::optional<SgTemplateParameter::canonical_source_identity> const& identity, char const* owner);
rawExactBoundSymbolRef
std::string rawExactBoundSymbolRef( SgSymbol* symbol, std::unordered_map<SgNode const*, uint64_t> const& ids, SgScopeStatement const* inline_scope = nullptr);
rawExpressionRef
std::string rawExpressionRef( SgExpression* expression, std::unordered_map<SgNode const*, uint64_t> const& ids);
rawExtendedFloatingValue
std::string rawExtendedFloatingValue(Rose::FloatingValue value);
rawExternalClassDeclarationJson
std::string rawExternalClassDeclarationJson(SgClassDeclaration* decl);
rawExternalDeclarationReferenceJson
std::string rawExternalDeclarationReferenceJson( SgDeclarationStatement* decl, SgDeclarationStatement* owner, std::unordered_map<SgNode const*, uint64_t> const& ids);
rawExternalFunctionJson
std::string rawExternalFunctionJson( SgFunctionDeclaration* decl, std::unordered_map<SgNode const*, uint64_t> const& ids, bool force_external = false);
rawExternalFunctionParameterScopeJson
std::string rawExternalFunctionParameterScopeJson( SgFunctionDeclaration* function, SgFunctionParameterScope* scope, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& function_name);
rawExternalInitializedNameJson
std::string rawExternalInitializedNameJson( SgInitializedName* name, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& function_name);
rawExternalModuleJson
std::string rawExternalModuleJson( SgModuleStatement* module, std::unordered_map<SgNode const*, uint64_t> const& ids);
rawExternalUseStatementJson
std::string rawExternalUseStatementJson( SgUseStatement* stmt, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& function_name);
rawExternalVariableDeclarationJson
std::string rawExternalVariableDeclarationJson( SgVariableDeclaration* decl, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& function_name);
rawFileInfoJson
std::string rawFileInfoJson(Sg_File_Info const* info);
rawFloatingValueBits
template<typename Float> std::string rawFloatingValueBits(Float value);
rawFormatDescriptor
std::string rawFormatDescriptor(SgFormatItem::Descriptor const& descriptor);
rawInteger128Value
std::string rawInteger128Value(Rose::Integer128Value value);
rawIntegerField
std::string rawIntegerField( std::string const& name, int64_t value);
rawLocationJson
std::string rawLocationJson(SgNode* node);
rawNodeFlagsJson
std::string rawNodeFlagsJson(SgNode* node);
rawNodeProperties
std::string rawNodeProperties( SgNode* node, std::unordered_map<SgNode const*, uint64_t> const& ids);
rawOptionalUnsignedIntegerField
std::string rawOptionalUnsignedIntegerField( std::string const& name, std::optional<unsigned int> const& value);
rawRequiredLocationJson
std::string rawRequiredLocationJson( SgNode* node, std::string const& context);
rawStringField
std::string rawStringField( std::string const& name, std::string const& value);
rawStringListJson
std::string rawStringListJson(SgStringList const& values);
rawSymbolRef
std::string rawSymbolRef( SgSymbol* symbol, std::unordered_map<SgNode const*, uint64_t> const& ids);
rawSymbolTableJson
std::string rawSymbolTableJson( SgScopeStatement* scope, std::unordered_map<SgNode const*, uint64_t> const& ids);
rawTargetAbiJson
std::string rawTargetAbiJson(SgSourceFile::target_abi_info const& abi);
rawTemplateArgumentListJson
std::string rawTemplateArgumentListJson( SgTemplateArgumentPtrList const& arguments, std::unordered_map<SgNode const*, uint64_t> const& ids);
rawTypeJson
std::string rawTypeJson( SgType* type, std::unordered_map<SgNode const*, uint64_t> const& ids);
rawTypeOwnedExprListExpJson
std::string rawTypeOwnedExprListExpJson( SgExprListExp* expr_list, std::unordered_map<SgNode const*, uint64_t> const& ids);
rawTypeOwnedExpressionListJson
std::string rawTypeOwnedExpressionListJson( SgExpressionPtrList const& expressions, std::unordered_map<SgNode const*, uint64_t> const& ids);
rawTypeOwnedExpressionRef
std::string rawTypeOwnedExpressionRef( SgExpression* expr, std::unordered_map<SgNode const*, uint64_t> const& ids);
rawUnaryTraitEvaluatedValue
std::string rawUnaryTraitEvaluatedValue( std::optional<Rose::Integer128Value> const& value, bool alignment);
rawVisibilitySymbolFields
std::vector<std::string> rawVisibilitySymbolFields( SgSymbol* symbol, std::unordered_map<SgNode const*, uint64_t> const& ids, SgScopeStatement const* inline_scope = nullptr);
readFile
std::string readFile(std::filesystem::path const& path);
rebuildConstructorOnlyNodes
void rebuildConstructorOnlyNodes( AstFileRecord const& ast, NodeMap& nodes);
reconstructSourceFile
SgSourceFile* reconstructSourceFile( AstFileRecord const& ast, SgSourceFile* old_file, NodeMap* restored_nodes = nullptr);
rejectRemovedQualifiedNameState
void rejectRemovedQualifiedNameState(JsonValue const& properties);
replaceFileInProject
void replaceFileInProject( SgSourceFile* old_file, SgSourceFile* new_file);
replaceProjectFiles
void replaceProjectFiles( SgProject* project, uint64_t root_id, uint64_t project_files_id, NodeMap const& original, NodeMap const& restored);
requireFileIdMapping
void requireFileIdMapping( int id, std::string const& filename, std::string const& context);
requireFortranProcedureComponentBinding
void requireFortranProcedureComponentBinding( std::optional<SgInitializedName::FortranProcedureComponentBinding> const& binding, SgType* type, SgScopeStatement* scope);
requireFortranProcedureInterface
void requireFortranProcedureInterface( SgExpression* interface, SgType* type, SgInitializedName::fortran_type_spec_enum spec, SgSymbol* source_symbol);
requireRestoredKind
void requireRestoredKind( SgNode* node, NodeRecord const& record);
requireUnaryTraitResultType
SgType* requireUnaryTraitResultType( SgType* type, std::string const& context);
requiredBaseClassAccessModifier
SgAccessModifier::access_modifier_enum requiredBaseClassAccessModifier( JsonValue const& object, std::string const& field, std::string const& context);
requiredClassType
SgClassDeclaration::class_types requiredClassType( JsonValue const& object, std::string const& context);
requiredClosedEnumRange
template<typename Enum> Enum requiredClosedEnumRange( JsonValue const& object, std::string const& field, std::string const& context, Enum first, Enum last);
requiredDeclarationAccessModifier
SgAccessModifier::access_modifier_enum requiredDeclarationAccessModifier( JsonValue const& object, std::string const& field, std::string const& context);
requiredEnum
template<typename Enum> Enum requiredEnum( JsonValue const& object, std::string const& field, std::string const& context, std::initializer_list<Enum> legal_values, std::string const& field_description = {});
requiredFortranTypeSpec
SgInitializedName::fortran_type_spec_enum requiredFortranTypeSpec( JsonValue const& object, std::string const& context);
requiredGnuDeclarationVisibility
SgDeclarationModifier::gnu_declaration_visibility_enum requiredGnuDeclarationVisibility( JsonValue const& object, std::string const& field, std::string const& context);
requiredIntegerBoolean
bool requiredIntegerBoolean( JsonValue const& object, std::string const& field);
requiredOmpDeclareVariantRegionOrdinal
std::optional<unsigned int> requiredOmpDeclareVariantRegionOrdinal( JsonValue const& properties, std::string const& semantic_function_name, std::string const& context);
requiredOptionalUnsignedInteger
std::optional<unsigned int> requiredOptionalUnsignedInteger( JsonValue const& properties, std::string const& name, std::string const& context);
requiredPositiveId
uint64_t requiredPositiveId( JsonValue const& value, std::string const& context);
requiredPreinitialization
SgInitializedName::preinitialization_enum requiredPreinitialization( JsonValue const& object, std::string const& context);
requiredSingleEdgeTarget
uint64_t requiredSingleEdgeTarget( NodeRecord const& record, std::string const& field);
requiredSourcePositionFieldsFromJson
SourcePositionFields requiredSourcePositionFieldsFromJson( JsonValue const& location, std::string const& context);
requiredSourcePositionsFromJson
SourcePositions requiredSourcePositionsFromJson( JsonValue const& location, std::string const& context);
requiredStorageModifier
SgStorageModifier::storage_modifier_enum requiredStorageModifier( JsonValue const& object, std::string const& field, std::string const& context);
requiredTemplateArgumentType
SgTemplateArgument::template_argument_enum requiredTemplateArgumentType( JsonValue const& object, std::string const& context);
requiredTemplateParameterType
SgTemplateParameter::template_parameter_enum requiredTemplateParameterType( JsonValue const& object, std::string const& context);
requiredTranslationUnitSourceOrder
std::optional<unsigned int> requiredTranslationUnitSourceOrder( JsonValue const& properties, std::string const& context);
requiresDelayedRebuild
bool requiresDelayedRebuild(NodeRecord const& record);
resolveExistingSymbolFromJson
SgSymbol* resolveExistingSymbolFromJson( JsonValue const& json, NodeMap const& nodes);
restoreAvailableAuxiliaryDeclarationOwnership
void restoreAvailableAuxiliaryDeclarationOwnership( AstFileRecord const& ast, NodeMap const& nodes);
restoreAvailableConstructionScopes
void restoreAvailableConstructionScopes( AstFileRecord const& ast, NodeMap const& nodes);
restoreAvailableParentsAndScopes
void restoreAvailableParentsAndScopes( AstFileRecord const& ast, NodeMap const& nodes);
restoreFileIdMapFromMetadata
void restoreFileIdMapFromMetadata(JsonValue const& metadata);
restoreRecordedParentEdges
void restoreRecordedParentEdges( AstFileRecord const& ast, NodeMap const& nodes);
restoreSerializedSymbolTables
void restoreSerializedSymbolTables( AstFileRecord const& ast, NodeMap const& nodes, std::unordered_set<uint64_t> const& scope_ids, SerializedSymbolTableConstruction* construction = nullptr);
restoredExternalClassFromJson
SgClassDeclaration* restoredExternalClassFromJson(JsonValue const& json);
restoredExternalFunctionFromJson
SgFunctionDeclaration* restoredExternalFunctionFromJson(JsonValue const& json);
returnStatementFieldsFromJson
ReturnStatementFields returnStatementFieldsFromJson(JsonValue const& properties);
roundTripSourceFile
SgSourceFile* roundTripSourceFile( SgSourceFile* file, Checkpoint checkpoint);
safeNodeText
std::string safeNodeText(SgNode* node);
sameAstJsonPath
bool sameAstJsonPath( std::string const& lhs, std::string const& rhs);
sanitizePathComponent
std::string sanitizePathComponent(std::string name);
semanticArrayDependenciesReady
bool semanticArrayDependenciesReady( JsonValue const& json, SemanticArrayConstruction const* owner);
semanticArrayJsonIdentity
uint64_t semanticArrayJsonIdentity(SgArrayType* type);
semanticFunctionTypeFromJson
SgFunctionType* semanticFunctionTypeFromJson( JsonValue const& json, NodeMap const& nodes);
semanticFunctionTypeKindFromJson
VariantT semanticFunctionTypeKindFromJson(JsonValue const& json);
semanticSignature
std::string semanticSignature(AstFileRecord const& ast);
semanticSignatureEquals
bool semanticSignatureEquals( AstFileRecord const& ast, std::string const& signature);
singleEdgeTarget
uint64_t singleEdgeTarget( NodeRecord const& record, std::string const& field);
sourceFileMatchesExternalRecord
bool sourceFileMatchesExternalRecord( SgSourceFile* file, std::string const& source_file);
sourceFileNameForExternalFunction
std::string sourceFileNameForExternalFunction(SgFunctionDeclaration* decl);
sourceFileNameForNode
std::string sourceFileNameForNode(SgNode* node);
sourceIsBeingReplaced
bool sourceIsBeingReplaced(SgSourceFile* file);
sourceLocationBuiltinFromProperties
SgSourceLocationBuiltinExp* sourceLocationBuiltinFromProperties( JsonValue const& properties, NodeMap const& nodes);
sourceLocationBuiltinKindFromJson
SgSourceLocationBuiltinExp::source_location_builtin_kind_enum sourceLocationBuiltinKindFromJson(JsonValue const& properties);
sourcePositionsFromJson
SourcePositions sourcePositionsFromJson( JsonValue const& location, bool expression);
sourceTypeJsonIdentity
uint64_t sourceTypeJsonIdentity(SgType* type);
startsWith
bool startsWith( std::string const& s, std::string const& prefix);
statementFieldsFromJson
StatementFields statementFieldsFromJson( NodeRecord const& record, VariantT kind);
storageSizeFromJson
std::optional<long long> storageSizeFromJson( JsonValue const& properties, std::string const& field);
stringListFromJson
SgStringList stringListFromJson( JsonValue const& value, std::string const& context);
structuredBindingKindFromJson
SgInitializedName::structured_binding_kind_enum structuredBindingKindFromJson(JsonValue const& properties);
subobjectDestructionKindFromJson
SgCxxSubobjectDestruction::target_kind_enum subobjectDestructionKindFromJson(JsonValue const& json);
symbolBasis
SgNode const* symbolBasis(SgSymbol const* symbol);
symbolDependencyOrder
std::vector<size_t> symbolDependencyOrder(std::vector<std::optional<size_t>> const& dependencies);
symbolFromJson
SgSymbol* symbolFromJson( JsonValue const& json, NodeMap const& nodes);
symbolIsLookupPreferred
bool symbolIsLookupPreferred( SgSymbolTable* table, SgName const& name, SgSymbol* symbol);
symbolLookupPreferenceCategory
VariantT symbolLookupPreferenceCategory(VariantT kind);
symbolName
std::string symbolName(SgSymbol const* symbol);
symbolTableEntriesFromRecord
std::vector<SerializedSymbolTableEntry> symbolTableEntriesFromRecord(NodeRecord const& record);
symbolVariantFromJsonKind
VariantT symbolVariantFromJsonKind(std::string const& kind);
targetAbiFromJson
SgSourceFile::target_abi_info targetAbiFromJson(JsonValue const& json);
targetSizeTypeFromJson
SgType* targetSizeTypeFromJson( JsonValue const& json, NodeMap const& nodes, bool target_available);
templateArgumentListFromJson
SgTemplateArgumentPtrList templateArgumentListFromJson( JsonValue const& json, NodeMap const& nodes, SgNode* parent);
templateFunctionReferenceFromProperties
SgTemplateFunctionRefExp* templateFunctionReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes);
templateMemberFunctionReferenceFromProperties
SgTemplateMemberFunctionRefExp* templateMemberFunctionReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes, SgTypeExpression* type_id);
templateParameterOperandsFromRecord
TemplateParameterOperands templateParameterOperandsFromRecord( NodeRecord const& record, NodeMap const& nodes, SgTemplateParameter const* owner = nullptr);
templateParameterSourceFieldsFromJson
TemplateParameterSourceFields templateParameterSourceFieldsFromJson(JsonValue const& object);
templateParameterValueFromProperties
SgTemplateParameterVal* templateParameterValueFromProperties( JsonValue const& properties, NodeMap const& nodes);
temporaryWritePath
std::filesystem::path temporaryWritePath(std::filesystem::path const& path);
thisExpressionFromProperties
SgThisExp* thisExpressionFromProperties( JsonValue const& properties, NodeMap const& nodes);
trim
std::string trim(std::string const& input);
typeFromJson
SgType* typeFromJson( JsonValue const& json, NodeMap const& nodes, std::string const& exact_type_error = "AST JSON type requires an exact type");
typeIdFromProperties
SgTypeIdOp* typeIdFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpression* operand, SgType* operand_type, bool operand_is_evaluated);
typeModifierFieldsFromJson
TypeModifierFields typeModifierFieldsFromJson( JsonValue const& json, std::string const& context, std::string const& prefix = "declaration_type");
typeOwnsSourceJsonIdentity
bool typeOwnsSourceJsonIdentity(SgType const* type);
typeRequirementFromProperties
SgTypeRequirement* typeRequirementFromProperties( JsonValue const& properties, NodeMap const& nodes);
typeTraitBuiltinFromProperties
SgTypeTraitBuiltinOperator* typeTraitBuiltinFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpressionPtrList const& arguments);
typedefMetadataFromJson
TypedefMetadata typedefMetadataFromJson(JsonValue const& properties);
unaryConstructionFieldsFromJson
UnaryConstructionFields unaryConstructionFieldsFromJson( JsonValue const& properties, std::string const& kind, NodeMap const& nodes);
unaryTraitEvaluatedValueFromJson
std::optional<Rose::Integer128Value> unaryTraitEvaluatedValueFromJson( JsonValue const& json, bool alignment);
unaryTraitKindFromProperties
SgExpression::unary_type_trait_kind_enum unaryTraitKindFromProperties(NodeRecord const& record);
unaryTraitSourceFieldsFromJson
UnaryTraitSourceFields unaryTraitSourceFieldsFromJson( JsonValue const& properties, std::string const& context);
unsigned64ValueFromJson
uint64_t unsigned64ValueFromJson(JsonValue const& json);
validFortranSeparatePointerOwnership
bool validFortranSeparatePointerOwnership(SgInitializedName const* name);
validateAnonymousDataMemberReferenceQualification
void validateAnonymousDataMemberReferenceQualification(SgVarRefExp* ref);
validateConstructionFlags
NodeConstructionFlags validateConstructionFlags(NodeRecord const& record);
validateExactSemanticExpressionType
void validateExactSemanticExpressionType( SgExpression const* expression, SgType const* type, std::string const& phase);
validateExpressionLifetime
void validateExpressionLifetime( ExpressionConstructionFields const& fields, JsonValue const& properties, NodeMap const& nodes);
validateExternalSymbolBasisOwnership
void validateExternalSymbolBasisOwnership(SgSymbol* symbol);
validateFortranAggregateConstruction
void validateFortranAggregateConstruction(AggregateConstructionFields const& fields);
validateFortranInterfaceFields
void validateFortranInterfaceFields(FortranInterfaceFields const& fields);
validateFortranProgramNameMetadata
void validateFortranProgramNameMetadata( std::string const& opening_name, int64_t statement_kind, bool named_in_end_statement, std::string const& end_statement_name);
validateFunctionCallInputs
void validateFunctionCallInputs( FunctionCallSourceFields const& fields, SgExpression* function, SgExprListExp* arguments, SgType* type, SgCxxLiteralTokenList* literal_tokens, size_t argument_count, size_t token_count);
validateLabelSymbolFields
void validateLabelSymbolFields( SgLabelSymbol const* symbol, JsonValue const& json);
validateNamespaceSymbolKey
void validateNamespaceSymbolKey( SgName const& entry_name, SgNode* basis);
validateNonrealResolvedTargetIdentity
template<typename Identity> void validateNonrealResolvedTargetIdentity( Identity function, Identity variable, Identity spelling_target);
validateOmpContextKindAny
void validateOmpContextKindAny( bool has_any, size_t property_count, size_t selector_count);
validateOmpContextPropertyPayload
void validateOmpContextPropertyPayload( bool has_expression, SgOmpClause::omp_when_context_kind_enum kind, SgOmpClause::omp_when_context_vendor_enum vendor, SgOmpClause::omp_atomic_default_mem_order_kind_enum atomic_order, SgOmpClause::omp_requires_property_kind_enum requires_kind, SgOmpClause::omp_atomic_default_mem_order_kind_enum requires_atomic_order, bool has_requires_expression, bool has_requires_extension);
validateOmpContextPropertySelectorKind
void validateOmpContextPropertySelectorKind( SgOmpClause::omp_context_trait_selector_kind_enum selector_kind, bool has_expression, SgOmpClause::omp_when_context_kind_enum kind, SgOmpClause::omp_when_context_vendor_enum vendor, SgOmpClause::omp_atomic_default_mem_order_kind_enum atomic_order, SgOmpClause::omp_requires_property_kind_enum requires_kind);
validateOmpContextSelector
void validateOmpContextSelector(SgOmpContextSelector const* selector);
validateOmpContextSelectorPayload
void validateOmpContextSelectorPayload( SgOmpClause::omp_context_trait_selector_kind_enum kind, SgName const& implementation_name, SgExpression* score, SgStatement* construct_directive, SgOmpContextSelectorPropertyPtrList const& properties);
validateOmpContextSelectorProperty
void validateOmpContextSelectorProperty( SgOmpContextSelectorProperty const* property, SgOmpContextSelector const* selector);
validateOmpContextSelectorPropertyPayload
OmpContextPropertyIdentity validateOmpContextSelectorPropertyPayload( SgOmpContextSelectorProperty const* property, SgOmpClause::omp_context_trait_selector_kind_enum selector_kind);
validateOmpContextSelectorSet
void validateOmpContextSelectorSet(SgOmpContextSelectorSet const* set);
validateOmpContextSelectorSetPayload
void validateOmpContextSelectorSetPayload( SgOmpClause::omp_context_selector_set_kind_enum kind, SgOmpContextSelectorPtrList const& selectors);
validateOmpContextSelectorSets
void validateOmpContextSelectorSets( SgOmpContextSelectorSetPtrList const& sets, SgNode const* owner);
validateOmpContextSelectorSetsPayload
void validateOmpContextSelectorSetsPayload(SgOmpContextSelectorSetPtrList const& sets);
validateOmpContextSelectorShape
void validateOmpContextSelectorShape( SgOmpClause::omp_context_trait_selector_kind_enum kind, SgName const& implementation_name, bool has_score, bool has_construct, size_t property_count);
validateOmpContextTraitInSet
void validateOmpContextTraitInSet( SgOmpClause::omp_context_selector_set_kind_enum set_kind, SgOmpClause::omp_context_trait_selector_kind_enum selector_kind);
validateParentChains
void validateParentChains(AstFileRecord const& ast);
validateReconstructedTypesAndSymbols
void validateReconstructedTypesAndSymbols( AstFileRecord const& ast, NodeMap const& nodes);
validateRestoredOmpOwnedClausePayloads
void validateRestoredOmpOwnedClausePayloads( AstFileRecord const& ast, NodeMap const& nodes);
validateSourcePositionRecord
SourcePositionFields validateSourcePositionRecord(NodeRecord const& record);
validateSymbolTablePreferenceGroups
void validateSymbolTablePreferenceGroups( std::vector<ExpectedSymbolTablePreference> const& entries, std::optional<bool> case_insensitive = std::nullopt);
validateSymbolTablePreferences
void validateSymbolTablePreferences(std::vector<ExpectedSymbolTablePreference> const& entries);
validateTemplateParameterContract
void validateTemplateParameterContract( SgTemplateParameter const* parameter, std::string const& context);
validateTypedefBaseShape
void validateTypedefBaseShape(JsonValue const& properties);
validatedExpressionTypeProperty
JsonValue const* validatedExpressionTypeProperty(NodeRecord const& record);
varArgFromProperties
SgVarArgOp* varArgFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpression* operand);
varRefSymbolDeclarationId
uint64_t varRefSymbolDeclarationId( SgVarRefExp* ref, std::unordered_map<SgNode const*, uint64_t> const& ids);
variableReferenceFromProperties
SgVarRefExp* variableReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes);
writeBoolField
void writeBoolField( std::ostream& out, int level, char const* name, bool value, bool comma = true);
writeFile
void writeFile( std::filesystem::path const& path, std::string const& content);
writeFileIdMapJson
void writeFileIdMapJson( std::ostream& out, int level, bool comma = true);
writeFileInfoJson
void writeFileInfoJson( std::ostream& out, int level, Sg_File_Info const* info, bool comma = true);
writeIntegerField
void writeIntegerField( std::ostream& out, int level, char const* name, int64_t value, bool comma = true);
writeJson
void writeJson( std::ostream& out, SgNode* root, Checkpoint checkpoint, SgSourceFile* file, SgFileList* project_files = nullptr, NodeMap* serialized_nodes = nullptr);
writeNodeJson
void writeNodeJson( std::ostream& out, SgNode* node, std::unordered_map<SgNode const*, uint64_t> const& ids, bool comma);
writeProjectJson
void writeProjectJson( SgProject* project, std::string const& path, Options const& options);
writeRawObject
void writeRawObject( std::ostream& out, int level, std::vector<std::string> const& fields, bool comma = true);
writeSemanticSignature
void writeSemanticSignature( std::ostream& out, AstFileRecord const& ast);
writeSourceFileJson
void writeSourceFileJson( SgSourceFile* file, Checkpoint checkpoint, std::string const& path, Options const& options);
writeStringField
void writeStringField( std::ostream& out, int level, char const* name, std::string const& value, bool comma = true);
writeToString
std::string writeToString(std::function<void(std::ostream&)> const& write);
operator<<
std::ostream& operator<<( std::ostream& out, JsonKey const& key);
Stream insertion operator
operator==
bool operator==( JsonKey const& lhs, char const* rhs);
Equality operators
operator!=
bool operator!=( JsonKey const& lhs, char const* rhs);
Inequality operators

Rose::Builder::Templates

Name
buildTemplateArgument
SgTemplateArgument* buildTemplateArgument(bool v);
instantiateNonrealRefExps
SgExpression* instantiateNonrealRefExps( SgExpression* expr, std::vector<SgTemplateParameter*>& tpl_params, std::vector<SgTemplateArgument*>& tpl_args);
instantiateNonrealTypes
SgType* instantiateNonrealTypes( SgType* type, std::vector<SgTemplateParameter*>& tpl_params, std::vector<SgTemplateArgument*>& tpl_args, SgScopeStatement* semantic_receiver_scope);

Rose::BuiltinOperands

Name
haveExclusiveOwnership
bool haveExclusiveOwnership( SgExpressionPtrList const& arguments, SgNode* owner);
haveValidRoles
bool haveValidRoles( SgTypeTraitBuiltinOperator::builtin_operator_kind_enum kind, SgName const& name, SgExpressionPtrList const& arguments);
isTypeOperand
bool isTypeOperand(SgExpression* argument);
isValueOperand
bool isValueOperand(SgExpression* argument);

Rose::ClangFrontend

Name
canonical_function_identity
SgFunctionDeclaration* canonical_function_identity(SgFunctionDeclaration* decl);
requireChooseExprOperands
ChooseExprOperands requireChooseExprOperands(clang::ChooseExpr* expression);
requireExactPredefinedIdentifierType
void requireExactPredefinedIdentifierType( SgInitializedName* name, SgType* expected_type);

Rose::Cmdline

Name Description
NormalizeIncludePathOptions
std::vector<std::string> NormalizeIncludePathOptions(std::vector<std::string>& argv);
Convert -I <path> to -I<path>
normalizeAndAppendIncludeOption
template< typename IndexType, typename CountType, typename NextArgumentProvider> IncludeOptionParseResult normalizeAndAppendIncludeOption( std::string const& current_arg, IndexType& index, CountType arg_count, NextArgumentProvider&& next_argument, std::vector<std::string>& output_args);

Rose::Cmdline::Fortran

Name Description
Process
void Process( SgProject* project, std::vector<std::string>& argv);
Process all Fortran commandline options.
ProcessFortranOnly
void ProcessFortranOnly( SgProject* project, std::vector<std::string>& argv);

Rose::Cmdline::Gnu

Name
Process
void Process( SgProject* project, std::vector<std::string>& argv);
ProcessParam
void ProcessParam( SgProject* project, std::vector<std::string>& argv);

Rose::Cmdline::Unparser

Name Description
Process
void Process( SgProject* project, std::vector<std::string>& argv);
Process all Unparser-specific commandline options, i.e. -rose:unparser.
ProcessClobberInputFile
void ProcessClobberInputFile( SgProject* project, std::vector<std::string>& argv);
StripRoseOptions
void StripRoseOptions(std::vector<std::string>& argv);

Rose::FileSystem

Name Description
copyFile
[[visibility("default")]] void copyFile( Path const& sourceFileName, Path const& destinationFileName);
Copy a file.
copyFiles
[[visibility("default")]] void copyFiles( std::vector<Path> const& files, Path const& root, Path const& destinationDirectory);
Copy files from one directory to another.
copyFilesRecursively
template< class Select, class Descend> void copyFilesRecursively( Path const& root, Path const& destination, Select select, Descend descend);
Recursively copy files.
createTemporaryDirectory
[[visibility("default")]] Path createTemporaryDirectory();
Create a temporary directory.
findNames
[[visibility("default")]] std::vector<Path> findNames(Path const& root);
Entries within a directory.
findNamesRecursively
[[visibility("default")]] std::vector<Path> findNamesRecursively(Path const& root);
Recursive list of names satisfying predicate.
findRoseFilesRecursively
[[visibility("default")]] std::vector<Path> findRoseFilesRecursively(Path const& root);
Return a list of all rose_* files
isDirectory
[[visibility("default")]] bool isDirectory(Path const& path);
Predicate returning true for existing directories.
isExisting
[[visibility("default")]] bool isExisting(Path const& path);
Predicate returning true if path exists.
isFile
[[visibility("default")]] bool isFile(Path const& path);
Predicate returning true for existing regular files.
isNotSymbolicLink
[[visibility("default")]] bool isNotSymbolicLink(Path const& path);
Predicate returning inverse of isSymbolicLink.
isSymbolicLink
[[visibility("default")]] bool isSymbolicLink(Path const& path);
Predicate returning true for existing symbolic links.
makeAbsolute
[[visibility("default")]] Path makeAbsolute( Path const& path, Path const& root = std::filesystem::current_path());
Make path absolute.
makeNormal
[[visibility("default")]] Path makeNormal(Path const&);
Normalize a path name.
makeRelative
[[visibility("default")]] Path makeRelative( Path const& path, Path const& root = std::filesystem::current_path());
Make path relative.
readFile
template<class Container> Container readFile( std::filesystem::path const& fileName, std::ios_base::openmode openMode = std::ios_base::in | std::ios_base::binary);
Load an entire file into an STL container.
toString
[[visibility("default")]] std::string toString(Path const& path);
Convert a path to a string.
writeFile
template<class Container> void writeFile( std::filesystem::path const& fileName, Container const& data, std::ios_base::openmode openMode = std::ios_base::out | std::ios_base::binary);
Write a container to a file.

Rose::FortranLex

Name
BlankBytes
int BlankBytes(char const* p);
SpaceBytes
int SpaceBytes(char const* p);

Rose::FortranLineWrapSupport

Name
isCommentLine
bool isCommentLine(std::string const& text);
isFixedFormatCommentLine
bool isFixedFormatCommentLine(std::string const& text);
stringLiteralLexicalBoundaries
std::vector<size_t> stringLiteralLexicalBoundaries( std::string const& literal, char delimiter);
wrapFixedFormatComment
std::vector<std::string> wrapFixedFormatComment( std::string const& text, int first_line_used_columns, int usable_columns);
wrapFreeFormatComment
std::vector<std::string> wrapFreeFormatComment( std::string const& text, int first_line_used_columns, int usable_columns);

Rose::FortranSource

Name
prepareEdit
void prepareEdit( SgSourceFile*, EditReason, std::vector<SgLocatedNode const*> const& syntax, std::vector<SgStatement const*> const& consumedBodies = {});
preparePairedBoundary
void preparePairedBoundary( SgLocatedNode* begin, SgLocatedNode* end);
selectedOutput
bool selectedOutput(SgSourceFile const*);
validate
void validate(SgSourceFile const*);
validateSelectedPragma
void validateSelectedPragma(SgPragmaDeclaration const*);

Rose::Frontend

Name
Run
int Run(SgProject* project);
RunSerial
int RunSerial(SgProject* project);

Rose::MemPool

Name
snapshot
void snapshot(std::ostream&);

Rose::OpenMP

Name
isNonnegativeConstantInteger
bool isNonnegativeConstantInteger(SgExpression* expression);

Rose::OpenMP::Detail

Name
initModifierContextForClause
bool initModifierContextForClause( SgOmpInitClause* clause, InitModifierContext* context, std::string* detail);
isDepinfoModifier
bool isDepinfoModifier(SgOmpClause::omp_init_modifier_kind_enum kind);
modifierValidationFailure
bool modifierValidationFailure( std::string* detail, std::string const& message);
validApplyTransformationFields
bool validApplyTransformationFields( SgOmpClause::omp_apply_transform_kind_enum kind, std::string const& name, bool has_argument, bool has_nested);
validInductionItemFields
bool validInductionItemFields( SgOmpClause::omp_induction_item_kind_enum kind, std::string const& label);
validMapDistDataPolicyFields
bool validMapDistDataPolicyFields( SgOmpClause::omp_map_dist_data_enum kind, bool has_expression);
validMapDistDataPolicyPayload
bool validMapDistDataPolicyPayload(SgOmpMapDistDataPolicy const* policy);
validateAdjustArgsClause
bool validateAdjustArgsClause( SgOmpAdjustArgsClause* clause, std::string* detail);
validateAppendArgsClause
bool validateAppendArgsClause( SgOmpAppendArgsClause* clause, std::string* detail);
validateInitClause
bool validateInitClause( SgOmpInitClause* clause, std::string* detail);
validateInitModifierComposition
bool validateInitModifierComposition( SgOmpInitModifierPtrList const& modifiers, InitModifierContext context, std::string* detail);
validateInitModifierExpression
bool validateInitModifierExpression( SgOmpClause::omp_init_modifier_kind_enum kind, SgExpression* expression, std::string* detail);
validateInitModifierList
bool validateInitModifierList( SgOmpInitModifierList* modifier_list, SgNode* expected_parent, InitModifierContext context, std::string* detail);
validateInitModifierPayload
bool validateInitModifierPayload( SgOmpInitModifier* modifier, SgNode* expected_parent, std::string* detail);
validateMapModifiers
bool validateMapModifiers( std::array<SgOmpClause::omp_map_modifier_enum, 3> const& modifiers, MapModifierFields& fields, std::string* detail);

Rose::StringUtility

Name Description
addrToString
[[visibility("default")]] std::string addrToString( uint64_t value, size_t nbits = 0);
Convert a virtual address to a string.
bourneEscape
[[visibility("default")]] std::string bourneEscape(std::string const&);
Escapes characters that are special to the Bourne shell.
cEscape
[[visibility("default")]] std::string cEscape( char, char context = '\'');
Escapes characters that are special to C/C++.
cUnescape
[[visibility("default")]] std::string cUnescape(std::string const&);
Unescapes C++ string literals.
centerJustify
[[visibility("default")]] std::string centerJustify( std::string const& input, size_t width, char fill = ' ');
Center a string in a field.
classifyFileName
[[visibility("default")]] FileNameClassification classifyFileName( std::string const& fileName, std::string const& appPath);
Determine whether a file is source code or system library.
convertToLowerCase
[[visibility("default")]] std::string convertToLowerCase(std::string const& inputString);
Convert to lower case.
copyEdit
[[visibility("default")]] FileWithLineNumbers copyEdit( FileWithLineNumbers const& inputString, std::string const& oldToken, FileWithLineNumbers const& newToken);
Replace all occurrences of a string with another string.
csvEscape
[[visibility("default")]] std::string csvEscape(std::string const&);
Escapes characters that are special in CSV tables.
decode_base64
[[visibility("default")]] std::vector<uint8_t> decode_base64(std::string const& encoded);
Convert base-64 to binary.
directoryDistance
[[visibility("default")]] int directoryDistance( std::string const& left, std::string const& right);
Edit distance between two directory names.
encode_base64
[[visibility("default")]] std::string encode_base64( std::vector<uint8_t> const& data, bool do_pad = true);
Convert binary data to base-64.
escapeNewlineAndDoubleQuoteCharacters
[[visibility("default")]] std::string escapeNewlineAndDoubleQuoteCharacters(std::string const&);
Escapes line feeds as l and double quotes for DOT labels.
fileNameSuffix
[[visibility("default")]] std::string fileNameSuffix(std::string const& fileName);
Get the file name suffix (extension) without the leading dot.
fixLineTermination
[[visibility("default")]] std::string fixLineTermination(std::string const& input);
Normalizes line termination.
getAbsolutePathFromRelativePath
[[visibility("default")]] std::string getAbsolutePathFromRelativePath(std::string const& relativePath);
Get the canonical absolute path of an existing filesystem entry.
getOSType
[[visibility("default")]] OSType getOSType();
Obtain operating system type information.
getPathFromFileName
[[visibility("default")]] std::string getPathFromFileName(std::string const& fileNameWithPath);
Returns all but the last component of a path in a filesystem.
hexadecimalToInt
[[visibility("default")]] unsigned int hexadecimalToInt(char);
Convert an ASCII hexadecimal character to an integer.
htmlEscape
[[visibility("default")]] std::string htmlEscape(std::string const&);
Escapes HTML special characters.
intToHex
[[visibility("default")]] std::string intToHex(uint64_t);
Convert an integer to a hexadecimal string.
isContainedIn
bool isContainedIn( std::string const& longString, std::string const& shortString);
Determines whether one string contains another.
isLineTerminated
[[visibility("default")]] bool isLineTerminated(std::string const& s);
Returns true if the string ends with line termination.
join
template<class Container> std::string join( char separator, Container const& container);
join_range
template<class Iterator> std::string join_range( std::string const& separator, Iterator begin, Iterator end);
Join individual items to form a single string.
jsonEscape
[[visibility("default")]] std::string jsonEscape(std::string const&);
Escapes characters that are special inside a JSON string.
leftJustify
[[visibility("default")]] std::string leftJustify( std::string const& input, size_t width, char fill = ' ');
Left justify a string to specified width.
listToString
[[visibility("default")]] std::string listToString( std::list<int> const&, bool separateStrings = false);
listToString overloads
makeOneLine
[[visibility("default")]] std::string makeOneLine( std::string const& s, std::string replacement = " ");
Converts a multi-line string to a single line.
numberToString
[[visibility("default")]] std::string numberToString(__int128 x);
numberToString overloads
operator+
FileWithLineNumbers operator+( FileWithLineNumbers const& a, FileWithLineNumbers const& b);
Concatenate vectors of strings with source location.
operator+=
FileWithLineNumbers& operator+=( FileWithLineNumbers& a, FileWithLineNumbers const& b);
Append strings with source location information to vector of such.
prefixLines
[[visibility("default")]] std::string prefixLines( std::string const& lines, std::string const& prefix, bool prefixAtFront = true, bool prefixAtBack = false);
Insert a prefix string before every line.
readFile
[[visibility("default")]] std::string readFile(std::string const& fileName);
Reads entire text file.
readFileWithPos
[[visibility("default")]] FileWithLineNumbers readFileWithPos(std::string const& fileName);
Reads an entire text file.
removeAnsiEscapes
[[visibility("default")]] std::string removeAnsiEscapes(std::string const&);
Remove ANSI escape characters.
removeRedundantSubstrings
[[visibility("default")]] std::string removeRedundantSubstrings(std::string const&);
Remove redundant and blank lines.
replaceAllCopy
[[visibility("default")]] std::string replaceAllCopy( std::string const& input, std::string const& search, std::string const& replacedWith);
Replace every occurrence of a nonempty pattern in a string.
rightJustify
[[visibility("default")]] std::string rightJustify( std::string const& input, size_t width, char fill = ' ');
Right justify a string to specified width.
signedToHex
template<typename T> std::string signedToHex(T value);
signedToHex2
[[visibility("default")]] std::string signedToHex2( uint64_t value, size_t nbits);
split
[[visibility("default")]] std::vector<std::string> split( char separator, std::string const& str, size_t maxparts = UNLIMITED, bool trim_white_space = false);
Splits strings into parts.
splitStringIntoStrings
[[visibility("default")]] void splitStringIntoStrings( std::string const& inputString, char separator, std::vector<std::string>& stringList);
Splits string into substring based on a separator character.
stringToList
[[visibility("default")]] std::list<std::string> stringToList(std::string const&);
Split a string into substrings at line feeds.
stripDotsFromHeaderFileName
[[visibility("default")]] std::string const stripDotsFromHeaderFileName(std::string const& name);
Remove leading dots.
stripFileSuffixFromFileName
[[visibility("default")]] std::string stripFileSuffixFromFileName(std::string const& fileNameWithSuffix);
Get the file name without the ".suffix".
stripPathFromFileName
[[visibility("default")]] std::string stripPathFromFileName(std::string const& fileNameWithPath);
Returns the last component of a path in a filesystem.
toHex2
[[visibility("default")]] std::string toHex2( uint64_t value, size_t nbits, bool show_unsigned_decimal = true, bool show_signed_decimal = true, uint64_t decimal_threshold = 256);
Convert a number to a hexadecimal and decimal string.
toNumber
template<typename T> NumberParseResult<T> toNumber(std::string const& input);
toString
[[visibility("default")]] std::string toString( FileWithLineNumbers const& strings, std::string const& filename = "<unknown>", int line = 1);
Generate C preprocessor #line directives.
tokenize
[[visibility("default")]] std::list<std::string> tokenize( std::string const&, char delim);
Split a string into a list based on a separator character.
trim
[[visibility("default")]] std::string trim( std::string const& str, std::string const& strip = " \t\r\n", bool at_beginning = true, bool at_end = true);
Trims white space from the beginning and end of a string.
unsignedToHex
template<typename T> std::string unsignedToHex(T value);
unsignedToHex2
[[visibility("default")]] std::string unsignedToHex2( uint64_t value, size_t nbits);
writeFile
[[visibility("default")]] void writeFile( std::string const& outputString, std::string const& fileNameString, std::string const& directoryName);
Create a file.
operator<<
std::ostream& operator<<( std::ostream& os, StringWithLineNumber const& s);
Stream insertion operators

Rose::TestOutput

Name
resolvePath
std::string resolvePath(std::string const& filename);

Rose::TestOutput::detail

Name
defaultOutputDir
std::string defaultOutputDir();
isWithinTree
bool isWithinTree( std::filesystem::path const& root, std::filesystem::path const& candidate);
normalizePath
std::filesystem::path normalizePath(std::filesystem::path const& path);

SageBuilder

Name Description
adoptFunctionDeclaratorScope
[[visibility("default")]] void adoptFunctionDeclaratorScope( SgFunctionDeclaration* owner, SgDeclarationScope* scope);
Transfer one detached signature scope to its exact function owner.
adoptSourceDeclaratorScope
[[visibility("default")]] void adoptSourceDeclaratorScope( SgDeclarationStatement* owner, SgDeclarationScope* scope);
Transfer a detached declarator-local source scope to its exact non-function declaration owner. The scope's declarations keep their independent semantic symbol scopes; only structural source ownership changes.
attachAuxiliaryDeclaration
[[visibility("default")]] void attachAuxiliaryDeclaration( SgScopeStatement* owner, SgDeclarationStatement* declaration);
Own a semantic-only declaration without adding it to source emission.
attachSemanticDeclarationScope
[[visibility("default")]] void attachSemanticDeclarationScope( SgScopeStatement* owner, SgDeclarationScope* scope);
Attach semantic-only declaration-scope infrastructure to its exact structural owner. Both the container and scope must already carry exact semantic provenance; this operation never publishes a physical output owner or reclassifies their subtree.
attachSourceDeclaratorTag
[[visibility("default")]] void attachSourceDeclaratorTag( SgDeclarationScope* owner, SgDeclarationStatement* declaration);
Attach a fresh source-written class/enum declaration to its exact function declarator scope without changing its semantic symbol scope. This is the construction-time structural transaction used by Clang TypeLoc producers; it does not synthesize source provenance or transfer an existing owner.
beginSourceDeclaratorScopeConstruction
[[visibility("default")]] void beginSourceDeclaratorScopeConstruction( SgDeclarationStatement* owner, SgDeclarationScope* scope);
Begin construction of a non-function declaration whose TypeLoc owns nested source-written tags. Both nodes must be fresh and the scope must be empty; finishSourceDeclaratorScopeConstruction() hard-validates the populated source children before the declaration can be published.
buildActualArgumentExpression_nfi
SgActualArgumentExpression* buildActualArgumentExpression_nfi( SgName arg_name, SgExpression* arg);
Build an Actual Argument Expression
buildAddOp
[[visibility("default")]] SgAddOp* buildAddOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildAddOp_nfi
[[visibility("default")]] SgAddOp* buildAddOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildAddressOfOp
[[visibility("default")]] SgAddressOfOp* buildAddressOfOp( SgExpression* operand, SgType* type, SgAddressOfOp::address_operand_form_enum form);
buildAddressOfOp_nfi
[[visibility("default")]] SgAddressOfOp* buildAddressOfOp_nfi( SgExpression* operand, SgType* type, SgAddressOfOp::address_operand_form_enum form);
buildAddressOfResultType
[[visibility("default")]] SgPointerType* buildAddressOfResultType(SgType* operand_type);
Build the exact semantic result type of applying unary '&' to an expression of operand_type. C++ reference declarations denote their referred-to object in an expression, so this never constructs the illegal pointer-to-reference type.
buildAggregateInitializer
[[visibility("default")]] SgAggregateInitializer* buildAggregateInitializer( SgExprListExp* initializers, SgType* type, SgAggregateInitializer::aggregate_initializer_source_form_enum source_form);
Build an aggregate initializer
buildAggregateInitializer_nfi
[[visibility("default")]] SgAggregateInitializer* buildAggregateInitializer_nfi( SgExprListExp* initializers, SgType* type, SgAggregateInitializer::aggregate_initializer_source_form_enum source_form);
buildAlignOfOp
[[visibility("default")]] SgAlignOfOp* buildAlignOfOp( SgExpression* exp, SgType* expression_type, SgExpression::unary_type_trait_kind_enum operator_kind = SgExpression::e_preferred_alignof, std::optional<Rose::Integer128Value> evaluated_value = std::nullopt);
buildAlignOfOp overloads
buildAlignOfOp_nfi
[[visibility("default")]] SgAlignOfOp* buildAlignOfOp_nfi( SgExpression* exp, SgType* expression_type, SgExpression::unary_type_trait_kind_enum operator_kind = SgExpression::e_preferred_alignof, std::optional<Rose::Integer128Value> evaluated_value = std::nullopt);
buildAndAssignOp
[[visibility("default")]] SgAndAssignOp* buildAndAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildAndAssignOp_nfi
[[visibility("default")]] SgAndAssignOp* buildAndAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildAndOp
[[visibility("default")]] SgAndOp* buildAndOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildAndOp_nfi
[[visibility("default")]] SgAndOp* buildAndOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildAnonymousStructDeclaration
[[visibility("default")]] SgClassDeclaration* buildAnonymousStructDeclaration( declaration_ownership const& ownership, SgName const& internalName, SgScopeStatement* scope);
Build a source-anonymous structure with an explicit, non-empty semantic identity. The internal name is never emitted as source.
buildArrayType
[[visibility("default")]] SgArrayType* buildArrayType( SgType* base_type, SgExprListExp* dim_info);
buildArrayType overloads
buildArrowExp
[[visibility("default")]] SgArrowExp* buildArrowExp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildArrowExp_nfi
[[visibility("default")]] SgArrowExp* buildArrowExp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildArrowStarOp
[[visibility("default")]] SgArrowStarOp* buildArrowStarOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildArrowStarOp_nfi
[[visibility("default")]] SgArrowStarOp* buildArrowStarOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildAsmStatement
[[visibility("default")]] SgAsmStmt* buildAsmStatement(std::string s);
Build an asm statement
buildAssignInitializer
[[visibility("default")]] SgAssignInitializer* buildAssignInitializer( SgExpression* operand_i, SgType* expression_type);
Build the rhs of a variable declaration which includes an assignment
buildAssignInitializer_nfi
[[visibility("default")]] SgAssignInitializer* buildAssignInitializer_nfi( SgExpression* operand_i, SgType* expression_type);
buildAssignOp
[[visibility("default")]] SgAssignOp* buildAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildAssignOp_nfi
[[visibility("default")]] SgAssignOp* buildAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildAssignStatement
[[visibility("default")]] SgExprStatement* buildAssignStatement( SgExpression* lhs, SgExpression* rhs);
Build an assignment statement from lefthand operand and right hand operand
buildAttributeSpecificationStatement
[[visibility("default")]] SgAttributeSpecificationStatement* buildAttributeSpecificationStatement( SgAttributeSpecificationStatement::attribute_spec_enum kind, SgDataStatementGroupPtrList const& groups = {});
Build Fortran attribute specification statement
buildAttributeSpecificationStatement_nfi
[[visibility("default")]] SgAttributeSpecificationStatement* buildAttributeSpecificationStatement_nfi( SgAttributeSpecificationStatement::attribute_spec_enum kind, SgDataStatementGroupPtrList const& groups = {});
Build a source-backed Fortran attribute specification statement whose exact file information will be published by the frontend.
buildAutoType
[[visibility("default")]] SgAutoType* buildAutoType();
buildAwaitExpression_nfi
[[visibility("default")]] SgAwaitExpression* buildAwaitExpression_nfi( SgExpression* value, SgType* result_type, SgAwaitExpression::coroutine_keyword_kind_enum keyword);
buildBFloat16Type
[[visibility("default")]] SgTypeBFloat16* buildBFloat16Type();
buildBFloat16Val
[[visibility("default")]] SgBFloat16Val* buildBFloat16Val(float v = 0);
Build a bfloat16
buildBFloat16Val_nfi
[[visibility("default")]] SgBFloat16Val* buildBFloat16Val_nfi( float v, std::string const& str);
buildBaseClass
[[visibility("default")]] SgBaseClass* buildBaseClass( SgClassDeclaration* classDeclaration, SgType* sourceType, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect, SgSymbol* fortranSourceSymbol = nullptr);
buildBasicBlock
[[visibility("default")]] SgBasicBlock* buildBasicBlock( SgStatement* stmt1 = NULL, SgStatement* stmt2 = NULL, SgStatement* stmt3 = NULL, SgStatement* stmt4 = NULL, SgStatement* stmt5 = NULL, SgStatement* stmt6 = NULL, SgStatement* stmt7 = NULL, SgStatement* stmt8 = NULL, SgStatement* stmt9 = NULL, SgStatement* stmt10 = NULL);
Build a SgBasicBlock, setting file info internally
buildBasicBlock_nfi
[[visibility("default")]] SgBasicBlock* buildBasicBlock_nfi();
Build a SgBasicBlock and set its parent. This function does NOT link the parent scope to the block.
buildBinaryConditionalExp
[[visibility("default")]] SgConditionalExp* buildBinaryConditionalExp( SgExpression* common, SgExpression* false_expression, SgType* result_type);
Build the GNU omitted-middle conditional common ?: false_expression. The common operand is represented once and therefore evaluated once.
buildBinaryConditionalExp_nfi
SgConditionalExp* buildBinaryConditionalExp_nfi( SgExpression* common, SgExpression* false_expression, SgType* result_type);
buildBinaryExpression
template<class T> T* buildBinaryExpression( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildBinaryExpression_nfi
template< class T, class... Args> T* buildBinaryExpression_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type, Args&&... args);
buildBitAndOp
[[visibility("default")]] SgBitAndOp* buildBitAndOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildBitAndOp_nfi
[[visibility("default")]] SgBitAndOp* buildBitAndOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildBitComplementOp
[[visibility("default")]] SgBitComplementOp* buildBitComplementOp( SgExpression* op, SgType* result_type);
buildBitComplementOp_nfi
[[visibility("default")]] SgBitComplementOp* buildBitComplementOp_nfi( SgExpression* op, SgType* result_type);
buildBitOrOp
[[visibility("default")]] SgBitOrOp* buildBitOrOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildBitOrOp_nfi
[[visibility("default")]] SgBitOrOp* buildBitOrOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildBitXorOp
[[visibility("default")]] SgBitXorOp* buildBitXorOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildBitXorOp_nfi
[[visibility("default")]] SgBitXorOp* buildBitXorOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildBoolType
[[visibility("default")]] SgTypeBool* buildBoolType();
buildBoolType overloads
buildBoolValExp
[[visibility("default")]] SgBoolValExp* buildBoolValExp(bool value = 0);
Build a bool value expression.
buildBoolValExp_nfi
[[visibility("default")]] SgBoolValExp* buildBoolValExp_nfi(int value);
buildBracedInitializer
[[visibility("default")]] SgBracedInitializer* buildBracedInitializer( SgExprListExp* initializers, SgType* expression_type);
Build an braced initializer
buildBracedInitializer_nfi
[[visibility("default")]] SgBracedInitializer* buildBracedInitializer_nfi( SgExprListExp* initializers, SgType* expression_type);
buildBreakStmt
[[visibility("default")]] SgBreakStmt* buildBreakStmt();
Build a break statement
buildBreakStmt_nfi
SgBreakStmt* buildBreakStmt_nfi();
buildCaseOptionStmt
[[visibility("default")]] SgCaseOptionStmt* buildCaseOptionStmt( SgExpression* key = NULL, SgStatement* body = NULL);
Build a case option statement
buildCaseOptionStmt_nfi
SgCaseOptionStmt* buildCaseOptionStmt_nfi( SgExpression* key, SgStatement* body);
buildCastExp
[[visibility("default")]] SgCastExp* buildCastExp( SgExpression* operand_i, SgType* expression_type);
buildCastExp overloads
buildCastExp_nfi
[[visibility("default")]] SgCastExp* buildCastExp_nfi( SgExpression* operand_i, SgType* expression_type);
buildCatchOptionStmt
[[visibility("default")]] SgCatchOptionStmt* buildCatchOptionStmt( SgVariableDeclaration* condition = NULL, SgStatement* body = NULL);
Build a catch statement.
buildCatchOptionStmt_nfi
[[visibility("default")]] SgCatchOptionStmt* buildCatchOptionStmt_nfi( SgVariableDeclaration* condition = NULL, SgStatement* body = NULL);
buildChar16Type
[[visibility("default")]] SgTypeChar16* buildChar16Type();
buildChar16Val
[[visibility("default")]] SgChar16Val* buildChar16Val(unsigned short value = 0);
buildChar16Val_nfi
[[visibility("default")]] SgChar16Val* buildChar16Val_nfi( unsigned short value, std::string const& str);
buildChar32Type
[[visibility("default")]] SgTypeChar32* buildChar32Type();
buildChar32Val
[[visibility("default")]] SgChar32Val* buildChar32Val(unsigned int value = 0);
buildChar32Val_nfi
[[visibility("default")]] SgChar32Val* buildChar32Val_nfi( unsigned int value, std::string const& str);
buildChar8Type
[[visibility("default")]] SgTypeChar8* buildChar8Type();
buildCharType
[[visibility("default")]] SgTypeChar* buildCharType();
buildCharVal
[[visibility("default")]] SgCharVal* buildCharVal(int64_t value = 0);
buildCharVal_nfi
[[visibility("default")]] SgCharVal* buildCharVal_nfi( int64_t value, std::string const& str);
buildChooseExpression_nfi
[[visibility("default")]] SgChooseExpression* buildChooseExpression_nfi( SgExpression* condition, SgExpression* true_expression, SgExpression* false_expression, SgType* result_type, SgChooseExpression::selection_kind_enum selection);
buildClassDeclaration
[[visibility("default")]] SgClassDeclaration* buildClassDeclaration( declaration_ownership const& ownership, SgName name, SgScopeStatement* scope);
Build both nondefining and defining class declarations, in that order.
buildClassDeclarationStatement_nfi
template<class DeclClass> [[visibility("default")]] DeclClass* buildClassDeclarationStatement_nfi( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl);
Build a generic class declaration statement (SgClassDeclaration or subclass) with a class declaration and definition (creating both the defining and nondefining declarations as required.
buildClassDeclaration_nfi
[[visibility("default")]] SgClassDeclaration* buildClassDeclaration_nfi( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList, SgName const* templateInstantiationName);
buildClassDefinition
[[visibility("default")]] SgClassDefinition* buildClassDefinition( SgClassDeclaration* d, bool buildTemplateInstantiation = false);
Build a class definition scope statement
buildClassDefinition_nfi
SgClassDefinition* buildClassDefinition_nfi( SgClassDeclaration* d, bool buildTemplateInstantiation = false);
Build a class definition scope statement
buildClassNameRefExp
[[visibility("default")]] SgClassNameRefExp* buildClassNameRefExp(SgClassSymbol* sym);
buildClassNameRefExp_nfi
SgClassNameRefExp* buildClassNameRefExp_nfi(SgClassSymbol* sym);
buildColonShapeExp
[[visibility("default")]] SgColonShapeExp* buildColonShapeExp();
Build a Fortran colon-shape expression, set file info as the default one.
buildColonShapeExp_nfi
[[visibility("default")]] SgColonShapeExp* buildColonShapeExp_nfi();
No file info version of buildColonShapeExp(). File info is to be set later on.
buildCommaOpExp
[[visibility("default")]] SgCommaOpExp* buildCommaOpExp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildCommaOpExp_nfi
[[visibility("default")]] SgCommaOpExp* buildCommaOpExp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildComment
[[visibility("default")]] PreprocessingInfo* buildComment( SgLocatedNode* target, std::string const& content, PreprocessingInfo::DirectiveType commentStyle, PreprocessingInfo::RelativePositionType position = PreprocessingInfo::before);
Build and attach a comment with an explicit lexical comment style. It is a wrapper of SageInterface::attachComment().
buildCommonBlock
[[visibility("default")]] SgCommonBlock* buildCommonBlock(SgCommonBlockObject* first_block = NULL);
Build a Fortran Common statement
buildCommonBlockObject
[[visibility("default")]] SgCommonBlockObject* buildCommonBlockObject( std::string name = "", SgExprListExp* exp_list = NULL);
Build a Fortran common block, possibly with a name
buildComplexType
[[visibility("default")]] SgTypeComplex* buildComplexType(SgType* base_type = nullptr);
Build a complex type
buildComplexVal
[[visibility("default")]] SgComplexVal* buildComplexVal( SgExpression* real_value, SgExpression* imaginary_value, SgType* precision_type);
buildComplexVal_nfi
[[visibility("default")]] SgComplexVal* buildComplexVal_nfi( SgExpression* real_value, SgExpression* imaginary_value, SgType* precision_type);
buildCompoundLiteralExp
SgCompoundLiteralExp* buildCompoundLiteralExp(SgVariableSymbol* varSymbol);
buildCompoundLiteralExp_nfi
SgCompoundLiteralExp* buildCompoundLiteralExp_nfi(SgVariableSymbol* varSymbol);
Build function for compound literals (uses a SgVariableSymbol and is similar to buildVarRefExp_nfi()).
buildCompoundRequirement_nfi
[[visibility("default")]] SgCompoundRequirement* buildCompoundRequirement_nfi( SgExpression* expression, bool noexcept_required, SgExpression* type_constraint);
buildConcatenationOp
[[visibility("default")]] SgConcatenationOp* buildConcatenationOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildConcatenationOp_nfi
[[visibility("default")]] SgConcatenationOp* buildConcatenationOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildConditionalExp
[[visibility("default")]] SgConditionalExp* buildConditionalExp( SgExpression* test, SgExpression* a, SgExpression* b, SgType* result_type);
Build a conditional expression ?:
buildConditionalExp_nfi
SgConditionalExp* buildConditionalExp_nfi( SgExpression* test, SgExpression* a, SgExpression* b, SgType* t);
buildConjugateOp
[[visibility("default")]] SgConjugateOp* buildConjugateOp( SgExpression* op, SgType* result_type);
buildConjugateOp_nfi
[[visibility("default")]] SgConjugateOp* buildConjugateOp_nfi( SgExpression* op, SgType* result_type);
buildConstType
[[visibility("default")]] SgModifierType* buildConstType(SgType* base_type = nullptr);
Build a const type.
buildConstVolatileModifier
[[visibility("default")]] SgConstVolatileModifier* buildConstVolatileModifier(SgConstVolatileModifier::cv_modifier_enum mtype = SgConstVolatileModifier::e_unknown);
Build a const/volatile type qualifier
buildConstVolatileType
[[visibility("default")]] SgModifierType* buildConstVolatileType(SgType* base_type = nullptr);
Build a const volatile type.
buildConstructorInitializer
[[visibility("default")]] SgConstructorInitializer* buildConstructorInitializer( SgMemberFunctionDeclaration* declaration, SgExprListExp* args, SgType* expression_type, bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown);
buildConstructorInitializer_nfi
[[visibility("default")]] SgConstructorInitializer* buildConstructorInitializer_nfi( SgMemberFunctionDeclaration* declaration, SgExprListExp* args, SgType* expression_type, bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown, SgConstructorInitializer::argument_source_enum argument_source = SgConstructorInitializer::e_constructor_argument_expressions);
buildContinueStmt_nfi
SgContinueStmt* buildContinueStmt_nfi();
Build a continue statement
buildCpreprocessorDefineDeclaration
[[visibility("default")]] PreprocessingInfo* buildCpreprocessorDefineDeclaration( SgLocatedNode* target, std::string const& content, PreprocessingInfo::RelativePositionType position = PreprocessingInfo::before);
Build and attach #define XX directives, pass "#define xxx xxx" as content.
buildCtorInitializerList_nfi
SgCtorInitializerList* buildCtorInitializerList_nfi();
buildCudaKernelCallExp_nfi
SgCudaKernelCallExp* buildCudaKernelCallExp_nfi( SgExpression* kernel, SgExprListExp* parameters = NULL, SgCudaKernelExecConfig* config = NULL);
Build a CUDA kernel call expression (kernel<<<config>>>(parameters))
buildCudaKernelExecConfig_nfi
SgCudaKernelExecConfig* buildCudaKernelExecConfig_nfi( SgExpression* grid = NULL, SgExpression* blocks = NULL, SgExpression* shared = NULL, SgExpression* stream = NULL);
Build a CUDA kernel execution configuration (<<<grid, blocks, shared, stream>>>)
buildDeclType
[[visibility("default")]] SgDeclType* buildDeclType( SgExpression* base_expression, SgType* base_type, bool is_gnu_decltype = false);
Build a decltype reference type
buildDeclarationScope
[[visibility("default")]] SgDeclarationScope* buildDeclarationScope(SgScopeStatement* semantic_outer_scope = nullptr);
Build a scope statement. Used to build SgNonrealDecl and SgNonrealType
buildDefaultOptionStmt
[[visibility("default")]] SgDefaultOptionStmt* buildDefaultOptionStmt(SgStatement* body = NULL);
Build a default option statement
buildDefaultOptionStmt_nfi
SgDefaultOptionStmt* buildDefaultOptionStmt_nfi(SgStatement* body);
buildDefiningClassDeclaration
[[visibility("default")]] SgClassDeclaration* buildDefiningClassDeclaration( declaration_ownership const& ownership, SgName name, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDeclaration);
buildDefiningFunctionDeclaration
[[visibility("default")]] SgFunctionDeclaration* buildDefiningFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope, bool forceFreeFunctionScope = false);
Build a function declaration with a function body
buildDefiningMemberFunctionDeclaration
[[visibility("default")]] SgMemberFunctionDeclaration* buildDefiningMemberFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope);
Build a defining ( non-prototype) member function declaration
buildDefiningTemplateFunctionDeclaration
[[visibility("default")]] SgTemplateFunctionDeclaration* buildDefiningTemplateFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parlist, SgScopeStatement* scope, SgTemplateFunctionDeclaration* first_nondefining_declaration, SgTemplateParameterPtrList* definingTemplateParameterList);
buildDefiningTemplateMemberFunctionDeclaration
[[visibility("default")]] SgTemplateMemberFunctionDeclaration* buildDefiningTemplateMemberFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parlist, SgScopeStatement* scope, unsigned int functionConstVolatileFlags, SgTemplateMemberFunctionDeclaration* first_nondefing_declaration, SgTemplateParameterPtrList* definingTemplateParameterList);
buildDeleteExp
[[visibility("default")]] SgDeleteExp* buildDeleteExp( SgExpression* target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration* deleteOperatorDeclaration = NULL);
Build a delete statement
buildDeleteExp_nfi
SgDeleteExp* buildDeleteExp_nfi( SgExpression* target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration* deleteOperatorDeclaration = NULL);
buildDerivedTypeStatement
[[visibility("default")]] SgDerivedTypeStatement* buildDerivedTypeStatement( declaration_ownership const& ownership, SgName const& name, SgScopeStatement* scope);
Build an SgDerivedTypeStatement Fortran derived type declaration with a class declaration and definition (creating both the defining and nondefining declarations as required).
buildDivAssignOp
[[visibility("default")]] SgDivAssignOp* buildDivAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildDivAssignOp_nfi
[[visibility("default")]] SgDivAssignOp* buildDivAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildDivideOp
[[visibility("default")]] SgDivideOp* buildDivideOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildDivideOp_nfi
[[visibility("default")]] SgDivideOp* buildDivideOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildDoWhileStmt
SgDoWhileStmt* buildDoWhileStmt( SgStatement* body, SgExpression* condition);
Build do-while statement
buildDoWhileStmt_nfi
SgDoWhileStmt* buildDoWhileStmt_nfi( SgStatement* body, SgStatement* condition);
buildDotExp
[[visibility("default")]] SgDotExp* buildDotExp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildDotExp_nfi
[[visibility("default")]] SgDotExp* buildDotExp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildDotStarOp
[[visibility("default")]] SgDotStarOp* buildDotStarOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildDotStarOp_nfi
[[visibility("default")]] SgDotStarOp* buildDotStarOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildDoubleType
[[visibility("default")]] SgTypeDouble* buildDoubleType();
buildDoubleVal
[[visibility("default")]] SgDoubleVal* buildDoubleVal(double value = 0.0);
Build a double value expression
buildDoubleVal_nfi
[[visibility("default")]] SgDoubleVal* buildDoubleVal_nfi( double value, std::string const& str);
buildEmptyDeclaration
[[visibility("default")]] SgEmptyDeclaration* buildEmptyDeclaration(SgEmptyDeclaration::empty_declaration_role_enum lexicalRole);
Build a detached empty declaration with one explicit lexical role. This builder never consults the ambient scope stack; callers must publish the result through one explicit structural ownership transaction and must distinguish a real ; from a zero-spelling preprocessing/source anchor.
buildEnumDeclaration
[[visibility("default")]] SgEnumDeclaration* buildEnumDeclaration( declaration_ownership const& ownership, SgName const& name, bool isUnNamed, SgScopeStatement* scope);
Build an enum, It is also a declaration statement in SAGE III
buildEnumDeclaration_nfi
[[visibility("default")]] SgEnumDeclaration* buildEnumDeclaration_nfi( declaration_ownership const& ownership, SgName const& name, bool isUnNamed, SgScopeStatement* scope, SgEnumDeclaration* canonicalDeclaration);
Build one enum definition over an explicit canonical type identity.
buildEnumVal
[[visibility("default")]] SgEnumVal* buildEnumVal(SgEnumFieldSymbol* sym);
buildEnumVal_nfi
[[visibility("default")]] SgEnumVal* buildEnumVal_nfi( long long value, SgEnumDeclaration* decl, SgName name);
buildEqualityOp
[[visibility("default")]] SgEqualityOp* buildEqualityOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildEqualityOp_nfi
[[visibility("default")]] SgEqualityOp* buildEqualityOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildEquivalenceStatement
[[visibility("default")]] SgEquivalenceStatement* buildEquivalenceStatement( SgExpression* lhs, SgExpression* rhs);
buildExponentiationAssignOp
[[visibility("default")]] SgExponentiationAssignOp* buildExponentiationAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildExponentiationAssignOp_nfi
[[visibility("default")]] SgExponentiationAssignOp* buildExponentiationAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildExponentiationOp
[[visibility("default")]] SgExponentiationOp* buildExponentiationOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildExponentiationOp_nfi
[[visibility("default")]] SgExponentiationOp* buildExponentiationOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildExprListExp
[[visibility("default")]] SgExprListExp* buildExprListExp(std::vector<SgExpression*> const& exprs);
Build a SgExprListExp, used for function call parameter list etc.
buildExprListExp_nfi
SgExprListExp* buildExprListExp_nfi();
buildExprStatement
[[visibility("default")]] SgExprStatement* buildExprStatement(SgExpression* exp = NULL);
Build a SgExprStatement, set File_Info automatically
buildExprStatement_nfi
SgExprStatement* buildExprStatement_nfi(SgExpression* exp);
buildFile
[[visibility("default")]] SgFile* buildFile( std::string const& inputFileName, std::string const& outputFileName, SgProject* project = NULL);
AST high level builders for others
buildFloat128Type
[[visibility("default")]] SgTypeFloat128* buildFloat128Type();
buildFloat128Val
[[visibility("default")]] SgFloat128Val* buildFloat128Val(Rose::FloatingValue value = 0.0);
buildFloat128Val_nfi
[[visibility("default")]] SgFloat128Val* buildFloat128Val_nfi( Rose::FloatingValue value, std::string const& str);
buildFloat16Type
[[visibility("default")]] SgTypeFloat16* buildFloat16Type();
buildFloat16Val
[[visibility("default")]] SgFloat16Val* buildFloat16Val(float v = 0);
Build a float16
buildFloat16Val_nfi
[[visibility("default")]] SgFloat16Val* buildFloat16Val_nfi( float v, std::string const& str);
buildFloat32Type
[[visibility("default")]] SgTypeFloat32* buildFloat32Type();
buildFloat32Val
[[visibility("default")]] SgFloat32Val* buildFloat32Val(float v = 0);
Build a float32
buildFloat32Val_nfi
[[visibility("default")]] SgFloat32Val* buildFloat32Val_nfi( float v, std::string const& str);
buildFloat32xType
[[visibility("default")]] SgTypeFloat32x* buildFloat32xType();
buildFloat64Type
[[visibility("default")]] SgTypeFloat64* buildFloat64Type();
buildFloat64Val
[[visibility("default")]] SgFloat64Val* buildFloat64Val(double v = 0);
Build a float64
buildFloat64Val_nfi
[[visibility("default")]] SgFloat64Val* buildFloat64Val_nfi( double v, std::string const& str);
buildFloat64xType
[[visibility("default")]] SgTypeFloat64x* buildFloat64xType();
buildFloat80Type
[[visibility("default")]] SgTypeFloat80* buildFloat80Type();
buildFloat80Val
[[visibility("default")]] SgFloat80Val* buildFloat80Val(Rose::FloatingValue value = 0.0);
buildFloat80Val_nfi
[[visibility("default")]] SgFloat80Val* buildFloat80Val_nfi( Rose::FloatingValue value, std::string const& str);
buildFloatType
[[visibility("default")]] SgTypeFloat* buildFloatType();
buildFloatVal
[[visibility("default")]] SgFloatVal* buildFloatVal(float value = 0.0);
buildFloatVal_nfi
[[visibility("default")]] SgFloatVal* buildFloatVal_nfi(float value = 0.0);
buildFoldExpression_nfi
[[visibility("default")]] SgFoldExpression* buildFoldExpression_nfi( SgExpression* operands, SgFoldExpression::operator_kind_enum operator_kind, bool is_left_associative, SgType* result_type);
buildForInitStatement
[[visibility("default")]] SgForInitStatement* buildForInitStatement();
Build a for init statement
buildForInitStatement_nfi
[[visibility("default")]] SgForInitStatement* buildForInitStatement_nfi(SgStatementPtrList& statements);
buildForStatement
[[visibility("default")]] SgForStatement* buildForStatement( SgStatement* initialize_stmt, SgStatement* test, SgExpression* increment, SgStatement* loop_body);
Build a for statement, assume none of the arguments is NULL
buildForStatement_nfi
[[visibility("default")]] SgForStatement* buildForStatement_nfi( SgForInitStatement* init_stmt, SgStatement* test, SgExpression* increment, SgStatement* loop_body);
buildFortranContinueStmt
[[visibility("default")]] SgFortranContinueStmt* buildFortranContinueStmt();
Build a Fortran continue statement
buildFortranContinueStmt_nfi
SgFortranContinueStmt* buildFortranContinueStmt_nfi();
buildFortranDo
[[visibility("default")]] SgFortranDo* buildFortranDo( SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* loop_body);
Build a Fortran do construct
buildFortranDo_nfi
[[visibility("default")]] SgFortranDo* buildFortranDo_nfi( SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* loop_body);
buildFortranFunctionRefExp
[[visibility("default")]] SgFunctionRefExp* buildFortranFunctionRefExp( SgFunctionSymbol* semantic_symbol, SgFunctionSymbol* source_visible_symbol, SgFunctionRefExp::fortran_source_visible_binding_kind_enum kind);
Build a Fortran function reference with separate resolved-procedure and source-visible binding identities.
buildFortranFunctionRefExp_nfi
[[visibility("default")]] SgFunctionRefExp* buildFortranFunctionRefExp_nfi( SgFunctionSymbol* semantic_symbol, SgFunctionSymbol* source_visible_symbol, SgFunctionRefExp::fortran_source_visible_binding_kind_enum kind);
buildFortranIncludeLine
[[visibility("default")]] SgFortranIncludeLine* buildFortranIncludeLine(std::string filename);
Build Fortran include line
buildFortranIncludeLine_nfi
[[visibility("default")]] SgFortranIncludeLine* buildFortranIncludeLine_nfi(std::string filename);
buildFortranKindType
[[visibility("default")]] SgModifierType* buildFortranKindType( SgType* base_type, SgExpression* kindExpression);
Build a type based on the Fortran kind mechanism
buildFp16Type
[[visibility("default")]] SgTypeFp16* buildFp16Type();
buildFriendTypeDeclaration
[[visibility("default")]] SgFriendTypeDeclaration* buildFriendTypeDeclaration(SgType* friend_type);
Build a C++11 type-only friend declaration, such as friend T;.
buildFunctionCallExp
[[visibility("default")]] SgFunctionCallExp* buildFunctionCallExp( SgFunctionSymbol* sym, SgExprListExp* parameters = NULL);
buildFunctionCallExp overloads
buildFunctionCallExp_nfi
SgFunctionCallExp* buildFunctionCallExp_nfi( SgExpression* f, SgType* result_type, SgExprListExp* parameters = NULL);
buildFunctionCallStmt
[[visibility("default")]] SgExprStatement* buildFunctionCallStmt( SgExpression* function, SgType* result_type, SgExprListExp* parameters = NULL);
buildFunctionCallStmt overloads
buildFunctionParameterList
[[visibility("default")]] SgFunctionParameterList* buildFunctionParameterList(SgFunctionParameterTypeList* paraTypeList);
buildFunctionParameterList overloads
buildFunctionParameterList_nfi
SgFunctionParameterList* buildFunctionParameterList_nfi();
buildFunctionParameterRefExp
[[visibility("default")]] SgFunctionParameterRefExp* buildFunctionParameterRefExp( int parameter_number, int parameter_level, SgType* parameter_type);
buildFunctionParameterRefExp_nfi
[[visibility("default")]] SgFunctionParameterRefExp* buildFunctionParameterRefExp_nfi( int parameter_number, int parameter_level, SgType* parameter_type);
buildFunctionParameterTypeList
[[visibility("default")]] SgFunctionParameterTypeList* buildFunctionParameterTypeList(SgExprListExp* expList);
buildFunctionParameterTypeList overloads
buildFunctionParameterTypeList_nfi
SgFunctionParameterTypeList* buildFunctionParameterTypeList_nfi(SgExprListExp* expList);
buildFunctionRefExp
[[visibility("default")]] SgFunctionRefExp* buildFunctionRefExp(SgFunctionSymbol* sym);
buildFunctionRefExp overloads
buildFunctionRefExp_nfi
SgFunctionRefExp* buildFunctionRefExp_nfi(SgFunctionSymbol* sym);
buildFunctionType
[[visibility("default")]] SgFunctionType* buildFunctionType( SgType* return_type, SgFunctionParameterList* argList);
buildFunctionType overloads
buildGeneratedFunctionParameterList
[[visibility("default")]] SgFunctionParameterList* buildGeneratedFunctionParameterList(SgFunctionParameterList const* sourceParameters);
Build an independent generated prototype signature from an existing parameter list. Default arguments remain owned by the source declaration; the result contains fresh transformation identities with the same names, types, pack roles, and qualification metadata. This is the generated-source counterpart to buildSemanticFunctionParameterList().
buildGeneratedSourceFile
[[visibility("default")]] SgSourceFile* buildGeneratedSourceFile( std::string const& outputFileName, SgProject* project = NULL);
Build an output-only SgSourceFile node and attach it to SgProject The file is constructed with an empty global scope without creating an input file or invoking a frontend. The output filename is canonicalized to one absolute translation-unit identity before construction and determines the source language. The same identity owns the file command line, source positions, and unparse output. If project is null, a new SgProject is created and can be retrieved with SgFile::get_project().
buildGotoStatement
[[visibility("default")]] SgGotoStatement* buildGotoStatement(SgLabelStatement* label = NULL);
buildGotoStatement overloads
buildGotoStatement_nfi
SgGotoStatement* buildGotoStatement_nfi(SgExpression* expr);
Build a goto statement from a label expression, supporting only C/C++ and not Fortran cases
buildGreaterOrEqualOp
[[visibility("default")]] SgGreaterOrEqualOp* buildGreaterOrEqualOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildGreaterOrEqualOp_nfi
[[visibility("default")]] SgGreaterOrEqualOp* buildGreaterOrEqualOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildGreaterThanOp
[[visibility("default")]] SgGreaterThanOp* buildGreaterThanOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildGreaterThanOp_nfi
[[visibility("default")]] SgGreaterThanOp* buildGreaterThanOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildIfStmt
SgIfStmt* buildIfStmt( SgExpression* conditional, SgStatement* true_body, SgStatement* false_body);
Build if statement
buildIfStmt_nfi
[[visibility("default")]] SgIfStmt* buildIfStmt_nfi( SgStatement* conditional, SgStatement* true_body, SgStatement* false_body);
buildImagPartOp
[[visibility("default")]] SgImagPartOp* buildImagPartOp( SgExpression* op, SgType* result_type);
buildImagPartOp_nfi
[[visibility("default")]] SgImagPartOp* buildImagPartOp_nfi( SgExpression* op, SgType* result_type);
buildImaginaryType
[[visibility("default")]] SgTypeImaginary* buildImaginaryType(SgType* base_type = nullptr);
Build an imaginary type
buildImaginaryVal
[[visibility("default")]] SgComplexVal* buildImaginaryVal(Rose::FloatingValue imaginary_value);
buildImaginaryVal_nfi
[[visibility("default")]] SgComplexVal* buildImaginaryVal_nfi( SgExpression* imaginary_value, SgType* precision_type);
buildInitializedName
[[visibility("default")]] SgInitializedName* buildInitializedName( std::string const& name, SgType* type);
e.g the scope of arguments of functions are different for defining and nondefining functions.
buildInitializedName_nfi
[[visibility("default")]] SgInitializedName* buildInitializedName_nfi( SgName const& name, SgType* type, SgInitializer* init, SgVariableDeclaration* declptr = NULL);
buildIntType
[[visibility("default")]] SgTypeInt* buildIntType();
buildIntVal
[[visibility("default")]] SgIntVal* buildIntVal(int value = 0);
Build an integer value expression
buildIntValHex
[[visibility("default")]] SgIntVal* buildIntValHex(int value = 0);
buildIntVal_nfi
[[visibility("default")]] SgIntVal* buildIntVal_nfi(int value = 0);
Build an integer value expression by converting the string
buildIntegerDivideAssignOp
[[visibility("default")]] SgIntegerDivideAssignOp* buildIntegerDivideAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildIntegerDivideAssignOp_nfi
[[visibility("default")]] SgIntegerDivideAssignOp* buildIntegerDivideAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildIntegerDivideOp
[[visibility("default")]] SgIntegerDivideOp* buildIntegerDivideOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildIntegerDivideOp_nfi
[[visibility("default")]] SgIntegerDivideOp* buildIntegerDivideOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildIorAssignOp
[[visibility("default")]] SgIorAssignOp* buildIorAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildIorAssignOp_nfi
[[visibility("default")]] SgIorAssignOp* buildIorAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildLabelRefExp
[[visibility("default")]] SgLabelRefExp* buildLabelRefExp(SgLabelSymbol* s);
Build a Fortran numeric label ref exp
buildLabelStatement
[[visibility("default")]] SgLabelStatement* buildLabelStatement( SgName const& name, SgStatement* stmt, SgScopeStatement* scope = NULL);
Note that the scope of a label statement is special. It is SgFunctionDefinition, not the closest scope statement such as SgBasicBlock.
buildLabelStatement_nfi
SgLabelStatement* buildLabelStatement_nfi( SgName const& name, SgStatement* stmt, SgScopeStatement* scope);
buildLambdaCaptureList_nfi
[[visibility("default")]] SgLambdaCaptureList* buildLambdaCaptureList_nfi();
buildLambdaCapture_nfi
[[visibility("default")]] SgLambdaCapture* buildLambdaCapture_nfi( SgExpression* capture_variable, SgExpression* capture_initializer, SgExpression* closure_variable, bool capture_by_reference, bool implicit, bool pack_expansion, bool is_init_capture);
buildLambdaExp_nfi
[[visibility("default")]] SgLambdaExp* buildLambdaExp_nfi( SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function);
buildLessOrEqualOp
[[visibility("default")]] SgLessOrEqualOp* buildLessOrEqualOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildLessOrEqualOp_nfi
[[visibility("default")]] SgLessOrEqualOp* buildLessOrEqualOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildLessThanOp
[[visibility("default")]] SgLessThanOp* buildLessThanOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildLessThanOp_nfi
[[visibility("default")]] SgLessThanOp* buildLessThanOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildLongDoubleType
[[visibility("default")]] SgTypeLongDouble* buildLongDoubleType();
buildLongDoubleVal
[[visibility("default")]] SgLongDoubleVal* buildLongDoubleVal(Rose::FloatingValue value = 0.0);
buildLongDoubleVal_nfi
[[visibility("default")]] SgLongDoubleVal* buildLongDoubleVal_nfi( Rose::FloatingValue value, std::string const& str);
buildLongIntVal
[[visibility("default")]] SgLongIntVal* buildLongIntVal(long value = 0);
Build a long integer value expression
buildLongIntVal_nfi
[[visibility("default")]] SgLongIntVal* buildLongIntVal_nfi( long value, std::string const& str);
buildLongLongIntVal
[[visibility("default")]] SgLongLongIntVal* buildLongLongIntVal(long long value = 0);
Build a long long integer value expression
buildLongLongIntValHex
[[visibility("default")]] SgLongLongIntVal* buildLongLongIntValHex(long long value = 0);
buildLongLongIntVal_nfi
[[visibility("default")]] SgLongLongIntVal* buildLongLongIntVal_nfi( long long value, std::string const& str);
buildLongLongType
[[visibility("default")]] SgTypeLongLong* buildLongLongType();
buildLongType
[[visibility("default")]] SgTypeLong* buildLongType();
buildLshiftAssignOp
[[visibility("default")]] SgLshiftAssignOp* buildLshiftAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildLshiftAssignOp_nfi
[[visibility("default")]] SgLshiftAssignOp* buildLshiftAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildLshiftOp
[[visibility("default")]] SgLshiftOp* buildLshiftOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildLshiftOp_nfi
[[visibility("default")]] SgLshiftOp* buildLshiftOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildMemberFunctionCall
[[visibility("default")]] SgFunctionCallExp* buildMemberFunctionCall( SgExpression* objectExpression, SgMemberFunctionSymbol* functionSymbol, SgExprListExp* params);
buildMemberFunctionCall overloads
buildMemberFunctionRefExp
[[visibility("default")]] SgMemberFunctionRefExp* buildMemberFunctionRefExp( SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
buildMemberFunctionRefExp_nfi
SgMemberFunctionRefExp* buildMemberFunctionRefExp_nfi( SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
buildMemberFunctionType
[[visibility("default")]] SgMemberFunctionType* buildMemberFunctionType( SgFunctionType const* type, SgScopeStatement* scope, unsigned int mfunc_specifier);
Bind a complete semantic function signature to its member class.
buildMinusAssignOp
[[visibility("default")]] SgMinusAssignOp* buildMinusAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildMinusAssignOp_nfi
[[visibility("default")]] SgMinusAssignOp* buildMinusAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildMinusMinusOp
[[visibility("default")]] SgMinusMinusOp* buildMinusMinusOp( SgExpression* op, SgType* result_type);
buildMinusMinusOp_nfi
[[visibility("default")]] SgMinusMinusOp* buildMinusMinusOp_nfi( SgExpression* op, SgType* result_type);
buildMinusOp
[[visibility("default")]] SgMinusOp* buildMinusOp( SgExpression* op, SgType* result_type);
Build -- expression, Sgop_mode is a value of either SgUnaryOp::prefix or SgUnaryOp::postfix
buildMinusOp_nfi
[[visibility("default")]] SgMinusOp* buildMinusOp_nfi( SgExpression* op, SgType* result_type);
buildModAssignOp
[[visibility("default")]] SgModAssignOp* buildModAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildModAssignOp_nfi
[[visibility("default")]] SgModAssignOp* buildModAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildModOp
[[visibility("default")]] SgModOp* buildModOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildModOp_nfi
[[visibility("default")]] SgModOp* buildModOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildModifierType
[[visibility("default")]] SgModifierType* buildModifierType( SgType* base_type, SgTypeModifier const& modifier);
Build a modifier type.
buildModuleStatement
[[visibility("default")]] SgModuleStatement* buildModuleStatement( declaration_ownership const& ownership, SgName const& name, SgScopeStatement* scope);
Build a Fortran module declaration.
buildMultAssignOp
[[visibility("default")]] SgMultAssignOp* buildMultAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildMultAssignOp_nfi
[[visibility("default")]] SgMultAssignOp* buildMultAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildMultiplyOp
[[visibility("default")]] SgMultiplyOp* buildMultiplyOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildMultiplyOp_nfi
[[visibility("default")]] SgMultiplyOp* buildMultiplyOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildNamespaceAliasDeclarationStatement
[[visibility("default")]] SgNamespaceAliasDeclarationStatement* buildNamespaceAliasDeclarationStatement( declaration_ownership const& ownership, SgName const& name, SgNamespaceDeclarationStatement* namespaceDeclaration, SgScopeStatement* scope);
buildNamespaceDeclaration
[[visibility("default")]] SgNamespaceDeclarationStatement* buildNamespaceDeclaration( SgName const& name, SgScopeStatement* scope);
tps (09/02/2009) : Added support for building namespaces
buildNamespaceDeclaration_nfi
[[visibility("default")]] SgNamespaceDeclarationStatement* buildNamespaceDeclaration_nfi( SgName const& name, bool unnamednamespace, SgScopeStatement* scope, namespace_declaration_ownership_enum ownership, SgNamespaceSourceFragment* openingIntroducerFragment, SgNamespaceSourceFragment* openingFragment, SgNamespaceSourceFragment* closingFragment, std::optional<unsigned int> sourceOrder);
Build one namespace declaration with explicit semantic and lexical ownership. Source-lexical declarations require source-spelled fragments and a positive producer-wide namespace order in the final expanded token stream; generated and semantic-only declarations require no order.
buildNamespaceDefinition
[[visibility("default")]] SgNamespaceDefinitionStatement* buildNamespaceDefinition(SgNamespaceDeclarationStatement* d = NULL);
buildNamespaceDefinition_nfi
[[visibility("default")]] SgNamespaceDefinitionStatement* buildNamespaceDefinition_nfi(SgNamespaceDeclarationStatement* d = NULL);
buildNestedRequirement_nfi
[[visibility("default")]] SgNestedRequirement* buildNestedRequirement_nfi(SgExpression* constraint);
buildNewExp
[[visibility("default")]] SgNewExp* buildNewExp( SgType* type, SgPointerType* result_type, SgExpression* array_bound, SgNewExp::array_bound_source_form_enum source_form, SgExprListExp* exprListExp, SgConstructorInitializer* constInit, SgExpression* expr, short val, SgFunctionDeclaration* funcDecl, unsigned int allocation_implicit_argument_count);
buildNewExp_nfi
[[visibility("default")]] SgNewExp* buildNewExp_nfi( SgType* type, SgPointerType* result_type, SgExpression* array_bound, SgNewExp::array_bound_source_form_enum source_form, SgExprListExp* exprListExp, SgConstructorInitializer* constInit, SgExpression* expr, short val, SgFunctionDeclaration* funcDecl, unsigned int allocation_implicit_argument_count);
buildNoexceptOp
[[visibility("default")]] SgNoexceptOp* buildNoexceptOp(SgExpression* exp);
Build noexcept operator expression with an expression parameter
buildNoexceptOp_nfi
[[visibility("default")]] SgNoexceptOp* buildNoexceptOp_nfi(SgExpression* exp);
buildNondefiningClassDeclaration
[[visibility("default")]] SgClassDeclaration* buildNondefiningClassDeclaration( declaration_ownership const& ownership, SgName name, SgScopeStatement* scope);
buildNondefiningClassDeclaration_nfi
[[visibility("default")]] SgClassDeclaration* buildNondefiningClassDeclaration_nfi( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateClassDeclaration* templateDeclaration, SgTemplateClassDeclaration* specializedTemplateDeclaration, SgTemplateArgumentPtrList* templateArgumentsList, SgName const* templateInstantiationNameOverride, bool anonymousInternalIdentity = false, SgTemplateArgumentPtrList const* semanticTemplateArgumentsList = nullptr, bool sourceSpellsInjectedClassName = false, SgTemplateArgumentPtrList* deducedTemplateArgumentsList = nullptr);
Build a class first nondefining declaration, without file info.
buildNondefiningDerivedTypeStatement
[[visibility("default")]] SgDerivedTypeStatement* buildNondefiningDerivedTypeStatement( declaration_ownership const& ownership, SgName const& name, SgScopeStatement* scope);
Build the canonical semantic forward declaration for a Fortran derived type. A derived-type forward has no source surface or definition and must be completed later by exactly one buildDerivedTypeStatement() call.
buildNondefiningEnumDeclaration_nfi
[[visibility("default")]] SgEnumDeclaration* buildNondefiningEnumDeclaration_nfi( SgName const& name, bool isUnNamed, SgScopeStatement* scope, declaration_ownership const& ownership, SgEnumDeclaration* canonicalDeclaration);
Build an enum nondefining declaration, without file info
buildNondefiningFunctionDeclaration
[[visibility("default")]] SgFunctionDeclaration* buildNondefiningFunctionDeclaration( function_declaration_ownership const& ownership, SgFunctionDeclaration const* funcdecl, SgScopeStatement* scope);
buildNondefiningFunctionDeclaration overloads
buildNondefiningMemberFunctionDeclaration
[[visibility("default")]] SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope);
Build a prototype member function declaration
buildNondefiningProcedureHeaderStatement
[[visibility("default")]] SgProcedureHeaderStatement* buildNondefiningProcedureHeaderStatement( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* param_list, SgProcedureHeaderStatement::subprogram_kind_enum, SgProcedureHeaderStatement::fortran_procedure_source_form_enum source_form, SgScopeStatement* scope, FortranBlockDataBuilderIdentity const* block_data_identity = nullptr);
Build a nondefining SgProcedureHeaderStatement, handle function type, symbol etc transparently
buildNondefiningTemplateClassDeclaration
[[visibility("default")]] SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, template_class_declaration_scopes const& scopes, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList, SgName const* templateSpecializationNameOverride);
buildNondefiningTemplateClassDeclaration()
buildNondefiningTemplateClassDeclaration_nfi
[[visibility("default")]] SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration_nfi( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, template_class_declaration_scopes const& scopes, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList, SgName const* templateSpecializationNameOverride);
buildNondefiningTemplateClassRedeclaration_nfi
[[visibility("default")]] SgTemplateClassDeclaration* buildNondefiningTemplateClassRedeclaration_nfi( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, template_class_declaration_scopes const& scopes, SgTemplateClassDeclaration* canonicalDeclaration, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList, SgName const* templateSpecializationNameOverride);
Build one nondefining redeclaration of an existing template class. The canonical declaration is required explicitly; the redeclaration reuses its exact type and symbol and never publishes another symbol.
buildNondefiningTemplateFunctionDeclaration
[[visibility("default")]] SgTemplateFunctionDeclaration* buildNondefiningTemplateFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parlist, SgScopeStatement* scope, SgTemplateParameterPtrList* templateParameterList = NULL);
buildNondefiningTemplateMemberFunctionDeclaration
[[visibility("default")]] SgTemplateMemberFunctionDeclaration* buildNondefiningTemplateMemberFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parlist, SgScopeStatement* scope, unsigned int functionConstVolatileFlags, SgTemplateParameterPtrList* templateParameterList, SgTemplateParameterPtrList* symbolIdentityTemplateParameterList);
buildNonrealBaseClass
[[visibility("default")]] SgNonrealBaseClass* buildNonrealBaseClass( SgNonrealDecl* classDeclaration, SgType* sourceType, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect);
buildNonrealDecl
[[visibility("default")]] SgNonrealDecl* buildNonrealDecl( SgName const& name, SgDeclarationScope* scope, SgDeclarationScope* child_scope = NULL);
Build a declaration of a non-real class or class-member in an explicit, non-null lexical declaration scope. A null child scope requests creation of a new owned child declaration scope.
buildNonrealRefExp_nfi
[[visibility("default")]] SgNonrealRefExp* buildNonrealRefExp_nfi(SgNonrealSymbol* sym);
Build a reference to the non-real declaration of a member of a non-real class
buildNotEqualOp
[[visibility("default")]] SgNotEqualOp* buildNotEqualOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildNotEqualOp_nfi
[[visibility("default")]] SgNotEqualOp* buildNotEqualOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildNotOp
[[visibility("default")]] SgNotOp* buildNotOp( SgExpression* op, SgType* result_type);
buildNotOp_nfi
[[visibility("default")]] SgNotOp* buildNotOp_nfi( SgExpression* op, SgType* result_type);
buildNullExpression
[[visibility("default")]] SgNullExpression* buildNullExpression(SgNullExpression::null_expression_role_enum role);
Build a typed null-expression placeholder, set file info as the default one.
buildNullExpression_nfi
[[visibility("default")]] SgNullExpression* buildNullExpression_nfi(SgNullExpression::null_expression_role_enum role);
No file info version of buildNullExpression(). File info is to be set later on.
buildNullStatement
[[visibility("default")]] SgNullStatement* buildNullStatement();
Build a NULL statement
buildNullStatement_nfi
SgNullStatement* buildNullStatement_nfi();
buildNullptrType
[[visibility("default")]] SgTypeNullptr* buildNullptrType();
buildNullptrValExp
[[visibility("default")]] SgNullptrValExp* buildNullptrValExp();
buildNullptrValExp_nfi
[[visibility("default")]] SgNullptrValExp* buildNullptrValExp_nfi();
buildOrOp
[[visibility("default")]] SgOrOp* buildOrOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildOrOp_nfi
[[visibility("default")]] SgOrOp* buildOrOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildPackExpansionExpr_nfi
[[visibility("default")]] SgPackExpansionExpr* buildPackExpansionExpr_nfi( SgExpression* pattern, SgType* result_type);
buildPlusAssignOp
[[visibility("default")]] SgPlusAssignOp* buildPlusAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildPlusAssignOp_nfi
[[visibility("default")]] SgPlusAssignOp* buildPlusAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildPlusPlusOp
[[visibility("default")]] SgPlusPlusOp* buildPlusPlusOp( SgExpression* op, SgType* result_type);
Build ++x or x++ , specify prefix or postfix using either SgUnaryOp::prefix or SgUnaryOp::postfix
buildPlusPlusOp_nfi
[[visibility("default")]] SgPlusPlusOp* buildPlusPlusOp_nfi( SgExpression* op, SgType* result_type);
buildPntrArrRefExp
[[visibility("default")]] SgPntrArrRefExp* buildPntrArrRefExp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildPntrArrRefExp_nfi
[[visibility("default")]] SgPntrArrRefExp* buildPntrArrRefExp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildPointerDerefExp
[[visibility("default")]] SgPointerDerefExp* buildPointerDerefExp( SgExpression* op, SgType* result_type);
buildPointerDerefExp_nfi
[[visibility("default")]] SgPointerDerefExp* buildPointerDerefExp_nfi( SgExpression* op, SgType* result_type);
buildPointerMemberType
[[visibility("default")]] SgPointerMemberType* buildPointerMemberType( SgType* base_type, SgType* classType);
buildPointerType
[[visibility("default")]] SgPointerType* buildPointerType(SgType* base_type = nullptr);
Build a pointer type
buildPragma
[[visibility("default")]] SgPragma* buildPragma(std::string const& name);
Build SgPragma
buildPragmaDeclaration
[[visibility("default")]] SgPragmaDeclaration* buildPragmaDeclaration( std::string const& name, SgScopeStatement* scope = NULL);
Build pragma declaration, handle SgPragma and defining/nondefining pointers internally
buildPragmaDeclaration_nfi
SgPragmaDeclaration* buildPragmaDeclaration_nfi( std::string const& name, SgScopeStatement* scope);
buildProcedureHeaderStatement
[[visibility("default")]] SgProcedureHeaderStatement* buildProcedureHeaderStatement( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgFunctionParameterList* canonical_parameter_list, SgProcedureHeaderStatement::subprogram_kind_enum, SgProcedureHeaderStatement::fortran_procedure_source_form_enum source_form, SgScopeStatement* scope);
Build a defining Fortran procedure with an explicit lexical source form.
buildProcedureHeaderStatementFromExactDefinition
[[visibility("default")]] SgProcedureHeaderStatement* buildProcedureHeaderStatementFromExactDefinition( function_declaration_ownership const& ownership, SgFunctionDefinition* exact_definition, char const* name, SgType* return_type, SgFunctionParameterList* parlist, SgProcedureHeaderStatement::subprogram_kind_enum, SgProcedureHeaderStatement::fortran_procedure_source_form_enum source_form, SgScopeStatement* scope, SgProcedureHeaderStatement* first_nondefining_declaration, FortranBlockDataBuilderIdentity const* block_data_identity = nullptr);
Complete a bottom-up Fortran procedure construction around its exact preconstructed definition and body. The definition is consumed exactly once and must already carry final source classification and scope identity.
buildRangeBasedForStatement_nfi
[[visibility("default")]] SgRangeBasedForStatement* buildRangeBasedForStatement_nfi( SgVariableDeclaration* initializer, SgVariableDeclaration* range, SgVariableDeclaration* begin_declaration, SgVariableDeclaration* end_declaration, SgExpression* not_equal_expression, SgExpression* increment_expression, SgStatement* body);
buildRangeExp
[[visibility("default")]] SgRangeExp* buildRangeExp( SgExpression* start, SgExpression* end, SgExpression* stride);
buildRangeExp_nfi
SgRangeExp* buildRangeExp_nfi( SgExpression* start, SgExpression* end, SgExpression* stride);
buildRealPartOp
[[visibility("default")]] SgRealPartOp* buildRealPartOp( SgExpression* op, SgType* result_type);
buildRealPartOp_nfi
[[visibility("default")]] SgRealPartOp* buildRealPartOp_nfi( SgExpression* op, SgType* result_type);
buildReferenceType
[[visibility("default")]] SgReferenceType* buildReferenceType(SgType* base_type = nullptr);
Build a reference type
buildRequirementSubstitutionFailure_nfi
[[visibility("default")]] SgRequirementSubstitutionFailure* buildRequirementSubstitutionFailure_nfi( SgRequirementSubstitutionFailure::failure_kind_enum failure_kind, std::string const& substituted_entity, std::string const& diagnostic_message);
buildRequiresExpr
[[visibility("default")]] SgRequiresExpr* buildRequiresExpr( SgFunctionParameterList* local_parameter_list, SgExprListExp* requirements, SgFunctionParameterScope* local_parameter_scope = nullptr, SgFunctionParameterList* local_parameter_list_syntax = nullptr);
buildRequiresExpr_nfi
[[visibility("default")]] SgRequiresExpr* buildRequiresExpr_nfi( SgFunctionParameterList* local_parameter_list, SgExprListExp* requirements, SgFunctionParameterScope* local_parameter_scope = nullptr, SgFunctionParameterList* local_parameter_list_syntax = nullptr);
buildRestrictType
[[visibility("default")]] SgModifierType* buildRestrictType(SgType* base_type);
Build a restrict type.
buildReturnStmt
[[visibility("default")]] SgReturnStmt* buildReturnStmt( SgExpression* expression = nullptr, SgInitializedName* nrvo_candidate = nullptr);
Build a return statement
buildReturnStmt_nfi
[[visibility("default")]] SgReturnStmt* buildReturnStmt_nfi( SgExpression* expression, SgInitializedName* nrvo_candidate = nullptr);
buildRshiftAssignOp
[[visibility("default")]] SgRshiftAssignOp* buildRshiftAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildRshiftAssignOp_nfi
[[visibility("default")]] SgRshiftAssignOp* buildRshiftAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildRshiftOp
[[visibility("default")]] SgRshiftOp* buildRshiftOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildRshiftOp_nfi
[[visibility("default")]] SgRshiftOp* buildRshiftOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildRvalueReferenceType
[[visibility("default")]] SgRvalueReferenceType* buildRvalueReferenceType(SgType* base_type);
Build a rvalue reference type
buildScopeOp
[[visibility("default")]] SgScopeOp* buildScopeOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildScopeOp_nfi
[[visibility("default")]] SgScopeOp* buildScopeOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildSemanticAuxiliaryVariableDeclaration
[[visibility("default")]] SgVariableDeclaration* buildSemanticAuxiliaryVariableDeclaration( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope);
Build and publish one named semantic-only variable declaration under the scope's exact auxiliary owner. Structural ownership is established before the variable symbol is inserted, so copied scope symbol tables can map the symbol only to an attached declaration basis.
buildSemanticFunctionParameterList
[[visibility("default")]] SgFunctionParameterList* buildSemanticFunctionParameterList(SgFunctionParameterList const* sourceParameters);
Build an independent semantic-only signature from an existing parameter list. Default arguments remain owned by the source declaration; the result contains fresh parameter identities with the same names, types, pack roles, and qualification metadata.
buildSemanticInitializedName
[[visibility("default")]] SgInitializedName* buildSemanticInitializedName( SgName const& name, SgType* type, SgInitializer* init = NULL, SgVariableDeclaration* declptr = NULL);
Build an initialized name that has no independently written source surface. The result is classified and validated as exact frontend semantic output at this producer; callers must not repair its provenance after attachment.
buildSemanticMemberFunctionRefExp
[[visibility("default")]] SgMemberFunctionRefExp* buildSemanticMemberFunctionRefExp( SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
buildSemanticNonrealType
[[visibility("default")]] SgNonrealType* buildSemanticNonrealType( SgNonrealDecl const* source, SgTemplateArgumentPtrList const& arguments, SgType* aliasedType);
Build a semantic non-real dependent type (optionally with template arguments). Every structurally owned located template-argument node must be unclassified or already have exact compiler-generated semantic provenance. The optional template declaration is linked before the internal SgNonrealDecl is published.
buildShortType
[[visibility("default")]] SgTypeShort* buildShortType();
buildShortVal
[[visibility("default")]] SgShortVal* buildShortVal(short value = 0);
buildShortValHex
[[visibility("default")]] SgShortVal* buildShortValHex(short value = 0);
buildShortVal_nfi
[[visibility("default")]] SgShortVal* buildShortVal_nfi( short value, std::string const& str);
buildSigned128bitIntegerType
[[visibility("default")]] SgTypeSigned128bitInteger* buildSigned128bitIntegerType();
buildSignedCharType
[[visibility("default")]] SgTypeSignedChar* buildSignedCharType();
buildSignedCharVal
[[visibility("default")]] SgSignedCharVal* buildSignedCharVal(signed char v = 0);
Build a signed char
buildSignedCharValHex
[[visibility("default")]] SgSignedCharVal* buildSignedCharValHex(signed char v = 0);
buildSignedCharVal_nfi
[[visibility("default")]] SgSignedCharVal* buildSignedCharVal_nfi( signed char v, std::string const& str);
buildSignedIntType
[[visibility("default")]] SgTypeSignedInt* buildSignedIntType();
buildSignedLongLongType
[[visibility("default")]] SgTypeSignedLongLong* buildSignedLongLongType();
buildSignedLongType
[[visibility("default")]] SgTypeSignedLong* buildSignedLongType();
buildSignedShortType
[[visibility("default")]] SgTypeSignedShort* buildSignedShortType();
buildSimpleRequirement_nfi
[[visibility("default")]] SgSimpleRequirement* buildSimpleRequirement_nfi(SgExpression* expression);
buildSizeOfOp
[[visibility("default")]] SgSizeOfOp* buildSizeOfOp( SgExpression* exp, SgType* expression_type, SgExpression::unary_type_trait_kind_enum operator_kind = SgExpression::e_sizeof, std::optional<Rose::Integer128Value> evaluated_value = std::nullopt);
buildSizeOfOp overloads
buildSizeOfOp_nfi
[[visibility("default")]] SgSizeOfOp* buildSizeOfOp_nfi( SgExpression* exp, SgType* expression_type, SgExpression::unary_type_trait_kind_enum operator_kind = SgExpression::e_sizeof, std::optional<Rose::Integer128Value> evaluated_value = std::nullopt);
buildSourceFile
[[visibility("default")]] SgSourceFile* buildSourceFile( std::string const& inputFileName, std::string const& outputFileName, SgProject* project);
Build a SgSourceFile node and attach it to SgProject Parse an existing readable input file. An unreadable input or frontend failure is a hard error. Use buildGeneratedSourceFile for output-only AST construction. outputFileName selects the unparse destination. The file is registered in project; buildFile creates a project when none is supplied. Retrieve its owner with SgFile::get_project().
buildSpaceshipOp
[[visibility("default")]] SgSpaceshipOp* buildSpaceshipOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildSpaceshipOp_nfi
[[visibility("default")]] SgSpaceshipOp* buildSpaceshipOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildStatementExpression
[[visibility("default")]] SgStatementExpression* buildStatementExpression( SgStatement* exp, SgType* result_type, SgScopeStatement* semantic_scope);
Build a GNU statement expression
buildStatementExpression_nfi
[[visibility("default")]] SgStatementExpression* buildStatementExpression_nfi( SgStatement* exp, SgType* result_type, SgScopeStatement* semantic_scope);
buildStaticAssertionDeclaration_nfi
[[visibility("default")]] SgStaticAssertionDeclaration* buildStaticAssertionDeclaration_nfi( SgExpression* condition, SgExpression* message = nullptr);
buildStringType
[[visibility("default")]] SgTypeString* buildStringType(SgExpression* stringLengthExpression);
Build a Fortran CHARACTER type from its typed length expression.
buildStringVal
[[visibility("default")]] SgStringVal* buildStringVal(std::string value = "");
buildStringVal_nfi
[[visibility("default")]] SgStringVal* buildStringVal_nfi(std::string value);
buildStructDeclaration
[[visibility("default")]] SgClassDeclaration* buildStructDeclaration( declaration_ownership const& ownership, SgName const& name, SgScopeStatement* scope);
Build a structure, It is also a declaration statement in SAGE III
buildSubscriptExpression_nfi
SgSubscriptExpression* buildSubscriptExpression_nfi( SgExpression* lower_bound, SgExpression* upper_bound, SgExpression* stride);
Build a SgSubscriptExpression, used for array shape expressions. The lower bound and stride may be nullptrs
buildSubtractOp
[[visibility("default")]] SgSubtractOp* buildSubtractOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildSubtractOp_nfi
[[visibility("default")]] SgSubtractOp* buildSubtractOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildSwitchStatement
SgSwitchStatement* buildSwitchStatement( SgExpression* item_selector, SgStatement* body = NULL);
Build a switch statement
buildSwitchStatement_nfi
[[visibility("default")]] SgSwitchStatement* buildSwitchStatement_nfi( SgStatement* item_selector, SgStatement* body);
buildTargetBuiltinType
[[visibility("default")]] SgTypeTargetBuiltin* buildTargetBuiltinType( SgName const& spelling, SgTypeTargetBuiltin::target_family_enum target_family);
buildTemplateClassDeclaration
[[visibility("default")]] SgTemplateClassDeclaration* buildTemplateClassDeclaration( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, template_class_declaration_scopes const& scopes, SgTemplateClassDeclaration* nonDefiningDecl, SgTemplateParameterPtrList* nondefiningTemplateParameterList, SgTemplateParameterPtrList* definingTemplateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList, SgName const* templateSpecializationNameOverride);
Build tempplate class declaration
buildTemplateClassDeclaration_nfi
[[visibility("default")]] SgTemplateClassDeclaration* buildTemplateClassDeclaration_nfi( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, template_class_declaration_scopes const& scopes, SgTemplateClassDeclaration* nonDefiningDecl, SgTemplateParameterPtrList* nondefiningTemplateParameterList, SgTemplateParameterPtrList* definingTemplateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList, SgName const* templateSpecializationNameOverride);
buildTemplateClassDefinition
SgTemplateClassDefinition* buildTemplateClassDefinition(SgTemplateClassDeclaration* d);
Build a template class definition statement
buildTemplateFunctionRefExp_nfi
SgTemplateFunctionRefExp* buildTemplateFunctionRefExp_nfi(SgTemplateFunctionSymbol* sym);
buildTemplateInstantiationTypedefDeclaration_nfi
[[visibility("default")]] SgTemplateInstantiationTypedefDeclaration* buildTemplateInstantiationTypedefDeclaration_nfi( typedef_declaration_ownership const& ownership, SgTypedefDeclaration::typedef_type_enum declarationForm, SgName& name, SgType* base_type, SgScopeStatement* scope, SgTemplateTypedefDeclaration* templateTypedefDeclaration, SgTemplateArgumentPtrList& templateArgumentsList, SgName const& semanticInstantiationName);
buildTemplateMemberFunctionRefExp_nfi
SgTemplateMemberFunctionRefExp* buildTemplateMemberFunctionRefExp_nfi( SgTemplateMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
buildTemplateParameter
[[visibility("default")]] SgTemplateParameter* buildTemplateParameter( SgTemplateParameter::template_parameter_enum parameterType, SgType*, SgTemplateParameter::template_parameter_keyword_enum keyword, SgInitializedName* initializedName = nullptr, SgTemplateParameter* canonicalNonTypeParameter = nullptr, SgTemplateDeclaration* templateDeclaration = nullptr);
Build a template parameter, passing enum kind and SgTemplateType template_parameter_enum
buildTemplateParameterVal
[[visibility("default")]] SgTemplateParameterVal* buildTemplateParameterVal( int template_parameter_position, SgTemplateParameter* parameter);
Build an template parameter value expression
buildTemplateParameterVal_nfi
[[visibility("default")]] SgTemplateParameterVal* buildTemplateParameterVal_nfi( int template_parameter_position, SgTemplateParameter* parameter);
buildTemplateType
[[visibility("default")]] SgTemplateType* buildTemplateType(SgName name = "");
Build a template type, used for template parameter and later argument
buildTemplateTypedefDeclaration_nfi
[[visibility("default")]] SgTemplateTypedefDeclaration* buildTemplateTypedefDeclaration_nfi( typedef_declaration_ownership const& ownership, SgTypedefDeclaration::typedef_type_enum declarationForm, SgName const& name, SgType* base_type, SgScopeStatement* scope);
buildTemplateVariableDeclaration
[[visibility("default")]] SgTemplateVariableDeclaration* buildTemplateVariableDeclaration( declaration_ownership const& ownership, SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgTemplateVariableDeclaration* specializedTemplateDeclaration, SgTemplateArgumentPtrList const& semanticArguments, SgInitializedName* priorDeclaration = nullptr);
Build and atomically publish a template variable declaration with explicit structural ownership. The semantic scope is supplied separately; sourceLexicalIn() represents an out-of-class definition without changing the variable entity's semantic class scope.
buildTemplateVariableDeclaration_nfi
[[visibility("default")]] SgTemplateVariableDeclaration* buildTemplateVariableDeclaration_nfi( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgTemplateVariableDeclaration* specializedTemplateDeclaration, SgTemplateArgumentPtrList const& semanticArguments, SgInitializedName* priorDeclaration = nullptr);
buildThisExp
[[visibility("default")]] SgThisExp* buildThisExp( SgSymbol* sym, SgType* expression_type);
Build this pointer
buildThisExp_nfi
[[visibility("default")]] SgThisExp* buildThisExp_nfi( SgSymbol* sym, SgType* expression_type);
buildThrowOp
[[visibility("default")]] SgThrowOp* buildThrowOp( SgExpression*, SgType* result_type, SgThrowOp::e_throw_kind);
Build a ThrowOp expression
buildThrowOp_nfi
[[visibility("default")]] SgThrowOp* buildThrowOp_nfi( SgExpression*, SgType* result_type, SgThrowOp::e_throw_kind);
buildTransformationCastExp
[[visibility("default")]] SgCastExp* buildTransformationCastExp( SgExpression* operand_i, SgType* expression_type, SgCastExp::cast_type_enum cast_type);
Build a source-emitting transformation cast whose semantics are completely determined by its exact operand and result types. Ambiguous conversions are rejected instead of being assigned a guessed conversion kind.
buildTransformationCastExp_nfi
[[visibility("default")]] SgCastExp* buildTransformationCastExp_nfi( SgExpression* operand_i, SgType* expression_type, SgCastExp::cast_type_enum cast_type);
buildTryStmt
[[visibility("default")]] SgTryStmt* buildTryStmt( SgStatement* body, SgCatchOptionStmt* catch0 = NULL, SgCatchOptionStmt* catch1 = NULL, SgCatchOptionStmt* catch2 = NULL, SgCatchOptionStmt* catch3 = NULL, SgCatchOptionStmt* catch4 = NULL);
Build a try statement.
buildTypeExpression
[[visibility("default")]] SgTypeExpression* buildTypeExpression(SgType* type);
buildTypeExpression_nfi
[[visibility("default")]] SgTypeExpression* buildTypeExpression_nfi(SgType* type);
buildTypeIdOp
[[visibility("default")]] SgTypeIdOp* buildTypeIdOp( SgExpression* operand_expr, SgType* operand_type, SgType* expression_type, bool operand_is_evaluated);
buildTypeIdOp_nfi
[[visibility("default")]] SgTypeIdOp* buildTypeIdOp_nfi( SgExpression* operand_expr, SgType* operand_type, SgType* expression_type, bool operand_is_evaluated);
buildTypeOfType
[[visibility("default")]] SgTypeOfType* buildTypeOfType( SgExpression* base_expression, SgType* base_type);
Build a GNU typeof operator
buildTypeRequirement_nfi
[[visibility("default")]] SgTypeRequirement* buildTypeRequirement_nfi(SgType* required_type);
buildTypeTraitBuiltinOperator
SgTypeTraitBuiltinOperator* buildTypeTraitBuiltinOperator( SgName functionName, SgTypeTraitBuiltinOperator::builtin_operator_kind_enum builtinKind, SgType* result_type, SgExpressionPtrList parameters);
buildTypeTraitBuiltinOperator_nfi
[[visibility("default")]] SgTypeTraitBuiltinOperator* buildTypeTraitBuiltinOperator_nfi( SgName functionName, SgTypeTraitBuiltinOperator::builtin_operator_kind_enum builtinKind, SgType* result_type, SgExpressionPtrList parameters);
buildTypedefDeclaration
[[visibility("default")]] SgTypedefDeclaration* buildTypedefDeclaration( typedef_declaration_ownership const& ownership, SgTypedefDeclaration::typedef_type_enum declarationForm, std::string const& name, SgType* base_type, SgScopeStatement* scope);
buildTypedefDeclarationWithEmbeddedTag
[[visibility("default")]] SgTypedefDeclaration* buildTypedefDeclarationWithEmbeddedTag( typedef_declaration_ownership const& ownership, SgTypedefDeclaration::typedef_type_enum declarationForm, std::string const& name, SgType* base_type, SgScopeStatement* scope, SgDeclarationStatement* embeddedDefinition);
buildTypedefDeclarationWithEmbeddedTag_nfi
[[visibility("default")]] SgTypedefDeclaration* buildTypedefDeclarationWithEmbeddedTag_nfi( typedef_declaration_ownership const& ownership, SgTypedefDeclaration::typedef_type_enum declarationForm, std::string const& name, SgType* base_type, SgScopeStatement* scope, SgDeclarationStatement* embeddedDefinition);
buildTypedefDeclaration_nfi
[[visibility("default")]] SgTypedefDeclaration* buildTypedefDeclaration_nfi( typedef_declaration_ownership const& ownership, SgTypedefDeclaration::typedef_type_enum declarationForm, std::string const& name, SgType* base_type, SgScopeStatement* scope);
buildUnaryAddOp
[[visibility("default")]] SgUnaryAddOp* buildUnaryAddOp( SgExpression* op, SgType* result_type);
buildUnaryAddOp_nfi
[[visibility("default")]] SgUnaryAddOp* buildUnaryAddOp_nfi( SgExpression* op, SgType* result_type);
buildUnaryExpression
template< class T, class... ConstructorArgs> T* buildUnaryExpression( SgExpression* operand, SgType* result_type, ConstructorArgs&&... constructor_args);
Template function to build a unary expression of type T. Instantiated functions include:buildAddressOfOp(),buildBitComplementOp(),buildBitComplementOp(),buildMinusOp(),buildNotOp(),buildPointerDerefExp(),buildUnaryAddOp(),buildMinusMinusOp(),buildPlusPlusOp(). They are also used for the unary vararg operators (which are not technically unary operators). The instantiated functions' prototypes are not shown since they are expanded using macros. Documentation tools do not expand these macros.
buildUnaryExpression_nfi
template< class T, class... ConstructorArgs> T* buildUnaryExpression_nfi( SgExpression* operand, SgType* result_type, ConstructorArgs&&... constructor_args);
Template function to build a unary expression of type T with no file info. Instantiated functions include:buildAddressOfOp(),buildBitComplementOp(),buildBitComplementOp(),buildMinusOp(),buildNotOp(),buildPointerDerefExp(),buildUnaryAddOp(),buildMinusMinusOp(),buildPlusPlusOp(). They are also used for the unary vararg operators (which are not technically unary operators). The instantiated functions' prototypes are not shown since they are expanded using macros. Documentation tools do not expand these macros.
buildUnknownType
[[visibility("default")]] SgTypeUnknown* buildUnknownType();
buildUnpublishedVariableDeclaration
[[visibility("default")]] SgVariableDeclaration* buildUnpublishedVariableDeclaration( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope);
Build one source-positioned variable declaration without publishing a symbol. This is an internal transaction primitive: the caller must establish exact lexical ownership and publish the symbol before returning the declaration to application code.
buildUnpublishedVariableDeclarationWithEmbeddedTag_nfi
[[visibility("default")]] SgVariableDeclaration* buildUnpublishedVariableDeclarationWithEmbeddedTag_nfi( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgDeclarationStatement* embeddedDefinition, SgStorageModifier::storage_modifier_enum sm = SgStorageModifier::e_default);
Build an embedded-tag variable subtree without publishing its symbol. The frontend must attach exact redeclaration identity and publish the symbol in the same construction transaction.
buildUnsigned128bitIntegerType
[[visibility("default")]] SgTypeUnsigned128bitInteger* buildUnsigned128bitIntegerType();
buildUnsignedCharType
[[visibility("default")]] SgTypeUnsignedChar* buildUnsignedCharType();
buildUnsignedCharVal
[[visibility("default")]] SgUnsignedCharVal* buildUnsignedCharVal(unsigned char v = 0);
Build an unsigned char
buildUnsignedCharValHex
[[visibility("default")]] SgUnsignedCharVal* buildUnsignedCharValHex(unsigned char v = 0);
buildUnsignedCharVal_nfi
[[visibility("default")]] SgUnsignedCharVal* buildUnsignedCharVal_nfi( unsigned char v, std::string const& str);
buildUnsignedIntType
[[visibility("default")]] SgTypeUnsignedInt* buildUnsignedIntType();
buildUnsignedIntVal
[[visibility("default")]] SgUnsignedIntVal* buildUnsignedIntVal(unsigned int v = 0);
Build an unsigned integer
buildUnsignedIntValHex
[[visibility("default")]] SgUnsignedIntVal* buildUnsignedIntValHex(unsigned int v = 0);
buildUnsignedIntVal_nfi
[[visibility("default")]] SgUnsignedIntVal* buildUnsignedIntVal_nfi( unsigned int v, std::string const& str);
buildUnsignedLongLongIntVal
[[visibility("default")]] SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal(unsigned long long v = 0);
Build an unsigned long long integer
buildUnsignedLongLongIntValHex
[[visibility("default")]] SgUnsignedLongLongIntVal* buildUnsignedLongLongIntValHex(unsigned long long v = 0);
buildUnsignedLongLongIntVal_nfi
[[visibility("default")]] SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal_nfi( unsigned long long v, std::string const& str);
buildUnsignedLongLongType
[[visibility("default")]] SgTypeUnsignedLongLong* buildUnsignedLongLongType();
buildUnsignedLongType
[[visibility("default")]] SgTypeUnsignedLong* buildUnsignedLongType();
buildUnsignedLongVal
[[visibility("default")]] SgUnsignedLongVal* buildUnsignedLongVal(unsigned long v = 0);
Build a unsigned long integer
buildUnsignedLongValHex
[[visibility("default")]] SgUnsignedLongVal* buildUnsignedLongValHex(unsigned long v = 0);
buildUnsignedLongVal_nfi
[[visibility("default")]] SgUnsignedLongVal* buildUnsignedLongVal_nfi( unsigned long v, std::string const& str);
buildUnsignedShortType
[[visibility("default")]] SgTypeUnsignedShort* buildUnsignedShortType();
buildUnsignedShortVal
[[visibility("default")]] SgUnsignedShortVal* buildUnsignedShortVal(unsigned short v = 0);
Build an unsigned short integer
buildUnsignedShortValHex
[[visibility("default")]] SgUnsignedShortVal* buildUnsignedShortValHex(unsigned short v = 0);
buildUnsignedShortVal_nfi
[[visibility("default")]] SgUnsignedShortVal* buildUnsignedShortVal_nfi( unsigned short v, std::string const& str);
buildUsingDirectiveStatement
[[visibility("default")]] SgUsingDirectiveStatement* buildUsingDirectiveStatement(SgNamespaceDeclarationStatement* ns_decl);
Build a using directive statement
buildUsingDirectiveStatement_nfi
[[visibility("default")]] SgUsingDirectiveStatement* buildUsingDirectiveStatement_nfi(SgNamespaceDeclarationStatement* ns_decl);
buildVarArgCopyOp
[[visibility("default")]] SgVarArgCopyOp* buildVarArgCopyOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildVarArgCopyOp_nfi
[[visibility("default")]] SgVarArgCopyOp* buildVarArgCopyOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildVarArgEndOp
[[visibility("default")]] SgVarArgEndOp* buildVarArgEndOp( SgExpression* op, SgType* result_type);
buildVarArgEndOp_nfi
[[visibility("default")]] SgVarArgEndOp* buildVarArgEndOp_nfi( SgExpression* op, SgType* result_type);
buildVarArgOp_nfi
[[visibility("default")]] SgVarArgOp* buildVarArgOp_nfi( SgExpression* operand_i, SgType* expression_type);
Build vararg op expression
buildVarArgStartOneOperandOp
[[visibility("default")]] SgVarArgStartOneOperandOp* buildVarArgStartOneOperandOp( SgExpression* op, SgType* result_type);
buildVarArgStartOneOperandOp_nfi
[[visibility("default")]] SgVarArgStartOneOperandOp* buildVarArgStartOneOperandOp_nfi( SgExpression* op, SgType* result_type);
buildVarArgStartOp
[[visibility("default")]] SgVarArgStartOp* buildVarArgStartOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildVarArgStartOp_nfi
[[visibility("default")]] SgVarArgStartOp* buildVarArgStartOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildVarRefExp
[[visibility("default")]] SgVarRefExp* buildVarRefExp(SgVariableDeclaration* vardecl);
buildVarRefExp overloads
buildVarRefExp_nfi
[[visibility("default")]] SgVarRefExp* buildVarRefExp_nfi(SgVariableSymbol* varSymbol);
buildVariableDeclaration
[[visibility("default")]] SgVariableDeclaration* buildVariableDeclaration( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgType* cxxSourceType = nullptr);
Build a fresh, structurally detached variable declaration in an exact semantic scope. A same-scope declaration with the same name is a hard error; use buildVariableRedeclaration() when the prior declaration is known. An explicit C/C++ written type must be distinct and semantically equivalent; it is attached before the declaration's variable symbol is published.
buildVariableDeclarationWithEmbeddedTag
[[visibility("default")]] SgVariableDeclaration* buildVariableDeclarationWithEmbeddedTag( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgInitializedName* priorDeclaration, SgDeclarationStatement* embeddedDefinition);
Build a fresh variable declaration which is the exact physical owner of a source-spelled class/enum definition embedded in its declarator.
buildVariableDeclarationWithEmbeddedTag_nfi
[[visibility("default")]] SgVariableDeclaration* buildVariableDeclarationWithEmbeddedTag_nfi( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgInitializedName* priorDeclaration, SgDeclarationStatement* embeddedDefinition, SgStorageModifier::storage_modifier_enum sm = SgStorageModifier::e_default);
Build an embedded-tag variable declaration with null frontend positions.
buildVariableDeclaration_nfi
[[visibility("default")]] SgVariableDeclaration* buildVariableDeclaration_nfi( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgStorageModifier::storage_modifier_enum sm = SgStorageModifier::e_default);
Build a fresh variable declaration with null frontend source positions.
buildVariableDefinition_nfi
[[visibility("default")]] SgVariableDefinition* buildVariableDefinition_nfi( SgVariableDeclaration* decl, SgInitializedName* init_name, SgInitializer* init);
Build variable definition
buildVariableRedeclaration
[[visibility("default")]] SgVariableDeclaration* buildVariableRedeclaration( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgInitializedName* priorDeclaration);
Build a fresh, detached redeclaration with an explicit prior identity.
buildVariableRedeclaration_nfi
[[visibility("default")]] SgVariableDeclaration* buildVariableRedeclaration_nfi( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgInitializedName* priorDeclaration, SgStorageModifier::storage_modifier_enum sm = SgStorageModifier::e_default);
Build a fresh, detached redeclaration with null frontend source positions.
buildVariantExpression
[[visibility("default")]] SgVariantExpression* buildVariantExpression(SgType* anchor_type);
buildVoidType
[[visibility("default")]] SgTypeVoid* buildVoidType();
buildVoidVal
[[visibility("default")]] SgVoidVal* buildVoidVal();
buildVoidVal_nfi
[[visibility("default")]] SgVoidVal* buildVoidVal_nfi();
buildVolatileType
[[visibility("default")]] SgModifierType* buildVolatileType(SgType* base_type = nullptr);
Build a volatile type.
buildWcharType
[[visibility("default")]] SgTypeWchar* buildWcharType();
buildWcharVal
[[visibility("default")]] SgWcharVal* buildWcharVal(int64_t value = 0);
buildWcharVal_nfi
[[visibility("default")]] SgWcharVal* buildWcharVal_nfi( int64_t value, std::string const& str);
buildWhileStmt
SgWhileStmt* buildWhileStmt( SgExpression* condition, SgStatement* body);
Build while statement
buildWhileStmt_nfi
SgWhileStmt* buildWhileStmt_nfi( SgStatement* condition, SgStatement* body);
buildXorAssignOp
[[visibility("default")]] SgXorAssignOp* buildXorAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
buildXorAssignOp_nfi
[[visibility("default")]] SgXorAssignOp* buildXorAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type);
clearScopeStack
[[visibility("default")]] void clearScopeStack();
completeSemanticFunctionDeclarationAsDefinition
[[visibility("default")]] SgFunctionDeclaration* completeSemanticFunctionDeclarationAsDefinition(SgFunctionDeclaration* declaration);
Complete one source-less semantic function declaration as its own definition when no distinct declaration precedes it.
copyFunctionSignature
[[visibility("default")]] std::unique_ptr<SgFunctionType> copyFunctionSignature( SgFunctionType const* specification, SgType* returnType, std::unique_ptr<SgFunctionParameterTypeList> arguments, SgType* classType, unsigned int memberFlags, SgCopyHelp& bindings, SgFunctionType* semanticSignature);
detachAuxiliaryDeclaration
[[visibility("default")]] bool detachAuxiliaryDeclaration( SgScopeStatement* owner, SgDeclarationStatement* declaration);
Remove a semantic-only declaration ownership edge.
detachDeclarationScope
[[visibility("default")]] void detachDeclarationScope( SgScopeStatement* owner, SgDeclarationScope* scope);
display
[[visibility("default")]] std::string display(SourcePositionClassification& scp);
display function for debugging
emptyScopeStack
[[visibility("default")]] bool emptyScopeStack();
errorCheckingTargetAST
[[visibility("default")]] void errorCheckingTargetAST( SgNode* node_copy, SgNode* node_original, SgFile* targetFile);
Error checking the inserted snippet AST.
findAssociatedSymbolInTargetAST
[[visibility("default")]] SgSymbol* findAssociatedSymbolInTargetAST( SgDeclarationStatement* snippet_declaration, SgScopeStatement* targetScope);
finishSourceDeclaratorScopeConstruction
[[visibility("default")]] void finishSourceDeclaratorScopeConstruction( SgDeclarationStatement* owner, SgDeclarationScope* scope);
Complete a source-declarator scope begun by beginSourceDeclaratorScopeConstruction(). Every child must have one exact nonautonomous structural role and already-published physical provenance.
fixupCopyOfNodeFromSeparateFileInNewTargetAst
[[visibility("default")]] void fixupCopyOfNodeFromSeparateFileInNewTargetAst( SgStatement* insertionPoint, bool insertionPointIsScope, SgNode* node_copy, SgNode* node_original);
functionParameterTypeFromDeclaredType
[[visibility("default")]] SgType* functionParameterTypeFromDeclaredType(SgType* type);
Derive a callable parameter type from a validated declared type without mutating the declaration's type.
getDeclarationScopeOwner
[[visibility("default")]] SgNode* getDeclarationScopeOwner(SgDeclarationScope const* scope);
getGlobalScopeFromScopeStack
SgScopeStatement* getGlobalScopeFromScopeStack();
Support to retrive the SgGlobal from the internal scope stack (error if not present in a non-empty list, return null for empty list).
getNonrealDeclarationScope
[[visibility("default")]] SgDeclarationScope* getNonrealDeclarationScope(SgDeclarationStatement* owner);
Get the nonreal declaration scope associated with a declaration (if any).
getOrCreateNonrealDeclarationScope
[[visibility("default")]] SgDeclarationScope* getOrCreateNonrealDeclarationScope(SgDeclarationStatement* owner);
Get or create the nonreal declaration scope associated with a declaration.
getSourcePositionClassificationMode
[[visibility("default")]] SourcePositionClassification getSourcePositionClassificationMode();
Get the current source position classification (defines how IR nodes built by the SageBuilder interface will be classified).
getTargetFileType
[[visibility("default")]] SgType* getTargetFileType( SgType* snippet_type, SgScopeStatement* targetScope);
getTemplateArgumentList
[[visibility("default")]] SgTemplateArgumentPtrList* getTemplateArgumentList(SgDeclarationStatement* decl);
getTemplateParameterList
[[visibility("default")]] SgTemplateParameterPtrList* getTemplateParameterList(SgDeclarationStatement* decl);
inSwitchScope
bool inSwitchScope();
initializePendingSourceVariableDeclarationProvenance
[[visibility("default")]] void initializePendingSourceVariableDeclarationProvenance(SgVariableDeclaration* declaration);
Complete the provenance of a detached frontend source declaration before its exact declaration range is known. Fresh structural wrappers receive semantic generated provenance while already source-positioned expression operands retain their exact immutable provenance.
initializeSemanticExpressionSourceProvenance
[[visibility("default")]] void initializeSemanticExpressionSourceProvenance(SgExpression* expression);
Classify one fresh semantic-only expression with complete compiler-generated provenance. Source-positioned or partially positioned input is malformed.
initializeSemanticVariableDeclarationSourceProvenance
[[visibility("default")]] void initializeSemanticVariableDeclarationSourceProvenance(SgVariableDeclaration* declaration);
Classify a freshly built semantic-only variable declaration and every structurally owned located child with exact compiler-generated provenance. Source-positioned or partially positioned input is malformed and aborts.
internFunctionType
[[visibility("default")]] SgFunctionType* internFunctionType(std::unique_ptr<SgFunctionType> candidate);
Intern a complete semantic signature, consuming its owned children even when an identical canonical type already exists.
popScopeStack
[[visibility("default")]] void popScopeStack();
publishExactSourceLexicalDeclaration
[[visibility("default")]] void publishExactSourceLexicalDeclaration( SgDeclarationStatement* declaration, SgScopeStatement* scope);
Complete one source-lexical declaration transaction whose builder used sourceLexicalPendingExactSource(). The declaration must still be detached and must already own exact physical source provenance. This operation publishes the lexical owner exactly once and never synthesizes or repairs source information.
pushScopeStack
[[visibility("default")]] void pushScopeStack(SgScopeStatement* stmt);
Public interfaces of the scope stack, should be stable
rebindCopiedSourceFilePhysicalIdentity
[[visibility("default")]] void rebindCopiedSourceFilePhysicalIdentity( SgSourceFile* sourceFile, std::string const& newFileName);
Commit the physical identity of a parsed source-file copy. The source file must still identify the primary file it was parsed from. Positions owned by that primary file are rebound to newFileName. Positions originating in included files retain their exact physical provenance. Incomplete or shared source ranges are hard producer errors. Rooted Fortran transfers only the primary occurrence, preserving included occurrences even when they refer to the same physical file. Composite Fortran endpoints keep their independent occurrence identities and canonical lexical order. Mixed physical ranges outside that validated Fortran contract still fail. The requested spelling remains the logical identity; its absolute resolved destination is the physical identity recorded by the Fortran context.
requireFreshNfiExpressionSourceState
[[visibility("default")]] void requireFreshNfiExpressionSourceState( SgExpression* expression, char const* producer);
requireFreshNfiLocatedNodeSourceState
[[visibility("default")]] void requireFreshNfiLocatedNodeSourceState( SgLocatedNode* node, char const* producer);
Enforce the construction-time contract shared by all expression builders whose names end in _nfi: the newly allocated root must not already own any source-position object. This validator never clears or repairs provenance.
setNonrealDeclarationScope
[[visibility("default")]] void setNonrealDeclarationScope( SgDeclarationStatement* owner, SgDeclarationScope* scope);
Attach a nonreal declaration scope to a declaration.
setSourcePositionClassificationMode
[[visibility("default")]] void setSourcePositionClassificationMode(SourcePositionClassification X);
Set the current source position classification (defines how IR nodes built by the SageBuilder interface will be classified).
setTemplateArgumentParents
[[visibility("default")]] void setTemplateArgumentParents(SgDeclarationStatement* decl);
setTemplateArgumentsInDeclaration
[[visibility("default")]] void setTemplateArgumentsInDeclaration( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateArgumentsList_input);
setTemplateNameInTemplateInstantiations
[[visibility("default")]] void setTemplateNameInTemplateInstantiations( SgFunctionDeclaration* func, SgName const& name);
setTemplateParameterParents
[[visibility("default")]] void setTemplateParameterParents(SgDeclarationStatement* decl);
setTemplateParametersInDeclaration
[[visibility("default")]] void setTemplateParametersInDeclaration( SgDeclarationStatement* decl, SgTemplateParameterPtrList* templateParametersList_input);
setTemplateSpecializationArgumentsInDeclaration
[[visibility("default")]] void setTemplateSpecializationArgumentsInDeclaration( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateSpecializationArgumentsList_input);
testTemplateArgumentParents
[[visibility("default")]] void testTemplateArgumentParents(SgDeclarationStatement* decl);
testTemplateParameterParents
[[visibility("default")]] void testTemplateParameterParents(SgDeclarationStatement* decl);
topScopeStack
[[visibility("default")]] SgScopeStatement* topScopeStack();

SageInterface

Name Description
HasNoThrowAssign
bool HasNoThrowAssign(SgType const const* inputType);
HasNoThrowConstructor
bool HasNoThrowConstructor(SgType const const* inputType);
HasNoThrowCopy
bool HasNoThrowCopy(SgType const const* inputType);
HasTrivialAssign
bool HasTrivialAssign(SgType const const* inputType);
HasTrivialConstructor
bool HasTrivialConstructor(SgType const const* inputType);
HasTrivialCopy
bool HasTrivialCopy(SgType const const* inputType);
HasTrivialDestructor
bool HasTrivialDestructor(SgType const const* inputType);
HasVirtualDestructor
bool HasVirtualDestructor(SgType const const* inputType);
IsAbstract
bool IsAbstract(SgType const const* inputType);
IsBaseOf
bool IsBaseOf( SgType const const* inputBaseType, SgType const const* inputDerivedType);
IsClass
bool IsClass(SgType const const* inputType);
strip off typedef and modifer types, then check if a type is a class type, excluding union type.
IsEmpty
bool IsEmpty(SgType const const* inputType);
IsEnum
bool IsEnum(SgType const const* inputType);
IsLiteralType
bool IsLiteralType(SgType const const* inputType);
IsPod
bool IsPod(SgType const const* inputType);
IsPolymorphic
bool IsPolymorphic(SgType const const* inputType);
IsStandardLayout
bool IsStandardLayout(SgType const const* inputType);
IsTrivial
bool IsTrivial(SgType const const* inputType);
IsUnion
bool IsUnion(SgType const const* inputType);
ReductionRecognition
[[visibility("default")]] 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.0 specification for allowed reduction variable types and operation types.
addMangledNameToCache
std::string addMangledNameToCache( SgNode* astNode, std::string const& mangledName);
addMessageStatement
void addMessageStatement( SgStatement* stmt, std::string message);
Function to add "C" style comment to statement.
addStepToLoopBody
[[visibility("default")]] 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
addVarRefExpFromArrayDimInfo
void addVarRefExpFromArrayDimInfo( SgNode* astNode, std::vector<SgNode*>& NodeList_t);
Find all SgPntrArrRefExp under astNode, then add SgVarRefExp (if any) of SgPntrArrRefExp's dim_info into NodeList_t
annotateExpressionsWithUniqueNames
void annotateExpressionsWithUniqueNames(SgProject* project);
Generate unique names for expressions and attach the names as persistent attributes ("UniqueNameAttribute")
appendArg
[[visibility("default")]] SgVariableSymbol* appendArg( SgFunctionParameterList*, SgInitializedName*);
Append an argument to SgFunctionParameterList, transparently set parent,scope, and symbols for arguments when possible We recommend to build SgFunctionParameterList before building a function declaration However, it is still allowed to append new arguments for existing function declarations.
appendExpression
[[visibility("default")]] void appendExpression( SgExprListExp*, SgExpression*);
Append an expression to a SgExprListExp, set the parent pointer also
appendExpressionList
[[visibility("default")]] void appendExpressionList( SgExprListExp*, std::vector<SgExpression*> const&);
Append an expression list to a SgExprListExp, set the parent pointers also
appendStatement
[[visibility("default")]] void appendStatement( SgStatement* stmt, SgForInitStatement* for_init_stmt);
appendStatement overloads
appendStatementList
[[visibility("default")]] void appendStatementList( std::vector<SgStatement*> const& stmt, SgScopeStatement* scope);
Append a list of statements to the end of an explicit lexical scope.
appendStatementWithDependentDeclaration
[[visibility("default")]] void appendStatementWithDependentDeclaration( SgDeclarationStatement* decl, SgGlobal* scope, SgFunctionDeclaration* source_call_declaration, bool excludeHeaderFiles, std::vector<PreprocessingInfo> const& original_directives, std::vector<SgDeclarationStatement*> const& original_dependencies, SgSourceFile* original_source_file);
astIntersection
[[visibility("default")]] std::vector<SgNode*> astIntersection( SgNode* original, SgNode* copy, SgCopyHelp* help = NULL);
Compute the intersection set for two ASTs.
attachComment
[[visibility("default")]] PreprocessingInfo* attachComment( SgLocatedNode* target, std::string const& content, PreprocessingInfo::DirectiveType commentStyle, PreprocessingInfo::RelativePositionType position = PreprocessingInfo::before);
Build and attach a comment with an explicit lexical comment style.
beginDetachedForStatementConstruction
[[visibility("default")]] void beginDetachedForStatementConstruction( SgForStatement* statement, SgScopeStatement* exactOutputOwner);
beginDetachedFunctionParameterScopeConstruction
[[visibility("default")]] void beginDetachedFunctionParameterScopeConstruction( SgFunctionParameterScope* parameterScope, SgScopeStatement* exactPhysicalOutputOwner, SgScopeStatement* exactSemanticScope);
Begin the one exact bottom-up construction transaction for a detached function-parameter scope. The scope is semantic name infrastructure and must already carry exact semantic-only provenance. The physical output owner and semantic lookup scope are independent, explicit roles; this is required for a parameter scope nested in another detached declarative region. No parent-chain inference is performed.
buildFunctionPrototype
[[visibility("default")]] SgFunctionDeclaration* buildFunctionPrototype(SgFunctionDeclaration* functionDeclaration);
Build a nondefining declaration from an exact function definition whose structural and semantic scopes permit a prototype at the same source location. In particular, out-of-class member definitions are rejected: their existing in-class declaration is the only legal prototype. Malformed or unsupported inputs are hard errors; this function never returns null.
call_liveness_analysis
[[visibility("default")]] LivenessAnalysis* call_liveness_analysis( SgProject* project, bool debug = false);
Call liveness analysis on an entire project
changeAllBodiesToBlocks
void changeAllBodiesToBlocks( SgNode* top, bool createEmptyBody = true);
Fix up ifs, loops, while, switch, Catch, OmpBodyStatement, etc. to have blocks as body components. It also adds an empty else body to if statements that don't have them.
changeBreakStatementsToGotos
[[visibility("default")]] void changeBreakStatementsToGotos(SgStatement* loopOrSwitch);
If the given statement contains any break statements in its body, add a new label below the statement and change the breaks into gotos to that new label.
changeContinuesToGotos
[[visibility("default")]] void changeContinuesToGotos( SgStatement* stmt, SgLabelStatement* label);
Change continue statements in a given block of code to gotos to a label
checkSgNodePointers
[[visibility("default")]] void checkSgNodePointers();
checkTypesAreEqual
bool checkTypesAreEqual( SgType* typeA, SgType* typeB);
cleanupNontransformedBasicBlockNode
[[visibility("default")]] void cleanupNontransformedBasicBlockNode();
Remove unused basic block IR nodes added as part of normalization.
clearMangledNameCache
void clearMangledNameCache(SgGlobal* globalScope);
clearScopeNumbers
void clearScopeNumbers(SgFunctionDefinition* functionDefinition);
Clears the cache of scope,integer pairs for the input function.
clearSharedGlobalScopes
void clearSharedGlobalScopes(SgProject* project);
cloneDetachedGeneratedTemplateParameter
[[visibility("default")]] SgTemplateParameter* cloneDetachedGeneratedTemplateParameter( SgTemplateParameter const* source, char const* context);
Clone one template parameter for a generated declaration. Template-template declaration identities are copied independently, and every generated located descendant is left detached until the destination declaration publishes its exact physical output owner.
collectCppDirectiveSnapshot
[[visibility("default")]] std::vector<PreprocessingInfo> collectCppDirectiveSnapshot(SgSourceFile* file);
Capture the primary source file's preprocessing directives in physical source order. The returned values are independent of later AST mutations.
collectDependentDeclarations
[[visibility("default")]] std::vector<SgDeclarationStatement*> collectDependentDeclarations( SgStatement* stmt, bool includeHeaderDeclarations, int originalPhysicalFileId);
collectDirectIncludeSystemRoles
[[visibility("default")]] std::map<std::string, bool> collectDirectIncludeSystemRoles(SgSourceFile* file);
Return the exact system/application role of every direct textual include in a source file, keyed by its source spelling. A lazily absent graph root is accepted only when the exact primary preprocessing stream proves that the source has no includes. Conflicting or incomplete include-graph ownership is a frontend invariant violation.
collectModifiedLocatedNodes
[[visibility("default")]] std::set<SgLocatedNode*> collectModifiedLocatedNodes(SgNode* node);
This collects the SgLocatedNodes that are marked as modified (a flag automatically set by all set_* generated functions) (useful in debugging).
collectModifiedStatements
[[visibility("default")]] std::set<SgStatement*> collectModifiedStatements(SgNode* node);
This collects the statements that are marked as modified (a flag automatically set by all set_* generated functions) (useful in debugging).
collectReadOnlySymbols
[[visibility("default")]] 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, a scope, or a single line statement. For accesses to members of aggregate data, we return the coarse grain aggregate mem obj by default.
collectReadOnlyVariables
[[visibility("default")]] 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.
collectReadWriteRefs
[[visibility("default")]] 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, or a single statement. Note that a reference can be both read and written, like i++
collectReadWriteVariables
[[visibility("default")]] 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 both read and written. 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.
collectSourceSequenceNumbers
std::set<unsigned int> collectSourceSequenceNumbers(SgNode* astNode);
collectTransformedStatements
[[visibility("default")]] std::set<SgStatement*> collectTransformedStatements(SgNode* node);
This collects the statements that are marked as transformed (useful in debugging).
collectUseByAddressVariableRefs
[[visibility("default")]] void collectUseByAddressVariableRefs( SgStatement const* s, std::set<SgVarRefExp*>& varSetB);
Collect variable references involving use by address: including &a expression and foo(a) when type2 foo(Type& parameter) in C++
collectVarRefs
void collectVarRefs( SgLocatedNode* root, std::vector<SgVarRefExp*>& result);
Collect all variable references in a subtree
collectVariableReferenceUses
void collectVariableReferenceUses( SgLocatedNode* root, std::vector<VariableReferenceUse>& result);
Collect variable references together with their exact source use sites.
collectVariableReferencesInArrayTypes
[[visibility("default")]] int collectVariableReferencesInArrayTypes( SgLocatedNode* root, std::vector<SgNode*>& currentVarRefList);
Collect variable references in array types. The default NodeQuery::querySubTree() will miss variables referenced in array type's index list. e.g. double *buffer = new double[numItems];
commitLoopTiling
[[visibility("default")]] void commitLoopTiling(CheckedLoopTilingPlan const& plan);
commitLoopUnrolling
[[visibility("default")]] void commitLoopUnrolling(CheckedLoopUnrollPlan const& plan);
completeDetachedForStatementConstruction
[[visibility("default")]] void completeDetachedForStatementConstruction(SgForStatement* statement);
completeDetachedFunctionParameterScopeConstruction
[[visibility("default")]] void completeDetachedFunctionParameterScopeConstruction( SgFunctionDeclaration* declaration, SgFunctionParameterScope* parameterScope);
Attach a parameter scope to its final declaration and consume its exact detached construction transaction. The scope remains semantic-only while physically emitted descendants retain the transaction's explicit output owner. Missing, stale, or mismatched transactions are hard errors.
completeDetachedRequiresParameterScopeConstruction
[[visibility("default")]] void completeDetachedRequiresParameterScopeConstruction( SgRequiresExpr* requiresExpression, SgFunctionParameterScope* parameterScope);
Attach a detached local-parameter scope to the requires-expression that owns its declarative region and consume the same exact construction transaction used while translating the local parameters.
computeUniqueNameForUseAsIdentifier
void computeUniqueNameForUseAsIdentifier(SgNode* astNode);
Traversal to set the global map of names to node and node to names.collisions to support generateUniqueNameForUseAsIdentifier() function.
constantFolding
[[visibility("default")]] void constantFolding(SgNode* r);
Constant folding an AST subtree rooted at 'r' (replacing its children with their constant values, if applicable). Please be advised that constant folding on floating point computation may decrease the accuracy of floating point computations! It is a wrapper function for ConstantFolding::constantFoldingOptimization(). Note that only r's children are replaced with their corresponding constant values, not the input SgNode r itself. You have to call this upon an expression's parent node if you want to fold the expression.
constraintExpressionEquivalence
[[visibility("default")]] bool constraintExpressionEquivalence( SgExpression const* left, SgExpression const* right);
containsUnknownType
[[visibility("default")]] bool containsUnknownType(SgType const* type);
Check if a type (or any nested type) is unknown/incomplete.
convertAllForsToWhiles
[[visibility("default")]] void convertAllForsToWhiles(SgNode* top);
convertForToWhile
[[visibility("default")]] void convertForToWhile(SgForStatement* f);
convertRefToInitializedName
[[visibility("default")]] 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.
copyExpression
[[visibility("default")]] SgExpression* copyExpression(SgExpression* e);
Deep copy an expression
copyStatement
[[visibility("default")]] SgStatement* copyStatement(SgStatement* s);
Deep copy a statement
createTempVariableAndReferenceForExpression
std::pair<SgVariableDeclaration*, SgExpression*> createTempVariableAndReferenceForExpression( SgExpression* expression, SgScopeStatement* scope);
createTempVariableForExpression
std::pair<SgVariableDeclaration*, SgExpression*> createTempVariableForExpression( SgExpression* expression, SgStatement* insertionAnchor, bool initializeInDeclaration, SgAssignOp** reEvaluate = NULL);
Given an expression and an exact attached insertion anchor, atomically inserts a temporary variable immediately before the anchor and publishes its symbol. The returned variable-reference expression can be used instead of the original expression. The optional SgAssignOp reevaluates the expression. Reference types are represented by pointer temporaries.
cutPreprocessingInfo
[[visibility("default")]] 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 pastePreprocessingInfo(). The cut-paste operation is equivalent to a split movePreprocessingInfo() operation and permits the destination node to be unknown during the cut operation.
cxxCompoundLiteralInitializerTypeMatchesObjectType
[[visibility("default")]] bool cxxCompoundLiteralInitializerTypeMatchesObjectType( SgType const* initializer, SgType const* object);
Match a compound literal's initializer value and object types, whose top-level cv qualifications may differ.
cxxNonTypeTemplateArgumentTypeConversionIsExact
[[visibility("default")]] bool cxxNonTypeTemplateArgumentTypeConversionIsExact( SgType const* source, SgType const* parameter);
Verify that the exact type of a written C++ non-type template argument can undergo the standard conversion represented by its canonical parameter type. This is deliberately narrower than general implicit conversion: it covers top-level cv removal, qualification adjustment, array/function decay, reference binding, and null pointer conversion without treating unrelated but similarly spelled types as equivalent.
cxxParameterTypeMatchesSemanticType
[[visibility("default")]] bool cxxParameterTypeMatchesSemanticType( SgType const* source, SgType const* semantic);
Match a written parameter type to its object type, including array and function parameter adjustment. Qualification on the object is preserved.
cxxSourceTemplateArgumentPrefixMatchesSemantic
[[visibility("default")]] bool cxxSourceTemplateArgumentPrefixMatchesSemantic( SgTemplateArgumentPtrList const& source, SgTemplateArgumentPtrList const& semantic);
Verify that a list of written C++ template arguments is the exact explicit prefix of a resolved semantic argument list. The semantic list may contain a defaulted suffix and may canonicalize source type spelling.
cxxSourceTypeMatchesObjectType
[[visibility("default")]] bool cxxSourceTypeMatchesObjectType( SgType const* source, SgType const* semantic);
Match an object declaration, allowing completion of an omitted outer array bound.
cxxSourceTypeMatchesSemanticType
[[visibility("default")]] bool cxxSourceTypeMatchesSemanticType( SgType const* source, SgType const* semantic);
Verify that a distinct C++ TypeLoc-owned source type resolves to its exact canonical semantic type. This includes written template-id graphs whose SgNonrealType identity is intentionally distinct from the resolved class or alias-template instantiation.
declarationPositionString
std::string declarationPositionString(SgDeclarationStatement const* declaration);
Generate a unique string from the source file position information
declarationPreceedsDefinition
bool declarationPreceedsDefinition( SgDeclarationStatement* nonDefiningDeclaration, SgDeclarationStatement* definingDeclaration);
Compare declarations in structural preorder within one lexical AST. Identical declarations do not precede themselves. Both declarations must have unique traversal ownership paths to the same global or detached root.
deepCopy
template<typename NodeType> NodeType* deepCopy(NodeType const* subtree);
A template function for deep copying a subtree. It is also used to create deepcopy functions with specialized parameter and return types. e.g SgExpression* copyExpression(SgExpression* e);
deepCopyNode
[[visibility("default")]] SgNode* deepCopyNode(SgNode const* subtree);
Deep copy an arbitrary subtree
deepCopyNodeWithIdentityMap
[[visibility("default")]] SgNode* deepCopyNodeWithIdentityMap( SgNode const* subtree, SgCopyHelp::copiedNodeMapType& identityMap);
Deep copy an arbitrary subtree and return the copy transaction's exact original-to-copy identity map. Consumers must use this map instead of reconstructing correspondence from traversal order or spelling.
deepCopySemantic
template<typename NodeType> NodeType* deepCopySemantic(NodeType const* subtree);
Typed frontend-semantic counterpart to deepCopy().
deepCopySemanticSubtree
[[visibility("default")]] SgNode* deepCopySemanticSubtree(SgNode const* subtree);
Deep copy a frontend-owned semantic subtree while preserving its exact source-provenance classification. This is distinct from deepCopyNode(), which creates a new transformation output surface.
deepDelete
[[visibility("default")]] 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()
deleteAST
[[visibility("default")]] void deleteAST(SgNode* node);
Notify indexes of the complete unprotected deletion boundary after proof, before destruction. The callback must not change AST references.
detachAllSymbolsFromScope
void detachAllSymbolsFromScope(SgScopeStatement* scope);
Detach every symbol through the symbol table's exact ownership API.
doLoopNormalization
[[visibility("default")]] void doLoopNormalization(SgFortranDo* loop);
Normalize a Fortran Do loop. Make the default increment expression (1) explicit
dumpInfo
[[visibility("default")]] void dumpInfo( SgNode* node, std::string desc = "");
Dump information about a SgNode for debugging
enclosingNamespaceScope
SgNamespaceDefinitionStatement* enclosingNamespaceScope(SgDeclarationStatement* declaration);
Find the enclosing namespace of a declaration
ensureBasicBlockAsBodyOfCaseOption
SgBasicBlock* ensureBasicBlockAsBodyOfCaseOption(SgCaseOptionStmt* cs);
Check if the body of a 'case option' statement is a SgBasicBlock, create one if not.
ensureBasicBlockAsBodyOfCatch
[[visibility("default")]] SgBasicBlock* ensureBasicBlockAsBodyOfCatch(SgCatchOptionStmt* cos);
Check if the body of a 'catch' statement is a SgBasicBlock, create one if not.
ensureBasicBlockAsBodyOfDefaultOption
SgBasicBlock* ensureBasicBlockAsBodyOfDefaultOption(SgDefaultOptionStmt* cs);
Check if the body of a 'default option' statement is a SgBasicBlock, create one if not.
ensureBasicBlockAsBodyOfDoWhile
[[visibility("default")]] SgBasicBlock* ensureBasicBlockAsBodyOfDoWhile(SgDoWhileStmt* ws);
Check if the body of a 'do .. while' statement is a SgBasicBlock, create one if not.
ensureBasicBlockAsBodyOfFor
[[visibility("default")]] SgBasicBlock* ensureBasicBlockAsBodyOfFor(SgForStatement* fs);
Check if the body of a 'for' statement is a SgBasicBlock, create one if not.
ensureBasicBlockAsBodyOfOmpBodyStmt
[[visibility("default")]] SgBasicBlock* ensureBasicBlockAsBodyOfOmpBodyStmt(SgOmpBodyStatement* ompbodyStmt);
Check if the body of a SgOmpBodyStatement is a SgBasicBlock, create one if not
ensureBasicBlockAsBodyOfSwitch
[[visibility("default")]] SgBasicBlock* ensureBasicBlockAsBodyOfSwitch(SgSwitchStatement* ws);
Check if the body of a 'switch' statement is a SgBasicBlock, create one if not.
ensureBasicBlockAsBodyOfWhile
[[visibility("default")]] SgBasicBlock* ensureBasicBlockAsBodyOfWhile(SgWhileStmt* ws);
Check if the body of a 'while' statement is a SgBasicBlock, create one if not.
ensureBasicBlockAsFalseBodyOfIf
[[visibility("default")]] 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 true.
ensureBasicBlockAsTrueBodyOfIf
[[visibility("default")]] SgBasicBlock* ensureBasicBlockAsTrueBodyOfIf(SgIfStmt* ifs);
Check if the true body of a 'if' statement is a SgBasicBlock, create one if not.
ensureLocatedNodeFileInfoForTransformation
[[visibility("default")]] void ensureLocatedNodeFileInfoForTransformation(SgLocatedNode* locatedNode);
Ensure a located node has the file-info objects required before marking it as a transformation/output subtree.
evaluateConstIntegerExpression
const_int_expr_t evaluateConstIntegerExpression(SgExpression* expr);
The function tries to evaluate const integer expressions (such as are used in array dimension sizes). It follows variable symbols, and requires constness.
exactCanonicalLoopTripCount
[[visibility("default")]] std::optional<unsigned long long> exactCanonicalLoopTripCount(CheckedCanonicalLoopPlan const& plan);
Return an exact constant trip count when both bounds are exact integer constants in the induction type's domain and the terminal increment cannot overflow or wrap. Dynamic bounds, an unsafe terminal increment, and an unrepresentable count return nullopt; a consumer requiring a constant count must reject nullopt.
extractPragmaKeyword
std::string extractPragmaKeyword(SgPragmaDeclaration const*);
Extract a SgPragmaDeclaration's leading keyword . For example "#pragma omp parallel" has a keyword of "omp".
findBreakStmts
std::vector<SgBreakStmt*> findBreakStmts( SgStatement* code, std::string const& fortranLabel = "");
Find break statements inside a particular statement, stopping at nested loops or switches loops or switch statements defines their own contexts for break statements. The function will stop immediately if run on a loop or switch statement. If fortranLabel is non-empty, breaks (EXITs) to that label within nested loops are included in the returned list.
findContinueStmts
std::vector<SgContinueStmt*> findContinueStmts( SgStatement* code, std::string const& fortranLabel = "");
Find all continue statements inside a particular statement, stopping at nested loops Nested loops define their own contexts for continue statements. The function will stop immediately if run on a loop statement. If fortranLabel is non-empty, continues (CYCLEs) to that label within nested loops are included in the returned list.
findDeclarationStatement
template<typename T> 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.
findEnclosingLoop
[[visibility("default")]] SgScopeStatement* findEnclosingLoop( SgStatement* s, std::string const& fortranLabel = "", bool stopOnSwitches = false);
Find the closest loop outside the given statement; if fortranLabel is not empty, the Fortran label of the loop must be equal to it
findEnclosingOmpClauseBodyStatement
[[visibility("default")]] SgOmpClauseBodyStatement* findEnclosingOmpClauseBodyStatement(SgStatement* s);
Find enclosing OpenMP clause body statement from s. If s is already one, return it directly.
findEnclosingSwitch
[[visibility("default")]] SgSwitchStatement* findEnclosingSwitch(SgStatement* s);
Find the closest switch outside a given statement (normally used for case and default statements)
findFunctionDeclaration
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, scope (optional, can be NULL), and defining or nondefining flag. This is an instantiation of findDeclarationStatement<T>.
findFunctionType
[[visibility("default")]] SgFunctionType* findFunctionType( SgType* return_type, SgFunctionParameterTypeList* typeList);
Find the function type matching a function signature plus a given return type
findGotoStmts
std::vector<SgGotoStatement*> findGotoStmts( SgStatement* scope, SgLabelStatement* l);
findLastDeclarationStatement
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 insert another variable declaration statement. Pragma declarations are not treated as a declaration by default in this context.
findMain
[[visibility("default")]] SgFunctionDeclaration* findMain(SgNode* currentNode);
top-down traversal from current node to find the main() function declaration
findSurroundingStatementFromSameFile
[[visibility("default")]] SgStatement* findSurroundingStatementFromSameFile( SgStatement* targetStmt, bool& surroundingStatementPreceedsTargetStatement);
Supporting function to comment relocation in insertStatement() and removeStatement().
findUnusedLabels
[[visibility("default")]] std::set<SgLabelStatement*> findUnusedLabels(SgNode* top);
Find unused labels which are not targets of any goto statements
fixFunctionDeclaration
[[visibility("default")]] void fixFunctionDeclaration( SgFunctionDeclaration* stmt, SgScopeStatement* scope);
Fix the symbol table and set scope (only if scope in declaration is not already set).
fixLabelStatement
[[visibility("default")]] void fixLabelStatement( SgLabelStatement* label_stmt, SgScopeStatement* scope);
Register a label once its scope is known. A null scope defers registration.
fixStatement
[[visibility("default")]] void fixStatement( SgStatement* stmt, SgScopeStatement* scope);
fixVariableDeclaration
[[visibility("default")]] void fixVariableDeclaration( SgVariableDeclaration* varDecl, SgScopeStatement* scope);
Publish a completed variable declaration's semantic scope and symbols.
fixupReferencesToSymbols
void fixupReferencesToSymbols( SgScopeStatement const* this_scope, SgScopeStatement* copy_scope, SgCopyHelp& help);
Construct a copied scope's symbols and map references to their exact copies.
forLoopNormalization
[[visibility("default")]] void forLoopNormalization( SgForStatement* loop, bool foldConstant = true);
Normalize a for loop. Malformed or non-canonicalizable loop headers are hard errors detected by a read-only preflight before the AST is mutated.
forallMaskExpression
SgExpression* forallMaskExpression(SgForAllStatement* stmt);
Get the mask expression from the header of a SgForAllStatement
fortranSourceFunctionResultMatchesSemanticResult
[[visibility("default")]] bool fortranSourceFunctionResultMatchesSemanticResult( SgFunctionType const* source, SgFunctionType const* semantic);
Verify that a Fortran source-syntax function result has the same resolved meaning as its canonical semantic result. Explicit KIND/LEN selectors use typed folded metadata; only omitted selectors may match by intrinsic family.
fortranSourceTypeMatchesSemanticExpressionType
[[visibility("default")]] bool fortranSourceTypeMatchesSemanticExpressionType( SgType const* source, SgType const* semantic);
Verify that an exact Fortran source type resolves to a semantic expression result type. A nonconstant source CHARACTER LEN selector may match only the explicit dynamic-result marker used by semantic expression types.
fortranSourceTypeMatchesSemanticType
[[visibility("default")]] bool fortranSourceTypeMatchesSemanticType( SgType const* source, SgType const* semantic);
Verify that an exact Fortran source scalar type resolves to the canonical semantic scalar type without discarding explicit KIND/LEN selectors.
generateFileList
std::vector<SgFile*> generateFileList();
Returns STL vector of SgFile IR node pointers.
generateFunctionDefinitionsList
[[visibility("default")]] std::vector<SgFunctionDeclaration*> generateFunctionDefinitionsList(SgNode* node);
generateProjectName
[[visibility("default")]] std::string generateProjectName( SgProject const* project, bool supressSuffix = false);
Generate a project name from its file names.
generateUniqueName
std::string generateUniqueName( SgNode const* node, bool ignoreDifferenceBetweenDefiningAndNondefiningDeclarations);
Generate unique name from C and C++ constructs. The name may contain space.
generateUniqueNameForUseAsIdentifier
std::string generateUniqueNameForUseAsIdentifier(SgDeclarationStatement* declaration);
Generate a useful name to support construction of identifiers from declarations.
generateUniqueNameForUseAsIdentifier_support
std::string generateUniqueNameForUseAsIdentifier_support(SgDeclarationStatement* declaration);
generateUniqueVariableName
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. # is a unique integer counter.
getAllStatementsAtLine
[[visibility("default")]] void getAllStatementsAtLine( SgSourceFile* sourceFile, int line, SgStatementPtrList& returnList);
Obtain all the queryed statement at line of a source file
getArrayElementCount
[[visibility("default")]] size_t getArrayElementCount(SgArrayType* t);
Calculate the number of elements of an array type with constant bounds.
getArrayElementType
[[visibility("default")]] SgType* getArrayElementType(SgType* t);
Get the element type of an array. It recursively find the base type for multi-dimension array types
getBoolType
[[visibility("default")]] SgType* getBoolType(SgNode* n);
Get the right bool type according to C or C++ language input
getClassTypeChainForMemberReference
[[visibility("default")]] std::list<SgClassType*> getClassTypeChainForMemberReference(SgExpression* refExp);
getConditionValue
SgExpression* getConditionValue(SgScopeStatement* stmt);
Return the converted predicate of IF, WHILE, FOR, or SWITCH; null only for consteval IF or an absent FOR condition. Declaration conditions own a separate predicate evaluated after their initializer.
getDeclarationOfNamedFunction
SgFunctionDeclaration* getDeclarationOfNamedFunction(SgExpression* func);
Given a SgExpression that represents a named function (or bound member function), return the mentioned function
getDeclaredType
SgType* getDeclaredType(SgDeclarationStatement const* declaration);
Returns the type introduced by a declaration.
getDefaultDestructor
[[visibility("default")]] SgMemberFunctionDeclaration* getDefaultDestructor(SgClassDeclaration* classDeclaration);
Get the default destructor from the class declaration
getDependentDeclarations
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.
getDimensionCount
[[visibility("default")]] int getDimensionCount(SgType* t);
Get the number of dimensions of an array type
getElementType
[[visibility("default")]] SgType* getElementType(SgType* t);
Get the element type of an array, pointer or string, or NULL if not applicable. This function only check one level base type. No recursion.
getEnclosingClassDeclaration
[[visibility("default")]] SgClassDeclaration* getEnclosingClassDeclaration(SgNode* astNode);
Get the closest class declaration enclosing the specified AST node,
getEnclosingClassDefinition
[[visibility("default")]] SgClassDefinition* getEnclosingClassDefinition( SgNode* astnode, bool const includingSelf = false);
Get the closest class definition enclosing the specified AST node,
getEnclosingExprListExp
[[visibility("default")]] SgExprListExp* getEnclosingExprListExp( SgNode* astNode, bool const includingSelf = false);
Get the enclosing SgExprListExp (used as part of function argument index evaluation in subexpressions).
getEnclosingFileNode
[[visibility("default")]] SgFile* getEnclosingFileNode(SgNode* astNode);
get the SgFile node from current node
getEnclosingFunctionDeclaration
[[visibility("default")]] SgFunctionDeclaration* getEnclosingFunctionDeclaration( SgNode* astNode, bool const includingSelf = false);
Find the enclosing function declaration, including its derived instances like isSgProcedureHeaderStatement, isSgProgramHeaderStatement, and isSgMemberFunctionDeclaration.
getEnclosingFunctionDefinition
[[visibility("default")]] SgFunctionDefinition* getEnclosingFunctionDefinition( SgNode* astNode, bool const includingSelf = false);
getEnclosingModuleStatement
[[visibility("default")]] SgModuleStatement* getEnclosingModuleStatement( SgNode* astNode, bool const includingSelf = false);
Get the closest module statement enclosing the specified AST node,
getEnclosingNode
template<typename NodeType> NodeType* getEnclosingNode( SgNode const* astNode, bool const includingSelf = false);
Find a node by type using upward traversal.
getEnclosingProcedure
[[visibility("default")]] SgFunctionDefinition* getEnclosingProcedure( SgNode* n, bool const includingSelf = false);
Find the function definition
getEnclosingScope
[[visibility("default")]] SgScopeStatement* getEnclosingScope( SgNode* n, bool const includingSelf = false);
Get the enclosing scope from a node n
getEnclosingSourceFile
[[visibility("default")]] SgSourceFile* getEnclosingSourceFile( SgNode const* n, bool const includingSelf = false);
Find enclosing source file node
getEnclosingStatement
[[visibility("default")]] SgStatement* getEnclosingStatement(SgNode* n);
Find the closest enclosing statement, including the given node
getFirstGlobalScope
[[visibility("default")]] SgGlobal* getFirstGlobalScope(SgProject* project);
return the first global scope under current project
getFirstInitializedName
[[visibility("default")]] SgInitializedName* getFirstInitializedName(SgVariableDeclaration* decl);
Get the first initialized name of a declaration statement
getFirstStatement
[[visibility("default")]] SgStatement* getFirstStatement( SgScopeStatement* scope, bool includingCompilerGenerated = false);
Get the first statement within a scope, return NULL if it does not exist. Skip compiler-generated statement by default. Count transformation-generated ones, but excluding those which are not to be outputted in unparsers.
getFirstStatementAtLine
[[visibility("default")]] SgStatement* getFirstStatementAtLine( SgSourceFile* sourceFile, int line);
Obtain the first queryed statement at line of a source file
getFirstVarSym
[[visibility("default")]] SgVariableSymbol* getFirstVarSym(SgVariableDeclaration* decl);
Get the variable symbol for the first initialized name of a declaration stmt.
getFirstVarType
[[visibility("default")]] SgType* getFirstVarType(SgVariableDeclaration* decl);
Get the data type of the first initialized name of a declaration statement
getFirstVariable
SgInitializedName& getFirstVariable(SgVariableDeclaration& vardecl);
convenience function that returns the first initialized name in a list of variable declarations.
getFortranProgramUnitSymbolTableKey
[[visibility("default")]] SgName getFortranProgramUnitSymbolTableKey(SgFunctionDeclaration const* decl);
Return the symbol-table key for a Fortran program unit. Anonymous program units receive a stable, source-position-derived internal key while their public SgFunctionDeclaration::get_name() remains empty.
getFrontendSpecificNodes
[[visibility("default")]] std::set<SgNode*> getFrontendSpecificNodes();
getFunctionDeclaration
[[visibility("default")]] SgFunctionDeclaration* getFunctionDeclaration(SgFunctionCallExp* functionCallExp);
getGlobalScope
[[visibility("default")]] SgGlobal* getGlobalScope(SgNode const* astNode);
Traverse back through a node's parents to find the enclosing global scope
getInParameters
std::vector<SgInitializedName*> getInParameters(SgInitializedNamePtrList const& params);
Get a vector of input parameters from the function parameter list
getInitializerOfExpression
[[visibility("default")]] SgInitializer* getInitializerOfExpression(SgExpression* n);
Get the initializer containing an expression if it is within an initializer.
getIntegerConstantValue
unsigned long long getIntegerConstantValue(SgValueExp* expr);
Get the constant value from a constant integer expression; abort on everything else. Note that signed long longs are converted to unsigned.
getLastStatement
[[visibility("default")]] SgStatement* getLastStatement(SgScopeStatement* scope);
get the last statement within a scope, return NULL if it does not exit
getLiveVariables
[[visibility("default")]] 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.
getLoopBody
[[visibility("default")]] SgStatement* getLoopBody(SgScopeStatement* loop);
Routines to get and set the body of a loop
getLoopCondition
[[visibility("default")]] SgStatement* getLoopCondition(SgScopeStatement* loop);
Routines to get the condition of a loop. It recognize While-loop, For-loop, and Do-While-loop
getLoopIndexVariable
[[visibility("default")]] SgInitializedName* getLoopIndexVariable(SgNode* loop);
Return the loop index variable for a for loop
getMangledNameFromCache
std::string getMangledNameFromCache(SgNode* astNode);
getNextStatement
[[visibility("default")]] SgStatement* getNextStatement(SgStatement* currentStmt);
Get next statement within the same scope of current statement
getNonInstantiatonDeclarationForClass
SgDeclarationStatement* getNonInstantiatonDeclarationForClass(SgTemplateInstantiationMemberFunctionDecl* memberFunctionInstantiation);
getOutParameters
std::vector<SgInitializedName*> getOutParameters(SgInitializedNamePtrList const& params);
Get a vector of output parameters from the function parameter list
getPreviousStatement
[[visibility("default")]] SgStatement* getPreviousStatement( SgStatement* currentStmt, bool climbOutScope = true);
Get previous statement of the current statement. It may return a previous statement of a parent scope by default (climbOutScope is true), otherwise only a previous statement of the same scope is returned.
getProject
[[visibility("default")]] SgProject* getProject();
Get the current SgProject IR Node.
getScope
[[visibility("default")]] SgScopeStatement* getScope(SgNode const* astNode);
Get the closest scope from astNode. Return astNode if it is already a scope.
getSgNodeListFromMemoryPool
template<typename NodeType> static std::vector<NodeType*> getSgNodeListFromMemoryPool();
Query memory pools to grab SgNode of a specified type
getSwitchCases
std::vector<SgStatement*> getSwitchCases(SgSwitchStatement* sw);
getSymbolsUsedInExpression
std::vector<SgVariableSymbol*> getSymbolsUsedInExpression(SgExpression* expr);
Find referenced symbols within an expression
getTargetFileTypeWithCopyMap
SgType* getTargetFileTypeWithCopyMap( SgType* type, SgScopeStatement* scope, SgCopyHelp::copiedNodeMapType const& identities);
getTemplateParameterKeyword
[[visibility("default")]] SgTemplateParameter::template_parameter_keyword_enum getTemplateParameterKeyword(SgTemplateParameter* param);
getTypeName
[[visibility("default")]] std::string getTypeName(SgType* type);
Get the string representing the type name
get_C_array_dimensions
std::vector<SgExpression*> get_C_array_dimensions(SgArrayType const& arrtype);
returns the array dimensions in an array as defined for arrtype
get_name
std::string get_name(SgC_PreprocessorDirectiveStatement const* directive);
get_name overloads
hasDetachedTransformationSourcePosition
[[visibility("default")]] bool hasDetachedTransformationSourcePosition(SgLocatedNode const* generatedNode);
Return whether every owned source position on a located node identifies one exact detached transformation surface awaiting an output owner.
hasExactSemanticAuxiliaryOwnership
[[visibility("default")]] bool hasExactSemanticAuxiliaryOwnership(SgDeclarationStatement const* declaration);
Return whether a declaration has exact semantic-auxiliary ownership. A declaration whose parent is an auxiliary container must satisfy the complete reciprocal scope/container/list contract; malformed partial ownership is a hard error.
hasExactSemanticFrontendSourcePosition
[[visibility("default")]] bool hasExactSemanticFrontendSourcePosition( SgNode const* semanticNode, Sg_File_Info const* position);
Return whether one file-info record is exact semantic-only frontend provenance owned by semanticNode. A function declaration can additionally retain its typed physical source-file association, and an exactly auxiliary-owned declaration or definition can retain its complete frontend source coordinates, without either becoming a source-emitted declaration.
hasMultipleInitStatmentsOrExpressions
[[visibility("default")]] bool hasMultipleInitStatmentsOrExpressions(SgForStatement* for_loop);
Check if a for loop uses C99 style initialization statement with multiple expressions like for (int i=0, j=0; ..) or for (i=0,j=0;...)
hasSameGlobalScope
[[visibility("default")]] bool hasSameGlobalScope( SgStatement* statement_1, SgStatement* statement_2);
This is supporting the recognition of functions in header files from two different ASTs
hasSemanticOnlyFrontendSourcePosition
[[visibility("default")]] bool hasSemanticOnlyFrontendSourcePosition(SgLocatedNode const* semanticNode);
Return whether every owned source position on a located node identifies one exact compiler-generated, frontend-specific semantic-only surface.
hasSimpleChildrenList
[[visibility("default")]] bool hasSimpleChildrenList(SgScopeStatement* scope);
Check if a scope statement has a simple children statement list so insert additional statements under the scope is straightforward and unambiguous . for example, SgBasicBlock has a simple statement list while IfStmt does not.
insertAfterUsingCommaOp
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, without changing the original semantics. This is done by using two comma operators: type T1; ... ((T1 = anchor_exp, new_exp),T1) )... , where T1 is a temp variable saving the possible side effect of anchor_exp. The top level comma op exp is returned. The reference to T1 in T1 = anchor_exp is saved in temp_ref.
insertBeforeUsingCommaOp
SgCommaOpExp* insertBeforeUsingCommaOp( SgExpression* new_exp, SgExpression* anchor_exp);
Insert an expression (new_exp )before another expression (anchor_exp) has possible side effects, without changing the original semantics. This is achieved by using a comma operator: (new_exp, anchor_exp). The comma operator is returned.
insertHeader
[[visibility("default")]] PreprocessingInfo* insertHeader( std::string const& filename, PreprocessingInfo::RelativePositionType position, bool isSystemHeader, SgScopeStatement* scope);
insertHeader overloads
insertStatement
[[visibility("default")]] 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
insertStatementAfter
[[visibility("default")]] void insertStatementAfter( SgStatement* targetStmt, SgStatement* newStmt, bool autoMovePreprocessingInfo = true);
Insert a statement after a target statement, Move around preprocessing info automatically by default
insertStatementAfterLastDeclaration
[[visibility("default")]] void insertStatementAfterLastDeclaration( std::vector<SgStatement*> stmt_list, SgScopeStatement* scope);
insertStatementAfterLastDeclaration overloads
insertStatementBefore
[[visibility("default")]] void insertStatementBefore( SgStatement* targetStmt, SgStatement* newStmt, bool autoMovePreprocessingInfo = true);
Insert a statement before a target statement
insertStatementBeforeFirstNonDeclaration
[[visibility("default")]] 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-declaration statements
insertStatementList
[[visibility("default")]] void insertStatementList( SgStatement* targetStmt, std::vector<SgStatement*> const& newStmts, bool insertBefore = true);
Insert a list of statements before or after the target statement within the
insertStatementListAfter
[[visibility("default")]] void insertStatementListAfter( SgStatement* targetStmt, std::vector<SgStatement*> const& newStmt);
Insert a list of statements after a target statement
insertStatementListBefore
[[visibility("default")]] void insertStatementListBefore( SgStatement* targetStmt, std::vector<SgStatement*> const& newStmts);
Insert a list of statements before a target statement
insertStatementListBeforeFirstNonDeclaration
[[visibility("default")]] void insertStatementListBeforeFirstNonDeclaration( std::vector<SgStatement*> const& newStmts, SgScopeStatement* scope);
Insert statements before the first non-declaration statement in a scope. If the scope has no non-declaration statements
insideHeader
[[visibility("default")]] bool insideHeader(SgLocatedNode* node);
Check if a node is from a header file
insideSystemHeader
[[visibility("default")]] bool insideSystemHeader(SgLocatedNode* node);
Check if a node is from a system header file
instrumentEndOfFunction
[[visibility("default")]] int instrumentEndOfFunction( SgFunctionDeclaration* func, SgStatement* s);
Instrument(Add a statement, often a function call) into a function right before the return points, handle multiple return statements (with duplicated statement s) and return expressions with side effects. Return the number of statements inserted. Useful when adding a runtime library call to terminate the runtime system right before the end of a program (e.g., OpenMP). Return with complex expressions with side effects are rewritten using an additional assignment statement.
isAbbreviatedFunctionTemplateParameter
[[visibility("default")]] bool isAbbreviatedFunctionTemplateParameter(SgTemplateParameter* param);
isAddressOfCurrentObjectDataMemberReference
[[visibility("default")]] bool isAddressOfCurrentObjectDataMemberReference(SgVarRefExp* varRefExp);
Distinguish ordinary member addresses from pointers to members using the address expression's typed operand form, including dependent template expressions and transformed expressions.
isAddressTaken
[[visibility("default")]] bool isAddressTaken(SgExpression* refExp);
isAncestor
[[visibility("default")]] bool isAncestor( SgNode* node1, SgNode* node2);
check if node1 is a strict ancestor of node 2. (a node is not considered its own ancestor)
isArrayReference
[[visibility("default")]] 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 subscripts if requested. Users can use convertRefToInitializedName() to get the possible name. It does not check if the expression is a top level SgPntrArrRefExp.
isAssignable
[[visibility("default")]] bool isAssignable(SgType* type);
Is a type assignable? This may not quite work properly.
isAssignmentStatement
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)
isAstTeardownEnabled
[[visibility("default")]] bool isAstTeardownEnabled();
Returns true if AST teardown is enabled for this process.
isBodyStatement
bool isBodyStatement(SgStatement* s);
Check if a statement is a (true or false) body of a container-like parent, such as For, Do-while, switch, If, Catch, OmpBodyStmt, etc
isCallToParticularFunction
[[visibility("default")]] bool isCallToParticularFunction( SgFunctionDeclaration* decl, SgExpression* e);
isCanonicalDoLoop
[[visibility("default")]] bool isCanonicalDoLoop( SgFortranDo* loop, SgInitializedName** ivar, SgExpression** lb, SgExpression** ub, SgExpression** step, SgStatement** body, CanonicalFortranLoopDirection* direction, bool* isInclusiveUpperBound);
Check if a Fortran Do loop has a complete canonical form: Do I=1, 10, 1. A nonconstant step has runtime direction; it must never be guessed to be increasing by consumers.
isCanonicalForLoop
[[visibility("default")]] 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
isConstType
[[visibility("default")]] bool isConstType(SgType* t);
isConstantFalse
[[visibility("default")]] bool isConstantFalse(SgExpression* e);
Check if a bool or int constant expression evaluates to be a false value
isConstantTrue
[[visibility("default")]] bool isConstantTrue(SgExpression* e);
Check if a bool or int constant expression evaluates to be a true value
isCopyConstructible
[[visibility("default")]] bool isCopyConstructible(SgType* type);
Is a type copy constructible? This may not quite work properly.
isDataMemberReference
[[visibility("default")]] bool isDataMemberReference(SgVarRefExp* varRefExp);
isDefaultConstructible
[[visibility("default")]] bool isDefaultConstructible(SgType* type);
Is a type default constructible? This may not quite work properly.
isEqualToIntConst
[[visibility("default")]] bool isEqualToIntConst( SgExpression* e, int value);
Compare AST nodes, subtree, etc
isEquivalentFunctionType
[[visibility("default")]] bool isEquivalentFunctionType( SgFunctionType const* lhs, SgFunctionType const* rhs);
Test if two types are equivalent SgFunctionType nodes. This is necessary for template function types They may differ in one SgTemplateType pointer but identical otherwise.
isEquivalentType
[[visibility("default")]] bool isEquivalentType( SgType const* lhs, SgType const* rhs);
Test for equivalence of types independent of access permissions (private or protected modes for members of classes).
isExactTagTypeIdentity
[[visibility("default")]] bool isExactTagTypeIdentity( SgType* declaratorType, SgDeclarationStatement* sourceOwnedTag);
Returns true when a declarator type names the supplied exact source-owned class or enum declaration. Externally named tag types are shared across a project, so the type's canonical declaration family may belong to another translation unit while the supplied declaration remains the sole owner of its local source surface.
isExtern
[[visibility("default")]] bool isExtern(SgDeclarationStatement* stmt);
Check if a declaration has an "extern" modifier
isFortranProgramUnitWithoutSourceName
[[visibility("default")]] bool isFortranProgramUnitWithoutSourceName(SgFunctionDeclaration const* decl);
Return true only for a Fortran main program or BLOCK DATA program unit whose source syntax has no name. The function hard-fails when the public declaration name and the explicit source-name metadata disagree.
isFunctionPrototypeRefinement
[[visibility("default")]] bool isFunctionPrototypeRefinement( SgFunctionType const* prior, SgFunctionType const* current);
isInSubTree
[[visibility("default")]] bool isInSubTree( SgExpression* subtree, SgExpression* exp);
isIndexOperator
bool isIndexOperator(SgExpression* exp);
isLambdaCapturedVariable
[[visibility("default")]] bool isLambdaCapturedVariable(SgVarRefExp* varRef);
check if a variable reference is this->a[i]inside of a lambda function
isLambdaFunction
[[visibility("default")]] bool isLambdaFunction(SgFunctionDeclaration* func);
Check if a function declaration is a C++11 lambda function
isLastStatement
[[visibility("default")]] bool isLastStatement(SgStatement* stmt);
Check if a statement is the last statement within its closed scope
isLoopIndexVariable
[[visibility("default")]] 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 bottom-up traverse starting from the subtree_root to find all enclosing loops and check if ivar is used as an index for either of them.
isMain
[[visibility("default")]] bool isMain(SgNode const* node);
Check if a SgNode is a main() function declaration
isMemberFunctionMemberReference
[[visibility("default")]] bool isMemberFunctionMemberReference(SgMemberFunctionRefExp* memberFunctionRefExp);
isMutable
[[visibility("default")]] bool isMutable(SgInitializedName* name);
True if an SgInitializedName is "mutable' (has storage modifier set)
isNonconstReference
[[visibility("default")]] bool isNonconstReference(SgType* t);
Is this type a non-constant reference type? (Handles typedefs correctly)
isOmpStatement
[[visibility("default")]] bool isOmpStatement(SgNode*);
Check if a node is SgOmp*Statement
isOverloaded
bool isOverloaded(SgFunctionDeclaration* functionDeclaration);
Return true if function is overloaded.
isOverloadedArrowOperator
bool isOverloadedArrowOperator(SgExpression* expr);
isOverloadedArrowOperator overloads
isOverloadedArrowOperatorChain
bool isOverloadedArrowOperatorChain(SgExpression* expr);
Return true if expr is part of an overloaded operator-> call chain.
isPointerToNonConstType
[[visibility("default")]] bool isPointerToNonConstType(SgType* type);
Is this a pointer to a non-const type? Note that this function will return true for const pointers pointing to non-const types. For example, (int* const y) points to a modifiable int, so this function returns true. Meanwhile, it returns false for (int const * x) and (int const * const x) because these types point to a const int. Also, only the outer layer of nested pointers is unwrapped. So the function returns true for (const int ** y), but returns false for const (int * const * x)
isPointerType
[[visibility("default")]] bool isPointerType(SgType* t);
Is this type a pointer type? (Handles typedefs correctly)
isPostfixOperator
bool isPostfixOperator(SgExpression* exp);
isPrefixOperator
bool isPrefixOperator(SgExpression* exp);
Classify a call's exact source operator surface.
isPrototypeInScope
bool isPrototypeInScope( SgScopeStatement* scope, SgFunctionDeclaration* functionDeclaration, SgDeclarationStatement* startingAtDeclaration);
isPureVirtualClass
[[visibility("default")]] bool isPureVirtualClass( SgType* type, ClassHierarchyWrapper const& classHierarchy);
Check if a class type is a pure virtual class. True means that there is at least one pure virtual function that has not been overridden. In the case of an incomplete class type (forward declaration), this function returns false.
isReferenceType
[[visibility("default")]] bool isReferenceType(SgType* t);
Is this type a const or non-const reference type? (Handles typedefs correctly)
isRemovableStatement
[[visibility("default")]] bool isRemovableStatement(SgStatement* s);
isRestrictType
[[visibility("default")]] bool isRestrictType(SgType* t);
Is this a restrict type?
isScalarType
[[visibility("default")]] bool isScalarType(SgType* t);
Is this a scalar type? We define the following SgType as scalar types: char, short, int, long , void, Wchar, Float, double, long long, string, bool, complex, imaginary
isStatic
[[visibility("default")]] bool isStatic(SgDeclarationStatement* stmt);
Check if a declaration has a "static' modifier
isStrictIntegerType
[[visibility("default")]] 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
isStructDeclaration
[[visibility("default")]] bool isStructDeclaration(SgNode* node);
Check if a SgNode is a declaration for a structure
isStructType
[[visibility("default")]] bool isStructType(SgType* t);
Check if a type is a struct type (a special SgClassType in ROSE). Typedef and modifier types are not stripped off. Only direct struct type is returned as true.
isStructurallyEquivalentAST
bool isStructurallyEquivalentAST( SgNode* tree1, SgNode* tree2);
Compare node kinds, nesting, and null child positions in two ASTs.
isTemplateInstantiationNode
[[visibility("default")]] bool isTemplateInstantiationNode(SgNode* node);
isUnionDeclaration
[[visibility("default")]] bool isUnionDeclaration(SgNode* node);
Check if a SgNode is a declaration for a union
isUseByAddressVariableRef
[[visibility("default")]] bool isUseByAddressVariableRef(SgVarRefExp* ref);
Check if a variable reference is used by its address: including &a expression and foo(a) when type2 foo(Type& parameter) in C++
isValidFortranSourceIdentifier
[[visibility("default")]] bool isValidFortranSourceIdentifier(std::string const& name);
Return whether a spelling is a valid Fortran source identifier.
isVolatileType
[[visibility("default")]] bool isVolatileType(SgType* t);
Is this a volatile type?
is_C99_language
[[visibility("default")]] bool is_C99_language();
is_CAF_language
[[visibility("default")]] bool is_CAF_language();
is_C_language
[[visibility("default")]] bool is_C_language();
version, language properties of current AST.
is_Cuda_language
[[visibility("default")]] bool is_Cuda_language();
is_Cxx_family_language
[[visibility("default")]] bool is_Cxx_family_language();
is_Cxx_language
[[visibility("default")]] bool is_Cxx_language();
is_Fortran_language
[[visibility("default")]] bool is_Fortran_language();
is_OpenCL_language
[[visibility("default")]] bool is_OpenCL_language();
is_OpenMP_language
[[visibility("default")]] bool is_OpenMP_language();
is_language_case_insensitive
[[visibility("default")]] bool is_language_case_insensitive();
is_mixed_C_and_Cxx_language
[[visibility("default")]] bool is_mixed_C_and_Cxx_language();
is_mixed_Fortran_and_C_and_Cxx_language
[[visibility("default")]] bool is_mixed_Fortran_and_C_and_Cxx_language();
is_mixed_Fortran_and_C_language
[[visibility("default")]] bool is_mixed_Fortran_and_C_language();
is_mixed_Fortran_and_Cxx_language
[[visibility("default")]] bool is_mixed_Fortran_and_Cxx_language();
language_may_contain_nondeclarations_in_scope
[[visibility("default")]] bool language_may_contain_nondeclarations_in_scope();
listHeaderFiles
[[visibility("default")]] void listHeaderFiles(SgIncludeFile* includeFile);
return path prefix for subtree of include files.
lookupClassSymbolInParentScopes
[[visibility("default")]] SgClassSymbol* lookupClassSymbolInParentScopes( SgName const& name, SgScopeStatement* currentScope = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
lookupEnumSymbolInParentScopes
[[visibility("default")]] SgEnumSymbol* lookupEnumSymbolInParentScopes( SgName const& name, SgScopeStatement* currentScope = NULL);
lookupFortranCommonBlockObject
[[visibility("default")]] SgCommonBlockObject* lookupFortranCommonBlockObject( SgName const& useName, SgNode const* context);
Resolve a Fortran common-block designator in its lexical program-unit scope. Missing and ambiguous declarations are hard errors.
lookupFunctionSymbolInParentScopes
[[visibility("default")]] SgFunctionSymbol* lookupFunctionSymbolInParentScopes( SgName const& functionName, SgScopeStatement* currentScope = NULL);
lookupFunctionSymbolInParentScopes overloads
lookupNamedTypeInParentScopes
[[visibility("default")]] SgType* lookupNamedTypeInParentScopes( std::string const& type_name, SgScopeStatement* scope = NULL);
Lookup a named type based on its name, bottomup searching from a specified scope. Note name collison might be allowed for c (not C++) between typedef and enum/struct. Only the first matched named type will be returned in this case. typedef is returned as it is, not the base type it actually refers to.
lookupNamespaceSymbolInParentScopes
[[visibility("default")]] SgNamespaceSymbol* lookupNamespaceSymbolInParentScopes( SgName const& name, SgScopeStatement* currentScope = NULL);
lookupSymbolInParentScopes
[[visibility("default")]] SgSymbol* lookupSymbolInParentScopes( SgName const& name, SgScopeStatement* currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
Find a symbol by name in the current or an ancestor scope, starting from the top of ScopeStack when no scope is supplied.
lookupSymbolInParentScopesForAstCopyFixup
[[visibility("default")]] SgSymbol* lookupSymbolInParentScopesForAstCopyFixup( SgName const& name, SgScopeStatement* currentScope, VariantT requestedSymbolKind, SgType const* type = NULL, SgTemplateParameterPtrList* templateParameterList = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
Parent-scope lookup used only by AST snippet-copy fixup. Recursive base-class search is explicit to this call and never changes global state.
lookupSymbolInParentScopesForNameQualification
[[visibility("default")]] SgSymbol* lookupSymbolInParentScopesForNameQualification( SgName const& name, SgScopeStatement* currentScope, VariantT requestedSymbolKind, SgType const* type, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList, SgUnorderedNodeSet const& visibleAliasCausalNodes);
Parent-scope lookup for one name-qualification invocation. The caller must supply the exact symbol kind and its invocation-owned alias visibility set.
lookupTemplateClassSymbolInParentScopes
[[visibility("default")]] SgTemplateClassSymbol* lookupTemplateClassSymbolInParentScopes( SgName const& name, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList, SgScopeStatement* cscope = NULL);
lookupTemplateFunctionSymbolInParentScopes
[[visibility("default")]] SgFunctionSymbol* lookupTemplateFunctionSymbolInParentScopes( SgName const& functionName, SgFunctionType* ftype, SgTemplateParameterPtrList* tplparams, SgScopeStatement* currentScope = NULL);
lookupTemplateMemberFunctionSymbolInParentScopes
[[visibility("default")]] SgFunctionSymbol* lookupTemplateMemberFunctionSymbolInParentScopes( SgName const& functionName, SgFunctionType* ftype, SgTemplateParameterPtrList* tplparams, SgScopeStatement* currentScope = NULL);
lookupTemplateVariableSymbolInParentScopes
[[visibility("default")]] SgTemplateVariableSymbol* lookupTemplateVariableSymbolInParentScopes( SgName const& name, SgTemplateParameterPtrList* tplparams, SgTemplateArgumentPtrList* tplargs, SgScopeStatement* currentScope = NULL);
lookupTypedefSymbolInParentScopes
[[visibility("default")]] SgTypedefSymbol* lookupTypedefSymbolInParentScopes( SgName const& name, SgScopeStatement* currentScope = NULL);
lookupVariableSymbolInParentScopes
[[visibility("default")]] SgVariableSymbol* lookupVariableSymbolInParentScopes( SgName const& name, SgScopeStatement* currentScope = NULL);
loopCollapsing
SgExprListExp* loopCollapsing( SgForStatement* target_loop, size_t collapsing_factor, SgStatement* setup_insertion_anchor = nullptr);
loopInterchange
[[visibility("default")]] 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 number within (0,depth!).
loopTiling
[[visibility("default")]] void loopTiling( SgForStatement* loopNest, std::vector<size_t> const& tileSizes);
loopTiling overloads
loopUnrolling
[[visibility("default")]] void loopUnrolling( SgForStatement* loop, size_t unrolling_factor);
Unroll a target loop by grouping exact source iterations. The checked implementation never synthesizes range, endpoint, or stride products.
makeSingleStatementBodyToBlock
SgBasicBlock* makeSingleStatementBodyToBlock(SgStatement* singleStmt);
Make a single statement body to be a basic block. Its parent is if, while, catch, etc.
markNodeToBeUnparsed
void markNodeToBeUnparsed( SgNode* node, int physical_file_id);
markSubtreeToBeUnparsed
void markSubtreeToBeUnparsed( SgNode* root, int physical_file_id);
materializeTypeWithCopyMap
SgType* materializeTypeWithCopyMap( SgType* type, SgCopyHelp& help, bool copyOwnedSyntax = true);
mergeAssignmentWithDeclaration
[[visibility("default")]] bool mergeAssignmentWithDeclaration( SgExprStatement* assign_stmt, SgVariableDeclaration* decl);
Merge an assignment into its upstream declaration statement. Callers should make sure the merge is semantically correct.
mergeDeclarationAndAssignment
[[visibility("default")]] bool mergeDeclarationAndAssignment( SgVariableDeclaration* decl, SgExprStatement* assign_stmt);
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.
mergeDeclarationWithAssignment
[[visibility("default")]] bool mergeDeclarationWithAssignment( SgVariableDeclaration* decl, SgExprStatement* assign_stmt);
Merge a declaration statement into a matching followed variable assignment. Callers should make sure the merge is semantically correct (by not introducing compilation errors). This function simply does the merge transformation, without eligibility check.
moveCommentsToNewStatement
[[visibility("default")]] void moveCommentsToNewStatement( SgStatement* sourceStatement, std::vector<int> const& indexList, SgStatement* destinationStatement, bool destinationStatementPreceedsSourceStatement);
Relocate comments and CPP directives from one statement to another.
moveForStatementIncrementIntoBody
[[visibility("default")]] void moveForStatementIncrementIntoBody(SgForStatement* f);
movePreprocessingInfo
[[visibility("default")]] 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 specified source-relative position to a specified target position, otherwise move all preprocessing information with position information intact. The preprocessing information is appended to the existing preprocessing information list of the target node by default. Prepending is used if usePreprend is set to true. Optionally, the relative position can be adjust after the moving using dst_position.
moveStatementsBetweenBlocks
[[visibility("default")]] void moveStatementsBetweenBlocks( SgBasicBlock* sourceBlock, SgBasicBlock* targetBlock);
moveStatementsBetweenBlocks overloads
moveUpInnerDanglingIfEndifDirective
[[visibility("default")]] int moveUpInnerDanglingIfEndifDirective(SgLocatedNode* lnode);
moveVariableDeclaration
[[visibility("default")]] void moveVariableDeclaration( SgVariableDeclaration* decl, SgScopeStatement* target_scope);
Move a variable declaration to a new scope, handle symbol, special scopes like For loop, etc.
moveVariableDeclarationGroup
[[visibility("default")]] void moveVariableDeclarationGroup( SgDeclarationGroupStatement* group, SgBasicBlock* target);
Move a source group of variable declarations atomically into a block.
myRemoveStatement
[[visibility("default")]] void myRemoveStatement(SgStatement* stmt);
A special purpose statement removal function, originally from inlinerSupport.h, Need Jeremiah's attention to refine it. Please don't use it for now.
nonrealTypeCarriesWrittenQualification
[[visibility("default")]] bool nonrealTypeCarriesWrittenQualification(SgNonrealType const* nonreal_type);
nonrealTypeHasSemanticQualificationChain
[[visibility("default")]] bool nonrealTypeHasSemanticQualificationChain(SgNonrealType const* nonreal_type);
normalizeArrowExpWithAddressOfLeftOperand
[[visibility("default")]] int normalizeArrowExpWithAddressOfLeftOperand( SgNode* root, bool transformationGeneratedOnly = true);
Convert all code within root matching the patern of (&left)->right, and translate them into left.right. Return the number of matches of the pattern. Be default, only transformation generated nodes will be normalized.
normalizeCaseAndDefaultBlocks
[[visibility("default")]] bool normalizeCaseAndDefaultBlocks(SgSwitchStatement* switchStmt);
Normalize the structure of case and default blocks within a switch statement.
normalizeForLoopIncrement
[[visibility("default")]] void normalizeForLoopIncrement(SgForStatement* loop);
normalizeForLoopInitDeclaration
[[visibility("default")]] void normalizeForLoopInitDeclaration(SgForStatement* loop);
Normalize loop init stmt by promoting the single variable declaration statement outside of the for loop header's init statement, e.g. for (int i=0;) becomes int i_x; for (i_x=0;..) and rewrite the loop with the new index variable, if necessary
normalizeForLoopTest
[[visibility("default")]] void normalizeForLoopTest(SgForStatement* loop);
Validate a for loop's typed comparison without changing its inclusivity.
outputGlobalFunctionTypeSymbolTable
void outputGlobalFunctionTypeSymbolTable();
Output function type symbols in global function type symbol table.
outputLocalSymbolTables
[[visibility("default")]] void outputLocalSymbolTables(SgNode* node);
Output the local symbol tables.
pastePreprocessingInfo
[[visibility("default")]] 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 cutPreprocessingInfo()
preOrderCollectPreprocessingInfo
[[visibility("default")]] void preOrderCollectPreprocessingInfo( SgNode* current, std::vector<PreprocessingInfo*>& infoList, int depth);
prepareStatementInsertionAnchor
[[visibility("default")]] SgStatement* prepareStatementInsertionAnchor(SgStatement* targetStmt);
Normalize an attached statement into the exact lexical anchor used by a subsequent sibling insertion.
prepareTemplateArgumentCopy
void prepareTemplateArgumentCopy( SgTemplateArgument const* argument, SgCopyHelp& help);
prepareTemplateParameterTypeCopy
void prepareTemplateParameterTypeCopy( SgTemplateParameter const* parameter, SgCopyHelp& help);
prependArg
[[visibility("default")]] SgVariableSymbol* prependArg( SgFunctionParameterList*, SgInitializedName*);
Prepend an argument to SgFunctionParameterList
prependStatement
[[visibility("default")]] void prependStatement( SgStatement* stmt, SgForInitStatement* for_init_stmt);
prependStatement overloads
prependStatementList
[[visibility("default")]] void prependStatementList( std::vector<SgStatement*> const& stmt, SgScopeStatement* scope);
Prepend a list of statements to the beginning of an explicit lexical scope.
printAST2TextFile
void printAST2TextFile( SgNode* node, char const* filename, bool printType = true);
Pretty print AST horizontally, output to a specified text file. If printType is set to false, don't print out type info.
promoteSemanticOnlyNodeToGeneratedOutput
[[visibility("default")]] void promoteSemanticOnlyNodeToGeneratedOutput( SgLocatedNode* semanticNode, SgLocatedNode* exactOwner);
Promote one exact semantic-only frontend node that a transformation has rewritten into an independently emitted lexical node. The caller supplies the attached physical output owner explicitly; semantic descendants are not reclassified implicitly.
publishClassMemberAccessAtLexicalBoundary
[[visibility("default")]] void publishClassMemberAccessAtLexicalBoundary( SgDeclarationStatement* declaration, SgClassDefinition* definition);
Publish and validate the effective access of a declaration at its exact structural position in a C++ class definition. Fresh builder declarations may arrive with an unclassified access modifier; source-backed declarations must already agree with the surrounding access-label stream.
publishGeneratedPreprocessingInfo
[[visibility("default")]] void publishGeneratedPreprocessingInfo( PreprocessingInfo* record, SgLocatedNode* exactOwner);
Publish a generated preprocessing record with one exact physical output owner. The record remains typed as a transformation; its Sg_File_Info keeps logical spelling provenance and stores physical output identity separately.
publishGeneratedSubtreeOutputOwner
[[visibility("default")]] void publishGeneratedSubtreeOutputOwner( SgNode* generatedSubtree, SgLocatedNode* exactOwner);
Publish or validate the exact output owner for generated located nodes before a subtree crosses an attached AST mutation boundary. A physical owner publishes its exact file and occurrence. A semantic owner instead publishes detached transformation descendants as semantic-only frontend structure and validates existing semantic descendants.
publishGeneratedTrailingComment
[[visibility("default")]] void publishGeneratedTrailingComment( PreprocessingInfo* record, SgLocatedNode* exactOwner);
Publish a generated trailing comment whose explicit attachment is after the owner's syntax on the owner's current output line.
publishPreprocessingInfoPhysicalOutputOwner
[[visibility("default")]] void publishPreprocessingInfoPhysicalOutputOwner( PreprocessingInfo* record, SgLocatedNode* exactOwner);
Publish an existing preprocessing record at a new exact physical output owner. Source-spelled records retain their logical spelling and semantic classification while their physical output identity changes; generated records are validated by publishGeneratedPreprocessingInfo().
querySubTree
template<typename NodeType> 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.
rebindVariableReferencesAfterMove
[[visibility("default")]] void rebindVariableReferencesAfterMove(SgNode* root);
Mostly used internally when some AST pieces are built without knowing their target scope/parent, especially during bottom-up construction of AST. The associated symbols, parent and scope pointers cannot be set on construction then. A set of utility functions are provided to patch up scope, parent, symbol for them when the target scope/parent become know.
recordNormalizations
[[visibility("default")]] void recordNormalizations(SgStatement* s);
Record where normalization have been done so that we can preform denormalizations as required for the token-based unparsing to generate minimal diffs.
recursivePrintCurrentAndParent
void recursivePrintCurrentAndParent(SgNode* n);
Recursively print current and parent nodes. used within gdb to probe the context of a node.
registerAstTeardownAtExit
[[visibility("default")]] void registerAstTeardownAtExit();
Register an AST teardown handler to run at process exit if cleanup was not invoked.
registerAstTeardownProject
[[visibility("default")]] void registerAstTeardownProject(SgProject* project);
Record a project for teardown when running exit handlers.
relocateAttachedPreprocessingInfoPhysicalOutputOwner
[[visibility("default")]] void relocateAttachedPreprocessingInfoPhysicalOutputOwner( PreprocessingInfo* record, SgLocatedNode* priorOwner, SgLocatedNode* exactOwner);
Relocate an already-published preprocessing record whose typed output placement is the attached AST boundary. The record must identify priorOwner exactly; detached, shared, source-position-owned, or differently owned records are hard errors. Source/generated spelling provenance is immutable.
relocateGeneratedSubtreePhysicalOutputOwner
[[visibility("default")]] void relocateGeneratedSubtreePhysicalOutputOwner( SgNode* generatedSubtree, SgLocatedNode* priorOwner, SgLocatedNode* exactOwner);
Relocate generated descendants of an already-published subtree through one explicit physical-output file-and-occurrence transfer. Source-spelled descendants retain their original physical provenance. Every generated position must identify priorOwner exactly; this API never infers or repairs an owner.
removeAllOriginalExpressionTrees
[[visibility("default")]] void removeAllOriginalExpressionTrees(SgNode* top);
Delete exactly owned source-provenance trees before transforming their semantic expression owners.
removeConsecutiveLabels
[[visibility("default")]] void removeConsecutiveLabels(SgNode* top);
Remove consecutive labels
removeConst
SgType* removeConst(SgType* t);
Remove const (if present) from a type. stripType() cannot do this because it removes all modifiers.
removeJumpsToNextStatement
[[visibility("default")]] void removeJumpsToNextStatement(SgNode*);
Remove jumps whose label is immediately after the jump. Used to clean up inlined code fragments.
removeLabeledGotos
[[visibility("default")]] void removeLabeledGotos(SgNode* top);
Remove labeled goto statements
removeStatement
[[visibility("default")]] void removeStatement( SgStatement* stmt, bool autoRelocatePreprocessingInfo = true);
Remove a statement from its attach point of the AST. Automatically keep its associated preprocessing information at the original place after the removal. The statement is still in memory and it is up to the users to decide if the removed one will be inserted somewhere else or released from memory (deleteAST()).
removeUnusedLabels
[[visibility("default")]] void removeUnusedLabels( SgNode* top, bool keepChild = false);
Remove labels which are not targets of any goto statements: its child statement is also removed by default.
replaceExpression
[[visibility("default")]] 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.
replaceExpressionWithStatement
[[visibility("default")]] void replaceExpressionWithStatement( SgExpression* from, SageInterface::StatementGenerator* to);
Replace a given expression with a list of statements produced by a generator
replaceFunctionDefinitionWithDeclaration
[[visibility("default")]] SgDeclarationStatement* replaceFunctionDefinitionWithDeclaration( SgFunctionDeclaration* functionDefinition, bool movePreprocessingInfo = true);
Replace an exact defining function declaration with a legal declaration source surface. Free functions and member definitions written in their class are replaced by a newly built prototype. A member definition written outside its semantic class scope is replaced by SgEmptyDeclaration because a namespace-scope qualified member prototype is ill-formed C++. The removed definition remains semantically owned by its scope's SgAuxiliaryDeclarationList and its complete declaration family and symbol are preserved. Malformed or unsupported inputs are hard errors; this function never returns null.
replaceStatement
[[visibility("default")]] void replaceStatement( SgStatement* oldStmt, SgStatement* newStmt, bool movePreprocessinInfo = false);
Replace a statement with another. Move preprocessing information from oldStmt to newStmt if requested.
replaceSubexpressionWithStatement
[[visibility("default")]] void replaceSubexpressionWithStatement( SgExpression* from, SageInterface::StatementGenerator* to);
Similar to replaceExpressionWithStatement, but with more restrictions. Assumptions: from is not within the test of a loop or ifStmt, not currently traversing from or the statement it is in
replaceVariableReferences
[[visibility("default")]] 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.
replaceWithPattern
[[visibility("default")]] 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.
requireCanonicalVariableTemplatePrimary
[[visibility("default")]] SgTemplateVariableDeclaration* requireCanonicalVariableTemplatePrimary( SgTemplateVariableDeclaration* specialization, char const* context);
Return the canonical source variable template reached from a specialization after validating the complete, acyclic specialized-template chain.
requireCheckedCanonicalLoopPlan
[[visibility("default")]] CheckedCanonicalLoopPlan requireCheckedCanonicalLoopPlan( SgForStatement* loop, char const* operation);
Build a checked loop plan without modifying or allocating into the AST.
requireCheckedLoopTilingPlan
[[visibility("default")]] CheckedLoopTilingPlan requireCheckedLoopTilingPlan( SgForStatement* outer, std::vector<size_t> const& tile_sizes, char const* operation = "loop-tiling");
Validate a complete perfect nest and all tile sizes without mutation, then commit the planned strip-mining transformations in place.
requireCheckedLoopUnrollPlan
[[visibility("default")]] CheckedLoopUnrollPlan requireCheckedLoopUnrollPlan( SgForStatement* loop, size_t factor, char const* operation = "loop-unrolling");
Read-only unroll planning and one atomic commit.
requireNamedTypeInParentScopes
[[visibility("default")]] SgType* requireNamedTypeInParentScopes( std::string const& type_name, SgScopeStatement* scope);
Return an existing named type or terminate if the current AST has no such declaration. This never synthesizes a placeholder declaration.
requireResolvedFunctionTemplateReference
[[visibility("default")]] SgFunctionDeclaration* requireResolvedFunctionTemplateReference( SgNonrealRefExp const* reference, char const* context);
Validate and return the exact callable denoted by a resolved function- template nonreal reference. This is a hard AST contract: the synthetic source-spelling node, the real callable declaration, its canonical symbol, its function type, and both copies of the written arguments must agree.
requireResolvedVariableTemplateReference
[[visibility("default")]] SgInitializedName* requireResolvedVariableTemplateReference( SgNonrealRefExp const* reference, char const* context);
Validate and return the exact initialized name denoted by a resolved variable-template nonreal reference. This is a hard AST contract: the synthetic source-spelling node, the real specialization, its source template, its symbol, and both copies of the written arguments must agree.
requireStatementCanBeTransformed
[[visibility("default")]] void requireStatementCanBeTransformed(SgStatement* stmt);
Require exact physical/include ownership before mutating a statement in a token-unparsed header. Ambiguous or unsupported ownership is a hard error.
requireTargetDefaultPointerSizeBits
[[visibility("default")]] unsigned int requireTargetDefaultPointerSizeBits(SgNode const* context);
requireTargetFloatingDomain
[[visibility("default")]] void requireTargetFloatingDomain( SgType* type, SgNode const* context, unsigned int& precision, int& max_exponent);
requireTargetIntegerDomain
[[visibility("default")]] void requireTargetIntegerDomain( SgType* type, SgNode const* context, bool& is_unsigned, unsigned int& width);
requireTargetScalarSizeBits
[[visibility("default")]] unsigned int requireTargetScalarSizeBits( SgType* type, SgNode const* context);
requireTargetSizeType
[[visibility("default")]] SgType* requireTargetSizeType(SgNode const* context);
Return the exact target ABI type used by sizeof/alignof for the context's one owning translation unit. Detached or untyped contexts are malformed.
resetInternalMapsForTargetStatement
[[visibility("default")]] void resetInternalMapsForTargetStatement( SgStatement* sourceStatement, bool statementWillBeDetached = false);
resetMangledNameCache
void resetMangledNameCache(SgGlobal* globalScope);
resetScopeNumbers
void resetScopeNumbers(SgFunctionDefinition* functionDeclaration);
Assigns unique numbers to each SgScopeStatement of a function.
reset_name_collision_map
void reset_name_collision_map();
Reset map variables used to support generateUniqueNameForUseAsIdentifier() function.
retireBasicBlockNormalization
[[visibility("default")]] void retireBasicBlockNormalization(SgBasicBlock* block);
retireForLoopInitNormalization
[[visibility("default")]] void retireForLoopInitNormalization(SgForStatement* loop);
saveToPDF
void saveToPDF(SgNode* node);
Save AST into a pdf file. Start from a node to find its enclosing file node. The entire file's AST will be saved into a pdf.
scopeHasStatementsFromSameFile
[[visibility("default")]] bool scopeHasStatementsFromSameFile(SgScopeStatement* scope);
This function supports the token-based unparsing when used with unparsing of header files to know when the scope can be unparsed via it's token stream, even though a statement from a header file may contain a transformation. returns true if there is a statement in the scope that has to be unparsed (is from the same file as the scope). returns false if the scope is empty or contains only statements associated with one or more header files.
serialize
void serialize( SgNode* node, std::string& prefix, bool hasRemaining, std::ostringstream& out, std::string& edgeLabel);
we have two serialize() functions, one for a single node, the other for a list of pointers
serialize_list
template<typename T> void serialize_list( T& plist, std::string T_name, std::string& prefix, bool hasRemaining, std::ostringstream& out, std::string& edgeLabel);
setAbbreviatedFunctionTemplateParameter
[[visibility("default")]] void setAbbreviatedFunctionTemplateParameter( SgTemplateParameter* param, bool is_abbreviated_placeholder = true);
setBaseTypeDefiningDeclaration
void setBaseTypeDefiningDeclaration( SgVariableDeclaration* var_decl, SgDeclarationStatement* base_decl);
a better version for SgVariableDeclaration::set_baseTypeDefininingDeclaration(), handling all side effects automatically Used to have a struct declaration embedded into a variable declaration
setCanonicalForLoopInclusiveComparison
[[visibility("default")]] void setCanonicalForLoopInclusiveComparison( SgForStatement* loop, bool increasing);
setCtorInitializerList
template<class actualMemberFunction> void setCtorInitializerList( actualMemberFunction* func, SgCtorInitializerList* ctorlist);
Publish an exactly constructed ctor-initializer list for a member function.
setExtern
[[visibility("default")]] void setExtern(SgDeclarationStatement* stmt);
Set a declaration as extern
setFortranNumericLabel
[[visibility("default")]] void setFortranNumericLabel( SgStatement* stmt, int label_value, SgLabelSymbol::label_type_enum label_type, SgScopeStatement* label_scope);
Set a numerical label for a Fortran statement in its exact program-unit label scope. SgLabelSymbol and SgLabelRefExp are created as needed.
setLoopBody
[[visibility("default")]] void setLoopBody( SgScopeStatement* loop, SgStatement* body);
setLoopCondition
[[visibility("default")]] void setLoopCondition( SgScopeStatement* loop, SgStatement* cond);
Set the condition statement of a loop, including While-loop, For-loop, and Do-While-loop.
setLoopLowerBound
[[visibility("default")]] void setLoopLowerBound( SgNode* loop, SgExpression* lb);
Set the lower bound of a loop header for (i=lb; ...)
setLoopStride
[[visibility("default")]] void setLoopStride( SgNode* loop, SgExpression* stride);
Set the stride(step) of a loop 's incremental expression, regardless the expression types (i+=s; i= i+s, etc)
setLoopUpperBound
[[visibility("default")]] 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, ...)
setOneSourcePositionForTransformation
[[visibility("default")]] void setOneSourcePositionForTransformation(SgNode* root);
Set current node's source position as transformation generated
setOneSourcePositionNull
[[visibility("default")]] void setOneSourcePositionNull(SgNode* node);
Set current node's source position as NULL
setOperand
[[visibility("default")]] void setOperand( SgExpression* target, SgExpression* operand);
Set one expression operand and its parent.
setParameterList
template<class actualFunction> void setParameterList( actualFunction* func, SgFunctionParameterList* paralist);
Install a builder's parameter list and publish its exact declaration links.
setPragma
[[visibility("default")]] void setPragma( SgPragmaDeclaration* decl, SgPragma* pragma);
Set a pragma of a pragma declaration. handle memory release for preexisting pragma, and set parent pointer.
setSemanticOnlyFrontendSourcePosition
[[visibility("default")]] void setSemanticOnlyFrontendSourcePosition(SgLocatedNode* semanticNode);
Classify one freshly constructed, non-expression frontend node as semantic name/structure infrastructure. Any existing or partial source position is a producer error.
setSourcePosition
[[visibility("default")]] void setSourcePosition(SgNode* node);
Set the source code positon for the current (input) node.
setSourcePositionAsTransformation
void setSourcePositionAsTransformation(SgNode* node);
setSourcePositionAtRootAndAllChildren
[[visibility("default")]] void setSourcePositionAtRootAndAllChildren(SgNode* root);
Set the source code positon for the subtree (including the root).
setSourcePositionForTransformation
[[visibility("default")]] void setSourcePositionForTransformation(SgNode* root);
Recursively set source position info(Sg_File_Info) as transformation generated
setStatic
[[visibility("default")]] void setStatic(SgDeclarationStatement* stmt);
Set a declaration as static
setTemplateParameterKeyword
[[visibility("default")]] void setTemplateParameterKeyword( SgTemplateParameter* param, SgTemplateParameter::template_parameter_keyword_enum kw);
set_name
[[visibility("default")]] int set_name( SgInitializedName* initializedNameNode, SgName new_name);
set_name of symbol in symbol table.
sortSgNodeListBasedOnAppearanceOrderInSource
[[visibility("default")]] std::vector<SgDeclarationStatement*> sortSgNodeListBasedOnAppearanceOrderInSource(std::vector<SgDeclarationStatement*> const& nodevec);
Reorder a list of declaration statements based on their appearance order in source files
splitExpression
[[visibility("default")]] SgAssignInitializer* splitExpression( SgExpression* from, std::string newName = "");
Replace an expression with a temporary variable and an assignment statement
splitExpressionIntoBasicBlock
[[visibility("default")]] void splitExpressionIntoBasicBlock(SgExpression* expr);
Split long expressions into blocks of statements
splitVariableDeclaration
[[visibility("default")]] SgExprStatement* splitVariableDeclaration(SgVariableDeclaration* decl);
splitVariableDeclaration overloads
suggestNextNumericLabel
[[visibility("default")]] int suggestNextNumericLabel(SgFunctionDefinition* func_def);
Suggest next usable (non-conflicting) numeric label value for a Fortran function definition scope
tearDownAst
[[visibility("default")]] void tearDownAst(SgProject* project);
Explicitly tear down an AST and release global caches and memory pools. AST pointers are invalid after this call.
templateArgumentEquivalence
[[visibility("default")]] bool templateArgumentEquivalence( SgTemplateArgument* arg1, SgTemplateArgument* arg2);
Verify that 2 SgTemplateArgument are equivalent (same type, same expression, or same template declaration)
templateArgumentListEquivalence
[[visibility("default")]] bool templateArgumentListEquivalence( SgTemplateArgumentPtrList const& list1, SgTemplateArgumentPtrList const& list2);
Verify that 2 SgTemplateArgumentPtrList are equivalent.
templateDefinitionIsInClass
[[visibility("default")]] bool templateDefinitionIsInClass(SgTemplateInstantiationMemberFunctionDecl* memberFunctionDeclaration);
Return true if template definition is in the class, false if outside of class.
templateExpressionEquivalence
[[visibility("default")]] bool templateExpressionEquivalence( SgExpression const* left, SgExpression const* right);
templateParameterEquivalence
[[visibility("default")]] bool templateParameterEquivalence( SgTemplateParameter* parameter1, SgTemplateParameter* parameter2);
Verify that two template parameters describe the same parameter identity.
templateParameterListEquivalence
[[visibility("default")]] bool templateParameterListEquivalence( SgTemplateParameterPtrList const& list1, SgTemplateParameterPtrList const& list2);
Verify that two template parameter lists describe the same signature.
transferSymbols
[[visibility("default")]] void transferSymbols( SgScopeStatement* from_scope, SgScopeStatement* to_scope, bool skip_label_symbols = true);
typeCarriesIntrinsicNonrealQualification
[[visibility("default")]] bool typeCarriesIntrinsicNonrealQualification(SgType const* type);
typeCarriesWrittenNonrealQualification
[[visibility("default")]] bool typeCarriesWrittenNonrealQualification(SgType const* type);
typeHasSemanticNonrealQualificationChain
[[visibility("default")]] bool typeHasSemanticNonrealQualificationChain(SgType const* type);
unnormalizeForLoopInitDeclaration
[[visibility("default")]] bool unnormalizeForLoopInitDeclaration(SgForStatement* loop);
Undo the normalization of for loop's C99 init declaration. Previous record of normalization is used to ease the reverse transformation.
updateDefiningNondefiningLinks
[[visibility("default")]] void updateDefiningNondefiningLinks( SgFunctionDeclaration* func, SgScopeStatement* scope);
Validate a published function's canonical symbol and link its exact declaration family when the new function is a definition.
usualArithmeticConversionType
[[visibility("default")]] SgType* usualArithmeticConversionType( SgType* lhs, SgType* rhs, SgNode const* context);
Apply the C/C++ usual arithmetic conversions using the target ABI owned by context. Invalid, non-arithmetic, or detached inputs are hard errors.
validateFortranCommonBlockRef
[[visibility("default")]] void validateFortranCommonBlockRef(SgFortranCommonBlockRefExp const* reference);
Enforce the semantic and exact-source identity contract of a typed Fortran common-block directive designator.
validateSymbolOwnership
void validateSymbolOwnership(SgNode* root);
Validate that every symbol has one exact owning symbol-table entry.
whereAmI
void whereAmI(SgNode* node);
Diagnostic function for tracing back through the parent list to understand at runtime where in the AST a failure happened.
wrapFunction
std::pair<SgStatement*, SgInitializedName*> wrapFunction( SgFunctionDeclaration& definingDeclaration, SgName newName);
wrapFunction overloads

SageInterface::Detail

Name
fortranIntegerSelectorValue
std::optional<Rose::Integer128Value> fortranIntegerSelectorValue(SgExpression const*);
hasExactFortranFunctionReferenceBindings
bool hasExactFortranFunctionReferenceBindings( SgFunctionSymbol* semantic, SgFunctionSymbol* visible, SgFunctionRefExp::fortran_source_visible_binding_kind_enum kind);
isExactFortranSemanticProcedurePublication
bool isExactFortranSemanticProcedurePublication(SgFunctionSymbol* symbol);
isValidFortranKindSelector
bool isValidFortranKindSelector(SgExpression const*);
isValidFortranLengthSelector
bool isValidFortranLengthSelector(SgExpression const*);
unsignedValueFitsIn
template< typename Target, typename Source> constexpr bool unsignedValueFitsIn(Source value) noexcept;

TransformationTracking

Name Description
addInputNode
void addInputNode( SgNode* affected_node, SgNode* inputnode);
clearId
void clearId(SgNode*);
getFileInfo
std::pair<Sg_File_Info*, Sg_File_Info*> getFileInfo(AST_NODE_ID id);
getId
AST_NODE_ID getId(SgNode*);
getNextId
AST_NODE_ID getNextId();
getNode
SgNode* getNode(AST_NODE_ID id);
hasId
bool hasId(SgNode* n);
registerAstSubtreeIds
void registerAstSubtreeIds(SgNode* root);
Assign Ids and save current File Info.
setId
void setId(SgNode*);

VirtualCFG

Name Description
cfgBeginningOfConstruct
CFGNode cfgBeginningOfConstruct(SgNode* c);
The first CFG node for a construct (before the construct starts to execute)
cfgEndOfConstruct
CFGNode cfgEndOfConstruct(SgNode* c);
The last CFG node for a construct (after the entire construct has finished executing). This node may not actually be reached if, for example, a goto causes a loop to be exited in the middle
cfgIndexForEndWrapper
unsigned int cfgIndexForEndWrapper(SgNode* n);
cfgToDot
[[visibility("default")]] void cfgToDot( SgNode* start, std::string const& file_name);
Dump the filtered dot graph of a virtual control flow graph starting from SgNode (start)
cfgToDotForDebugging
[[visibility("default")]] void cfgToDotForDebugging( SgNode* start, std::string const& file_name);
Dump the full dot graph of a virtual control flow graph starting from SgNode (start)
defaultFilter
bool defaultFilter(CFGNode cfgn);
dfaToDot
template<typename FilterFunction> [[visibility("default")]] std::ostream& dfaToDot( std::ostream& o, std::string graphName, std::vector<FilteredCFGNode<FilterFunction>> start, DefUseAnalysis* dfa);
getCFGTargetOfFortranLabelRef
CFGNode getCFGTargetOfFortranLabelRef(SgLabelRefExp* lRef);
getCFGTargetOfFortranLabelSymbol
CFGNode getCFGTargetOfFortranLabelSymbol(SgLabelSymbol* sym);
interestingCfgToDot
[[visibility("default")]] void interestingCfgToDot( SgNode* start, std::string const& file_name);
Dump a CFG with only interesting nodes for a SgNode
makeCfg
CFGNode makeCfg(SgNode* start);
Returns CFG node for just before start
makeClosure
template< typename FilteredEdge, typename Filter> std::vector<FilteredEdge> makeClosure( std::vector<CFGEdge> const& orig, std::vector<CFGEdge> const(CFGNode::* closure)(), CFGNode const(CFGPath::* otherSide)(), CFGPath(* merge)(CFGPath const&, CFGPath const&), Filter const& filter);
makeEdge
template< class Node1T, class Node2T, class EdgeT> void makeEdge( Node1T from, Node2T to, std::vector<EdgeT>& result);
Utility function to make CFG Edges
makeInterestingCfg
InterestingNode makeInterestingCfg(SgNode* start);
mergePaths
CFGPath mergePaths( CFGPath const& hd, CFGPath const& tl);
mergePathsReversed
CFGPath mergePathsReversed( CFGPath const& tl, CFGPath const& hd);
printEdge
template< typename EdgeT, bool Debug> void printEdge( std::ostream& o, EdgeT const& e, bool isInEdge);
Edge printer
printNode
template< typename NodeT, bool Debug> void printNode( std::ostream& o, NodeT const& n);
Helper function to print Node information
printNodePlusEdges
template< typename NodeT, typename EdgeT, bool Debug> void printNodePlusEdges( std::ostream& o, NodeT n);
Print out a node plus all its outgoing edges

WalrusGraph

Name
generateWalrusGraph
void generateWalrusGraph( SgNode* node, std::string outputFilename);

cfgUtils

Name
getFuncEndCFG
VirtualCFG::DataflowNode getFuncEndCFG( SgFunctionDefinition* func, bool(* f)(VirtualCFG::CFGNode) = VirtualCFG::defaultFilter);
getFuncStartCFG
VirtualCFG::DataflowNode getFuncStartCFG( SgFunctionDefinition* func, bool(* f)(VirtualCFG::CFGNode) = VirtualCFG::defaultFilter);
unwrapCasts
SgExpression const* unwrapCasts(SgExpression const* e);

legacy

Name Description
anyOfListPotentiallyModifiedIn
bool anyOfListPotentiallyModifiedIn( std::vector<SgVariableSymbol*> const& syms, SgNode* n);
Are any variables in syms modified anywhere within n, or is n a declaration of one of them?
countComputationsOfExpressionIn
int countComputationsOfExpressionIn( SgExpression* expr, SgNode* root);
Count guaranteed computations, respecting conditional and unevaluated operands. Changes to expr's inputs require a separate check.
expressionComputedIn
bool expressionComputedIn( SgExpression* expr, SgNode* root);
Is expr guaranteed to be computed when root completes normally? Changes to expr's inputs require a separate check.

legacy::PRE

Name Description
addEdgeInsertionPoints
void addEdgeInsertionPoints(ControlFlowGraph& controlflow);
Add information to each edge on where to insert statements on that edge. The insertion point structure is a pair of (SgNode*, bool), where the bool is true for inserting before the given node and false for inserting after it.
makeCfg
void makeCfg( SgFunctionDefinition* n, ControlFlowGraph& graph);
Make the control flow graph for a given node
partialRedundancyElimination
[[visibility("default")]] void partialRedundancyElimination(SgNode* n);
Do partial redundancy elimination on all functions within the scope n.
partialRedundancyEliminationFunction
void partialRedundancyEliminationFunction(SgFunctionDefinition* n);
Do partial redundancy for all expressions within a given function, whose definition is given in n.
partialRedundancyEliminationOne
void partialRedundancyEliminationOne( SgExpression* expr, SgBasicBlock* root, myControlFlowGraph const& cfg, std::vector<SgExpression*>& retired_expressions);
Do partial redundancy elimination, looking for copies of one expression expr within the basic block root. A control flow graph for root must be provided in cfg, with a map from nodes to their statements in node_statements, a map from edges to their CFG edge types in edge_type, and a map from edges to their insertion points in edge_insertion_point. The algorithm used is that of Paleri, Srikant, and Shankar ("Partial redundancy elimination: a simple, pragmatic, and provably correct algorithm", Science of Computer Programming 48 (2003) 1--20). Removed roots are appended to retired_expressions. The caller owns them until its expression worklist and equality scans have finished, then must delete them. Their former AST parents are cleared at replacement.

rwAccessLabeler

Name
accessTypeToStr
std::string accessTypeToStr(accessType t);
addRWAnnotations
void addRWAnnotations(SgNode* root);
cloneAccessType
void cloneAccessType( SgNode* tgt, SgNode* src);
getAccessType
accessType getAccessType(SgNode* n);

sg

Name
_ancestor
template< class AncestorNode, class QualSgNode> AncestorNode* _ancestor(QualSgNode& n);
_dispatch
template<class RoseVisitor> std::remove_const<std::remove_reference<RoseVisitor>::type>::type _dispatch( RoseVisitor&& rv, SgNode* n);
ancestor
template<class AncestorNode> AncestorNode& ancestor(SgNode& n);
dispatch
template<class RoseVisitor> std::remove_const<std::remove_reference<RoseVisitor>::type>::type dispatch( RoseVisitor&& rv, SgNode* n);
report_error
[[noreturn]] void report_error( std::string desc, char const* file = nullptr, size_t ln = 0); [noreturn]
unexpected_node
[[noreturn]] void unexpected_node( SgNode const& n, char const* file = nullptr, size_t ln = 0); [noreturn]