Reference¶
Namespaces¶
| Name | Description |
|---|---|
ASTMemoryPool | |
AST_Graph | |
ASTtools | |
AliasAnalysisDetail | |
AstDOTGenerationExtended_Defaults | |
AstQueryNamespace | |
AstUtilInterface | |
CPreproc | |
CallTargetSet | |
CommandlineProcessing | Command line processing utility functions. Functions in this namespace are in the ROSE Utilities library and |
ConstantFolding | |
DUVariableAnalysisExt | |
Dbg | |
DominatorTreesAndDominanceFrontiers | |
IncludeFileGraph | |
Inliner | |
IntegerOps | Bit-wise operations on integers. |
IntegerOpsPrivate | |
MangledNameSupport | |
MaxSourceExtents | |
NameQuery | |
NewCallGraph | |
NodeQuery | |
NumberQuery | |
OmpSupport | Types and functions to support OpenMP |
Outliner | |
ProcessExpression | |
ROSE_Analysis | |
ROSE_Statistics | |
ROSE_token_ids | |
Rose | |
SageBuilder | High level SAGE III AST node and subtree builders. |
SageInterface | Functions that are useful when operating on the AST. |
StaticCFG | |
TransformationTracking | |
VirtualCFG | |
WalrusGraph | |
cfgUtils | |
legacy | |
rose_hash | |
rwAccessLabeler | |
sg | This namespace contains template functions that operate on the ROSE AST |
Types¶
Type Aliases¶
Enums¶
| Name | Description |
|---|---|
AssociativitySpecifier | |
CompareRel | |
CopyArrayOpt | |
Cxx_GrammarVariants | Variants used to identify elements of the grammar used in ROSE Each element is assigned a unique value defined by this enumerated type the values are used to generate the casts from one type toanother were permitted. This is a technique borrowed from the design of SAGE II. |
DepDirType | |
DepDirection | |
DepType | |
Format_Opt | |
MLOG_LEVEL | |
OmpExactSubexpressionKind | |
OpType | |
SimdType | |
SourceQualificationSurface | |
SymOpType | |
SymbolicValType | |
TemplateArgumentEmission | |
TokenStreamIntervalKind | |
VariantT | |
kmp_sched_t | |
t_traverseOrder | |
tgt_map_type |
Functions¶
| Name | Description |
|---|---|
AddConstint AddConst( int a, int b); | |
AnalyzeConditionRefsbool AnalyzeConditionRefs( AstInterface& fa, AstNodePtr const& n, CollectObject<AstNodePtr>& wRefs, CollectObject<AstNodePtr>& rRefs); | |
AnalyzeEquationtemplate< class CoeffVec, class BoundVec, class BoundOp, class Dep> bool AnalyzeEquation( CoeffVec const& vec, BoundVec const& bounds, BoundOp& boundop, Dep& result, DepRel const& rel); | |
AnalyzeStmtRefsbool AnalyzeStmtRefs( AstInterface& fa, AstNodePtr const& n, CollectObject<AstNodePtr>& wRefs, CollectObject<AstNodePtr>& rRefs); | |
ApplyBinOPSymbolicVal ApplyBinOP( SymOpType t, SymbolicVal const& v1, SymbolicVal const& v2); | |
ApplyLoopSplittingvoid ApplyLoopSplitting(LoopTreeNode* r); | |
ApplyUnaryOPSymbolicVal ApplyUnaryOP( SymOpType t, SymbolicVal const& v); | |
AstPostProcessing[[visibility("default")]] void AstPostProcessing(SgNode* node); | |
CloneDepInfoImpl* Clone(DepInfoImpl const& that); | |
ClosureDepInfoSet Closure(DepInfoSet d); | |
CompareValCompareRel CompareVal( SymbolicVal const& v1, SymbolicVal const& v2, MapObject<SymbolicVal, SymbolicBound>* f = 0); | |
ComputeLoopDeptemplate<class Result> void ComputeLoopDep( AstNodePtr const& exp, DepRel const& rel, Result& r); | |
CopyArrayOpt2Stringstd::string CopyArrayOpt2String(CopyArrayOpt opt); | |
CopyNodeEdgetemplate< class Graph, class Node> void CopyNodeEdge( Graph* graph, Node* orig, Node* des); | |
CopySplitNodeEdgetemplate< class Graph, class Node> void CopySplitNodeEdge( Graph* graph, Node* orig, Node* split, DomainCond const& splitCond); | |
CountEnclosedStmtsunsigned int CountEnclosedStmts(LoopTreeNode* root); | |
CountIteratorSizetemplate<class Iter> unsigned int CountIteratorSize(Iter iter); | |
DebugAnnotextern bool DebugAnnot(); | |
DecomposeAffineExpressiontemplate< class VarVec, class CoeffVec> SymbolicVal DecomposeAffineExpression( SymbolicVal const& exp, VarVec const& vars, CoeffVec& vec, int size); | |
DepGraphInsertLooptemplate< class Graph, class SelectNode> void DepGraphInsertLoop( Graph* graph, SelectNode nodes, int level); | |
DepGraphNodeAlignLooptemplate< class Graph, class Node> void DepGraphNodeAlignLoop( Graph* graph, Node* node, int level, int align); | |
DepGraphNodeInsertLooptemplate< class Graph, class Node> void DepGraphNodeInsertLoop( Graph* graph, Node* n, int level); | |
DepGraphNodeMergeLooptemplate< class Graph, class Node> void DepGraphNodeMergeLoop( Graph* graph, Node* node, int desc, int src); | |
DepGraphNodeRemoveLooptemplate< class Graph, class Node> void DepGraphNodeRemoveLoop( Graph* graph, Node* node, int level); | |
DepGraphNodeRestrictDomaintemplate< class Graph, class Node> void DepGraphNodeRestrictDomain( Graph* graph, Node* node, DomainCond const& cond); | |
DepGraphNodeSwapLooptemplate< class Graph, class Node> void DepGraphNodeSwapLoop( Graph* graph, Node* node, int level1, int level2); | |
DepType2Stringstd::string DepType2String(DepType t); | |
DoubleToStringstd::string DoubleToString(double d); | |
EdgeDir2DepDirDepDirection EdgeDir2DepDir(GraphAccess::EdgeDirection dir); | |
Equalbool Equal( SymbolicVal const& v1, SymbolicVal const& v2); | |
FindFirsttemplate< class Iter, class Update> bool FindFirst( Iter& iter, Update T); | |
FindValbool FindVal( SymbolicVal const& v, SymbolicVal const& sub); | |
FuseDepGraphNodetemplate< class Graph, class Node> void FuseDepGraphNode( Graph* graph, Node* orig, Node* split); | |
FuseSliceNestsvoid FuseSliceNests( CompSliceNest& g1, CompSliceNest& g2, DepInfo const& info); | |
GetCommonLooptemplate< class Stmt, class Interface> Stmt GetCommonLoop( Interface& ast_interface, Stmt b1, Stmt b2, int* level = 0); | |
GetEnclosingLooptemplate< class Stmt, class Interface> Stmt GetEnclosingLoop( Stmt n, Interface& ast_interface); | |
GetExprValSymbolicVal GetExprVal(SymbolicExpr* exp); | |
GetFirstOperandSgExpression* GetFirstOperand(SgExpression* expr); | |
GetFusionInfoFusionInfo GetFusionInfo( DepInfo const& info, int index1, int index2); | |
GetImplicitConversionObjectSgExpression* GetImplicitConversionObject(SgFunctionCallExp* call); | |
GetLoopLeveltemplate< class Stmt, class Interface> int GetLoopLevel( Stmt s, Interface& ast_interface); | |
GetOperatorVariantint GetOperatorVariant(SgExpression* expr); | |
GetValBoundSymbolicBound GetValBound( SymbolicVal val, MapObject<SymbolicVal, SymbolicBound>& f); | |
GetValLBSymbolicVal GetValLB( SymbolicVal const& val, MapObject<SymbolicVal, SymbolicBound>& f); | |
GetValUBSymbolicVal GetValUB( SymbolicVal const& val, MapObject<SymbolicVal, SymbolicBound>& f); | |
GraphNodeToStringtemplate< class Graph, class Node> std::string GraphNodeToString( Graph const& g, Node const* n); | |
GraphToStringtemplate<class Graph> std::string GraphToString(Graph const& g); | |
HasFractionbool HasFraction( SymbolicVal const& v, SymbolicVal* integral = 0, SymbolicVal* frac = 0); | |
IncreaseAlignDepRel IncreaseAlign( DepRel const& r, int a); | |
IsImportantForSliceSgFilter[[visibility("default")]] bool IsImportantForSliceSgFilter(SgNode* n); | |
IsNILbool IsNIL(DepInfo const& info); | |
IsOnebool IsOne(SymbolicTerm const& t); | |
IsSimpleStmtbool IsSimpleStmt(LoopTreeNode const* node); | |
IsValidDepbool IsValidDep( DepInfo const& info, int commLevel); | |
IsZerobool IsZero(SymbolicTerm const& t); | |
IteratorToString1template<class Iter> std::string IteratorToString1(Iter iter); | |
IteratorToString2template<class Iter> std::string IteratorToString2(Iter iter); | |
LessThanbool LessThan( DepRel const& e1, DepRel const& e2); | |
MaxSymbolicVal Max( SymbolicVal const& v1, SymbolicVal const& v2, MapObject<SymbolicVal, SymbolicBound>* f = 0); | |
MinSymbolicVal Min( SymbolicVal const& v1, SymbolicVal const& v2, MapObject<SymbolicVal, SymbolicBound>* f = 0); | |
MoveNodeEdgetemplate< class Graph, class Node> void MoveNodeEdge( Graph* graph, Node* orig, Node* des); | |
New_File_InfoSg_File_Info* New_File_Info(SgLocatedNode* p); | |
NormalizeForLoopvoid NormalizeForLoop( AstInterface& fa, AstNodePtr const& head); | |
NormalizeMatrixtemplate<class Mat> bool NormalizeMatrix( Mat& analMatrix, int rows, int cols); | |
OptimizeLoopTreevoid OptimizeLoopTree(LoopTreeNode* r); | |
PrintResultsvoid PrintResults(std::string const buffer); | |
PropagateDefUseChainUpdatetemplate<class Node> void PropagateDefUseChainUpdate( DefUseChain<Node>* graph, UpdateDefUseChainNode<Node>& update); | |
ReadAstTraversebool 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. |
RelToStringstd::string RelToString(CompareRel r); | |
ReplaceValSymbolicVal ReplaceVal( SymbolicVal const& v, MapObject<SymbolicVal, SymbolicVal>& valmap); | |
RestrictDepDomainvoid RestrictDepDomain( DepInfo& dep, DomainInfo const& domain, DepDirection dir); | |
ReverseCompareRel Reverse(CompareRel rel); | |
SelectDepLevelbool SelectDepLevel( DepInfo const& d, int level); | |
SelectDepTypebool SelectDepType( DepInfo const& info, DepType const& sel); | |
SelfSpatialReusefloat SelfSpatialReuse( AstNodePtr const& r, SymbolicVar const& induction, unsigned int linesize); | |
SetDepDirectiontemplate<class Collect> int SetDepDirection( DepInfo& edd, int commLevel, Collect& result); | |
SgExpr2VarvarID SgExpr2Var(SgExpression const* expr); | |
SgTreeTraversal_inFileToTraverse[[visibility("default")]] bool SgTreeTraversal_inFileToTraverse( SgNode* node, bool traversalConstraint, SgFile* fileToVisit); | |
Sg_optionsSg_Options& Sg_options(); | |
SliceLoopIvarSymbolicVar SliceLoopIvar( AstInterface& fa, CompSlice const* slice); | |
SliceLoopRangeSymbolicBound SliceLoopRange( CompSlice const* slice, LoopTreeNode* root); | |
SliceLoopStepLoopStepInfo SliceLoopStep(CompSlice const* slice); | |
SliceNestReverseTypedFusionvoid SliceNestReverseTypedFusion( CompSliceLocalityRegistry* anal, CompSliceDepGraphCreate& t, LoopNestFusion const& fuse); | |
SliceNestTypedFusionvoid SliceNestTypedFusion( CompSliceLocalityRegistry* anal, CompSliceDepGraphCreate& t, LoopNestFusion const& fuse); | |
SplitEquationtemplate< class CoeffVec, class BoundVec, class BoundOp> bool SplitEquation( CoeffVec& cur, SymbolicVal const& cut, BoundVec const& bounds, BoundOp& boundop, CoeffVec& split); | |
StatementListInsertChildtemplate<class Elemtype> bool StatementListInsertChild( SgStatement* parent, std::vector<Elemtype*>& statement_or_declaration_container, SgStatement* target, SgStatement* n, bool inFront, bool extractFromBasicBlock, bool removeCurrent); | |
StatementReplacetemplate<class Elemtype> bool StatementReplace( SgStatement* parent, Elemtype*& cur, SgStatement* target, SgStatement* newstmt); | |
TemporaryReuseRefsDepType TemporaryReuseRefs( DepInfoConstIterator ep, Map2Object<AstNodePtr, DepDirection, int>& loopmap, CollectObject<AstNodePtr>& refCollect, int* dist = 0); | |
ToStringstd::string ToString(std::vector<std::vector<SymbolicVal>>& analMatrix); | |
TransformAstTraverseAstNodePtr 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. |
UnwrapVarCondSymbolicVal UnwrapVarCond( SymbolicCond const& valCond, SymbolicVar const& pivot, SymbolicBound& pivotBound); | |
UpdateEachtemplate< class Iter, class Update> void UpdateEach( Iter iter, Update T); | |
UpdateEachNodeEdgetemplate< class Graph, class SelectNode, class EdgeOp> void UpdateEachNodeEdge( Graph* graph, SelectNode nodes, EdgeOp op); | |
UpdateMatrixtemplate< class Mat, class ElemOp> bool UpdateMatrix( Mat& d1, Mat const& d2, ElemOp op); | |
UpdateNodeEdgetemplate< class Graph, class EdgeOp, class Node> void UpdateNodeEdge( Graph* graph, Node* orig, EdgeOp op); | |
XOMP_barrierextern void XOMP_barrier(); | |
XOMP_static_even_divideextern void XOMP_static_even_divide( long start, long orig_size, int chunk_count, int chunk_id, long* chunk_offset, long* chunk_size); | |
XOMP_taskextern void XOMP_task( void(*)(void*), void*, void(*)(void*, void*), long, long, bool, unsigned int); | |
XOMP_taskwaitextern void XOMP_taskwait(); | |
addPredefinedVarsvoid addPredefinedVars(varIDSet& vars); | |
attachPreprocessingInfovoid 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); | |
buildArtificialFrontiervoid buildArtificialFrontier( SgSourceFile* sourceFile, bool traverseHeaderFiles, TokenUnparseFrontierFileContext& frontierContext); | |
buildClangTemplateInstantiationNameForFrontendstd::string buildClangTemplateInstantiationNameForFrontend( std::string const& baseName, llvm::ArrayRef<clang::TemplateArgument> templateArguments, clang::LangOptions const& languageOptions); | |
buildIntegralTemplateArgExprSgValueExp* buildIntegralTemplateArgExpr( llvm::APSInt const& value, SgType* type); | |
buildSourceFileForHeaderFileSgSourceFile* buildSourceFileForHeaderFile( SgProject* project, std::string originalFileName); | |
buildTokenStreamMappingvoid buildTokenStreamMapping( SgSourceFile* sourceFile, std::vector<stream_element*>& tokenVector); | |
buildTokenStreamMappingForRootvoid buildTokenStreamMappingForRoot( SgSourceFile* sourceFile, SgNode* traversalRoot, std::vector<stream_element*>& tokenVector); | |
buildVariableListvoid 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_declbool call_graph_traversal_includes_function_decl(SgFunctionDeclaration* decl); | |
checkOpenMPIRbool checkOpenMPIR(OpenMPDirective*); | |
checkPhysicalSourcePositionvoid checkPhysicalSourcePosition(SgNode* ast); | |
clangDeclHasBuiltinAttrbool clangDeclHasBuiltinAttr(clang::Decl const* decl); | |
clangFrontendDeclarationHasExactCompletedSourceSurfaceOwnershipbool clangFrontendDeclarationHasExactCompletedSourceSurfaceOwnership(SgDeclarationStatement* declaration); | |
clangFrontendImportedNamespaceModuleclang::Module const* clangFrontendImportedNamespaceModule(clang::NamespaceDecl const* namespace_decl); | |
clangFunctionDeclIsBuiltinSupportForFrontendbool clangFunctionDeclIsBuiltinSupportForFrontend( clang::FunctionDecl const* decl, clang::CompilerInstance const* ci, SagePreprocessorRecord const* preprocessor_record); | |
clangTemplateParameterSpellingstd::string clangTemplateParameterSpelling(clang::NamedDecl const* parameter); | |
clang_mainint 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. |
clearAnalysisvoid clearAnalysis(); | |
collectTemplateParameterLevelsFromDeclContextstd::vector<clang::TemplateParameterList const*> collectTemplateParameterLevelsFromDeclContext( clang::DeclContext const* start_context, bool use_defining_record_contexts = false); | |
constructorInitializerAssociatedClassUnknownbool constructorInitializerAssociatedClassUnknown(SgType* expression_type); | |
convertAdjustArgsClauseSgOmpAdjustArgsClause* convertAdjustArgsClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertAffinityClauseSgOmpAffinityClause* convertAffinityClause( SgStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertAllocatorClauseSgOmpAllocatorClause* convertAllocatorClause( SgOmpClauseStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertAppendArgsClauseSgOmpAppendArgsClause* convertAppendArgsClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertAtomicDefaultMemOrderClauseSgOmpAtomicDefaultMemOrderClause* convertAtomicDefaultMemOrderClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertBindClauseSgOmpBindClause* convertBindClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertBodyDirectiveSgStatement* convertBodyDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>); | |
convertClauseSgOmpVariablesClause* convertClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertCombinedBodyDirectiveSgOmpBodyStatement* convertCombinedBodyDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>); | |
convertDefaultClauseSgOmpDefaultClause* convertDefaultClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertDefaultmapClauseSgOmpDefaultmapClause* convertDefaultmapClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertDependClauseSgOmpDependClause* convertDependClause( SgStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertDepobjUpdateClauseSgOmpDepobjUpdateClause* convertDepobjUpdateClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertDirectiveSgStatement* convertDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>); | |
convertDistScheduleClauseSgOmpDistScheduleClause* convertDistScheduleClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertExpressionClauseSgOmpExpressionClause* convertExpressionClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertExtImplementationDefinedRequirementClauseSgOmpExtImplementationDefinedRequirementClause* convertExtImplementationDefinedRequirementClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertFromClauseSgOmpFromClause* convertFromClause( SgStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertInitializerIntoAssignmentSgAssignOp* convertInitializerIntoAssignment(SgAssignInitializer* init); | Convert something like "int a = foo();" into "int a; a = foo();" |
convertMapClauseSgOmpMapClause* convertMapClause( SgStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertMatchClauseSgOmpMatchClause* convertMatchClause( SgStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertNonBodyDirectiveSgStatement* convertNonBodyDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII); | |
convertOmpAllocateDirectiveSgStatement* convertOmpAllocateDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>); | |
convertOmpBeginDeclareVariantDirectiveSgStatement* convertOmpBeginDeclareVariantDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>); | |
convertOmpDeclareSimdDirectiveSgStatement* convertOmpDeclareSimdDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>); | |
convertOmpDeclareTargetDirectiveSgStatement* convertOmpDeclareTargetDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>); | |
convertOmpDeclareVariantDirectiveSgStatement* convertOmpDeclareVariantDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>); | |
convertOmpEndDeclareTargetDirectiveSgStatement* convertOmpEndDeclareTargetDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>); | |
convertOmpEndDeclareVariantDirectiveSgStatement* convertOmpEndDeclareVariantDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>); | |
convertOmpFlushDirectiveSgStatement* convertOmpFlushDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>); | |
convertOmpParallelStatementFromCombinedDirectivesSgOmpParallelStatement* convertOmpParallelStatementFromCombinedDirectives(std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII); | |
convertOmpRequiresDirectiveSgStatement* convertOmpRequiresDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII); | |
convertOmpTaskwaitDirectiveSgStatement* convertOmpTaskwaitDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII); | |
convertOmpThreadprivateStatementSgStatement* convertOmpThreadprivateStatement(std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII); | |
convertOpenACCDirectiveSgStatement* convertOpenACCDirective( SgPragmaDeclaration*, openacc::Directive const&); | |
convertOrderClauseSgOmpOrderClause* convertOrderClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertProcBindClauseSgOmpProcBindClause* convertProcBindClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertScheduleClauseSgOmpScheduleClause* convertScheduleClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertSizesClauseSgOmpSizesClause* convertSizesClause( SgStatement* directive, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertToClauseSgOmpToClause* convertToClause( SgStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertUsesAllocatorsClauseSgOmpUsesAllocatorsClause* convertUsesAllocatorsClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
convertVariantBodyDirectiveSgStatement* convertVariantBodyDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>); | |
convertVariantDirectiveSgStatement* convertVariantDirective(std::pair<SgPragmaDeclaration*, OpenMPDirective*>); | |
convertWhenClauseSgOmpWhenClause* convertWhenClause( SgOmpClauseBodyStatement* clause_body, std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClause* current_omp_clause); | |
copyClangFunctionArgumentTypesvoid copyClangFunctionArgumentTypes( SgFunctionType const* source, SgFunctionParameterTypeList* destination, char const* context); | |
copy_mapped_variableextern void copy_mapped_variable( XOMP_mapped_variable* desc, XOMP_mapped_variable* src); | A helper function to copy a mapped variable from src to desc |
cxxRecordDeclFromQualTypeWithoutDefinitionLookupclang::CXXRecordDecl const* cxxRecordDeclFromQualTypeWithoutDefinitionLookup(clang::QualType type); | |
debug_cfgbool debug_cfg(); | |
defaultArgumentParameterForLambdaclang::ParmVarDecl const* defaultArgumentParameterForLambda(clang::CXXRecordDecl const* declaration); | |
dependenceDiagnosticNodeTextstd::string dependenceDiagnosticNodeText(SgNode const* node); | |
destructorCallAnnotator[[visibility("default")]] void destructorCallAnnotator(SgProject* prj); | |
detachTokenMappingForRemovedNodevoid detachTokenMappingForRemovedNode( SgSourceFile* sourceFile, SgNode* node); | |
detectMacroExpansionsToBeUnparsedAsAstTransformationsvoid detectMacroExpansionsToBeUnparsedAsAstTransformations( SgSourceFile* sourceFile, TokenUnparseFrontierFileContext& frontierContext); | |
detectMacroOrIncludeFileExpansionsvoid detectMacroOrIncludeFileExpansions(SgSourceFile* sourceFile); | |
detectTransformationsvoid detectTransformations(SgNode* node); | |
determineFileTypeSgSourceFile* 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. |
doRTItemplate<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); | |
edgePointerReplacementvoid edgePointerReplacement(replacement_map_t const& replacements); | |
enforceTokenUnparseContract[[visibility("default")]] void enforceTokenUnparseContract(SgProject* project); | |
enumValueFromClanglong long enumValueFromClang(llvm::APSInt const& value); | |
escapeString[[visibility("default")]] std::string escapeString(std::string const& s); | |
escape_double_quotesstd::string escape_double_quotes(std::string const& input); | |
exactQualificationUseSiteForEmissionSgStatement* exactQualificationUseSiteForEmission( SgNode const* node, SgStatement* emissionStatement); | |
expressionTreeEqualbool expressionTreeEqual( SgExpression*, SgExpression*); | Are two expressions equal (using a deep comparison)? |
expressionTreeEqualStarbool 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] | |
filterGraphtemplate< typename Graph, typename Predicate> void filterGraph( Graph& graph, Predicate predicate); | Filter nodes from a graph. |
findBasicBlockForStmtstd::pair<SgBasicBlock*, SgNode*> findBasicBlockForStmt(SgStatement* stmt); | |
findFollowingPositionsstmt_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 |
findNearestParentOfTypetemplate< typename T, T* isT(SgNode*)> std::pair<T*, SgNode*> findNearestParentOfType(SgNode* node); | |
findPositionstmt_pos findPosition(SgNode* n); | |
findRootFuncSgFunctionDefinition 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. |
findStatementForExpressionSgStatement* findStatementForExpression(SgExpression* expr); | |
findVariablesUsedInRegion[[visibility("default")]] std::set<SgInitializedName*> findVariablesUsedInRegion(SgNode* e); | Find all variables referenced in a region |
finishSageASTvoid finishSageAST(ClangToSageTranslator& translator); | |
flattenBlocks[[visibility("default")]] void flattenBlocks(SgNode* n); | Flatten nested blocks while preserving declaration lifetimes and semantic auxiliary scopes. |
floatingValueFromClangRose::FloatingValue floatingValueFromClang(llvm::APFloat const& value); | |
formatRTIFieldtemplate<typename T> static std::string formatRTIField(void const* fieldPtr); | |
fortranAttributeStatementOwnsArrayShapebool 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); | |
frontierDetectionForTokenStreamMappingvoid 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); | |
generateModFileextern void generateModFile(SgFile* sfile); | |
generateNameQualificationSupportvoid 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 |
getAllNodesstd::set<SgNode*> getAllNodes(SgNode* node); | |
getCallGraphSgIncidenceDirectedGraph* getCallGraph(); | |
getClangTranslationUnitSourceOrderstd::optional<unsigned int> getClangTranslationUnitSourceOrder( SgDeclarationStatement const* declaration, char const* context); | |
getLiveOutVarsAtLiveVarsLattice* getLiveOutVarsAt( LiveDeadVarsAnalysis* ldva, SgNode* n, unsigned int index = 0); | |
getOpenMPBlockBodySgStatement* getOpenMPBlockBody(std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII); | |
getOperatorFunctionNamebool getOperatorFunctionName( SgExpression* expr, std::string& func_name); | |
getParmVarDeclDefaultArgExprclang::Expr const* getParmVarDeclDefaultArgExpr(clang::ParmVarDecl const* param_var_decl); | |
getPreprocessorDirectivesROSEAttributesList* getPreprocessorDirectives( std::string fileName, std::string new_filename = ""); | |
getReadVarRefsInSubtreevarIDSet getReadVarRefsInSubtree(SgNode* root); | |
getRootOfExpressionSgExpression* getRootOfExpression(SgExpression* n); | Get the topmost enclosing expression of a given expression. |
getStatementOfExpressionSgStatement* getStatementOfExpression(SgNode* n); | Get the statement of an expression. |
getTokenStreamstd::vector<stream_element*> getTokenStream(SgSourceFile* file); | |
getVarRefsInSubtreevarIDSet 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) |
getWriteVarRefsInSubtreevarIDSet getWriteVarRefsInSubtree(SgNode* root); | |
globalUnparseToString[[visibility("default")]] std::string globalUnparseToString( SgNode const* astNode, SgUnparse_Info* inputUnparseInfoPointer = nullptr); | |
graphNodesAfterCopyvoid graphNodesAfterCopy( std::set<SgNode*> const& nodesBeforeCopy, std::string filename); | |
graph_trim_trailing_spacesstd::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? |
initAnalysisvoid initAnalysis(SgProject* p); | |
integer128ValueFromClangRose::Integer128Value integer128ValueFromClang(llvm::APSInt const& value); | |
isExactCLexicalRecordTagSourceSurfacebool isExactCLexicalRecordTagSourceSurface( SgDeclarationStatement const* declaration, SgScopeStatement const* structuralScope); | |
isExactEmptyTranslationUnitTokenMappingbool isExactEmptyTranslationUnitTokenMapping( SgSourceFile* sourceFile, SgStatement* statement, TokenStreamSequenceToNodeMapping* mapping); | |
isFortranPairedDirectiveextern bool isFortranPairedDirective(OpenMPDirective* node); | |
isInstantiatedConversionOperatorDeclbool 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. |
isNonFriendMemberFunctionDeclarationbool 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 |
isVarExprbool isVarExpr(SgExpression* expr); | |
is_idbool is_id(char c); | |
is_numbool is_num(char c); | |
is_operatorint is_operator(char c); | |
is_spacebool is_space(char c); | |
joinMangledQualifiersSgName joinMangledQualifiers( SgName const& base, SgName const& name); | Joins two sets of mangled qualifiers to form a new mangled qualifier. |
joinMangledQualifiersToStringstd::string joinMangledQualifiersToString( std::string const& base, std::string const& name); | Joins two sets of mangled qualifiers to form a new mangled qualifier. |
linearize_subtreestd::vector<SgNode*> linearize_subtree(SgNode* node); | |
makeEdgetemplate< class NodeT1, class NodeT2, class EdgeT> void makeEdge( NodeT1 from, NodeT2 to, std::vector<EdgeT>& result); | Utility function to make CFG Edges |
makeRTIValueDescriptortemplate<typename T> static RTIValueDescriptor makeRTIValueDescriptor(T const& field); | |
mangleExpressionstd::string mangleExpression(SgExpression const* expr); | Mangles a constant expression, needed for template arguments. |
mangleFunctionNameSgName mangleFunctionName( SgName const& n, SgName const& ret_type_name = SgName("")); | Returns a mangled form of a C++ function name, as an SgName object. |
mangleFunctionNameToStringstd::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). |
mangleLocalScopeToStringstd::string mangleLocalScopeToString(SgScopeStatement const* scope); | Produces a mangled name for a scope statement. |
mangleQualifiersSgName mangleQualifiers(SgScopeStatement const* scope); | Mangles a chain of qualifiers, returning an SgName object. |
mangleQualifiersToStringstd::string mangleQualifiersToString(SgScopeStatement const* scope); | Mangles a chain of qualifiers followed from a given scope. |
mangleTemplateSgName mangleTemplate( SgName const& templ_name, SgTemplateArgumentPtrList const& templ_args, SgScopeStatement const* scope); | mangleTemplate overloads |
mangleTemplateArgsToStringstd::string mangleTemplateArgsToString( SgTemplateArgumentPtrList::const_iterator const b, SgTemplateArgumentPtrList::const_iterator const e); | mangleTemplateArgsToString overloads |
mangleTemplateFunctionSgName 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. |
mangleTemplateFunctionToStringstd::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. |
mangleTemplateToStringstd::string mangleTemplateToString( std::string const& templ_name, SgTemplateArgumentPtrList const& templ_args, SgScopeStatement const* scope); | mangleTemplateToString overloads |
mangleTranslationUnitQualifiersstd::string mangleTranslationUnitQualifiers(SgDeclarationStatement const* decl); | If the declaration has translation unit scope (as opposed to program scope), mangle the translation unit name. |
mangleTypesSgName mangleTypes( SgTypePtrList::const_iterator const b, SgTypePtrList::const_iterator const e); | Mangles a list of types, returning an SgName object. |
mangleTypesToStringstd::string mangleTypesToString( SgTypePtrList::const_iterator const b, SgTypePtrList::const_iterator const e); | Mangles a container of types, returning an STL std::string object. |
mangleValueExpstd::string mangleValueExp(SgValueExp const* expr); | Mangles a value expression, as used in a template argument. |
mark_compiler_generated_frontend_specificvoid mark_compiler_generated_frontend_specific(SgNode* node); | |
memoryUsage[[visibility("default")]] size_t memoryUsage(); | |
mlogAssertFail_Cvoid mlogAssertFail_C( char const* subject, char const* expr, char const* file, int line, char const* funcname, std::string const& message); | |
mlogLevelToString_CXXextern std::string mlogLevelToString_CXX(MLOG_LEVEL_t level); | |
mlogMore_Cextern void mlogMore_C(char const* format, ...); | |
mlogNullStream_CXXextern std::ostream& mlogNullStream_CXX(); | |
mlog_Cextern void mlog_C( MLOG_LEVEL_t level, char const* subject, char const* file, int line, char const* funcname, char const* format, ...); | |
myStatementInsertvoid 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. |
nestedNameSpecifierHasGlobalbool nestedNameSpecifierHasGlobal(clang::NestedNameSpecifier qualifier); | |
nestedNameSpecifierHasTemplateKeywordbool nestedNameSpecifierHasTemplateKeyword(clang::NestedNameSpecifier nns); | |
nestedNameSpecifierLocHasExplicitGlobalbool nestedNameSpecifierLocHasExplicitGlobal(clang::NestedNameSpecifierLoc qualifier_loc); | |
nestedNameSpecifierLocPrefixclang::NestedNameSpecifierLoc nestedNameSpecifierLocPrefix(clang::NestedNameSpecifierLoc current); | |
nestedNameSpecifierNamespaceclang::NamespaceDecl const* nestedNameSpecifierNamespace(clang::NestedNameSpecifier nns); | |
nestedNameSpecifierNamespaceBaseclang::NamespaceBaseDecl const* nestedNameSpecifierNamespaceBase(clang::NestedNameSpecifier nns); | |
nestedNameSpecifierPrefixclang::NestedNameSpecifier nestedNameSpecifierPrefix(clang::NestedNameSpecifier nns); | |
numberOfNodes[[visibility("default")]] size_t numberOfNodes(); | |
omp_simd_write_armvoid omp_simd_write_arm( SgOmpSimdStatement* target, SgForStatement* for_loop, std::vector<SgNode*>* ir_block, OmpSimdCompiler const& compiler); | |
omp_simd_write_intelvoid 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_AddOpPattern* p_AddOp( Pattern* lhs, Pattern* rhs); | Match an addition operation |
p_CommaOpPattern* p_CommaOp( Pattern* lhs, Pattern* rhs); | Match a comma operation |
p_MultiplyOpPattern* p_MultiplyOp( Pattern* lhs, Pattern* rhs); | Match a multiplication operation |
p_PlusAssignOpPattern* p_PlusAssignOp( Pattern* lhs, Pattern* rhs); | Match an add-assign operation |
p_intPattern* p_int(int x); | Match a particular integer |
p_varPattern* p_var(std::string name); | Match anything into a variable |
parallelBottomUpProcessingThreadtemplate<class S> void* parallelBottomUpProcessingThread(void* p); | |
parallelTopDownBottomUpProcessingThreadtemplate< class I, class S> void* parallelTopDownBottomUpProcessingThread(void* p); | |
parallelTopDownProcessingThreadtemplate<class I> void* parallelTopDownProcessingThread(void* p); | |
parseArraySectionExpressionextern SgExpression* parseArraySectionExpression( SgNode*, char const*); | |
parseExpressionextern SgExpression* parseExpression( SgNode*, char const*); | |
parseOmpArraySectionSgExpression* parseOmpArraySection( SgPragmaDeclaration* directive, OpenMPClauseKind clause_kind, std::string expression); | |
parseOmpExpressionSgExpression* parseOmpExpression( SgPragmaDeclaration* directive, OpenMPClauseKind clause_kind, std::string expression); | |
parseOmpVariablevoid parseOmpVariable( std::pair<SgPragmaDeclaration*, OpenMPDirective*> current_OpenMPIR_to_SageIII, OpenMPClauseKind clause_kind, std::string expression); | |
patactPatternActionRule* patact( Pattern* pattern, Pattern* action); | Create a PatternActionRule |
peek_chchar peek_ch(std::istream& in); | |
peek_idstd::string peek_id(std::istream& in); | |
peek_nextchar peek_next(std::istream& in); | |
preventConstructionOnStackvoid preventConstructionOnStack(SgNode* n); | |
printDivAnalysisStatesvoid printDivAnalysisStates( DivAnalysis* da, std::string indent = ""); | |
publishClangTranslationUnitSourceOrdervoid publishClangTranslationUnitSourceOrder( SgDeclarationStatement* declaration, unsigned int order); | |
pushTestIntoBodyvoid 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. |
qualifiedTypeHasQualifierbool qualifiedTypeHasQualifier(clang::Type const* type); | |
qualifiedTypeQualifierclang::NestedNameSpecifier qualifiedTypeQualifier(clang::Type const* type); | |
queryIsImportantForSliceTypeNodeQuerySynthesizedAttributeType queryIsImportantForSliceType(SgNode* astNode); | |
queryIsImportantForSliceTypeWithCallsNodeQuerySynthesizedAttributeType queryIsImportantForSliceTypeWithCalls(SgNode* astNode); | |
read_chchar read_ch(std::istream& in); | |
read_graphtemplate<class Graph> void read_graph( Graph& g, std::istream& in, std::string const& hint); | |
read_idstd::string read_id(std::istream& in); | |
read_listtemplate<class ItemGen> bool read_list( std::istream& in, ItemGen& op, char sep); | |
read_numstd::string read_num(std::istream& in); | |
read_operatorstd::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. |
replaceExpressionWithExpressionvoid 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. |
replaceNonAlphaNumstd::string replaceNonAlphaNum(std::string const& s); | |
requireClangFunctionDeclSourceProvenanceForFrontendvoid requireClangFunctionDeclSourceProvenanceForFrontend( clang::FunctionDecl const* decl, clang::CompilerInstance const* ci, SagePreprocessorRecord const* preprocessor_record); | |
requireClangOrderedDeclarationProvenanceForFrontendClangOrderedDeclarationProvenance requireClangOrderedDeclarationProvenanceForFrontend( SgDeclarationStatement const* declaration, char const* context); | |
requireFortranSourceDerivedTypeNameSgName requireFortranSourceDerivedTypeName( SgClassType* classType, SgUnparse_Info& info); | |
resolveNameQualificationProjectSgProject* resolveNameQualificationProject( SgNode* node, SgStatement* explicitEmissionStatement, SgNode* explicitReferenceNode); | |
resolveRosePaths[[visibility("default")]] RosePathRoots resolveRosePaths(char const* argv0); | |
resolveTemplateNameDeclarationclang::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); | |
roseResolveTestOutputPathstd::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 |
simpleFrontierDetectionForTokenStreamMappingvoid 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); | |
sourceQualificationFileLocclang::SourceLocation sourceQualificationFileLoc( clang::SourceManager& source_manager, clang::SourceLocation location, bool expansion_end = false); | |
sourceQualificationFromNestedNameSpecifierLocSourceQualification sourceQualificationFromNestedNameSpecifierLoc( clang::NestedNameSpecifierLoc qualifier_loc, clang::CompilerInstance* compiler_instance, char const* context, clang::SourceLocation exact_source_begin = clang::SourceLocation()); | |
sourceQualificationIsSemanticMacroExpansionFragmentbool sourceQualificationIsSemanticMacroExpansionFragment( clang::NestedNameSpecifierLoc qualifier_loc, clang::SourceManager& source_manager, clang::LangOptions const& lang_options); | |
sourceQualificationIsSemanticMacroFragmentbool sourceQualificationIsSemanticMacroFragment(SourceQualification const& qualification); | |
sourceQualificationMatchesSemanticIdentitybool 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); | |
templateClassMatchesPatternbool templateClassMatchesPattern( SgTemplateClassDeclaration const* declaration, SgTemplateClassDeclaration const* pattern); | |
templateInstantiationPatternDefinitiontemplate<typename Decl> Decl* templateInstantiationPatternDefinition(Decl* pattern); | |
templateParametersForDeclContextclang::TemplateParameterList const* templateParametersForDeclContext(clang::DeclContext const* context); | |
templateParametersForSageDeclarationSharedSgTemplateParameterPtrList const* templateParametersForSageDeclarationShared(SgDeclarationStatement const* decl); | |
testAstForUniqueNodesvoid testAstForUniqueNodes(SgNode* node); | |
toStringForRTItemplate<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); | |
trimSpacesstd::string trimSpaces(std::string const& s); | Returns the input std::string stripped of leading and trailing spaces. |
typedefDeclarationReferenceSharedSgDeclarationStatement* typedefDeclarationReferenceShared(SgTypedefDeclaration* typedef_decl); | |
unparseDirectoryvoid 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. |
unparseFileListvoid 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_namestd::string unparse_asm_clobber_name(std::string const& register_name); | |
unparse_asm_label_namestd::string unparse_asm_label_name(std::string const& label_name); | |
validateFreshSubtreeOwnershipvoid validateFreshSubtreeOwnership( SgNode* node, SgNode* boundary); | Validate a fresh subtree already owned by the supplied detached boundary. |
validateOpenACCDirectiveForSagevoid validateOpenACCDirectiveForSage(openacc::Directive const&); | |
validateTypedefDeclarationReferenceSharedvoid validateTypedefDeclarationReferenceShared(SgTypedefDeclaration* typedef_decl); | |
version_messagestd::string version_message(); | |
version_numberstd::string version_number(); | |
writeClangAstGraphvoid writeClangAstGraph( clang::CompilerInstance& compiler, std::string const& filename); | |
writeListtemplate<class T> void writeList( DoublyLinkedListWrap<T> const& list, std::ostream& out); | |
write_graphtemplate< class Graph, class OUTPUT> void write_graph( Graph const& g, OUTPUT& out, std::string const& hint); | |
write_graph2template< class Graph, class OUTPUT> void write_graph2( Graph const& g, OUTPUT& out, std::string const& hint); | |
write_graph_node_edgetemplate< 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_initextern void xomp_acc_init(); | |
xomp_beyond_block_reduction_doubledouble xomp_beyond_block_reduction_double( double* per_block_results, int numBlocks, int reduction_op); | |
xomp_beyond_block_reduction_floatfloat xomp_beyond_block_reduction_float( float* per_block_results, int numBlocks, int reduction_op); | |
xomp_beyond_block_reduction_intint xomp_beyond_block_reduction_int( int* per_block_results, int numBlocks, int reduction_op); | |
xomp_deviceDataEnvironmentAddVariableextern 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_deviceDataEnvironmentEnterextern void xomp_deviceDataEnvironmentEnter(int devID); | |
xomp_deviceDataEnvironmentExitextern void xomp_deviceDataEnvironmentExit(int devID); | |
xomp_deviceDataEnvironmentGetInheritedVariableextern void* xomp_deviceDataEnvironmentGetInheritedVariable( int devID, void* original_variable_address, int typeSize, int* size); | |
xomp_deviceDataEnvironmentPrepareVariableextern void* xomp_deviceDataEnvironmentPrepareVariable( int devID, void* original_variable_address, int nDim, int typeSize, int* size, int* offset, int* vDimSize, bool copyTo, bool copyFrom); | |
xomp_deviceMallocextern void* xomp_deviceMalloc(size_t size); | |
xomp_freeArrayPointerextern void xomp_freeArrayPointer( void* array, int* dimensions, size_t dimension_num); | |
xomp_freeDeviceextern bool xomp_freeDevice(void* devPtr); | |
xomp_freeHostextern bool xomp_freeHost(void* hostPtr); | |
xomp_get_max1DBlockextern size_t xomp_get_max1DBlock( int devID, size_t ss); | |
xomp_get_maxSegmentsPerDimensionOf2DBlockextern size_t xomp_get_maxSegmentsPerDimensionOf2DBlock( int devID, size_t dimension_size); | |
xomp_get_maxThreadsPerBlockextern size_t xomp_get_maxThreadsPerBlock(int devID); | |
xomp_get_max_devicesextern int xomp_get_max_devices(); | |
xomp_get_max_threads_per_dimesion_2Dextern size_t xomp_get_max_threads_per_dimesion_2D(int devID); | |
xomp_get_num_devicesextern int xomp_get_num_devices(); | |
xomp_hostMallocextern void* xomp_hostMalloc(size_t size); | |
xomp_mallocArrayextern void* xomp_mallocArray( int* dimensions, size_t dimension_num, size_t esize); | |
xomp_memcpyDeviceToDeviceextern void* xomp_memcpyDeviceToDevice( void* dest, void const* src, size_t n_n); | |
xomp_memcpyDeviceToHostextern void* xomp_memcpyDeviceToHost( void* dest, void const* src, size_t n_n); | |
xomp_memcpyDynamicDeviceToHostextern void* xomp_memcpyDynamicDeviceToHost( void* dest, int* dimensions, size_t dimension_size, void const* src, size_t element_size, size_t* bytes_copied); | |
xomp_memcpyDynamicHostToDeviceextern void* xomp_memcpyDynamicHostToDevice( void* dest, void const* src, int* dimensions, size_t dimension_size, size_t element_size, size_t* bytes_copied); | |
xomp_memcpyHostToDeviceextern void* xomp_memcpyHostToDevice( void* dest, void const* src, size_t n_n); | |
xomp_memcpyHostToHostextern void* xomp_memcpyHostToHost( void* dest, void const* src, size_t n_n); | |
xomp_set_default_deviceextern 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 |
Variables¶
Using Declarations¶
| Name |
|---|
cerr |
cout |
endl |
list |
make_pair |
map |
ofstream |
ofstream |
ostream |
ostream |
ostringstream |
ostringstream |
pair |
set |
string |
stringstream |
stringstream |
vector |
Macros¶
| Name | Description |
|---|---|
BUILD_BINARY_PROTO | The instantiated functions' prototypes are not shown since they are expanded using macros. Documentation tools do not expand these macros. |
MLOG_LEVEL_HEADER_CXX | ** for C++-style API, i.e. using cerr <<< ** |
TRANS_FILE | An alias for Sg_File_Info::generateDefaultFileInfoForTransformationNode() |
Using Namespace Directives¶
| Name | Description |
|---|---|
Rose | |
SageInterface | Functions that are useful when operating on the AST. |
SageBuilder | High level SAGE III AST node and subtree builders. |
OmpSupport | Types and functions to support OpenMP |
VirtualCFG | |
ROSE_token_ids | |
ROSE_Statistics | |
Outliner | |
ConstantFolding | |
NewCallGraph | |
DominatorTreesAndDominanceFrontiers | |
DUVariableAnalysisExt |
ASTMemoryPool namespace¶
Functions¶
| Name |
|---|
validNodeMarkerSgNode* validNodeMarker(); |
AST_Graph namespace¶
Types¶
| Name |
|---|
DataMemberPointersToIR |
FunctionalReturnType |
defaultFilterBinary |
defaultFilterUnary |
filterSgFileInfo |
filterSgFileInfoAndGnuCompatabilityNode |
nodePartOfGraph |
Type Aliases¶
| Name |
|---|
NodeType |
NodeTypeVector |
Enums¶
| Name |
|---|
pointerHandling |
traversalType |
Functions¶
| 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 namespace¶
Types¶
| Name | Description |
|---|---|
PrePostTraversal | |
VarSymLess | Stable ordering for variable symbols used by outlining/lowering interfaces. |
Type Aliases¶
| Name | Description |
|---|---|
JumpMap_t | Store a list of non-local "jumps" (continues, breaks) and ids. |
ThisExprSet_t | Stores a list of 'this' expressions. |
VarSymSet_t | Stores a collection of SgVariableSymbols (var syms). |
Functions¶
| Name | Description |
|---|---|
attachCommentvoid 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'. |
collectNonLocalGotosvoid collectNonLocalGotos( SgStatement const* root, JumpMap_t& jumps); | Collect non-local "goto" statements. |
collectNonLocalJumpsvoid 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'. |
collectThisExpressionsvoid 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 |
cutPreprocInfovoid 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. |
insertHeadervoid insertHeader( std::string const& filename, SgProject* proj); | Inserts an '#include' into every source file, including an empty file. |
isConstObjbool isConstObj(SgType const* type); | Returns 'true' if the specified type is a 'const' object. |
isIfCondbool isIfCond(SgStatement const* s); | Returns 'true' <==> 's' is the condition of some 'if' statement. |
isIfDirectiveBeginbool isIfDirectiveBegin(PreprocessingInfo const* info); | Returns true if the info is an '#if', '#ifdef', or '#ifndef'. |
isIfDirectiveEndbool isIfDirectiveEnd(PreprocessingInfo const* info); | |
isIfDirectiveMiddlebool isIfDirectiveMiddle(PreprocessingInfo const* info); | Returns true if the info is an '#elif' or '#else'. |
isPositionAfterbool isPositionAfter(PreprocessingInfo const* info); | Returns true if info is positioned after its statement. |
isPositionBeforebool isPositionBefore(PreprocessingInfo const* info); | Returns true if info is positioned before its statement. |
isPositionInsidebool isPositionInside(PreprocessingInfo const* info); | Returns true if info is positioned inside its statement. |
isSwitchCondbool isSwitchCond(SgStatement const* s); | Returns 'true' <==> 's' is the conditional selector of some 'switch' statement. |
isWhileCondbool isWhileCond(SgStatement const* s); | Returns 'true' <==> 's' is the condition of some 'while' or 'do ... while' statement. |
moveAfterPreprocInfovoid moveAfterPreprocInfo( SgStatement* src, SgStatement* dest); | Moves 'after' preprocessing information. |
moveBeforePreprocInfovoid moveBeforePreprocInfo( SgStatement* src, SgStatement* dest); | Moves 'before' preprocessing information. |
moveInsidePreprocInfovoid moveInsidePreprocInfo( SgBasicBlock* src, SgBasicBlock* dest); | Moves 'inside' preprocessing information. |
moveUpPreprocInfovoid moveUpPreprocInfo( SgStatement* stmt1, SgStatement* stmt2); | Moves preprocessingInfo of stmt2 to stmt1. |
pastePreprocInfoBackvoid pastePreprocInfoBack( AttachedPreprocessingInfoType& save_buf, SgStatement* s); | Pastes preprocessing information at the back of a statement. |
pastePreprocInfoFrontvoid 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. |
toStringFileLocstd::string toStringFileLoc(SgLocatedNode const* n); | Convert a node's location to a string-friendly form. |
transformToBlockShellSgBasicBlock* transformToBlockShell(SgBasicBlock* b_orig); | Create an SgBasicBlock shell around an existing SgBasicBlock. |
AliasAnalysisDetail namespace¶
Functions¶
| Name |
|---|
deleteOwnedGraph[[visibility("default")]] void deleteOwnedGraph(SgIncidenceDirectedGraph* graph); |
virtualFunctionReference[[visibility("default")]] SgMemberFunctionRefExp* virtualFunctionReference(SgFunctionCallExp* call); |
AstDOTGenerationExtended_Defaults namespace¶
Types¶
| Name |
|---|
AddressExtraNodeInfo |
ContainerSizeExtraNodeInfo |
DefaultExtraEdgeInfo |
DefaultExtraEdgeOptions |
DefaultExtraNodeInfo |
DefaultExtraNodeOptions |
LValueExtraNodeInfo |
NamedExtraNodeInfo |
TypeExtraNodeInfo |
AstQueryNamespace namespace¶
Namespaces¶
| Name |
|---|
detail |
Types¶
| Name | Description |
|---|---|
AstQuery | |
AstQuery_DUMMY | |
DefaultNodeFunctional | Simplifies development of queries on the AST that return lists of AST nodes. |
Enums¶
| Name |
|---|
QueryDepth |
Functions¶
| Name |
|---|
Mergetemplate<typename ResultType> void Merge( std::vector<ResultType>& mergeWith, std::vector<ResultType> const& mergeTo); |
queryMemoryPooltemplate<typename NodeFunctional> detail::invoke_result_t<NodeFunctional&, SgNode*> queryMemoryPool( NodeFunctional nodeFunc, VariantVector* targetVariantVector = NULL); |
queryRangetemplate<class _Result> _Result queryRange( _Result::iterator begin, _Result::iterator end, _Result(* __x)(SgNode*)); |
querySubTreetemplate<class _Result> _Result querySubTree( SgNode* subTree, _Result(* __x)(SgNode*), AstQueryNamespace::QueryDepth defineQueryType = AstQueryNamespace::AllNodes); |
AstQueryNamespace::detail namespace¶
Types¶
| Name |
|---|
is_invocable |
is_invocable_impl |
make_void |
Type Aliases¶
| Name |
|---|
invoke_result_t |
void_t |
Functions¶
| Name |
|---|
invoketemplate< 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 namespace¶
Types¶
| Name | Description |
|---|---|
CollectDependences | |
CollectTransitiveDependences | |
DependenceEntry | |
DependenceTable | Stores dependence entries in a table. |
SaveOperatorSideEffectInterface | |
SaveOperatorSideEffectIntoVectors | |
SelectDependences | |
WholeProgramDependenceAnalysis |
Enums¶
| Name |
|---|
OperatorSideEffect |
Functions¶
| Name | Description |
|---|---|
AddOperatorSideEffectAnnotationvoid AddOperatorSideEffectAnnotation( SgNode* op_ast, AstNodePtr const& var, OperatorSideEffect relation); | |
CollectSideEffectVariablesvoid 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. |
ComputeAstSideEffectsvoid 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. |
GetVariableSignaturestd::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. |
IsLocalRefbool IsLocalRef( SgNode* ref, SgNode* scope, bool* has_ptr_deref = 0); | |
OperatorSideEffectNamestd::string OperatorSideEffectName(OperatorSideEffect what); | |
OutputOperatorSideEffectAnnotationsvoid OutputOperatorSideEffectAnnotations( std::ostream& output, DependenceTable* use_dep_analysis = 0); | |
OutputSignatureDictionaryvoid OutputSignatureDictionary(std::ostream& output); | |
ReadAnnotationsvoid ReadAnnotations( std::istream& input, DependenceTable* use_dep_table = 0); | |
RegisterOperatorSideEffectAnnotationvoid RegisterOperatorSideEffectAnnotation(); | |
SetFunctionNameManglingvoid SetFunctionNameMangling(std::string(*)(SgFunctionDeclaration const*)); | |
SetSaveVariableDictionaryvoid SetSaveVariableDictionary(bool doit); | |
operator<<std::ostream& operator<<( std::ostream& output, DependenceEntry const& e); | Stream insertion operator |
CPreproc namespace¶
Types¶
| Name | Description |
|---|---|
If | Stores a preprocessor '#if' directive and nested directives. |
IfDirectiveContextFinder | Find the '#if' case surrounding a given node. |
IfDirectiveExtractor | Traversal to extract '#if' directives. |
Type Aliases¶
| Name | Description |
|---|---|
Ifs_t | Stores lists of directives. |
Functions¶
| Name | Description |
|---|---|
dumpvoid dump(Ifs_t const ifs); | dump overloads |
extractIfDirectivesvoid extractIfDirectives( SgNode* root, Ifs_t& ifs); | Extracts the '#if' directive structure from a project. |
findIfDirectiveContextvoid findIfDirectiveContext( SgLocatedNode const* target, Ifs_t& ifs, If::Case*& top, If::Case*& bottom); | Locate the '#if' directive context at a node. |
CallTargetSet namespace¶
Functions¶
| Name | Description |
|---|---|
getDeclarationsForExpressionvoid 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. |
getDefinitionsForExpressionvoid 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 |
getExpressionsForDefinitionvoid getExpressionsForDefinition( SgFunctionDefinition* targetDef, ClassHierarchyWrapper* classHierarchy, std::vector<SgExpression*>& exps); | |
getFirstVirtualFunctionDefinitionFromAncestorsSgFunctionDeclaration* 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. |
isNonExecutableCallExpressionbool isNonExecutableCallExpression(SgExpression* expression); | |
solveConstructorInitializerstd::vector<SgFunctionDeclaration*> solveConstructorInitializer(SgConstructorInitializer* sgCtorInit); | Return the selected constructor's canonical declaration. |
solveFunctionPointerCallstd::vector<SgFunctionDeclaration*> solveFunctionPointerCall(SgPointerDerefExp* pointerDerefExp); | Return signature-compatible functions in the dereference's exact project. |
solveFunctionPointerCallsFunctionalstd::vector<SgFunctionDeclaration*> solveFunctionPointerCallsFunctional( SgNode* node, SgFunctionType* functionType); | Return the canonical declaration if its callable signature matches. |
solveMemberFunctionCallstd::vector<SgFunctionDeclaration*> solveMemberFunctionCall( SgClassType*, ClassHierarchyWrapper*, SgMemberFunctionDeclaration*, bool, bool includePureVirtualFunc = false); | |
solveMemberFunctionPointerCallstd::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 namespace¶
Command line processing utility functions. Functions in this namespace are in the ROSE Utilities library and
Types¶
| Name | Description |
|---|---|
ArgvStorage | RAII storage for argv-style arguments. |
ClangLanguageSelection | Language state active at one exact driver input operand. |
Enums¶
| Name | Description |
|---|---|
ClangLanguageFamily | Exact language family selected by Clang's ordered -x driver state. |
Functions¶
| 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. |
Variables¶
| Name |
|---|
extraCppSourceFileSuffixes |
ConstantFolding namespace¶
Types¶
| Name |
|---|
ConstantFoldingInheritedAttribute |
ConstantFoldingSynthesizedAttribute |
ConstantFoldingTraversal |
ConstantUnFoldingSynthesizedAttribute |
ConstantUnFoldingTraversal |
Functions¶
| Name | Description |
|---|---|
buildPredicateResultSgValueExp* buildPredicateResult( SgBinaryOp* op, bool value); | |
buildResultValueExp_float_ttemplate< typename T1, typename T2> static SgValueExp* buildResultValueExp_float_t( SgBinaryOp* binaryOperator, SgValueExp* lhsValue, SgValueExp* rhsValue); | |
buildResultValueExp_ttemplate< typename T1, typename T2> static SgValueExp* buildResultValueExp_t( SgBinaryOp* binaryOperator, SgValueExp* lhsValue, SgValueExp* rhsValue); | |
buildResultValueExp_u_ttemplate< typename T1, typename T2> static SgValueExp* buildResultValueExp_u_t( SgUnaryOp* unaryOperator, SgValueExp* theValue); | |
calculateIntegraltemplate<typename T> std::optional<T> calculateIntegral( SgBinaryOp* op, T lhs, T rhs); | |
calculate_float_ttemplate<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_ttemplate<typename T> T calculate_u_t( SgUnaryOp* unaryOperator, T theValue); | |
cf_get_value_ttemplate< typename T1, typename T2> T1 cf_get_value_t(T2* sg_value_exp); | |
checkedIntegralProducttemplate<typename T> bool checkedIntegralProduct( T lhs, T rhs, T& result); | |
constantFoldingOptimization[[visibility("default")]] void constantFoldingOptimization(SgNode* n); | |
constantUnFoldingTest[[visibility("default")]] void constantUnFoldingTest(SgNode* n); | |
isPredicateBinaryOperatorbool isPredicateBinaryOperator(VariantT kind); | |
returnConstantFoldedValueExpression[[visibility("default")]] SgValueExp* returnConstantFoldedValueExpression(SgNode* n); |
DUVariableAnalysisExt namespace¶
Functions¶
| Name |
|---|
getNextParentInterstingNodeSgNode* getNextParentInterstingNode(SgNode* node); |
isDefbool isDef(SgNode* node); |
isIDefbool isIDef(SgNode* node); |
isIUsebool isIUse(SgNode* node); |
isUsebool isUse(SgNode* node); |
Dbg namespace¶
Types¶
| Name |
|---|
dbgBuf |
dbgStream |
Functions¶
| Name | Description |
|---|---|
addDOTstd::string addDOT(std::string dot); | |
addDOTStrstd::string addDOTStr(dottable& obj); | |
addImagestd::string addImage(std::string ext = "gif"); | |
diagnosticNodeTextstd::string diagnosticNodeText(SgNode const* node); | |
dotGraphGeneratorvoid dotGraphGenerator(Analysis* a); | Generate dot graphs for an analysis: it handles intra-procedural analysis for now. |
enterFuncvoid enterFunc(std::string funcName); | |
escapestd::string escape(std::string s); | |
exitFuncvoid exitFunc(std::string funcName); | |
initvoid init( std::string title, std::string workDir, std::string fName = "debug"); |
Variables¶
| Name |
|---|
dbg |
initialized |
DominatorTreesAndDominanceFrontiers namespace¶
Types¶
| Name | Description |
|---|---|
DefaultBasicDominatorTreeIsStatementFilter | |
DominatorForwardBackwardWrapperClass | This class provides a uniform view of the CFG dissregarding the direction of the CFG-traversal (forward/backward) |
TemplatedDominanceFrontier | |
TemplatedDominatorTree | TemplatedDominatorTree constructs a dominator/postdominator tree for a cfg. For the template parameter any cfg following Jeremias interface may be used |
Type Aliases¶
| Name | Description |
|---|---|
Direction | |
DominatorTree | STD-Dominator-Tree |
Enums¶
| Name |
|---|
Dir_ection |
IncludeFileGraph namespace¶
Functions¶
| Name |
|---|
graph_include_filesvoid graph_include_files(SgIncludeFile* includeFile); |
insertGraphNodevoid insertGraphNode(void* node); |
Variables¶
| Name |
|---|
file |
graphNodeSet |
Inliner namespace¶
Variables¶
| Name |
|---|
skipHeaders |
verbose |
IntegerOps namespace¶
Bit-wise operations on integers.
Types¶
| Name | Description |
|---|---|
GenMask | Bit mask constant with bits 0 through n-1 set. |
SHL1 | Bitmask constant with bit n set. Handles the case where n is greater than the width of type T. |
Functions¶
| Name | Description |
|---|---|
bitmask_subsettemplate<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. |
countCleartemplate<typename T> size_t countClear(T val); | Counts how many bits are clear (zero). |
countSettemplate<typename T> size_t countSet(T val); | Counts how many bits are set (one). |
extracttemplate< 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. |
extract2template<typename T> T extract2( size_t lobit, size_t hibit, T bits); | |
genMasktemplate<typename T> T genMask(size_t n); | genMask overloads |
isPowerOfTwotemplate<typename T> bool isPowerOfTwo(T value); | Returns true if the value is a power of two. Zero is considered a power of two. |
log2template<typename T> T log2(T a); | |
log2maxtemplate<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_settemplate<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. |
rotateLefttemplate< size_t NBits, typename T> T rotateLeft( T value, size_t count); | Rotate the bits of the value left by count bits. |
rotateLeft2template<typename T> T rotateLeft2( T value, size_t count, size_t width = 8 * sizeof(T)); | |
rotateRighttemplate< size_t NBits, typename T> T rotateRight( T value, size_t count); | Rotate bits of the value right by count bits. |
rotateRight2template<typename T> T rotateRight2( T value, size_t count, size_t width = 8 * sizeof(T)); | |
shiftLefttemplate< size_t NBits, typename T> T shiftLeft( T value, size_t count); | Shifts bits of value left by count bits. |
shiftLeft2template<typename T> T shiftLeft2( T value, size_t count, size_t width = 8 * sizeof(T)); | |
shiftRightArithmetictemplate< size_t NBits, typename T> T shiftRightArithmetic( T value, size_t count); | Shifts bits of value right by count bits with sign extension. |
shiftRightArithmetic2template<typename T> T shiftRightArithmetic2( T value, size_t count, size_t width = 8 * sizeof(T)); | |
shiftRightLogicaltemplate< size_t NBits, typename T> T shiftRightLogical( T value, size_t count); | Shifts bits of value right by count bits without sign extension. |
shiftRightLogical2template<typename T> T shiftRightLogical2( T value, size_t count, size_t width = 8 * sizeof(T)); | |
shift_totemplate< 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_to2template<typename T> T shift_to2( size_t lobit, size_t hibit, T value); | |
shl1template<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. |
signBittemplate< size_t NBits, typename T> bool signBit(T value); | Returns true if the sign bit is set, false if clear. |
signBit2template<typename T> bool signBit2( T value, size_t width = 8 * sizeof(T)); | |
signExtendtemplate< 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. |
signExtend2template<typename T> T signExtend2( T value, size_t from_width, size_t to_width); |
IntegerOpsPrivate namespace¶
Types¶
| Name |
|---|
NumBits |
SHL1Helper |
MangledNameSupport namespace¶
Type Aliases¶
| Name |
|---|
functionSetType |
setType |
Variables¶
| Name |
|---|
visitedFunctionDefinitions |
visitedTemplateDefinitions |
MaxSourceExtents namespace¶
Types¶
| Name |
|---|
InheritedAttribute |
SourceExtentsTraversal |
SynthesizedAttribute |
Functions¶
| Name |
|---|
computeMaxSourceExtentsvoid computeMaxSourceExtents( SgSourceFile* sourceFile, SgNode* n, int& start_line, int& start_column, int& end_line, int& end_column); |
NameQuery namespace¶
Type Aliases¶
| Name |
|---|
QueryDepth |
roseFunctionPointerOneParameter |
Enums¶
| Name |
|---|
TypeOfQueryTypeOneParameter |
Functions¶
| Name |
|---|
getFunctionstd::function<std::vector<std::string>(SgNode*)> getFunction(TypeOfQueryTypeOneParameter oneParam); |
queryMemoryPoolNameQuerySynthesizedAttributeType queryMemoryPool( TypeOfQueryTypeOneParameter elementReturnType, VariantVector* targetVariantVector = NULL); |
queryNameArgumentNamesNameQuerySynthesizedAttributeType queryNameArgumentNames(SgNode* astNode); |
queryNameClassDeclarationNamesNameQuerySynthesizedAttributeType queryNameClassDeclarationNames(SgNode* astNode); |
queryNameClassFieldNamesNameQuerySynthesizedAttributeType queryNameClassFieldNames(SgNode* astNode); |
queryNameFunctionDeclarationNamesNameQuerySynthesizedAttributeType queryNameFunctionDeclarationNames(SgNode* astNode); |
queryNameFunctionReferenceNamesNameQuerySynthesizedAttributeType queryNameFunctionReferenceNames(SgNode* astNode); |
queryNameMemberFunctionDeclarationNamesNameQuerySynthesizedAttributeType queryNameMemberFunctionDeclarationNames(SgNode* astNode); |
queryNameStructFieldNamesNameQuerySynthesizedAttributeType queryNameStructFieldNames(SgNode* astNode); |
queryNameStructNamesNameQuerySynthesizedAttributeType queryNameStructNames(SgNode* astNode); |
queryNameTypeNameNameQuerySynthesizedAttributeType queryNameTypeName(SgNode* astNode); |
queryNameTypedefDeclarationNamesNameQuerySynthesizedAttributeType queryNameTypedefDeclarationNames(SgNode* astNode); |
queryNameUnionFieldNamesNameQuerySynthesizedAttributeType queryNameUnionFieldNames(SgNode* astNode); |
queryNameUnionNamesNameQuerySynthesizedAttributeType queryNameUnionNames(SgNode* astNode); |
queryNameVariableNamesNameQuerySynthesizedAttributeType queryNameVariableNames(SgNode* astNode); |
queryNameVariableTypeNamesNameQuerySynthesizedAttributeType 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 namespace¶
Types¶
| Name |
|---|
CallGraph |
CallGraphEdgeInfo |
CallGraphFileStructure |
CallGraphNodeInfo |
Functions¶
| Name |
|---|
buildCallGraphint buildCallGraph(SgProject* project); |
generateCallGraphFilevoid generateCallGraphFile( SgProject* project, CallGraph& cg); |
getLockint getLock(); |
readCallGraphFilestd::vector<CallGraphFileStructure>* readCallGraphFile(std::string binaryFilename); |
releaseLockvoid releaseLock(int fd); |
NodeQuery namespace¶
Type Aliases¶
| Name |
|---|
QueryDepth |
roseFunctionPointerOneParameter |
Enums¶
| Name |
|---|
TypeOfQueryTypeOneParameter |
Functions¶
| Name |
|---|
generateListOfTypesstd::vector<SgNode*> generateListOfTypes(SgNode* astNode); |
getFunctionstd::function<std::vector<SgNode*>(SgNode*)> getFunction(TypeOfQueryTypeOneParameter oneParam); |
queryMemoryPool[[visibility("default")]] NodeQuerySynthesizedAttributeType queryMemoryPool(VariantVector& targetVariantVector); |
queryNodeAnonymousTypedefNodeQuerySynthesizedAttributeType queryNodeAnonymousTypedef(SgNode* node); |
queryNodeAnonymousTypedefClassDeclarationNodeQuerySynthesizedAttributeType queryNodeAnonymousTypedefClassDeclaration(SgNode* node); |
queryNodeList[[visibility("default")]] NodeQuerySynthesizedAttributeType queryNodeList( NodeQuerySynthesizedAttributeType, VariantT targetVariant); |
queryNodePragmaDeclarationFromNamestd::vector<SgNode*> queryNodePragmaDeclarationFromName( SgNode* node, SgNode* nameNode); |
querySolverArgumentsNodeQuerySynthesizedAttributeType querySolverArguments(SgNode* astNode); |
querySolverClassDeclarationsNodeQuerySynthesizedAttributeType querySolverClassDeclarations(SgNode* astNode); |
querySolverClassFieldsNodeQuerySynthesizedAttributeType querySolverClassFields(SgNode* astNode); |
querySolverFunctionDeclarationsNodeQuerySynthesizedAttributeType querySolverFunctionDeclarations(SgNode* astNode); |
querySolverMemberFunctionDeclarationsNodeQuerySynthesizedAttributeType querySolverMemberFunctionDeclarations(SgNode* astNode); |
querySolverStructDeclarationsNodeQuerySynthesizedAttributeType querySolverStructDeclarations(SgNode* astNode); |
querySolverStructDefinitionsNodeQuerySynthesizedAttributeType querySolverStructDefinitions(SgNode* astNode); |
querySolverStructFieldsNodeQuerySynthesizedAttributeType querySolverStructFields(SgNode* astNode); |
querySolverTypedefDeclarationsNodeQuerySynthesizedAttributeType querySolverTypedefDeclarations(SgNode* astNode); |
querySolverUnionDeclarationsNodeQuerySynthesizedAttributeType querySolverUnionDeclarations(SgNode* astNode); |
querySolverUnionFieldsNodeQuerySynthesizedAttributeType querySolverUnionFields(SgNode* astNode); |
querySolverVariableDeclarationsNodeQuerySynthesizedAttributeType querySolverVariableDeclarations(SgNode* astNode); |
querySolverVariableTypesNodeQuerySynthesizedAttributeType querySolverVariableTypes(SgNode* astNode); |
querySubTree[[visibility("default")]] NodeQuerySynthesizedAttributeType querySubTree( SgNode* subTree, TypeOfQueryTypeOneParameter elementReturnType, AstQueryNamespace::QueryDepth defineQueryType = AstQueryNamespace::AllNodes); |
NumberQuery namespace¶
Type Aliases¶
| Name |
|---|
roseFunctionPointerOneParameter |
Enums¶
| Name |
|---|
TypeOfQueryTypeOneParameter |
Functions¶
| Name |
|---|
getFunctionstd::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); |
queryNumberOfArgsInConstructorNumberQuerySynthesizedAttributeType queryNumberOfArgsInConstructor(SgNode* astNode); |
queryNumberOfArgsInParenthesisOperatorNumberQuerySynthesizedAttributeType queryNumberOfArgsInParenthesisOperator( SgNode* astNode, SgType* returnType); |
queryNumberOfArgsInScalarIndexingOperatorNumberQuerySynthesizedAttributeType queryNumberOfArgsInScalarIndexingOperator(SgNode* astNode); |
queryNumberOfOperandsNumberQuerySynthesizedAttributeType queryNumberOfOperands(SgNode* astNode); |
querySubTree[[visibility("default")]] NumberQuerySynthesizedAttributeType querySubTree( SgNode* subTree, TypeOfQueryTypeOneParameter elementReturnType, AstQueryNamespace::QueryDepth defineQueryType = AstQueryNamespace::AllNodes); |
OmpSupport namespace¶
Types and functions to support OpenMP
Types¶
| Name | Description |
|---|---|
ClauseVariableCopyIdentity | Exact identities produced when an outlined OpenMP clause-variable record is transferred through one deep-copy transaction. |
ComplexClause | |
OpenMPConversionSession | |
OpenMPConversionSessionAccess |
Type Aliases¶
| Name |
|---|
VariableSymbolMap_t |
Enums¶
| Name | Description |
|---|---|
AssociatedLoopPathContract | Typed allowlists for the structural path from an OpenMP directive's exact body edge to its associated loop. Worksharing and SIMD constructs permit only transparent singleton basic blocks. Loop transformations additionally permit nested, supported loop-transformation directives; semantic OpenMP regions and attributed statements are never transparent wrappers. |
omp_construct_enum |
Functions¶
| 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 |
addGeneratedOmpClausevoid addGeneratedOmpClause( SgStatement* node, SgOmpClause* clause); | Attach a transformation-generated OpenMP clause, assigning exact source-order provenance when the directive came from combined syntax. |
addOmpClausevoid addOmpClause( SgStatement* node, SgOmpClause* clause); | Attach an OpenMP clause to directive |
analyze_ompvoid analyze_omp(SgSourceFile*); | |
beginOpenACCCxxExactSemanticConsumptionvoid beginOpenACCCxxExactSemanticConsumption(SgPragmaDeclaration* pragma); | |
beginOpenACCCxxExactSemanticExpressionvoid beginOpenACCCxxExactSemanticExpression( SgPragmaDeclaration* pragma, std::string const& expression, OpenMPExprParseMode parse_mode); | |
beginOpenACCFortranExactSemanticConsumptionvoid beginOpenACCFortranExactSemanticConsumption(SgPragmaDeclaration* pragma); | |
beginOpenACCFortranExactSemanticExpressionvoid beginOpenACCFortranExactSemanticExpression( SgPragmaDeclaration* pragma, std::string const& expression); | |
buildAndInsertDeclarationForOmpSgVariableDeclaration* 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 |
buildFortranOutlinedFunctionRefSgFunctionRefExp* 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 |
collectThreadprivateVariablesstd::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 |
commandLineProcessingvoid commandLineProcessing(std::vector<std::string>& argvList); | |
consumeOpenACCFortranExactSemanticEndvoid consumeOpenACCFortranExactSemanticEnd(SgPragmaDeclaration* pragma); | |
consumeOpenACCFortranExactSemanticSyntaxvoid 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 |
createOmpStatementTreevoid createOmpStatementTree(SgSourceFile* file); | Analysis helpers |
discardOpenMPProducerSemanticRecordsvoid discardOpenMPProducerSemanticRecords(SgSourceFile* source_file); | |
endOpenACCCxxExactSemanticExpressionvoid endOpenACCCxxExactSemanticExpression(SgPragmaDeclaration* pragma); | |
endOpenACCFortranExactSemanticExpressionvoid endOpenACCFortranExactSemanticExpression(SgPragmaDeclaration* pragma); | |
finishOpenACCCxxExactSemanticConsumptionvoid finishOpenACCCxxExactSemanticConsumption(SgPragmaDeclaration* pragma); | |
finishOpenACCFortranExactSemanticConsumptionvoid finishOpenACCFortranExactSemanticConsumption(SgPragmaDeclaration* pragma); | |
generateOutlinedTaskSgFunctionDeclaration* 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 |
getEnclosingRegionOrFuncDefinitionSgBasicBlock* getEnclosingRegionOrFuncDefinition(SgNode*); | Find an enclosing parallel region or function definition's body |
getKmpcRuntimeFunctionNamestd::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. |
getOmpClauseListSgOmpClauseList* getOmpClauseList(SgStatement* node); | |
getOmpParentSgStatement* getOmpParent(SgStatement* node); | |
getOpenMPMergedEndClauseSourcestd::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 |
initializeTaskDataEnvironmentvoid initializeTaskDataEnvironment( SgOmpTaskStatement* task, SgOmpClauseBodyStatement* source_context, std::vector<SgInitializedName*> const& generated_firstprivate, std::vector<SgInitializedName*> const& generated_private); | |
insertAcceleratorInitvoid insertAcceleratorInit(SgSourceFile*); | |
insertRTLHeadersvoid insertRTLHeaders(SgSourceFile*); | Insert #include "xxx.h", the interface of a runtime library to the compiler |
isClausebool isClause(omp_construct_enum omp_type); | Check if an OpenMP construct is a clause |
isDependenceTypebool isDependenceType(omp_construct_enum omp_type); | Check if an OpenMP construct is a dependence type for omp task depend |
isDirectivebool isDirective(omp_construct_enum omp_type); | Check if an OpenMP construct is a directive |
isDirectiveWithBodybool isDirectiveWithBody(omp_construct_enum omp_type); | Check if an OpenMP directive has a structured body |
isFortranBeginDirectivebool isFortranBeginDirective(omp_construct_enum omp_type); | Check if the construct is a Fortran directive which can (optionally) have a corresponding END directive |
isFortranEndDirectivebool 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 |
isInOmpTargetRegionbool isInOmpTargetRegion(SgStatement* node); | Check whether a SgNode is inside omp target |
isOmpContextSelectorMetadataDirectivebool 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. |
isOpenMPMergedEndClausebool isOpenMPMergedEndClause(OpenMPClause const* clause); | |
isReductionOperatorbool 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_ompvoid lower_omp(SgSourceFile*); | The top level interface to translate OpenMP directives |
markImplicitTargetMapVariable[[visibility("default")]] void markImplicitTargetMapVariable( SgOmpClauseBodyStatement* target, SgInitializedName* var); | |
markOpenMPMergedEndClausevoid markOpenMPMergedEndClause( OpenMPClause* clause, std::string const& source_text); | |
mergeSgNodeListstd::vector<SgNode*> mergeSgNodeList( std::vector<SgNode*> node_list1, std::vector<SgNode*> node_list2); | |
openMPExpressionVariablesstd::vector<SgNode*>& openMPExpressionVariables(); | |
patchUpPrivateVariables[[visibility("default")]] int patchUpPrivateVariables(SgFile*); | patchUpPrivateVariables overloads |
prepareSourceForOpenMPTransformationvoid 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. |
processOpenMPvoid processOpenMP(SgSourceFile*& sageFilePtr); | |
registerOpenACCCxxExactSemanticBindingsvoid registerOpenACCCxxExactSemanticBindings( SgSourceFile* source_file, SgPragmaDeclaration* pragma, OpenACCCxxExactSemanticBindings bindings); | |
registerOpenMPFortranExactSemanticBindingsvoid registerOpenMPFortranExactSemanticBindings( SgSourceFile* source_file, SgPragmaDeclaration* pragma, OmpFortranExactSemanticBindings bindings); | |
registerOpenMPProducerSemanticRecordsvoid 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 |
replaceVariablesWithPointerDereferenceint replaceVariablesWithPointerDereference( SgNode* root, std::set<SgVariableSymbol*>& vars); | Replace all variable references in a set by pointers to the variable |
requireExactAssociatedForLoopSgForStatement* requireExactAssociatedForLoop( SgOmpBodyStatement* directive, SgStatement* expected_root, AssociatedLoopPathContract path_contract, char const* contract); | |
requireExactAssociatedLoopSgStatement* 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. |
requireExactIntegralConstantExpressionvoid 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. |
requireExactPositiveIntegralConstantunsigned 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. |
requireFortranDirectiveSemanticProducervoid requireFortranDirectiveSemanticProducer( SgPragmaDeclaration* pragma, OmpFortranExactSemanticBindings::Producer producer, char const* operation, SgPragmaDeclaration::fortran_directive_family_enum expected_family = SgPragmaDeclaration::e_fortran_directive_none); | |
requireOpenMPConversionSessionvoid requireOpenMPConversionSession(); | |
retireConsumedOmpDirectivevoid retireConsumedOmpDirective(SgStatement* directive); | |
setOmpRelationshipvoid setOmpRelationship( SgStatement* parent, SgStatement* child); | |
snapshotOpenMPProducerSemanticRecordsOpenMPProducerSemanticRecords snapshotOpenMPProducerSemanticRecords(SgPragmaDeclaration* pragma); | |
toStringstd::string toString(omp_construct_enum omp_type); | toString overloads |
transOmpAtomicvoid transOmpAtomic(SgNode* node); | Translate omp atomic |
transOmpBarriervoid transOmpBarrier(SgNode* node); | Translate omp barrier |
transOmpCollapsevoid transOmpCollapse(SgStatement* node); | |
transOmpCriticalvoid transOmpCritical(SgNode* node); | Translate omp critical |
transOmpFlushvoid transOmpFlush(SgNode* node); | Translate omp flush |
transOmpLoopvoid transOmpLoop(SgNode* node); | Translate omp for or omp do loops |
transOmpMastervoid transOmpMaster(SgNode* node); | Translate omp master |
transOmpMetadirectivevoid transOmpMetadirective(SgNode* node); | Translate omp metadirective |
transOmpOrderedvoid transOmpOrdered(SgNode* node); | Translate the ordered directive (not the ordered clause) |
transOmpParallelvoid transOmpParallel(SgNode* node); | Translate omp parallel |
transOmpSectionsvoid transOmpSections(SgNode* node); | Translate omp sections |
transOmpSimdvoid transOmpSimd(SgNode* node); | Translate omp simd |
transOmpSinglevoid transOmpSingle(SgNode* node); | Translate omp single |
transOmpTargetvoid transOmpTarget(SgNode* node); | Translate "omp target" |
transOmpTargetDatavoid transOmpTargetData(SgNode* node); | Translate "omp target data" |
transOmpTargetParallelvoid transOmpTargetParallel(SgNode* node); | Translate omp parallel under "omp target" |
transOmpTaskvoid transOmpTask(SgNode* node); | Translate omp task |
transOmpTaskgroupvoid transOmpTaskgroup(SgNode* node); | |
transOmpTaskloopvoid transOmpTaskloop(SgNode* node); | |
transOmpTaskwaitvoid transOmpTaskwait(SgNode* node); | Translate omp taskwait |
transOmpThreadprivatevoid transOmpThreadprivate(SgNode* node); | Translate omp threadprivate |
transOmpTilevoid transOmpTile(SgNode* node); | Translate omp tile |
transOmpUnrollvoid 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]) |
Variables¶
| Name |
|---|
cur_omp_directive |
enable_accelerator |
nCounter |
Outliner namespace¶
Namespaces¶
| Name |
|---|
Preprocess |
Types¶
| Name | Description |
|---|---|
OutlinedLocalTypeTemplateEntry | |
OutlinedLocalTypeTemplatePlan | |
Result | Stores the main results of an outlining transformation. |
Type Aliases¶
| Name |
|---|
OutlinedFunctionParameterBindings |
Functions¶
| Name | Description |
|---|---|
appendIndividualFunctionCallArgsvoid 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); | |
collectVarsvoid 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 |
ensureDlopenSupportHeaderInCallSitevoid 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. |
generateCallSgStatement* 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. |
generateFuncArgNamestd::string generateFuncArgName(SgStatement const* stmt); | Create a unique outlined-function's wrapper argument name for the specified statement. |
generateFuncNamestd::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); | |
isFortranModuleDefinitionScopebool 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." |
isValidOutliningScopebool isValidOutliningScope(SgScopeStatement const* scope); | |
outlineResult outline(SgPragmaDeclaration* s); | outline overloads |
outlineAll[[visibility("default")]] size_t outlineAll(SgProject*); | Outlines all regions marked by outlining pragmas. |
outlineBlockResult 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. |
Variables¶
| Name | Description |
|---|---|
AUTOTUNING_LIB_HEADER | |
DEFAULT_OUTPUT_PATH | |
FIND_AND_CALL_FUNCP_DLOPEN | |
FIND_FUNCP_DLOPEN | |
MASTER_SHARED_LIB_NAME | |
copy_origFile | |
enable_classic | |
enable_debug | |
enable_liveness | |
enable_template | |
exclude_headers | |
lines | |
output_path | |
preproc_only_ | |
select_omp_loop | |
suppress_autotuning_header | |
temp_variable | A set of flags to control the internal behavior of the outliner |
useNewFile | |
useParameterWrapper | |
useStructureWrapper | |
use_dlopen | |
use_dlopen_simple |
Outliner::Preprocess namespace¶
Functions¶
| Name | Description |
|---|---|
checkAndPatchUpOptionsvoid checkAndPatchUpOptions(); | Sanity check and patch up outliner options |
copyNonLocalFunctionDeclarationSgFunctionDeclaration* copyNonLocalFunctionDeclaration( SgFunctionDeclaration* source, SgScopeStatement* scope, SgStatement* insertionAnchor); | |
createBlockSgBasicBlock* createBlock(SgStatement* s); | Convert the "plain-old" statement into an SgBasicBlock. This normalization simplifies outlining of single statements. |
gatherNonLocalDeclsvoid gatherNonLocalDecls(SgBasicBlock* b); | Gathers non-local declarations into the local scope. |
moveLeadingPreprocessorPrefixForPrototypevoid moveLeadingPreprocessorPrefixForPrototype( SgStatement* source, SgStatement* destination); | |
preparePrototypeParameterDeclarationsvoid preparePrototypeParameterDeclarations( SgFunctionDeclaration const* prototype, SgGlobal* scope, SgDeclarationStatement* boundary); | |
preprocessOutlineTargetSgBasicBlock* preprocessOutlineTarget(SgStatement* s); | Preprocesses the outline target and returns an equivalent SgBasicBlock to outline. |
transformNonLocalControlFlowSgBasicBlock* transformNonLocalControlFlow(SgBasicBlock* b_orig); | Preprocess non-local control flow for outlining. |
transformPreprocIfsSgBasicBlock* 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. |
transformThisExprsSgBasicBlock* transformThisExprs(SgBasicBlock* b); | Canonicalize references to 'this'. |
ProcessExpression namespace¶
Functions¶
| Name |
|---|
processLHSvoid processLHS( SgNode* node, AliasRelationNode& arNode); |
processRHSvoid processRHS( SgNode* node, AliasRelationNode& arNode); |
ROSE_Analysis namespace¶
Functions¶
| Name |
|---|
BuildCFGtemplate<class Node> void BuildCFG( AstInterface& fa, AstInterface::AstNodeList const& head, BuildCFGConfig<Node>& g); |
ROSE_Statistics namespace¶
Types¶
| Name |
|---|
AstNodeMemoryPoolStatistics |
AstNodeTraversalStatistics |
ROSE_token_ids namespace¶
Enums¶
| Name |
|---|
ROSE_C_CXX_Additional_Info |
ROSE_C_CXX_alternate_tok |
ROSE_C_CXX_keywords |
whitespace |
Rose namespace¶
Namespaces¶
| Name | Description |
|---|---|
AST | |
AstJson | |
Builder | |
BuiltinOperands | |
ClangFrontend | |
Cmdline | |
FileSystem | Functions for operating on files in a filesystem. |
FortranLex | |
FortranLineWrapSupport | |
FortranSource | |
Frontend | |
MemPool | |
OpenMP | |
StringUtility | Functions for operating on strings. |
TestOutput |
Types¶
| Name | Description |
|---|---|
FloatingValue | |
Integer128Value | |
Options | |
PluginAction | |
Registry | A global registry used in conjunction with static constructors to make pluggable components (like targets or garbage collectors) "just work" when linked with an executable. |
RegistryTraits | Traits for registry entries. If using other than SimpleRegistryEntry, it is necessary to define an alternate traits class. |
SimpleRegistryEntry | A simple registry entry which provides only a name, description, and no-argument constructor. |
iterator_range | A range adaptor for a pair of iterators. |
Type Aliases¶
| Name |
|---|
PluginRegistry |
Functions¶
| Name | Description |
|---|---|
getNextStatementSgStatement* getNextStatement(SgStatement* targetStatement); | |
getPathFromFileName[[visibility("default")]] std::string getPathFromFileName(std::string fileNameWithPath); | get the filename from the full filename |
getPreviousStatementSgStatement* getPreviousStatement( SgStatement* targetStatement, bool climbOutScope = true); | |
getWorkingDirectory[[visibility("default")]] std::string getWorkingDirectory(); | |
make_rangetemplate<typename T> iterator_range<T> make_range(std::pair<T, T> p); | Convenience function for iterating over sub-ranges. |
obtainAndExecuteActionsint 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); | |
processPluginCommandLinevoid 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 |
Variables¶
| Name | Description |
|---|---|
INVALID_INDEX | Invalid array index. |
PluginActions | |
PluginArgs | |
PluginLibs | |
UNLIMITED | Effectively unlimited size. |
global_options | |
is_C99_language | |
is_CAF_language | |
is_C_language | |
is_Cuda_language | |
is_Cxx_language | |
is_Fortran_language | |
is_OpenCL_language | |
is_OpenMP_language | |
macroExpansionMapOfMaps | |
representativeWhitespaceStatementMapOfMaps | |
tokenSubsequenceMapOfMapsBySourceFile |
Rose::AST namespace¶
Functions¶
| Name |
|---|
expressionHasSemanticValueTypebool expressionHasSemanticValueType( VariantT kind, bool unevaluated_string); |
namedTypeScopeHasCrossTranslationUnitIdentitybool namedTypeScopeHasCrossTranslationUnitIdentity(SgScopeStatement* scope); |
resolvedClassTypeSgClassType* resolvedClassType( SgType* type, bool strip_indirection = false); |
selectedDestructorClassSgClassType* selectedDestructorClass(SgMemberFunctionDeclaration* destructor); |
temporaryStorageMatchesOwnerbool temporaryStorageMatchesOwner( SgExpression::temporary_storage_duration_enum storage, VariantT scope, bool static_storage, bool thread_storage); |
Rose::AstJson namespace¶
Types¶
Type Aliases¶
Enums¶
| Name |
|---|
Checkpoint |
ExternalFunctionParameterScopeOwner |
LabelSymbolBasisKind |
OperandRequirementKind |
Functions¶
| Name | Description |
|---|---|
addExpressionQualificationFieldsvoid addExpressionQualificationFields( std::vector<std::string>& fields, SgExpression* expr); | |
addExpressionTypevoid addExpressionType( std::vector<std::string>& fields, SgExpression* expr, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
addLocatedPreprocessingvoid addLocatedPreprocessing( std::vector<std::string>& fields, SgLocatedNode const* node); | |
aggregateConstructionFieldsFromJsonAggregateConstructionFields aggregateConstructionFieldsFromJson( JsonValue const& properties, NodeMap const& nodes, SgUnsignedCharList source_roles); | |
aggregateSourceElementRolesFromJsonSgUnsignedCharList aggregateSourceElementRolesFromJson(JsonValue const& properties); | |
alignmentSpecifierFromPropertiesSgAlignmentSpecifier* alignmentSpecifierFromProperties( JsonValue const& properties, SgExpression* operand); | |
alignmentSpellingFromPropertiesSgAlignmentSpecifier::spelling_enum alignmentSpellingFromProperties( JsonValue const& properties, bool has_operand); | |
appendCanonicalJsonvoid appendCanonicalJson( std::ostream& out, JsonValue const& value); | |
appendRawExternalDeclarationStatementFieldsvoid appendRawExternalDeclarationStatementFields( std::vector<std::string>& fields, SgDeclarationStatement* decl, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& context); | |
appendRawTypeModifierFieldsvoid appendRawTypeModifierFields( std::vector<std::string>& fields, SgTypeModifier const& modifier, std::string const& prefix = "declaration_type"); | |
applyFunctionCallSourceFieldsvoid applyFunctionCallSourceFields( SgFunctionCallExp* call, FunctionCallSourceFields const& fields); | |
argumentSelectsCheckpointbool argumentSelectsCheckpoint( std::string const& value, Checkpoint checkpoint); | |
arrayInitBindingCategoryFromJsonSgCastExp::value_category_enum arrayInitBindingCategoryFromJson(JsonValue const& json); | |
arrayInitReferenceFieldsFromJsonArrayInitReferenceFields arrayInitReferenceFieldsFromJson(JsonValue const& json); | |
asmOperandFieldsFromJsonAsmOperandConstructionFields asmOperandFieldsFromJson(JsonValue const& properties); | |
asmStatementFieldsFromJsonAsmStatementConstructionFields asmStatementFieldsFromJson(JsonValue const& properties); | |
assignmentInitializerSourceFieldsFromJsonAssignmentInitializerSourceFields assignmentInitializerSourceFieldsFromJson(JsonValue const& properties); | |
attachAstAttributesvoid attachAstAttributes( SgNode* node, PreparedAstAttributes attributes); | |
attachJsonNodeIdvoid attachJsonNodeId( SgNode* node, uint64_t id); | |
attachPointerMemberJsonIdentityvoid attachPointerMemberJsonIdentity( SgPointerMemberType* type, uint64_t identity); | |
attachPreprocessingInfovoid attachPreprocessingInfo( SgNode* node, PreparedPreprocessingInfo entries); | |
attachSemanticArrayJsonIdentityvoid attachSemanticArrayJsonIdentity( SgArrayType* type, uint64_t identity); | |
attachSourceTypeJsonIdentityvoid attachSourceTypeJsonIdentity( SgType* type, uint64_t identity); | |
binaryEmissionRoleFromJsonstd::optional<SgArrowExp::emission_role_enum> binaryEmissionRoleFromJson( JsonValue const& properties, std::string const& kind); | |
binaryStorageSizeFromJsonstd::optional<long long> binaryStorageSizeFromJson( JsonValue const& properties, std::string const& kind); | |
binarySubscriptStridesFromJsonstd::vector<std::optional<long long>> binarySubscriptStridesFromJson( JsonValue const& properties, std::string const& kind); | |
bitVectorFromJsonSgBitVector bitVectorFromJson( JsonValue const& json, std::string const& context, std::size_t expected_size); | |
buildCachedJsonPointerTypeSgPointerType* buildCachedJsonPointerType(SgType* base); | |
buildFileInfoSg_File_Info* buildFileInfo( JsonValue const& json, SgNode* parent); | |
buildJsonstd::string buildJson( SgNode* root, Checkpoint checkpoint, SgSourceFile* file, SgFileList* project_files = nullptr, NodeMap* serialized_nodes = nullptr); | |
canonicalSourceIdentityFromJsonstd::optional<SgTemplateParameter::canonical_source_identity> canonicalSourceIdentityFromJson( JsonValue const& object, char const* owner); | |
canonicalSubtreeSignaturestd::string canonicalSubtreeSignature(SgNode* root); | |
canonicalTypedefDeclarationIduint64_t canonicalTypedefDeclarationId( std::unordered_map<SgNode const*, uint64_t> const& ids, SgTypedefDeclaration const* decl); | |
castConstructionFieldsFromJsonCastConstructionFields castConstructionFieldsFromJson(JsonValue const& properties); | |
castExpressionFromPropertiesSgCastExp* castExpressionFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpression* operand, SgType* type, CastConstructionFields const& fields); | |
checkpointEnabledbool checkpointEnabled( SgSourceFile const* file, Checkpoint checkpoint); | |
checkpointNamechar const* checkpointName(Checkpoint checkpoint); | |
checkpointPathstd::filesystem::path checkpointPath( SgSourceFile* file, Checkpoint checkpoint, Options const& options); | |
chooseSelectionFromJsonSgChooseExpression::selection_kind_enum chooseSelectionFromJson(JsonValue const& properties); | |
classDeclarationHasDefinitionbool classDeclarationHasDefinition(SgClassDeclaration* decl); | |
classDeclarationIsFirstNondefiningbool classDeclarationIsFirstNondefining(SgClassDeclaration* decl); | |
classSymbolForDeclarationSgClassSymbol* classSymbolForDeclaration(SgClassDeclaration* decl); | |
classTypeForDeclarationSgClassType* classTypeForDeclaration(SgClassDeclaration* decl); | |
collectDelayedDeclarationsstd::vector<NodeRecord const*> collectDelayedDeclarations( AstFileRecord const& ast, NodeMap const& nodes); | |
collectExternalFunctionConstructionDependenciesvoid collectExternalFunctionConstructionDependencies( JsonValue const& json, std::unordered_set<uint64_t>& ids); | |
collectNodesstd::vector<SgNode*> collectNodes(SgNode* root); | |
collectTypeDependencyIdsvoid collectTypeDependencyIds( JsonValue const& json, std::unordered_set<uint64_t>& ids, std::unordered_set<uint64_t>& symbol_ids, std::unordered_set<uint64_t>& type_ids); | |
commandLinestd::vector<std::string> commandLine(SgSourceFile const* file); | |
commandLineFromJsonstd::vector<std::string> commandLineFromJson(JsonValue const& properties); | |
commandLineValuestd::string commandLineValue( SgSourceFile const* file, std::string const& option); | |
complexValueFromPropertiesSgComplexVal* complexValueFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
compoundLiteralFromPropertiesSgCompoundLiteralExp* compoundLiteralFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
conditionalFromPropertiesSgConditionalExp* conditionalFromProperties( JsonValue const& properties, NodeMap const& nodes, SgConditionalExp::conditional_operator_kind_enum kind, SgExpression* condition, SgExpression* true_expression, SgExpression* false_expression); | |
conditionalOperatorKindFromJsonSgConditionalExp::conditional_operator_kind_enum conditionalOperatorKindFromJson(JsonValue const& properties); | |
constructAggregateInitializerSgAggregateInitializer* constructAggregateInitializer( AggregateConstructionFields const& fields, SgExprListExp* initializers, SgExpressionPtrList const& elements); | |
constructAsmOperandSgAsmOp* constructAsmOperand( AsmOperandConstructionFields const& fields, SgExpression* expression); | |
constructAsmStatementSgAsmStmt* constructAsmStatement( AsmStatementConstructionFields const& fields, SgExpressionPtrList const& operands); | |
constructBinaryOpSgBinaryOp* 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); | |
constructChooseExpressionSgChooseExpression* constructChooseExpression( SgType* type, SgChooseExpression::selection_kind_enum selection, SgExpression* condition, SgExpression* true_expression, SgExpression* false_expression); | |
constructClassTypeForDeclarationSgClassType* constructClassTypeForDeclaration(SgClassDeclaration* decl); | |
constructExternalFunctionOwnedAttributesvoid constructExternalFunctionOwnedAttributes( SgFunctionDeclaration* declaration, JsonValue const& json, NodeMap const& nodes); | |
constructExternalFunctionParameterScopeDeclarationsFromJsonvoid constructExternalFunctionParameterScopeDeclarationsFromJson( JsonValue const& json, NodeMap const& nodes, SgFunctionParameterScope* scope, SgInitializedNamePtrList const& parameters, std::string const& function_name, std::optional<SourcePositions> positions); | |
constructExternalFunctionParameterScopeSymbolsbool constructExternalFunctionParameterScopeSymbols( AstFileRecord const& ast, NodeMap const& nodes, bool require_complete); | |
constructExternalFunctionParameterScopeSymbolsFromJsonvoid constructExternalFunctionParameterScopeSymbolsFromJson( JsonValue const& json, NodeMap const& nodes, SgFunctionParameterScope* scope, SgInitializedNamePtrList const& parameters, std::string const& function_name); | |
constructExternalInitializedNameSgInitializedName* constructExternalInitializedName( JsonValue const& json, NodeMap const& nodes, ExternalInitializedNameFields const& fields, SgDeclarationStatement* decl, SgNode* parent, SgScopeStatement* scope, std::string const& context); | |
constructFileInfoSg_File_Info* constructFileInfo( std::optional<FileInfoFields> const& fields, SgNode* parent); | |
constructFortranImplicitRangeSgFortranImplicitRange* constructFortranImplicitRange( char first, std::optional<char> last, SgFortranImplicitRange::type_spec_enum type_spec, JsonValue const& properties, NodeMap const& nodes); | |
constructFunctionCallSgFunctionCallExp* constructFunctionCall( FunctionCallSourceFields const& fields, SgExpression* function, SgExprListExp* arguments, SgType* type, SgCxxLiteralTokenList* literal_tokens); | |
constructInitializedNameSgInitializedName* constructInitializedName( SgName const& name, SgType* type); | |
constructNewExpressionSgNewExp* constructNewExpression( NewConstructionFields const& fields, SgExpression* array_bound, SgExprListExp* placement, SgConstructorInitializer* constructor, SgExpression* builtin, SgFunctionDeclaration* operator_declaration, SgExpressionPtrList const& placement_elements); | |
constructOperandRequirementSgExpression* constructOperandRequirement( OperandRequirementKind kind, SgExpression* operand, SgExpression* type_constraint, bool noexcept_required); | |
constructPendingSerializedSymbolsbool constructPendingSerializedSymbols( SerializedSymbolTableConstruction& construction, NodeMap const& nodes, bool require_complete); | |
constructPreprocessingInfoPreparedPreprocessingInfo constructPreprocessingInfo(std::vector<PreprocessingInfoFields> const& fields); | |
constructSourcePositionsSourcePositions constructSourcePositions(SourcePositionFields const& fields); | |
constructTypedefDeclarationSgTypedefDeclaration* 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); | |
constructUnaryOpSgUnaryOp* constructUnaryOp( std::string const& kind, SgExpression* operand, UnaryConstructionFields const& fields, SgType* result_type); | |
constructVisibilitySymbolstd::unique_ptr<SgSymbol> constructVisibilitySymbol( VisibilitySymbolFields const& fields, NodeMap const& nodes, SgNodePtrList causes); | |
constructorArgumentSourceFromPropertiesSgConstructorInitializer::argument_source_enum constructorArgumentSourceFromProperties(JsonValue const& properties); | |
constructorElisionFromPropertiesbool constructorElisionFromProperties(JsonValue const& properties); | |
constructorInitializerFromPropertiesSgConstructorInitializer* constructorInitializerFromProperties( JsonValue const& properties, SgMemberFunctionDeclaration* declaration, SgExprListExp* arguments, SgExpressionPtrList const& elements, SgType* type); | |
contextPropertyFieldsFromRecordOmpContextPropertyFields contextPropertyFieldsFromRecord(NodeRecord const& record); | |
contextSelectorFieldsFromJsonOmpContextSelectorFields contextSelectorFieldsFromJson(JsonValue const& properties); | |
contextSelectorSetKindFromJsonSgOmpClause::omp_context_selector_set_kind_enum contextSelectorSetKindFromJson(JsonValue const& properties); | |
coroutineKeywordKindFromJsonSgAwaitExpression::coroutine_keyword_kind_enum coroutineKeywordKindFromJson(JsonValue const& properties); | |
createExternalSymbolFromJsonSgSymbol* createExternalSymbolFromJson( JsonValue const& json, NodeMap const& nodes, SgSymbolTable* owner_table); | |
createNodeFromRecordSgNode* createNodeFromRecord( NodeRecord const& record, SgProject* project, NodeMap const& dependencies); | |
createSourceFileFromRecordSgSourceFile* createSourceFileFromRecord( NodeRecord const& record, SgProject* project, SgFileList* owner, NodeMap const& dependencies = {}); | |
createSymbolForKindAndBasisSgSymbol* createSymbolForKindAndBasis( VariantT kind, SgNode* basis, JsonValue const& properties); | |
createUseStatementFromRecordSgNode* createUseStatementFromRecord( NodeRecord const& record, SgProject* project, SgModuleStatement* module); | |
currentDeserializationSourceFilesstd::vector<SgSourceFile*> currentDeserializationSourceFiles(); | |
declarationConstructionDependencyReadybool declarationConstructionDependencyReady( AstFileRecord const& ast, NodeMap const& nodes, uint64_t id, bool needs_symbol, bool needs_type_identity, VariantT symbol_kind = V_SgSymbol); | |
declarationFieldsFromJsonDeclarationFields declarationFieldsFromJson( JsonValue const& properties, VariantT kind, std::string const& context, std::string const& qualifier_context = "declaration source qualifier"); | |
declarationNameQualificationFieldsFromJsonDeclarationNameQualificationFields declarationNameQualificationFieldsFromJson(JsonValue const& properties); | |
declarationNeedsExternalReferenceRecordbool declarationNeedsExternalReferenceRecord( SgDeclarationStatement* decl, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
declarationSourceFieldsFromJsonDeclarationSourceFields declarationSourceFieldsFromJson( JsonValue const& properties, std::string const& context, std::string const& qualifier_context = "declaration source qualifier", bool variable = false); | |
decodeExternalClassDeclarationstd::function<SgClassDeclaration*()> decodeExternalClassDeclaration(JsonValue const& json); | |
decodeExternalFunctionstd::function<SgFunctionDeclaration*()> decodeExternalFunction( JsonValue const& json, NodeMap const& nodes); | |
decodeExternalModulestd::function<SgModuleStatement*()> decodeExternalModule(JsonValue const& json); | |
defaultInitializerDeclarationFromJsonSgInitializedName* defaultInitializerDeclarationFromJson( JsonValue const& json, NodeMap const& nodes); | |
defaultInitializerDeclarationNodeFromJsonuint64_t defaultInitializerDeclarationNodeFromJson(JsonValue const& json); | |
defaultInitializerKindFromJsonSgCxxDefaultInitExp::source_kind_enum defaultInitializerKindFromJson(JsonValue const& properties); | |
defaultOutputDirectorystd::string defaultOutputDirectory(SgSourceFile const* file); | |
drainDelayedDeclarationsvoid drainDelayedDeclarations( AstFileRecord const& ast, std::vector<NodeRecord const*>& pending, NodeMap& nodes, bool require_complete, SymbolConstructionAdvance const& symbols = {}); | |
edgeTargetIsInParentChainbool edgeTargetIsInParentChain( SgNode const* node, SgNode const* target); | |
edgesForstd::vector<EdgeRecord> edgesFor( NodeRecord const& record, std::string const& field); | |
enforceSymbolTablePreferencesvoid enforceSymbolTablePreferences(std::vector<ExpectedSymbolTablePreference> const& entries); | |
enumValueFromPropertiesSgEnumVal* enumValueFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
exactBoundSymbolFromJsonSgSymbol* exactBoundSymbolFromJson( JsonValue const& json, NodeMap const& nodes, SgSymbolTable* local_table = nullptr); | |
exactInitializedNameTypeSgType* exactInitializedNameType( JsonValue const& properties, NodeMap const& nodes); | |
exactJsonValueHashuint64_t exactJsonValueHash(JsonValue const& value); | |
exactSerializedPointerTargetuint64_t exactSerializedPointerTarget( NodeRecord const& record, std::string const& property, std::string const& edge); | |
exactSymbolBindingDependenciesReadybool exactSymbolBindingDependenciesReady( JsonValue const& json, NodeMap const& nodes); | |
exactSymbolBindingEntryIndexsize_t exactSymbolBindingEntryIndex( JsonValue const& binding, JsonValue const& entries); | |
exactTypedefBaseTypeSgType* exactTypedefBaseType( JsonValue const& properties, NodeMap const& nodes); | |
exprListExpFromTypeJsonSgExprListExp* exprListExpFromTypeJson( JsonValue const& json, NodeMap const& nodes); | |
expressionCarriesSemanticTypebool expressionCarriesSemanticType(SgExpression const* expression); | |
expressionConstructionFieldsFromJsonExpressionConstructionFields expressionConstructionFieldsFromJson(JsonValue const& properties); | |
expressionFromRefSgExpression* expressionFromRef( JsonValue const& json, NodeMap const& nodes); | |
expressionQualificationFieldsFromJsonstd::optional<ExpressionQualificationFields> expressionQualificationFieldsFromJson( std::string const& kind, JsonValue const& properties); | |
expressionSourceFieldsFromJsonExpressionSourceFields expressionSourceFieldsFromJson( std::string const& kind, JsonValue const& properties); | |
extendedFloatingValueFromJsonRose::FloatingValue extendedFloatingValueFromJson(JsonValue const& json); | |
externalClassDeclarationFromJsonSgClassDeclaration* externalClassDeclarationFromJson(JsonValue const& json); | |
externalDeclarationFieldsFromJsonExternalDeclarationFields externalDeclarationFieldsFromJson( JsonValue const& json, VariantT kind, std::string const& context); | |
externalDeclarationReferenceFromJsonSgDeclarationStatement* externalDeclarationReferenceFromJson( JsonValue const& json, NodeMap const& nodes, std::string const& context); | |
externalFunctionFromJsonSgFunctionDeclaration* externalFunctionFromJson( JsonValue const& json, NodeMap const& nodes); | |
externalFunctionParameterScopeOwnerSgFunctionDeclaration* externalFunctionParameterScopeOwner( SgFunctionDeclaration* decl, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
externalInitializedNameFieldsFromJsonExternalInitializedNameFields externalInitializedNameFieldsFromJson( JsonValue const& json, NodeMap const& nodes, std::string const& context); | |
externalInitializedNameFromJsonSgInitializedName* externalInitializedNameFromJson( JsonValue const& json, NodeMap const& nodes, SgDeclarationStatement* decl, SgNode* parent, SgScopeStatement* scope, std::string const& context); | |
externalModuleFromJsonSgModuleStatement* externalModuleFromJson(JsonValue const& json); | |
externalParameterScopeDeclarationFromJsonSgDeclarationStatement* externalParameterScopeDeclarationFromJson( JsonValue const& json, NodeMap const& nodes, SgFunctionParameterScope* scope, std::string const& function_name); | |
fileInfoFieldsFromJsonstd::optional<FileInfoFields> fileInfoFieldsFromJson(JsonValue const& json); | |
fileLanguageFromJsonSgFile::languageOption_enum fileLanguageFromJson( JsonValue const& properties, std::string const& key); | |
fileOutputFormatFromJsonSgFile::outputFormatOption_enum fileOutputFormatFromJson( JsonValue const& properties, std::string const& key); | |
filenameForFileIdstd::string filenameForFileId( int id, std::string const& context); | |
floatingValueFromJsontemplate<typename Float> Float floatingValueFromJson(JsonValue const& json); | |
fnv1a64uint64_t fnv1a64(std::string const& value); | |
foldConstructionFieldsFromJsonFoldConstructionFields foldConstructionFieldsFromJson(JsonValue const& properties); | |
formatItemFieldsFromJsonFormatItemFields formatItemFieldsFromJson(JsonValue const& properties); | |
fortranCArgumentPassingFromJsonSgInitializedName::fortran_c_argument_passing_enum fortranCArgumentPassingFromJson(JsonValue const& properties); | |
fortranInterfaceFieldsFromJsonFortranInterfaceFields fortranInterfaceFieldsFromJson(JsonValue const& properties); | |
fortranProcedureComponentBindingFromJsonstd::optional<SgInitializedName::FortranProcedureComponentBinding> fortranProcedureComponentBindingFromJson(JsonValue const& properties); | |
fortranSourceContextFromJsonSgSourceFile::fortran_source_context fortranSourceContextFromJson(JsonValue const& properties); | |
functionCallSourceFieldsFromJsonFunctionCallSourceFields functionCallSourceFieldsFromJson(JsonValue const& properties); | |
functionConstexprSpecifierFromJsonSgFunctionDeclaration::constexpr_specifier_enum functionConstexprSpecifierFromJson( JsonValue const& properties, std::string const& kind); | |
functionModifierFieldsFromJsonFunctionModifierFields functionModifierFieldsFromJson(NodeRecord const& record); | |
functionParameterReferenceFromPropertiesSgFunctionParameterRefExp* functionParameterReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
functionParameterScopeNeedsExternalReferenceRecordbool functionParameterScopeNeedsExternalReferenceRecord( SgFunctionDeclaration* decl, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
functionReferenceFromPropertiesSgFunctionRefExp* functionReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
functionReturnTypeSourceFieldsFromJsonFunctionReturnTypeSourceFields functionReturnTypeSourceFieldsFromJson(JsonValue const& properties); | |
groupSymbolTablePreferencesSymbolTablePreferenceGroups groupSymbolTablePreferences( std::vector<ExpectedSymbolTablePreference> const& entries, std::optional<bool> case_insensitive = std::nullopt); | |
hasCheckpointArgumentbool hasCheckpointArgument( SgSourceFile const* file, Checkpoint checkpoint); | |
hasExternalMarkerAncestorbool hasExternalMarkerAncestor(SgNode* node); | |
hex64std::string hex64(uint64_t value); | |
idForuint64_t idFor( std::unordered_map<SgNode const*, uint64_t> const& ids, SgNode const* node); | |
ifStatementKindFromJsonSgIfStmt::if_statement_kind_enum ifStatementKindFromJson(JsonValue const& properties); | |
indentvoid indent( std::ostream& out, int level); | |
initModifierKindFromJsonSgOmpClause::omp_init_modifier_kind_enum initModifierKindFromJson(JsonValue const& properties); | |
initializeScalarLiteralTypevoid initializeScalarLiteralType( SgValueExp* value, JsonValue const& properties, NodeMap const& nodes); | |
initializeTemplateParameterTypesvoid initializeTemplateParameterTypes( SgTemplateParameter* parameter, NodeRecord const& record, NodeMap const& nodes); | |
initializedNameMetadataFromJsonInitializedNameMetadata initializedNameMetadataFromJson(JsonValue const& properties); | |
initializedNameRolesFromJsonInitializedNameRoles initializedNameRolesFromJson(JsonValue const& properties); | |
insideCollectionBoundarybool insideCollectionBoundary(SgNode* node); | |
installSourcePositionsvoid installSourcePositions( SgNode* node, SourcePositions positions, std::string const& context); | |
installTransformationSourcePositionvoid installTransformationSourcePosition(SgLocatedNode* node); | |
integer128ValueFromJsonRose::Integer128Value integer128ValueFromJson(JsonValue const& json); | |
isAnonymousDataMemberReferencebool isAnonymousDataMemberReference(SgVarRefExp* ref); | |
isAstJsonExternalClassDeclarationbool isAstJsonExternalClassDeclaration(SgClassDeclaration* decl); | |
isAstJsonExternalFunctionbool isAstJsonExternalFunction(SgFunctionDeclaration* decl); | |
isAstJsonExternalModulebool isAstJsonExternalModule(SgModuleStatement* module); | |
isExternalUseModuleEdgebool isExternalUseModuleEdge( SgNode* source, SgNode* target, std::string const& field, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
isJsonBinaryOpKindbool isJsonBinaryOpKind(std::string const& kind); | |
isJsonScalarLiteralKindbool isJsonScalarLiteralKind(std::string const& kind); | |
isJsonUnaryOpKindbool isJsonUnaryOpKind(std::string const& kind); | |
isJsonValueExpressionKindbool isJsonValueExpressionKind(std::string const& kind); | |
isRightHandSideOfMemberAccessbool isRightHandSideOfMemberAccess(SgNode const* node); | |
isStructuralAstChildOfParentbool isStructuralAstChildOfParent(SgNode* node); | |
isTypedefOwnedSourceTypebool isTypedefOwnedSourceType(SgType* base); | |
jsonStringstd::string jsonString(std::string const& input); | |
kindInVariantsbool kindInVariants( std::string const& kind, VariantVector const& variants); | |
labelReferenceFromPropertiesSgLabelRefExp* labelReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
labelSymbolBasisKindLabelSymbolBasisKind labelSymbolBasisKind(SgLabelSymbol const* symbol); | |
labelSymbolFieldsFromJsonLabelSymbolFields labelSymbolFieldsFromJson(JsonValue const& json); | |
labelSymbolScopeForBasisSgScopeStatement* labelSymbolScopeForBasis(SgNode* basis); | |
linkDeclarationGroupEdgesvoid linkDeclarationGroupEdges( AstFileRecord const& ast, NodeMap const& nodes); | |
linkNodeEdgesvoid linkNodeEdges( NodeRecord const& record, NodeMap const& nodes); | |
literalSpellingFormFromJsonSgValueExp::literal_spelling_form_enum literalSpellingFormFromJson(JsonValue const& properties); | |
literalTokenFieldsFromJsonLiteralTokenFields literalTokenFieldsFromJson(JsonValue const& properties); | |
mappedNodePointersNodeIds mappedNodePointers(NodeMap const& nodes); | |
markAstJsonExternalClassDeclarationvoid markAstJsonExternalClassDeclaration( SgClassDeclaration* decl, std::string const& source_file); | |
markAstJsonExternalFunctionvoid markAstJsonExternalFunction( SgFunctionDeclaration* decl, std::string const& source_file); | |
markAstJsonExternalModulevoid markAstJsonExternalModule( SgModuleStatement* module, std::string const& source_file); | |
memberFunctionReferenceFromPropertiesSgMemberFunctionRefExp* memberFunctionReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes, SgTypeExpression* type_id); | |
moduleNameForNodestd::string moduleNameForNode(SgNode* node); | |
nearestScopeSgScopeStatement* nearestScope(SgNode* node); | |
newArrayBoundSourceFormFromJsonSgNewExp::array_bound_source_form_enum newArrayBoundSourceFormFromJson(JsonValue const& properties); | |
newConstructionFieldsFromJsonNewConstructionFields newConstructionFieldsFromJson( JsonValue const& properties, NodeMap const& nodes); | |
nodeByIdSgNode* nodeById( NodeMap const& nodes, uint64_t id); | |
nodeByIdAstemplate<typename T> T* nodeByIdAs( NodeMap const& nodes, uint64_t id); | |
noexceptFromPropertiesSgNoexceptOp* noexceptFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpression* operand); | |
nonrealReferenceFromPropertiesSgNonrealRefExp* nonrealReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes, SgTypeExpression* type_id); | |
nonrealSymbolForDeclarationSgNonrealSymbol* nonrealSymbolForDeclaration(SgNonrealDecl* decl); | |
nullableCxxSourceTypeFromJsonSgType* nullableCxxSourceTypeFromJson( JsonValue const& json, NodeMap const& nodes); | |
nullableDeclaredExceptionSignatureFromJsonSgFunctionType* nullableDeclaredExceptionSignatureFromJson( JsonValue const& json, NodeMap const& nodes); | |
nullableFunctionSyntaxTypeFromJsonSgFunctionType* nullableFunctionSyntaxTypeFromJson( JsonValue const& json, NodeMap const& nodes); | |
nullableTypeFromJsonSgType* nullableTypeFromJson( JsonValue const& json, NodeMap const& nodes); | |
nullptrValueFromPropertiesSgNullptrValExp* nullptrValueFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
ompClauseFieldsFromJsonOmpClauseFields ompClauseFieldsFromJson(NodeRecord const& record); | |
ompContextHierarchyVariantstd::optional<VariantT> ompContextHierarchyVariant(std::string const& kind); | |
ompContextSelectorIdentityOmpContextSelectorIdentity ompContextSelectorIdentity( SgOmpClause::omp_context_trait_selector_kind_enum kind, SgName const& implementation_name, std::optional<VariantT> construct_kind); | |
ompDefaultOptionFromJsonSgOmpClause::omp_default_option_enum ompDefaultOptionFromJson(JsonValue const& properties); | |
ompDeviceTypeKindFromJsonSgOmpClause::omp_when_context_kind_enum ompDeviceTypeKindFromJson( JsonValue const& properties, std::string const& node_kind); | |
ompDoacrossKindFromJsonSgOmpClause::omp_doacross_kind_enum ompDoacrossKindFromJson(JsonValue const& properties); | |
opaqueValueFieldsFromJsonOpaqueValueFields opaqueValueFieldsFromJson(JsonValue const& json); | |
optionsFromCommandLineOptions optionsFromCommandLine(SgSourceFile const* file); | |
ordinaryOmpVariablesClauseVariantstd::optional<VariantT> ordinaryOmpVariablesClauseVariant(std::string const& kind); | |
owningProjectSgProject* owningProject(SgSourceFile* file); | |
parseAstFileJsonAstFileRecord parseAstFileJson( std::string const& json, std::string const& expected_checkpoint); | |
parseJsonJsonValue parseJson(std::string const& json); | |
pointerMemberJsonIdentityuint64_t pointerMemberJsonIdentity(SgPointerMemberType* type); | |
populateExternalFunctionParameterScopeFromJsonvoid populateExternalFunctionParameterScopeFromJson( JsonValue const& json, NodeMap const& nodes, SgFunctionParameterScope* scope, SgInitializedNamePtrList const& parameters, std::string const& function_name); | |
prepareAstAttributesPreparedAstAttributes prepareAstAttributes(NodeRecord const& record); | |
prepareExternalSymbolFromJsonstd::function<SgSymbol*()> prepareExternalSymbolFromJson( JsonValue const& json, NodeMap const& nodes, SgSymbolTable* owner_table); | |
preparePreprocessingInfoPreparedPreprocessingInfo preparePreprocessingInfo(NodeRecord const& record); | |
prepareSymbolForKindAndBasisstd::function<SgSymbol*()> prepareSymbolForKindAndBasis( VariantT kind, SgNode* basis, JsonValue const& properties); | |
preprocessingInfoFieldsFromJsonstd::vector<PreprocessingInfoFields> preprocessingInfoFieldsFromJson(NodeRecord const& record); | |
preservedJsonNodeIduint64_t preservedJsonNodeId(SgNode* node); | |
preservedPointerMemberJsonIdentityuint64_t preservedPointerMemberJsonIdentity(SgPointerMemberType const* type); | |
preservedSemanticArrayJsonIdentityuint64_t preservedSemanticArrayJsonIdentity(SgArrayType const* type); | |
preservedSourceTypeJsonIdentityuint64_t preservedSourceTypeJsonIdentity(SgType const* type); | |
processIduint64_t processId(); | |
rawAlignmentSpecifiersJsonstd::string rawAlignmentSpecifiersJson( SgAlignmentSpecifierPtrList const& specifiers, SgNode* owner, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawAstAttributesJsonstd::string rawAstAttributesJson(SgNode* node); | |
rawBitVectorJsonstd::string rawBitVectorJson(SgBitVector const& bits); | |
rawBoolFieldstd::string rawBoolField( std::string const& name, bool value); | |
rawCanonicalSourceIdentityJsonstd::string rawCanonicalSourceIdentityJson( std::optional<SgTemplateParameter::canonical_source_identity> const& identity, char const* owner); | |
rawExactBoundSymbolRefstd::string rawExactBoundSymbolRef( SgSymbol* symbol, std::unordered_map<SgNode const*, uint64_t> const& ids, SgScopeStatement const* inline_scope = nullptr); | |
rawExpressionRefstd::string rawExpressionRef( SgExpression* expression, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawExtendedFloatingValuestd::string rawExtendedFloatingValue(Rose::FloatingValue value); | |
rawExternalClassDeclarationJsonstd::string rawExternalClassDeclarationJson(SgClassDeclaration* decl); | |
rawExternalDeclarationReferenceJsonstd::string rawExternalDeclarationReferenceJson( SgDeclarationStatement* decl, SgDeclarationStatement* owner, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawExternalFunctionJsonstd::string rawExternalFunctionJson( SgFunctionDeclaration* decl, std::unordered_map<SgNode const*, uint64_t> const& ids, bool force_external = false); | |
rawExternalFunctionParameterScopeJsonstd::string rawExternalFunctionParameterScopeJson( SgFunctionDeclaration* function, SgFunctionParameterScope* scope, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& function_name); | |
rawExternalInitializedNameJsonstd::string rawExternalInitializedNameJson( SgInitializedName* name, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& function_name); | |
rawExternalModuleJsonstd::string rawExternalModuleJson( SgModuleStatement* module, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawExternalUseStatementJsonstd::string rawExternalUseStatementJson( SgUseStatement* stmt, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& function_name); | |
rawExternalVariableDeclarationJsonstd::string rawExternalVariableDeclarationJson( SgVariableDeclaration* decl, std::unordered_map<SgNode const*, uint64_t> const& ids, std::string const& function_name); | |
rawFileInfoJsonstd::string rawFileInfoJson(Sg_File_Info const* info); | |
rawFloatingValueBitstemplate<typename Float> std::string rawFloatingValueBits(Float value); | |
rawFormatDescriptorstd::string rawFormatDescriptor(SgFormatItem::Descriptor const& descriptor); | |
rawInteger128Valuestd::string rawInteger128Value(Rose::Integer128Value value); | |
rawIntegerFieldstd::string rawIntegerField( std::string const& name, int64_t value); | |
rawLocationJsonstd::string rawLocationJson(SgNode* node); | |
rawNodeFlagsJsonstd::string rawNodeFlagsJson(SgNode* node); | |
rawNodePropertiesstd::string rawNodeProperties( SgNode* node, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawOptionalUnsignedIntegerFieldstd::string rawOptionalUnsignedIntegerField( std::string const& name, std::optional<unsigned int> const& value); | |
rawRequiredLocationJsonstd::string rawRequiredLocationJson( SgNode* node, std::string const& context); | |
rawStringFieldstd::string rawStringField( std::string const& name, std::string const& value); | |
rawStringListJsonstd::string rawStringListJson(SgStringList const& values); | |
rawSymbolRefstd::string rawSymbolRef( SgSymbol* symbol, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawSymbolTableJsonstd::string rawSymbolTableJson( SgScopeStatement* scope, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawTargetAbiJsonstd::string rawTargetAbiJson(SgSourceFile::target_abi_info const& abi); | |
rawTemplateArgumentListJsonstd::string rawTemplateArgumentListJson( SgTemplateArgumentPtrList const& arguments, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawTypeJsonstd::string rawTypeJson( SgType* type, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawTypeOwnedExprListExpJsonstd::string rawTypeOwnedExprListExpJson( SgExprListExp* expr_list, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawTypeOwnedExpressionListJsonstd::string rawTypeOwnedExpressionListJson( SgExpressionPtrList const& expressions, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawTypeOwnedExpressionRefstd::string rawTypeOwnedExpressionRef( SgExpression* expr, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
rawUnaryTraitEvaluatedValuestd::string rawUnaryTraitEvaluatedValue( std::optional<Rose::Integer128Value> const& value, bool alignment); | |
rawVisibilitySymbolFieldsstd::vector<std::string> rawVisibilitySymbolFields( SgSymbol* symbol, std::unordered_map<SgNode const*, uint64_t> const& ids, SgScopeStatement const* inline_scope = nullptr); | |
readFilestd::string readFile(std::filesystem::path const& path); | |
rebuildConstructorOnlyNodesvoid rebuildConstructorOnlyNodes( AstFileRecord const& ast, NodeMap& nodes); | |
reconstructSourceFileSgSourceFile* reconstructSourceFile( AstFileRecord const& ast, SgSourceFile* old_file, NodeMap* restored_nodes = nullptr); | |
rejectRemovedQualifiedNameStatevoid rejectRemovedQualifiedNameState(JsonValue const& properties); | |
replaceFileInProjectvoid replaceFileInProject( SgSourceFile* old_file, SgSourceFile* new_file); | |
replaceProjectFilesvoid replaceProjectFiles( SgProject* project, uint64_t root_id, uint64_t project_files_id, NodeMap const& original, NodeMap const& restored); | |
requireFileIdMappingvoid requireFileIdMapping( int id, std::string const& filename, std::string const& context); | |
requireFortranProcedureComponentBindingvoid requireFortranProcedureComponentBinding( std::optional<SgInitializedName::FortranProcedureComponentBinding> const& binding, SgType* type, SgScopeStatement* scope); | |
requireFortranProcedureInterfacevoid requireFortranProcedureInterface( SgExpression* interface, SgType* type, SgInitializedName::fortran_type_spec_enum spec, SgSymbol* source_symbol); | |
requireRestoredKindvoid requireRestoredKind( SgNode* node, NodeRecord const& record); | |
requireUnaryTraitResultTypeSgType* requireUnaryTraitResultType( SgType* type, std::string const& context); | |
requiredBaseClassAccessModifierSgAccessModifier::access_modifier_enum requiredBaseClassAccessModifier( JsonValue const& object, std::string const& field, std::string const& context); | |
requiredClassTypeSgClassDeclaration::class_types requiredClassType( JsonValue const& object, std::string const& context); | |
requiredClosedEnumRangetemplate<typename Enum> Enum requiredClosedEnumRange( JsonValue const& object, std::string const& field, std::string const& context, Enum first, Enum last); | |
requiredDeclarationAccessModifierSgAccessModifier::access_modifier_enum requiredDeclarationAccessModifier( JsonValue const& object, std::string const& field, std::string const& context); | |
requiredEnumtemplate<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 = {}); | |
requiredFortranTypeSpecSgInitializedName::fortran_type_spec_enum requiredFortranTypeSpec( JsonValue const& object, std::string const& context); | |
requiredGnuDeclarationVisibilitySgDeclarationModifier::gnu_declaration_visibility_enum requiredGnuDeclarationVisibility( JsonValue const& object, std::string const& field, std::string const& context); | |
requiredIntegerBooleanbool requiredIntegerBoolean( JsonValue const& object, std::string const& field); | |
requiredOmpDeclareVariantRegionOrdinalstd::optional<unsigned int> requiredOmpDeclareVariantRegionOrdinal( JsonValue const& properties, std::string const& semantic_function_name, std::string const& context); | |
requiredOptionalUnsignedIntegerstd::optional<unsigned int> requiredOptionalUnsignedInteger( JsonValue const& properties, std::string const& name, std::string const& context); | |
requiredPositiveIduint64_t requiredPositiveId( JsonValue const& value, std::string const& context); | |
requiredPreinitializationSgInitializedName::preinitialization_enum requiredPreinitialization( JsonValue const& object, std::string const& context); | |
requiredSingleEdgeTargetuint64_t requiredSingleEdgeTarget( NodeRecord const& record, std::string const& field); | |
requiredSourcePositionFieldsFromJsonSourcePositionFields requiredSourcePositionFieldsFromJson( JsonValue const& location, std::string const& context); | |
requiredSourcePositionsFromJsonSourcePositions requiredSourcePositionsFromJson( JsonValue const& location, std::string const& context); | |
requiredStorageModifierSgStorageModifier::storage_modifier_enum requiredStorageModifier( JsonValue const& object, std::string const& field, std::string const& context); | |
requiredTemplateArgumentTypeSgTemplateArgument::template_argument_enum requiredTemplateArgumentType( JsonValue const& object, std::string const& context); | |
requiredTemplateParameterTypeSgTemplateParameter::template_parameter_enum requiredTemplateParameterType( JsonValue const& object, std::string const& context); | |
requiredTranslationUnitSourceOrderstd::optional<unsigned int> requiredTranslationUnitSourceOrder( JsonValue const& properties, std::string const& context); | |
requiresDelayedRebuildbool requiresDelayedRebuild(NodeRecord const& record); | |
resolveExistingSymbolFromJsonSgSymbol* resolveExistingSymbolFromJson( JsonValue const& json, NodeMap const& nodes); | |
restoreAvailableAuxiliaryDeclarationOwnershipvoid restoreAvailableAuxiliaryDeclarationOwnership( AstFileRecord const& ast, NodeMap const& nodes); | |
restoreAvailableConstructionScopesvoid restoreAvailableConstructionScopes( AstFileRecord const& ast, NodeMap const& nodes); | |
restoreAvailableParentsAndScopesvoid restoreAvailableParentsAndScopes( AstFileRecord const& ast, NodeMap const& nodes); | |
restoreFileIdMapFromMetadatavoid restoreFileIdMapFromMetadata(JsonValue const& metadata); | |
restoreRecordedParentEdgesvoid restoreRecordedParentEdges( AstFileRecord const& ast, NodeMap const& nodes); | |
restoreSerializedSymbolTablesvoid restoreSerializedSymbolTables( AstFileRecord const& ast, NodeMap const& nodes, std::unordered_set<uint64_t> const& scope_ids, SerializedSymbolTableConstruction* construction = nullptr); | |
restoredExternalClassFromJsonSgClassDeclaration* restoredExternalClassFromJson(JsonValue const& json); | |
restoredExternalFunctionFromJsonSgFunctionDeclaration* restoredExternalFunctionFromJson(JsonValue const& json); | |
returnStatementFieldsFromJsonReturnStatementFields returnStatementFieldsFromJson(JsonValue const& properties); | |
roundTripSourceFileSgSourceFile* roundTripSourceFile( SgSourceFile* file, Checkpoint checkpoint); | |
safeNodeTextstd::string safeNodeText(SgNode* node); | |
sameAstJsonPathbool sameAstJsonPath( std::string const& lhs, std::string const& rhs); | |
sanitizePathComponentstd::string sanitizePathComponent(std::string name); | |
semanticArrayDependenciesReadybool semanticArrayDependenciesReady( JsonValue const& json, SemanticArrayConstruction const* owner); | |
semanticArrayJsonIdentityuint64_t semanticArrayJsonIdentity(SgArrayType* type); | |
semanticFunctionTypeFromJsonSgFunctionType* semanticFunctionTypeFromJson( JsonValue const& json, NodeMap const& nodes); | |
semanticFunctionTypeKindFromJsonVariantT semanticFunctionTypeKindFromJson(JsonValue const& json); | |
semanticSignaturestd::string semanticSignature(AstFileRecord const& ast); | |
semanticSignatureEqualsbool semanticSignatureEquals( AstFileRecord const& ast, std::string const& signature); | |
singleEdgeTargetuint64_t singleEdgeTarget( NodeRecord const& record, std::string const& field); | |
sourceFileMatchesExternalRecordbool sourceFileMatchesExternalRecord( SgSourceFile* file, std::string const& source_file); | |
sourceFileNameForExternalFunctionstd::string sourceFileNameForExternalFunction(SgFunctionDeclaration* decl); | |
sourceFileNameForNodestd::string sourceFileNameForNode(SgNode* node); | |
sourceIsBeingReplacedbool sourceIsBeingReplaced(SgSourceFile* file); | |
sourceLocationBuiltinFromPropertiesSgSourceLocationBuiltinExp* sourceLocationBuiltinFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
sourceLocationBuiltinKindFromJsonSgSourceLocationBuiltinExp::source_location_builtin_kind_enum sourceLocationBuiltinKindFromJson(JsonValue const& properties); | |
sourcePositionsFromJsonSourcePositions sourcePositionsFromJson( JsonValue const& location, bool expression); | |
sourceTypeJsonIdentityuint64_t sourceTypeJsonIdentity(SgType* type); | |
startsWithbool startsWith( std::string const& s, std::string const& prefix); | |
statementFieldsFromJsonStatementFields statementFieldsFromJson( NodeRecord const& record, VariantT kind); | |
storageSizeFromJsonstd::optional<long long> storageSizeFromJson( JsonValue const& properties, std::string const& field); | |
stringListFromJsonSgStringList stringListFromJson( JsonValue const& value, std::string const& context); | |
structuredBindingKindFromJsonSgInitializedName::structured_binding_kind_enum structuredBindingKindFromJson(JsonValue const& properties); | |
subobjectDestructionKindFromJsonSgCxxSubobjectDestruction::target_kind_enum subobjectDestructionKindFromJson(JsonValue const& json); | |
symbolBasisSgNode const* symbolBasis(SgSymbol const* symbol); | |
symbolDependencyOrderstd::vector<size_t> symbolDependencyOrder(std::vector<std::optional<size_t>> const& dependencies); | |
symbolFromJsonSgSymbol* symbolFromJson( JsonValue const& json, NodeMap const& nodes); | |
symbolIsLookupPreferredbool symbolIsLookupPreferred( SgSymbolTable* table, SgName const& name, SgSymbol* symbol); | |
symbolLookupPreferenceCategoryVariantT symbolLookupPreferenceCategory(VariantT kind); | |
symbolNamestd::string symbolName(SgSymbol const* symbol); | |
symbolTableEntriesFromRecordstd::vector<SerializedSymbolTableEntry> symbolTableEntriesFromRecord(NodeRecord const& record); | |
symbolVariantFromJsonKindVariantT symbolVariantFromJsonKind(std::string const& kind); | |
targetAbiFromJsonSgSourceFile::target_abi_info targetAbiFromJson(JsonValue const& json); | |
targetSizeTypeFromJsonSgType* targetSizeTypeFromJson( JsonValue const& json, NodeMap const& nodes, bool target_available); | |
templateArgumentListFromJsonSgTemplateArgumentPtrList templateArgumentListFromJson( JsonValue const& json, NodeMap const& nodes, SgNode* parent); | |
templateFunctionReferenceFromPropertiesSgTemplateFunctionRefExp* templateFunctionReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
templateMemberFunctionReferenceFromPropertiesSgTemplateMemberFunctionRefExp* templateMemberFunctionReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes, SgTypeExpression* type_id); | |
templateParameterOperandsFromRecordTemplateParameterOperands templateParameterOperandsFromRecord( NodeRecord const& record, NodeMap const& nodes, SgTemplateParameter const* owner = nullptr); | |
templateParameterSourceFieldsFromJsonTemplateParameterSourceFields templateParameterSourceFieldsFromJson(JsonValue const& object); | |
templateParameterValueFromPropertiesSgTemplateParameterVal* templateParameterValueFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
temporaryWritePathstd::filesystem::path temporaryWritePath(std::filesystem::path const& path); | |
thisExpressionFromPropertiesSgThisExp* thisExpressionFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
trimstd::string trim(std::string const& input); | |
typeFromJsonSgType* typeFromJson( JsonValue const& json, NodeMap const& nodes, std::string const& exact_type_error = "AST JSON type requires an exact type"); | |
typeIdFromPropertiesSgTypeIdOp* typeIdFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpression* operand, SgType* operand_type, bool operand_is_evaluated); | |
typeModifierFieldsFromJsonTypeModifierFields typeModifierFieldsFromJson( JsonValue const& json, std::string const& context, std::string const& prefix = "declaration_type"); | |
typeOwnsSourceJsonIdentitybool typeOwnsSourceJsonIdentity(SgType const* type); | |
typeRequirementFromPropertiesSgTypeRequirement* typeRequirementFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
typeTraitBuiltinFromPropertiesSgTypeTraitBuiltinOperator* typeTraitBuiltinFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpressionPtrList const& arguments); | |
typedefMetadataFromJsonTypedefMetadata typedefMetadataFromJson(JsonValue const& properties); | |
unaryConstructionFieldsFromJsonUnaryConstructionFields unaryConstructionFieldsFromJson( JsonValue const& properties, std::string const& kind, NodeMap const& nodes); | |
unaryTraitEvaluatedValueFromJsonstd::optional<Rose::Integer128Value> unaryTraitEvaluatedValueFromJson( JsonValue const& json, bool alignment); | |
unaryTraitKindFromPropertiesSgExpression::unary_type_trait_kind_enum unaryTraitKindFromProperties(NodeRecord const& record); | |
unaryTraitSourceFieldsFromJsonUnaryTraitSourceFields unaryTraitSourceFieldsFromJson( JsonValue const& properties, std::string const& context); | |
unsigned64ValueFromJsonuint64_t unsigned64ValueFromJson(JsonValue const& json); | |
validFortranSeparatePointerOwnershipbool validFortranSeparatePointerOwnership(SgInitializedName const* name); | |
validateAnonymousDataMemberReferenceQualificationvoid validateAnonymousDataMemberReferenceQualification(SgVarRefExp* ref); | |
validateConstructionFlagsNodeConstructionFlags validateConstructionFlags(NodeRecord const& record); | |
validateExactSemanticExpressionTypevoid validateExactSemanticExpressionType( SgExpression const* expression, SgType const* type, std::string const& phase); | |
validateExpressionLifetimevoid validateExpressionLifetime( ExpressionConstructionFields const& fields, JsonValue const& properties, NodeMap const& nodes); | |
validateExternalSymbolBasisOwnershipvoid validateExternalSymbolBasisOwnership(SgSymbol* symbol); | |
validateFortranAggregateConstructionvoid validateFortranAggregateConstruction(AggregateConstructionFields const& fields); | |
validateFortranInterfaceFieldsvoid validateFortranInterfaceFields(FortranInterfaceFields const& fields); | |
validateFortranProgramNameMetadatavoid validateFortranProgramNameMetadata( std::string const& opening_name, int64_t statement_kind, bool named_in_end_statement, std::string const& end_statement_name); | |
validateFunctionCallInputsvoid validateFunctionCallInputs( FunctionCallSourceFields const& fields, SgExpression* function, SgExprListExp* arguments, SgType* type, SgCxxLiteralTokenList* literal_tokens, size_t argument_count, size_t token_count); | |
validateLabelSymbolFieldsvoid validateLabelSymbolFields( SgLabelSymbol const* symbol, JsonValue const& json); | |
validateNamespaceSymbolKeyvoid validateNamespaceSymbolKey( SgName const& entry_name, SgNode* basis); | |
validateNonrealResolvedTargetIdentitytemplate<typename Identity> void validateNonrealResolvedTargetIdentity( Identity function, Identity variable, Identity spelling_target); | |
validateOmpContextKindAnyvoid validateOmpContextKindAny( bool has_any, size_t property_count, size_t selector_count); | |
validateOmpContextPropertyPayloadvoid 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); | |
validateOmpContextPropertySelectorKindvoid 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); | |
validateOmpContextSelectorvoid validateOmpContextSelector(SgOmpContextSelector const* selector); | |
validateOmpContextSelectorPayloadvoid validateOmpContextSelectorPayload( SgOmpClause::omp_context_trait_selector_kind_enum kind, SgName const& implementation_name, SgExpression* score, SgStatement* construct_directive, SgOmpContextSelectorPropertyPtrList const& properties); | |
validateOmpContextSelectorPropertyvoid validateOmpContextSelectorProperty( SgOmpContextSelectorProperty const* property, SgOmpContextSelector const* selector); | |
validateOmpContextSelectorPropertyPayloadOmpContextPropertyIdentity validateOmpContextSelectorPropertyPayload( SgOmpContextSelectorProperty const* property, SgOmpClause::omp_context_trait_selector_kind_enum selector_kind); | |
validateOmpContextSelectorSetvoid validateOmpContextSelectorSet(SgOmpContextSelectorSet const* set); | |
validateOmpContextSelectorSetPayloadvoid validateOmpContextSelectorSetPayload( SgOmpClause::omp_context_selector_set_kind_enum kind, SgOmpContextSelectorPtrList const& selectors); | |
validateOmpContextSelectorSetsvoid validateOmpContextSelectorSets( SgOmpContextSelectorSetPtrList const& sets, SgNode const* owner); | |
validateOmpContextSelectorSetsPayloadvoid validateOmpContextSelectorSetsPayload(SgOmpContextSelectorSetPtrList const& sets); | |
validateOmpContextSelectorShapevoid validateOmpContextSelectorShape( SgOmpClause::omp_context_trait_selector_kind_enum kind, SgName const& implementation_name, bool has_score, bool has_construct, size_t property_count); | |
validateOmpContextTraitInSetvoid validateOmpContextTraitInSet( SgOmpClause::omp_context_selector_set_kind_enum set_kind, SgOmpClause::omp_context_trait_selector_kind_enum selector_kind); | |
validateParentChainsvoid validateParentChains(AstFileRecord const& ast); | |
validateReconstructedTypesAndSymbolsvoid validateReconstructedTypesAndSymbols( AstFileRecord const& ast, NodeMap const& nodes); | |
validateRestoredOmpOwnedClausePayloadsvoid validateRestoredOmpOwnedClausePayloads( AstFileRecord const& ast, NodeMap const& nodes); | |
validateSourcePositionRecordSourcePositionFields validateSourcePositionRecord(NodeRecord const& record); | |
validateSymbolTablePreferenceGroupsvoid validateSymbolTablePreferenceGroups( std::vector<ExpectedSymbolTablePreference> const& entries, std::optional<bool> case_insensitive = std::nullopt); | |
validateSymbolTablePreferencesvoid validateSymbolTablePreferences(std::vector<ExpectedSymbolTablePreference> const& entries); | |
validateTemplateParameterContractvoid validateTemplateParameterContract( SgTemplateParameter const* parameter, std::string const& context); | |
validateTypedefBaseShapevoid validateTypedefBaseShape(JsonValue const& properties); | |
validatedExpressionTypePropertyJsonValue const* validatedExpressionTypeProperty(NodeRecord const& record); | |
varArgFromPropertiesSgVarArgOp* varArgFromProperties( JsonValue const& properties, NodeMap const& nodes, SgExpression* operand); | |
varRefSymbolDeclarationIduint64_t varRefSymbolDeclarationId( SgVarRefExp* ref, std::unordered_map<SgNode const*, uint64_t> const& ids); | |
variableReferenceFromPropertiesSgVarRefExp* variableReferenceFromProperties( JsonValue const& properties, NodeMap const& nodes); | |
writeBoolFieldvoid writeBoolField( std::ostream& out, int level, char const* name, bool value, bool comma = true); | |
writeFilevoid writeFile( std::filesystem::path const& path, std::string const& content); | |
writeFileIdMapJsonvoid writeFileIdMapJson( std::ostream& out, int level, bool comma = true); | |
writeFileInfoJsonvoid writeFileInfoJson( std::ostream& out, int level, Sg_File_Info const* info, bool comma = true); | |
writeIntegerFieldvoid writeIntegerField( std::ostream& out, int level, char const* name, int64_t value, bool comma = true); | |
writeJsonvoid writeJson( std::ostream& out, SgNode* root, Checkpoint checkpoint, SgSourceFile* file, SgFileList* project_files = nullptr, NodeMap* serialized_nodes = nullptr); | |
writeNodeJsonvoid writeNodeJson( std::ostream& out, SgNode* node, std::unordered_map<SgNode const*, uint64_t> const& ids, bool comma); | |
writeProjectJsonvoid writeProjectJson( SgProject* project, std::string const& path, Options const& options); | |
writeRawObjectvoid writeRawObject( std::ostream& out, int level, std::vector<std::string> const& fields, bool comma = true); | |
writeSemanticSignaturevoid writeSemanticSignature( std::ostream& out, AstFileRecord const& ast); | |
writeSourceFileJsonvoid writeSourceFileJson( SgSourceFile* file, Checkpoint checkpoint, std::string const& path, Options const& options); | |
writeStringFieldvoid writeStringField( std::ostream& out, int level, char const* name, std::string const& value, bool comma = true); | |
writeToStringstd::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 |
Variables¶
Rose::Builder namespace¶
Namespaces¶
| Name |
|---|
Templates |
Rose::Builder::Templates namespace¶
Functions¶
| Name |
|---|
buildTemplateArgumentSgTemplateArgument* buildTemplateArgument(bool v); |
instantiateNonrealRefExpsSgExpression* instantiateNonrealRefExps( SgExpression* expr, std::vector<SgTemplateParameter*>& tpl_params, std::vector<SgTemplateArgument*>& tpl_args); |
instantiateNonrealTypesSgType* instantiateNonrealTypes( SgType* type, std::vector<SgTemplateParameter*>& tpl_params, std::vector<SgTemplateArgument*>& tpl_args, SgScopeStatement* semantic_receiver_scope); |
Rose::BuiltinOperands namespace¶
Functions¶
| Name |
|---|
haveExclusiveOwnershipbool haveExclusiveOwnership( SgExpressionPtrList const& arguments, SgNode* owner); |
haveValidRolesbool haveValidRoles( SgTypeTraitBuiltinOperator::builtin_operator_kind_enum kind, SgName const& name, SgExpressionPtrList const& arguments); |
isTypeOperandbool isTypeOperand(SgExpression* argument); |
isValueOperandbool isValueOperand(SgExpression* argument); |
Rose::ClangFrontend namespace¶
Types¶
| Name |
|---|
ChooseExprOperands |
Functions¶
| Name |
|---|
canonical_function_identitySgFunctionDeclaration* canonical_function_identity(SgFunctionDeclaration* decl); |
requireChooseExprOperandsChooseExprOperands requireChooseExprOperands(clang::ChooseExpr* expression); |
requireExactPredefinedIdentifierTypevoid requireExactPredefinedIdentifierType( SgInitializedName* name, SgType* expected_type); |
Rose::Cmdline namespace¶
Namespaces¶
| Name |
|---|
Fortran |
Gnu |
Unparser |
Enums¶
| Name | Description |
|---|---|
Unnamed enum | Constants to be used with CommandlineProcessing::isOptionWithParameter to specify the removeOption argument. |
IncludeOptionParseResult |
Functions¶
| Name | Description |
|---|---|
NormalizeIncludePathOptionsstd::vector<std::string> NormalizeIncludePathOptions(std::vector<std::string>& argv); | Convert -I <path> to -I<path> |
normalizeAndAppendIncludeOptiontemplate< 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); |
Variables¶
| Name |
|---|
verbose |
Rose::Cmdline::Fortran namespace¶
Functions¶
| Name | Description |
|---|---|
Processvoid Process( SgProject* project, std::vector<std::string>& argv); | Process all Fortran commandline options. |
ProcessFortranOnlyvoid ProcessFortranOnly( SgProject* project, std::vector<std::string>& argv); |
Rose::Cmdline::Gnu namespace¶
Functions¶
| Name |
|---|
Processvoid Process( SgProject* project, std::vector<std::string>& argv); |
ProcessParamvoid ProcessParam( SgProject* project, std::vector<std::string>& argv); |
Rose::Cmdline::Unparser namespace¶
Functions¶
| Name | Description |
|---|---|
Processvoid Process( SgProject* project, std::vector<std::string>& argv); | Process all Unparser-specific commandline options, i.e. -rose:unparser. |
ProcessClobberInputFilevoid ProcessClobberInputFile( SgProject* project, std::vector<std::string>& argv); | |
StripRoseOptionsvoid StripRoseOptions(std::vector<std::string>& argv); |
Rose::FileSystem namespace¶
Functions for operating on files in a filesystem.
Types¶
| Name | Description |
|---|---|
baseNameMatches | Predicate returning true for matching names. |
Type Aliases¶
| Name | Description |
|---|---|
DirectoryIterator | Iterate over directory contents non-recursively. |
Path | Name of entities in a filesystem. |
RecursiveDirectoryIterator | Iterate recursively into subdirectories. |
Functions¶
| 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. |
copyFilesRecursivelytemplate< 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. |
readFiletemplate<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. |
writeFiletemplate<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 namespace¶
Functions¶
| Name |
|---|
BlankBytesint BlankBytes(char const* p); |
SpaceBytesint SpaceBytes(char const* p); |
Rose::FortranLineWrapSupport namespace¶
Functions¶
| Name |
|---|
isCommentLinebool isCommentLine(std::string const& text); |
isFixedFormatCommentLinebool isFixedFormatCommentLine(std::string const& text); |
stringLiteralLexicalBoundariesstd::vector<size_t> stringLiteralLexicalBoundaries( std::string const& literal, char delimiter); |
wrapFixedFormatCommentstd::vector<std::string> wrapFixedFormatComment( std::string const& text, int first_line_used_columns, int usable_columns); |
wrapFreeFormatCommentstd::vector<std::string> wrapFreeFormatComment( std::string const& text, int first_line_used_columns, int usable_columns); |
Rose::FortranSource namespace¶
Types¶
| Name |
|---|
Context |
Enums¶
| Name |
|---|
EditReason |
ProgramUnitBoundary |
Functions¶
| Name |
|---|
prepareEditvoid prepareEdit( SgSourceFile*, EditReason, std::vector<SgLocatedNode const*> const& syntax, std::vector<SgStatement const*> const& consumedBodies = {}); |
preparePairedBoundaryvoid preparePairedBoundary( SgLocatedNode* begin, SgLocatedNode* end); |
selectedOutputbool selectedOutput(SgSourceFile const*); |
validatevoid validate(SgSourceFile const*); |
validateSelectedPragmavoid validateSelectedPragma(SgPragmaDeclaration const*); |
Rose::Frontend namespace¶
Functions¶
| Name |
|---|
Runint Run(SgProject* project); |
RunSerialint RunSerial(SgProject* project); |
Rose::MemPool namespace¶
Functions¶
| Name |
|---|
snapshotvoid snapshot(std::ostream&); |
Rose::OpenMP namespace¶
Namespaces¶
| Name |
|---|
Detail |
Functions¶
| Name |
|---|
isNonnegativeConstantIntegerbool isNonnegativeConstantInteger(SgExpression* expression); |
Rose::OpenMP::Detail namespace¶
Types¶
| Name |
|---|
MapModifierFields |
Enums¶
| Name |
|---|
InitModifierContext |
Functions¶
| Name |
|---|
initModifierContextForClausebool initModifierContextForClause( SgOmpInitClause* clause, InitModifierContext* context, std::string* detail); |
isDepinfoModifierbool isDepinfoModifier(SgOmpClause::omp_init_modifier_kind_enum kind); |
modifierValidationFailurebool modifierValidationFailure( std::string* detail, std::string const& message); |
validApplyTransformationFieldsbool validApplyTransformationFields( SgOmpClause::omp_apply_transform_kind_enum kind, std::string const& name, bool has_argument, bool has_nested); |
validInductionItemFieldsbool validInductionItemFields( SgOmpClause::omp_induction_item_kind_enum kind, std::string const& label); |
validMapDistDataPolicyFieldsbool validMapDistDataPolicyFields( SgOmpClause::omp_map_dist_data_enum kind, bool has_expression); |
validMapDistDataPolicyPayloadbool validMapDistDataPolicyPayload(SgOmpMapDistDataPolicy const* policy); |
validateAdjustArgsClausebool validateAdjustArgsClause( SgOmpAdjustArgsClause* clause, std::string* detail); |
validateAppendArgsClausebool validateAppendArgsClause( SgOmpAppendArgsClause* clause, std::string* detail); |
validateInitClausebool validateInitClause( SgOmpInitClause* clause, std::string* detail); |
validateInitModifierCompositionbool validateInitModifierComposition( SgOmpInitModifierPtrList const& modifiers, InitModifierContext context, std::string* detail); |
validateInitModifierExpressionbool validateInitModifierExpression( SgOmpClause::omp_init_modifier_kind_enum kind, SgExpression* expression, std::string* detail); |
validateInitModifierListbool validateInitModifierList( SgOmpInitModifierList* modifier_list, SgNode* expected_parent, InitModifierContext context, std::string* detail); |
validateInitModifierPayloadbool validateInitModifierPayload( SgOmpInitModifier* modifier, SgNode* expected_parent, std::string* detail); |
validateMapModifiersbool validateMapModifiers( std::array<SgOmpClause::omp_map_modifier_enum, 3> const& modifiers, MapModifierFields& fields, std::string* detail); |
Rose::StringUtility namespace¶
Functions for operating on strings.
Types¶
| Name | Description |
|---|---|
FileNameClassification | |
NumberParseResult | |
StringWithLineNumber | String with source location information. |
Type Aliases¶
| Name | Description |
|---|---|
FileNameLibrary | |
FileWithLineNumbers | A vector of strings with line numbers and file names. |
Enums¶
| Name | Description |
|---|---|
FileNameLocation | |
OSType | ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
Functions¶
| 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. |
isContainedInbool 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. |
jointemplate<class Container> std::string join( char separator, Container const& container); | |
join_rangetemplate<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. |
signedToHextemplate<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. |
toNumbertemplate<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. |
unsignedToHextemplate<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 namespace¶
Namespaces¶
| Name |
|---|
detail |
Functions¶
| Name |
|---|
resolvePathstd::string resolvePath(std::string const& filename); |
Rose::TestOutput::detail namespace¶
Functions¶
| Name |
|---|
defaultOutputDirstd::string defaultOutputDir(); |
isWithinTreebool isWithinTree( std::filesystem::path const& root, std::filesystem::path const& candidate); |
normalizePathstd::filesystem::path normalizePath(std::filesystem::path const& path); |
SageBuilder namespace¶
High level SAGE III AST node and subtree builders.
Types¶
| Name | Description |
|---|---|
FortranBlockDataBuilderIdentity | Build a Fortran subroutine or procedure |
declaration_ownership | Exact structural ownership selected by named declaration producers. |
function_declaration_ownership | Exact, typed structural ownership established by function-declaration builders. Invalid kind/owner combinations cannot be constructed. |
template_class_declaration_scopes | Exact semantic and canonical symbol scopes for a template-class surface. |
typedef_declaration_ownership | Build a typedef declaration, such as: typedef int myint; typedef struct A {..} s_A; |
Enums¶
| Name |
|---|
SourcePositionClassification |
namespace_declaration_ownership_enum |
Functions¶
| 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_nfiSgActualArgumentExpression* 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_nfiSgConditionalExp* buildBinaryConditionalExp_nfi( SgExpression* common, SgExpression* false_expression, SgType* result_type); | |
buildBinaryExpressiontemplate<class T> T* buildBinaryExpression( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildBinaryExpression_nfitemplate< 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_nfiSgBreakStmt* buildBreakStmt_nfi(); | |
buildCaseOptionStmt[[visibility("default")]] SgCaseOptionStmt* buildCaseOptionStmt( SgExpression* key = NULL, SgStatement* body = NULL); | Build a case option statement |
buildCaseOptionStmt_nfiSgCaseOptionStmt* 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_nfitemplate<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_nfiSgClassDefinition* buildClassDefinition_nfi( SgClassDeclaration* d, bool buildTemplateInstantiation = false); | Build a class definition scope statement |
buildClassNameRefExp[[visibility("default")]] SgClassNameRefExp* buildClassNameRefExp(SgClassSymbol* sym); | |
buildClassNameRefExp_nfiSgClassNameRefExp* 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); | |
buildCompoundLiteralExpSgCompoundLiteralExp* buildCompoundLiteralExp(SgVariableSymbol* varSymbol); | |
buildCompoundLiteralExp_nfiSgCompoundLiteralExp* 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_nfiSgConditionalExp* 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_nfiSgContinueStmt* 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_nfiSgCtorInitializerList* buildCtorInitializerList_nfi(); | |
buildCudaKernelCallExp_nfiSgCudaKernelCallExp* buildCudaKernelCallExp_nfi( SgExpression* kernel, SgExprListExp* parameters = NULL, SgCudaKernelExecConfig* config = NULL); | Build a CUDA kernel call expression (kernel<<<config>>>(parameters)) |
buildCudaKernelExecConfig_nfiSgCudaKernelExecConfig* 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_nfiSgDefaultOptionStmt* 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_nfiSgDeleteExp* 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); | |
buildDoWhileStmtSgDoWhileStmt* buildDoWhileStmt( SgStatement* body, SgExpression* condition); | Build do-while statement |
buildDoWhileStmt_nfiSgDoWhileStmt* 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_nfiSgExprListExp* buildExprListExp_nfi(); | |
buildExprStatement[[visibility("default")]] SgExprStatement* buildExprStatement(SgExpression* exp = NULL); | Build a SgExprStatement, set File_Info automatically |
buildExprStatement_nfiSgExprStatement* 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_nfiSgFortranContinueStmt* 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_nfiSgFunctionCallExp* 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_nfiSgFunctionParameterList* 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_nfiSgFunctionParameterTypeList* buildFunctionParameterTypeList_nfi(SgExprListExp* expList); | |
buildFunctionRefExp[[visibility("default")]] SgFunctionRefExp* buildFunctionRefExp(SgFunctionSymbol* sym); | buildFunctionRefExp overloads |
buildFunctionRefExp_nfiSgFunctionRefExp* 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_nfiSgGotoStatement* 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); | |
buildIfStmtSgIfStmt* 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_nfiSgLabelStatement* 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_nfiSgMemberFunctionRefExp* 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_nfiSgNullStatement* 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_nfiSgPragmaDeclaration* 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_nfiSgRangeExp* 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_nfiSgSubscriptExpression* 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); | |
buildSwitchStatementSgSwitchStatement* 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); | |
buildTemplateClassDefinitionSgTemplateClassDefinition* buildTemplateClassDefinition(SgTemplateClassDeclaration* d); | Build a template class definition statement |
buildTemplateFunctionRefExp_nfiSgTemplateFunctionRefExp* 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_nfiSgTemplateMemberFunctionRefExp* 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); | |
buildTypeTraitBuiltinOperatorSgTypeTraitBuiltinOperator* 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); | |
buildUnaryExpressiontemplate< 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_nfitemplate< 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); | |
buildWhileStmtSgWhileStmt* buildWhileStmt( SgExpression* condition, SgStatement* body); | Build while statement |
buildWhileStmt_nfiSgWhileStmt* 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); | |
getGlobalScopeFromScopeStackSgScopeStatement* 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); | |
inSwitchScopebool 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(); |
Variables¶
| Name | Description |
|---|---|
ScopeStack | intended to be a private member, don't access it directly. could be changed any time |
SourcePositionClassificationMode | C++ SageBuilder namespace specific state for storage of the source code position state (used to control how the source code positon is defined for IR nodes built within the SageBuilder interface). |
symbol_table_case_insensitive_semantics | Support for construction of case sensitive/insensitive symbol table handling in scopes. |
Using Declarations¶
| Name |
|---|
buildTemplateArgument |
instantiateNonrealRefExps |
instantiateNonrealTypes |
SageInterface namespace¶
Functions that are useful when operating on the AST.
Namespaces¶
| Name |
|---|
Detail |
Types¶
| Name | Description |
|---|---|
CheckedCanonicalLoopPlan | Immutable, fully checked description of one transformable C/C++ loop. |
CheckedCanonicalLoopStride | Exact positive stride captured by a checked canonical-loop plan. |
CheckedLoopTilingPlan | |
CheckedLoopUnrollPlan | |
DeferredTransformation | Add, remove,and replace AST |
OutputLocalSymbolTables | |
StatementGenerator | Interface for creating a statement whose computation writes its answer into a given variable. |
Transformation_Record | |
UniqueNameAttribute | A persistent attribute to represent a unique name for an expression |
VariableReferenceUse | One variable-reference spelling and the exact statement that emits it. |
const_int_expr_t | The datastructure is used as the return type for SageInterface::evaluateConstIntegerExpression(). One needs to always check whether hasValue_ is true before accessing value_ |
Enums¶
| Name | Description |
|---|---|
CanonicalFortranLoopDirection | |
DeleteAstMode | Function to delete AST subtree's nodes only, users must take care of any dangling pointers, symbols or types that result. |
Functions¶
| Name | Description |
|---|---|
HasNoThrowAssignbool HasNoThrowAssign(SgType const const* inputType); | |
HasNoThrowConstructorbool HasNoThrowConstructor(SgType const const* inputType); | |
HasNoThrowCopybool HasNoThrowCopy(SgType const const* inputType); | |
HasTrivialAssignbool HasTrivialAssign(SgType const const* inputType); | |
HasTrivialConstructorbool HasTrivialConstructor(SgType const const* inputType); | |
HasTrivialCopybool HasTrivialCopy(SgType const const* inputType); | |
HasTrivialDestructorbool HasTrivialDestructor(SgType const const* inputType); | |
HasVirtualDestructorbool HasVirtualDestructor(SgType const const* inputType); | |
IsAbstractbool IsAbstract(SgType const const* inputType); | |
IsBaseOfbool IsBaseOf( SgType const const* inputBaseType, SgType const const* inputDerivedType); | |
IsClassbool IsClass(SgType const const* inputType); | strip off typedef and modifer types, then check if a type is a class type, excluding union type. |
IsEmptybool IsEmpty(SgType const const* inputType); | |
IsEnumbool IsEnum(SgType const const* inputType); | |
IsLiteralTypebool IsLiteralType(SgType const const* inputType); | |
IsPodbool IsPod(SgType const const* inputType); | |
IsPolymorphicbool IsPolymorphic(SgType const const* inputType); | |
IsStandardLayoutbool IsStandardLayout(SgType const const* inputType); | |
IsTrivialbool IsTrivial(SgType const const* inputType); | |
IsUnionbool 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. |
addMangledNameToCachestd::string addMangledNameToCache( SgNode* astNode, std::string const& mangledName); | |
addMessageStatementvoid 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 |
addVarRefExpFromArrayDimInfovoid 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 |
annotateExpressionsWithUniqueNamesvoid 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 |
changeAllBodiesToBlocksvoid 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(); | |
checkTypesAreEqualbool checkTypesAreEqual( SgType* typeA, SgType* typeB); | |
cleanupNontransformedBasicBlockNode[[visibility("default")]] void cleanupNontransformedBasicBlockNode(); | Remove unused basic block IR nodes added as part of normalization. |
clearMangledNameCachevoid clearMangledNameCache(SgGlobal* globalScope); | |
clearScopeNumbersvoid clearScopeNumbers(SgFunctionDefinition* functionDefinition); | Clears the cache of scope,integer pairs for the input function. |
clearSharedGlobalScopesvoid 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. |
collectSourceSequenceNumbersstd::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++ |
collectVarRefsvoid collectVarRefs( SgLocatedNode* root, std::vector<SgVarRefExp*>& result); | Collect all variable references in a subtree |
collectVariableReferenceUsesvoid 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. |
computeUniqueNameForUseAsIdentifiervoid 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 |
createTempVariableAndReferenceForExpressionstd::pair<SgVariableDeclaration*, SgExpression*> createTempVariableAndReferenceForExpression( SgExpression* expression, SgScopeStatement* scope); | |
createTempVariableForExpressionstd::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. |
declarationPositionStringstd::string declarationPositionString(SgDeclarationStatement const* declaration); | Generate a unique string from the source file position information |
declarationPreceedsDefinitionbool 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. |
deepCopytemplate<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. |
deepCopySemantictemplate<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. |
detachAllSymbolsFromScopevoid 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 |
enclosingNamespaceScopeSgNamespaceDefinitionStatement* enclosingNamespaceScope(SgDeclarationStatement* declaration); | Find the enclosing namespace of a declaration |
ensureBasicBlockAsBodyOfCaseOptionSgBasicBlock* 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. |
ensureBasicBlockAsBodyOfDefaultOptionSgBasicBlock* 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. |
evaluateConstIntegerExpressionconst_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. |
extractPragmaKeywordstd::string extractPragmaKeyword(SgPragmaDeclaration const*); | Extract a SgPragmaDeclaration's leading keyword . For example "#pragma omp parallel" has a keyword of "omp". |
findBreakStmtsstd::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. |
findContinueStmtsstd::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. |
findDeclarationStatementtemplate<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) |
findFunctionDeclarationSgFunctionDeclaration* 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 |
findGotoStmtsstd::vector<SgGotoStatement*> findGotoStmts( SgStatement* scope, SgLabelStatement* l); | |
findLastDeclarationStatementSgStatement* 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. |
fixupReferencesToSymbolsvoid 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. |
forallMaskExpressionSgExpression* 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. |
generateFileListstd::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. |
generateUniqueNamestd::string generateUniqueName( SgNode const* node, bool ignoreDifferenceBetweenDefiningAndNondefiningDeclarations); | Generate unique name from C and C++ constructs. The name may contain space. |
generateUniqueNameForUseAsIdentifierstd::string generateUniqueNameForUseAsIdentifier(SgDeclarationStatement* declaration); | Generate a useful name to support construction of identifiers from declarations. |
generateUniqueNameForUseAsIdentifier_supportstd::string generateUniqueNameForUseAsIdentifier_support(SgDeclarationStatement* declaration); | |
generateUniqueVariableNamestd::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); | |
getConditionValueSgExpression* 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. |
getDeclarationOfNamedFunctionSgFunctionDeclaration* getDeclarationOfNamedFunction(SgExpression* func); | Given a SgExpression that represents a named function (or bound member function), return the mentioned function |
getDeclaredTypeSgType* 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 |
getDependentDeclarationsstd::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, |
getEnclosingNodetemplate<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 |
getFirstVariableSgInitializedName& 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 |
getInParametersstd::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. |
getIntegerConstantValueunsigned 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 |
getMangledNameFromCachestd::string getMangledNameFromCache(SgNode* astNode); | |
getNextStatement[[visibility("default")]] SgStatement* getNextStatement(SgStatement* currentStmt); | Get next statement within the same scope of current statement |
getNonInstantiatonDeclarationForClassSgDeclarationStatement* getNonInstantiatonDeclarationForClass(SgTemplateInstantiationMemberFunctionDecl* memberFunctionInstantiation); | |
getOutParametersstd::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. |
getSgNodeListFromMemoryPooltemplate<typename NodeType> static std::vector<NodeType*> getSgNodeListFromMemoryPool(); | Query memory pools to grab SgNode of a specified type |
getSwitchCasesstd::vector<SgStatement*> getSwitchCases(SgSwitchStatement* sw); | |
getSymbolsUsedInExpressionstd::vector<SgVariableSymbol*> getSymbolsUsedInExpression(SgExpression* expr); | Find referenced symbols within an expression |
getTargetFileTypeWithCopyMapSgType* 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_dimensionsstd::vector<SgExpression*> get_C_array_dimensions(SgArrayType const& arrtype); | returns the array dimensions in an array as defined for arrtype |
get_namestd::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. |
insertAfterUsingCommaOpSgCommaOpExp* 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. |
insertBeforeUsingCommaOpSgCommaOpExp* 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. |
isAssignmentStatementbool 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. |
isBodyStatementbool 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); | |
isIndexOperatorbool 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 |
isOverloadedbool isOverloaded(SgFunctionDeclaration* functionDeclaration); | Return true if function is overloaded. |
isOverloadedArrowOperatorbool isOverloadedArrowOperator(SgExpression* expr); | isOverloadedArrowOperator overloads |
isOverloadedArrowOperatorChainbool 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) |
isPostfixOperatorbool isPostfixOperator(SgExpression* exp); | |
isPrefixOperatorbool isPrefixOperator(SgExpression* exp); | Classify a call's exact source operator surface. |
isPrototypeInScopebool 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. |
isStructurallyEquivalentASTbool 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); | |
loopCollapsingSgExprListExp* 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. |
makeSingleStatementBodyToBlockSgBasicBlock* makeSingleStatementBodyToBlock(SgStatement* singleStmt); | Make a single statement body to be a basic block. Its parent is if, while, catch, etc. |
markNodeToBeUnparsedvoid markNodeToBeUnparsed( SgNode* node, int physical_file_id); | |
markSubtreeToBeUnparsedvoid markSubtreeToBeUnparsed( SgNode* root, int physical_file_id); | |
materializeTypeWithCopyMapSgType* 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. |
outputGlobalFunctionTypeSymbolTablevoid 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. |
prepareTemplateArgumentCopyvoid prepareTemplateArgumentCopy( SgTemplateArgument const* argument, SgCopyHelp& help); | |
prepareTemplateParameterTypeCopyvoid 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. |
printAST2TextFilevoid 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(). |
querySubTreetemplate<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. |
recursivePrintCurrentAndParentvoid 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 |
removeConstSgType* 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); | |
resetMangledNameCachevoid resetMangledNameCache(SgGlobal* globalScope); | |
resetScopeNumbersvoid resetScopeNumbers(SgFunctionDefinition* functionDeclaration); | Assigns unique numbers to each SgScopeStatement of a function. |
reset_name_collision_mapvoid 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); | |
saveToPDFvoid 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. |
serializevoid 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_listtemplate<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); | |
setBaseTypeDefiningDeclarationvoid 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); | |
setCtorInitializerListtemplate<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. |
setParameterListtemplate<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. |
setSourcePositionAsTransformationvoid 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. |
validateSymbolOwnershipvoid validateSymbolOwnership(SgNode* root); | Validate that every symbol has one exact owning symbol-table entry. |
whereAmIvoid whereAmI(SgNode* node); | Diagnostic function for tracing back through the parent list to understand at runtime where in the AST a failure happened. |
wrapFunctionstd::pair<SgStatement*, SgInitializedName*> wrapFunction( SgFunctionDeclaration& definingDeclaration, SgName newName); | wrapFunction overloads |
Variables¶
| Name | Description |
|---|---|
gensym_counter | An internal counter for generating unique SgName |
local_name_collision_map | Global map of name collisions to support generateUniqueNameForUseAsIdentifier() function. |
local_name_to_node_map | |
local_node_to_name_map | |
trans_records |
SageInterface::Detail namespace¶
Functions¶
| Name |
|---|
fortranIntegerSelectorValuestd::optional<Rose::Integer128Value> fortranIntegerSelectorValue(SgExpression const*); |
hasExactFortranFunctionReferenceBindingsbool hasExactFortranFunctionReferenceBindings( SgFunctionSymbol* semantic, SgFunctionSymbol* visible, SgFunctionRefExp::fortran_source_visible_binding_kind_enum kind); |
isExactFortranSemanticProcedurePublicationbool isExactFortranSemanticProcedurePublication(SgFunctionSymbol* symbol); |
isValidFortranKindSelectorbool isValidFortranKindSelector(SgExpression const*); |
isValidFortranLengthSelectorbool isValidFortranLengthSelector(SgExpression const*); |
unsignedValueFitsIntemplate< typename Target, typename Source> constexpr bool unsignedValueFitsIn(Source value) noexcept; |
StaticCFG namespace¶
Types¶
| Name | Description |
|---|---|
CFG | |
CustomFilteredCFG | A CFG implementation with Custom filters |
InterproceduralCFG |
Using Declarations¶
| Name |
|---|
CFGEdge |
CFGNode |
CFGPath |
TransformationTracking namespace¶
Functions¶
| Name | Description |
|---|---|
addInputNodevoid addInputNode( SgNode* affected_node, SgNode* inputnode); | |
clearIdvoid clearId(SgNode*); | |
getFileInfostd::pair<Sg_File_Info*, Sg_File_Info*> getFileInfo(AST_NODE_ID id); | |
getIdAST_NODE_ID getId(SgNode*); | |
getNextIdAST_NODE_ID getNextId(); | |
getNodeSgNode* getNode(AST_NODE_ID id); | |
hasIdbool hasId(SgNode* n); | |
registerAstSubtreeIdsvoid registerAstSubtreeIds(SgNode* root); | Assign Ids and save current File Info. |
setIdvoid setId(SgNode*); |
Variables¶
| Name |
|---|
inputIDs |
VirtualCFG namespace¶
Types¶
| Name | Description |
|---|---|
CFGEdge | A control flow edge connecting two CFG nodes, with an edge condition to indicate edge types |
CFGNode | A node in the control flow graph. Each CFG node corresponds to an AST node, but there can be several CFG nodes for a given AST node. |
CFGPath | |
CfgToDotImpl | |
DataflowEdge | |
DataflowNode | |
FilteredCFGEdge | |
FilteredCFGNode | |
InterestingEdge | "Interesting" node and edge filters |
InterestingNode | |
MakeClosure | |
back_dataflow | |
back_iterator | |
dataflow | |
iterator |
Enums¶
| Name | Description |
|---|---|
EdgeConditionKind | The conditions attached to edges are marked to determine which conditions trigger control to flow along that edge (as opposed to other edges out of the same source node). For conditional branches (except eckCaseLabel and eckDefault), the conditions are implicit and depend on knowledge of the particular control structure. Fortran support for this is underdeveloped; single AST nodes representing variable-length loops was not part of the original design of the CFG code. |
Functions¶
| Name | Description |
|---|---|
cfgBeginningOfConstructCFGNode cfgBeginningOfConstruct(SgNode* c); | The first CFG node for a construct (before the construct starts to execute) |
cfgEndOfConstructCFGNode 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 |
cfgIndexForEndWrapperunsigned 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) |
defaultFilterbool defaultFilter(CFGNode cfgn); | |
dfaToDottemplate<typename FilterFunction> [[visibility("default")]] std::ostream& dfaToDot( std::ostream& o, std::string graphName, std::vector<FilteredCFGNode<FilterFunction>> start, DefUseAnalysis* dfa); | |
getCFGTargetOfFortranLabelRefCFGNode getCFGTargetOfFortranLabelRef(SgLabelRefExp* lRef); | |
getCFGTargetOfFortranLabelSymbolCFGNode 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 |
makeCfgCFGNode makeCfg(SgNode* start); | Returns CFG node for just before start |
makeClosuretemplate< 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); | |
makeEdgetemplate< class Node1T, class Node2T, class EdgeT> void makeEdge( Node1T from, Node2T to, std::vector<EdgeT>& result); | Utility function to make CFG Edges |
makeInterestingCfgInterestingNode makeInterestingCfg(SgNode* start); | |
mergePathsCFGPath mergePaths( CFGPath const& hd, CFGPath const& tl); | |
mergePathsReversedCFGPath mergePathsReversed( CFGPath const& tl, CFGPath const& hd); | |
printEdgetemplate< typename EdgeT, bool Debug> void printEdge( std::ostream& o, EdgeT const& e, bool isInEdge); | Edge printer |
printNodetemplate< typename NodeT, bool Debug> void printNode( std::ostream& o, NodeT const& n); | Helper function to print Node information |
printNodePlusEdgestemplate< typename NodeT, typename EdgeT, bool Debug> void printNodePlusEdges( std::ostream& o, NodeT n); | Print out a node plus all its outgoing edges |
WalrusGraph namespace¶
Functions¶
| Name |
|---|
generateWalrusGraphvoid generateWalrusGraph( SgNode* node, std::string outputFilename); |
cfgUtils namespace¶
Functions¶
| Name |
|---|
getFuncEndCFGVirtualCFG::DataflowNode getFuncEndCFG( SgFunctionDefinition* func, bool(* f)(VirtualCFG::CFGNode) = VirtualCFG::defaultFilter); |
getFuncStartCFGVirtualCFG::DataflowNode getFuncStartCFG( SgFunctionDefinition* func, bool(* f)(VirtualCFG::CFGNode) = VirtualCFG::defaultFilter); |
unwrapCastsSgExpression const* unwrapCasts(SgExpression const* e); |
legacy namespace¶
Namespaces¶
| Name |
|---|
PRE |
Functions¶
| Name | Description |
|---|---|
anyOfListPotentiallyModifiedInbool 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? |
countComputationsOfExpressionInint countComputationsOfExpressionIn( SgExpression* expr, SgNode* root); | Count guaranteed computations, respecting conditional and unevaluated operands. Changes to expr's inputs require a separate check. |
expressionComputedInbool 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 namespace¶
Types¶
| Name | Description |
|---|---|
myControlFlowGraph | The whole CFG structure, including some external properties |
simpleGraph | Graph structure for control flow graphs. Based loosely on BGL graph type. |
Type Aliases¶
| Name |
|---|
ControlFlowGraph |
EdgeIter |
Edges |
InEdgeIter |
OutEdgeIter |
Vertex |
VertexIter |
Vertices |
Functions¶
| Name | Description |
|---|---|
addEdgeInsertionPointsvoid 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. |
makeCfgvoid 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. |
partialRedundancyEliminationFunctionvoid partialRedundancyEliminationFunction(SgFunctionDefinition* n); | Do partial redundancy for all expressions within a given function, whose definition is given in n. |
partialRedundancyEliminationOnevoid 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. |
rose_hash namespace¶
Types¶
| Name | Description |
|---|---|
hash_integer | Hash name support for symbol tables within ROSE. |
hash_integer_pair |
Using Declarations¶
| Name |
|---|
hash |
unordered_map |
unordered_multimap |
rwAccessLabeler namespace¶
Enums¶
| Name |
|---|
accessType |
Functions¶
| Name |
|---|
accessTypeToStrstd::string accessTypeToStr(accessType t); |
addRWAnnotationsvoid addRWAnnotations(SgNode* root); |
cloneAccessTypevoid cloneAccessType( SgNode* tgt, SgNode* src); |
getAccessTypeaccessType getAccessType(SgNode* n); |
sg namespace¶
This namespace contains template functions that operate on the ROSE AST
Types¶
| Name |
|---|
AncestorTypeFinder |
DefaultHandler |
DispatchHandler |
VisitDispatcher |
Functions¶
| Name |
|---|
_ancestortemplate< class AncestorNode, class QualSgNode> AncestorNode* _ancestor(QualSgNode& n); |
_dispatchtemplate<class RoseVisitor> std::remove_const<std::remove_reference<RoseVisitor>::type>::type _dispatch( RoseVisitor&& rv, SgNode* n); |
ancestortemplate<class AncestorNode> AncestorNode& ancestor(SgNode& n); |
dispatchtemplate<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] |
Created with MrDocs