Skip to content

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

Name Description
AST_Error
AdhocDependenceTesting
AliasAnalysisInterface
AliasCfgFilter
AliasInfoGenerator Helper class to hold Alias Information
AliasRelationNode A struct to hold the information about an alias node
AliasWriteEffects
AllLoopReuseBlocking
Analysis
AndApplicator
AnnotCollectionBase
AnyReuseFusionAnal
AppendPtrSet
AppendSTLSet
ArrangeNestingOrder
ArrangeOrigNestingOrder
ArrangeReuseOrder
ArrayAbstractionInterface ***QY: Interface classes used by loop optimizations
ArrayAnnotation
ArrayCollection
ArrayConstructDescriptor
ArrayConstructOpCollection
ArrayDefineDescriptor
ArrayDescriptor
ArrayElemDescriptor
ArrayInterface
ArrayModifyDescriptor
ArrayModifyOpCollection
ArrayOptCollection
ArrayOptDescriptor
ArrayShapeDescriptor
ArrayUseAccessFunction
ArtificialFrontierTraversal
ArtificialFrontier_InheritedAttribute
ArtificialFrontier_SynthesizedAttribute
AssumeNoAlias
Ast2StringMap
AstAttribute Base class for all IR node attribute values.
AstAttributeDOT
AstAttributeMechanism Stores named attributes in Sage IR nodes.
AstBottomUpProcessing Attribute evaluator for synthesized attributes.
AstCombinedBottomUpProcessing
AstCombinedPrePostProcessing
AstCombinedSimpleProcessing
AstCombinedTopDownBottomUpProcessing
AstCombinedTopDownProcessing
AstCycleTest AstCycleTest is based on the successor information of SgNodes (the same information that is used by the traversals). It tests such that it allows a preorder traversal to revisit nodes but reports an error if the traversal would run into a cycle. If a cycle is found it reports the list of SgNodes that are part of the cycle to stdout, starting with "CYCLE FOUND: ..." and stops testing. Usage: AstCycleTest t; t.traverse(SgNode* n); // where n is the root node of the subtree to be tested.
AstDOTGeneration
AstDOTGenerationExtended
AstInheritedAttribute
AstIntAttribute
AstInterface provides an abstract interface to access/modify AST nodes.
AstInterfaceImpl
AstNodePtr
AstNodeStatistics Statistics about IR nodes used.
AstNodeType
AstNodeTypeImpl
AstNodeVisitMapping
AstObserver This is the base class for anyone who wants to be notified when AST nodes are being copied.
AstPDFGeneration
AstPerformance
AstPreOrderTraversal
AstPrePostOrderTraversal
AstPrePostProcessing
AstProcessingClasses AST Processing
AstReverseBranchInhProcessing
AstReverseBranchInhSynProcessing
AstReverseBranchSimpleProcessing
AstReverseBranchSynProcessing
AstReversePrefixInhProcessing
AstReversePrefixInhSynProcessing
AstReversePrefixSimpleProcessing
AstReversePrefixSynProcessing
AstSgNodeAttribute Attribute storing an SgNode.
AstSharedMemoryParallelBottomUpProcessing
AstSharedMemoryParallelBottomUpThreadArgs
AstSharedMemoryParallelPrePostProcessing
AstSharedMemoryParallelProcessingSynchronizationBase
AstSharedMemoryParallelProcessingSynchronizationInfo
AstSharedMemoryParallelSimpleProcessing
AstSharedMemoryParallelTopDownBottomUpProcessing
AstSharedMemoryParallelTopDownBottomUpThreadArgs
AstSharedMemoryParallelTopDownProcessing
AstSharedMemoryParallelTopDownThreadArgs
AstSharedMemoryParallelizableBottomUpProcessing
AstSharedMemoryParallelizablePrePostProcessing
AstSharedMemoryParallelizableSimpleProcessing
AstSharedMemoryParallelizableTopDownBottomUpProcessing
AstSharedMemoryParallelizableTopDownProcessing
AstSimpleProcessing Class for traversing the AST.
AstSuccessorsSelectors
AstSynthesizedAttribute
AstTerm
AstTests
AstTopDownBottomUpProcessing Attribute evaluator for inherited and synthesized attributes.
AstTopDownProcessing Attribute evaluator for inherited attributes.
AstTreeDepGraphAnal
AstTreeDepGraphBuildImpl
AstTreeReplaceVar
AstValueAttribute IR node attribute that stores a copyable value.
AttachPreprocessingInfoTreeTrav
AttachPreprocessingInfoTreeTraversalInheritedAttrribute
AttachPreprocessingInfoTreeTraversalSynthesizedAttribute
BaseGraphCreate
BaseGraphCreateWrap
BetterReuseFusionAnal
BitVectorRepr
BitVectorReprBase
BitVectorReprGenerator
BitVectorReprImpl
BlockLoopInfo
BoolAndLattice ** Commonly used lattices ***
BoolDescriptor
BooleanSafeKeeper
BottomUpTraversalLivenessIN
BottomUpTraversalLivenessOUT
BreakupStatement
BuildAstTreeDepGraph
BuildCFGConfig
BuildCFGTraverse
CFGConfig
CFGEdgeImpl
CFGImplTemplate
CFGNodeImpl
CGFunction
CPPAstInterface
CPPTypeCollection
CallGraphBuilder
ChainableTypeLayoutGenerator Basic type layout engine -- handles bookkeeping, plus handing typedefs and
ClangDeclTranslationMap
ClangExpandedTokenOrder
ClangOrderedDeclarationProvenance
ClangTemplateInstantiationCacheKey
ClangTemplateInstantiationCacheKeyHash
ClangTemplateParameterContextStack
ClangToSageTranslator Translator from Clang AST to SAGE III (ROSE Compiler AST)
ClassHierarchyWrapper
CloseDescriptor A descriptor with begin(left) and end(right) characters, such as {x}, (x), etc
CmdOptions
Collect2Object
CollectAliasRelations Helper class to collect Alias Relations
CollectDoublyLinkedList
CollectFunctions
CollectObject
CollectPair A pair of items separated by 'sep'
CollectSinglyLinkedList
CompReprBase
CompReprPtr Null means unreachable/pending; an allocated empty graph is reachable with no alias facts.
CompSlice
CompSliceAlignInfo
CompSliceDeleteInfo
CompSliceDepGraphCreate
CompSliceDepGraphNode
CompSliceFuseInfo
CompSliceImpl
CompSliceLocalityAnal
CompSliceLocalityRegistry
CompSliceLoop
CompSliceNest
CompSliceNestAlignEntryInfo
CompSliceNestDeleteEntryInfo
CompSliceNestDeleteInfo
CompSliceNestDuplicateEntryInfo
CompSliceNestFusionInfo
CompSliceNestObserveInfo
CompSliceNestObserver
CompSliceNestSwapInfo
CompSliceObserveInfo
CompSliceObserver
CompSliceRegistry
CompSliceSelect
CompSliceStmt
CompactRepresentation
CompareObject
ConstraintSatisfactionResult
ContainerDescriptor
ContextInsensitiveInterProceduralDataflow
ContextVis_R Strategy pattern applied to visitors: serves as a context to a strategy, which itself is a visitor; delegates all requests to the current strategy; capable of switching strategy at will. Derived classes may declare the known strategies as friend to facilitate communication between the strategies and their context.
ControlDependenceGraph
CopyArrayConfig
CopyArrayOperator
CopyArrayUnderSizeLimit
CopyAstRecord
CountRefHandle
CreateSlice
CreateSliceSet
CreateTmpArray
CustomAstDOTGeneration
CustomAstDOTGenerationData
CustomAstDOTGenerationEdgeType
CustomAstDOTGenerationNodeType
CustomMemoryPoolDOTGeneration
CustomMemoryPoolDOTGenerationData
CxxCodeGenerator Backend Cxx Code Generator
DAG
DAGBaseEdgeImpl
DAGBaseGraphImpl
DAGBaseNodeImpl
DAGEdge
DAGNode
DDE_data
DFAnalysis
DFStateAtReturns
DGBaseEdgeImpl
DGBaseGraphImpl
DGBaseNodeImpl
DOTGeneration
DOTGraphEdge
DOTGraphNode
DOTInheritedAttribute
DOTRepresentation
DOTSynthesizedAttribute
DataDependenceGraph
DataFlowAnalysis
DataFlowNode
DebugLog
DeclAttachmentSession
Declaration
DefUseAnalysis
DefUseAnalysisAbstract
DefUseAnalysisPF
DefUseChain
DefUseChainNode
DefaultCFGImpl
DefaultDUchain
DefineVariableDescriptor
DeleteNodeInfo
DeleteStmtLoopInfo
DepCompAstRef
DepCompAstRefAnal
DepCompAstRefGraphCreate
DepCompAstRefGraphNode
DepCompCopyArrayCollect
DepCompCopyArrayToBuffer
DepCompDistributeLoop
DepInfo
DepInfoAlignLoop
DepInfoAnal
DepInfoAnalInterface
DepInfoEdge
DepInfoEdgeConstInfoIterator
DepInfoGenerator
DepInfoGraphCreate
DepInfoImpl
DepInfoInsertLoop
DepInfoMergeLoop
DepInfoRemoveLoop
DepInfoRestrictDomain
DepInfoSet
DepInfoSetEdge
DepInfoSetGenerator
DepInfoSetGraphCreate
DepInfoSetImpl
DepInfoSwapLoop
DepRel
DependenceGraph
DependenceHoisting
DependenceNode
DependenceTesting
DetectMacroOrIncludeFileExpansions
DetectMacroOrIncludeFileExpansionsInheritedAttribute
DetectMacroOrIncludeFileExpansionsSynthesizedAttribute
DirectedEdgeInterface
DirectedGraph
DirectedGraphEdge
DirectedGraphNode
DistNodeInfo
DistributedMemoryAnalysisPostTraversal
DistributedMemoryAnalysisPreTraversal
DivAnalysis
DivAnalysisTransfer
DivLattice
DomainCond
DomainInfo
DomainInfoImpl
DoublyLinkedEntryWrap
DoublyLinkedListWrap
DynamicCompSlice
DynamicSlicing
EDefUse
EqualApplicator
ExtendibleParamDescriptor a parameter with a named range of values. parameter:range_name:lower_bound:upper_bound
ExtractFunctionArguments This normalization makes sure each function call argument is a side-effect free expression of only one variable. To accomplish this, temporary variables are declared and the arguments of a function are evaluated before the function itself. Note: Normalization is not performed if it is unsafe. E,g.: while(Foo(Bar()) {} is not equal to t = Bar(); while(Foo(t) {} Note that only SgFunctionCall arguments are normalized. For example the arguments of the constructor initializer MyObject o(foo(), bar()) will not be extracted.
FileHelper
FindAllFunctionCalls
FiniteLattice
FiniteProductLattice
FiniteVarsExprsProductLattice
FortranCodeGeneration_locatedNode
FortranCodeGenerator Backend Fortran Code Generator
FrontierDetectionForTokenStreamMapping
FrontierDetectionForTokenStreamMapping_InheritedAttribute
FrontierDetectionForTokenStreamMapping_SynthesizedAttribute
FrontierNode
Function
FunctionAliasInterface
FunctionCallInfo Stores a function call expression, along with associated information about its context.
FunctionCallInheritedAttribute
FunctionCallNormalization
FunctionData
FunctionEvaluationOrderTraversal Traverses a given AST and finds all function calls in the order in which they're evaluated Also, for each function we find where to put declarations of temporary variables so that they're accessible at the function call
FunctionSideEffectInterface
FunctionState
FusionInfo
GetOneFuncDeclarationPerFunction
GlobalVarAnalysis
GraphAccess
GraphAccessTemplate
GraphAccessWrapTemplate
GraphCrossEdgeIterator
GraphDotOutput
GraphEdgeIterator
GraphGetNodeReachable
GraphNodePredecessorIterator
GraphNodeSuccessorIterator
GraphReverseEdge
GraphSelect
GraphTransAnalysis
GroupGraphCreate
GroupGraphEdge
GroupGraphNode
GroupNodeSelect
HasValueCollection
HasValueDescriptor
HasValueMap
HasValueMapReplace
HoldAncesLoopObserver
HoldLoopAlignObserver
HoldTreeNodeObserver
I386PrimitiveTypeLayoutGenerator Layout generator for i386 primitive types
IncludeDirective
IncludedFilesUnparser
IncludingPreprocessingInfosCollector
InfiniteLattice
InitDataflowState
InnerLoopReuseBlocking
InnermostLoopFission
InsertLoopInfo
InsertStmtLoopInfo
IntDescriptor
InterProcDataFlowAnalysis
InterProcVariableUniqueRepr
InterProceduralAnalysis
InterProceduralDataflow ***** Dataflow Analyses ******
InterproceduralInfo
IntraBWDataflow
IntraDFTransferVisitor Apply an analysis A's transfer function at a particular AST node type
IntraFWDataflow
IntraProcAliasAnalysis IntraProcedurial DataFlow Analysis to compute exit and entry from all the function which
IntraProcDataFlowAnalysis
IntraProceduralAnalysis
IntraProceduralDataflow
IntraUniDirectionalDataflow
IntraUnitDataflow
IsDFAFilter
IsDefUseFilter Struct containing a filtering function to determine what CFG nodes are interesting during the DefUse traversal. This is a functor.
IsImportantForSliceCFGFilter
IteratorImpl
IteratorImplTemplate
IteratorWrap
LDVAExpressionTransfer Visits live expressions - helper to LiveDeadVarsTransfer
LanguageIndependentCodeGenerator Backend Language Independent Code Generator
Lattice
LatticeElemList
LatticeElemMerge
LinearizeAST
LinearizeInheritedAttribute
LiveDeadVarsAnalysis
LiveDeadVarsTransfer
LiveVarsLattice
LivenessAnalysis
LoopAlignInfo
LoopAnalInfo
LoopBlocking
LoopFusionAnal
LoopInfo
LoopInterface
LoopNestFusion
LoopNoBlocking
LoopStepInfo
LoopTransformInterface QY: Singular interface class which remembers configurations for loop optimizations*
LoopTransformOptions
LoopTreeBlockLoop
LoopTreeBlockLoopNode
LoopTreeBodyNode
LoopTreeBuild
LoopTreeCodeGenInfo
LoopTreeCopyArray
LoopTreeCopyArrayToBuffer
LoopTreeCreate
LoopTreeDepComp
LoopTreeDepCompCreate
LoopTreeDepCompSubtree
LoopTreeDepGraphCreate
LoopTreeDepGraphNode
LoopTreeDepGraphSubtree
LoopTreeDistributeNode
LoopTreeDummyNode
LoopTreeEmbedStmt
LoopTreeEmission
LoopTreeGetVarBound
LoopTreeGetVarConstBound
LoopTreeIfCond
LoopTreeInterface
LoopTreeLocalityAnal
LoopTreeLoopNode
LoopTreeMergeLoop
LoopTreeMergeStmtLoop
LoopTreeNode
LoopTreeNodeDepMap
LoopTreeObserveImpl
LoopTreeObserveInfo
LoopTreeObserver
LoopTreeRelateLoopIvar
LoopTreeReplAst
LoopTreeReplLoopVar
LoopTreeReplaceAst
LoopTreeRestrLoopRange
LoopTreeRoot
LoopTreeShadowCreate
LoopTreeShadowNode
LoopTreeSplitStmt
LoopTreeStmtNode
LoopTreeSwapNodePos
LoopTreeTransform
LoopTreeTraverse
LoopTreeTraverseSelectLoop
LoopTreeTraverseSelectStmt
LoopUnrolling
MacroDirective
MacroExpansion
MakeUniqueVar
MakeUniqueVarGetBound
Map2Object
MapDescriptor
MapObject
MapVarBound
Matrix
MergeAllReturnStates
MergeLoopInfo
MergeStmtLoopInfo
MergedDependenceGraph
MetricAttribute Attribute corresponding to a metric.
ModifyVariableMap
MultiGraphCreate
MultiGraphDeleteEdgeInfo
MultiGraphDeleteNodeInfo
MultiGraphElem
MultiGraphElemTemplate
MultiGraphObserveEdgeTemplate
MultiGraphObserveNodeTemplate
MultiGraphObserver
MultiIterator
MultiLevelFusion
MultiplyApplicator
NameDescriptor
NameGenerator
NameQualificationContext
NameQualificationEvaluationSet
NameQualificationFileAnalysis
NameQualificationInheritedAttribute
NameQualificationNodeSet
NameQualificationNodeStrings
NameQualificationResult
NameQualificationSynthesizedAttribute
NameQualificationTraversal
NameQualificationUseSiteStrings
NameQualificationUsingDirectiveOrderCache
NoCopyArrayOperator
NoFunctionAliasAnalysis
NoFunctionSideEffectAnalysis
NodeFact
NodeState ** NodeState ***** The state of all the Lattice elements ***** associated by dataflow analyses with a ***** given node. This state will evolve as ***** a result of the dataflow analysis. ***
NonpackedTypeLayoutGenerator Layout generator for i386 ABI-like struct layout
NotApplicator
NotSelectPtrSet
OPApplicator
OPDescriptorTemp
ObserveInfo
ObserveObject
ObserveTransform
OmpExactSubexpressionType
OmpFortranExactSemanticBindings
OmpSimdCompiler
OpenACCCxxExactSemanticBindings
OpenMPProducerSemanticRecords
OperatorAliasAnnotation
OperatorAliasCollection
OperatorAllowAliasCollection
OperatorAnnotCollection
OperatorCallInfoCollection
OperatorDeclaration Representation for an operator (function)
OperatorKillInfoCollection
OperatorModInfoCollection
OperatorReadInfoCollection
OperatorSideEffectAnnotation
OperatorSideEffectDescriptor
OrigLoopFusionAnal
OuterLoopReuseBlocking
PDFGeneration
PDFInheritedAttribute
ParameterDeclaration Representation for function parameter names and types.
Pattern Abstract interface for a pattern which can match ASTs
PatternActionRule A rule which changes one pattern of code to another
PendingConditionDeclarationConstruction
PerfectLoopReversible
PerfectLoopSlicable
PlusApplicator
PreOrderTraversal
PrePostOrderTraversal
PrePostTransformation
PreprocessingInfo For preprocessing information including source comments, include , if, define, etc
PrivatizeScalar
ProcessAstNode Interface class for processing each AstNode from within the ReadAstTraverse function.
ProcessAstTree
ProcessAstTreeBase
ProcessingPhase
ProductLattice
PtrAliasAnalysis PtrAliasAnalysis computes Alias Information, which is used for Virtual Function Resolving.
PtrAnal
PtrMapWrap
PtrSetWrap
ROSEAttributesList
ROSEAttributesListContainer
ROSE_AST_InliningGroup Inlining Transformations
ROSE_FrontEndGroup ROSE Frontend Group
ROSE_MemoryUsage
ROSE_ProgramTransformationGroup ROSE Program Transformations
ROSE_VisitTraversal
ROSE_VisitorPattern
ROSE_VisitorPatternDefaultBase
RTIMemberData
RTIValue
RTIValueDescriptor Access to C++ Run Time Information (RTI)
ReachingDefNode
ReachingDefinitionAnalysis
ReachingDefinitionBase
ReachingDefinitionFacade
ReachingDefinitionGenerator
ReadAnnotCollection
ReadAnnotation An interface to read into type(class) and operator(function) annotations
ReadContainer
ReadContainerWrap
ReadError
ReadSymbolicFunctionDeclaration
ReferenceToPointerHandler
ReferenceToPointerHandlerImpl
ReplaceParams
RestrictValueOpCollection
RestrictValueOpDescriptor
RewriteArrayModOp
RewriteConstructArrayAccess
RewriteFromArrayAst
RewriteRule A replacement must detach the old node and attach a distinct new tree to its former parent. rewrite deletes the displaced tree after traversal.
RewriteRuleCombiner Combine several rules into one, doing the constituents in order
RewriteToArrayAst
RoseAst Interface for iterating over an AST.
RoseOpenMPPragmaCallback
RosePathRoots
RoseSelectObject
SCCAnalOperator
SCCAnalysis
SCCGraphCreate
SCCGroupGraphOperator
SDGLibraryExtender
SFINAEFailureResult
SageClasses Sage III Intermediate Representation
SageExpression Sage III Expression Classes
SagePreprocessorRecord
SageStatement Sage III Statement Classes
SageSymbol Sage III Symbol Classes
SageType Sage III Type Classes
SameLevelFusion
Select2Object
SelectApplicator
SelectApplicatorWithBound
SelectArray
SelectObject1
SelectObject2
SelectPair Similar to CollectPair, but the second item may start with 'sel' without 'sep' in front of it.
SelectPtrSet
SelectSTLSet
SelectSingleNode
SetDep
SetDepEntry
SetDescriptor
SgAccAsyncClause
SgAccAtomicStatement
SgAccBodyStatement
SgAccCacheStatement
SgAccCaptureClause
SgAccClause
SgAccClauseBodyStatement
SgAccClauseStatement
SgAccCollapseClause
SgAccCopyClause
SgAccCopyinClause
SgAccCopyoutClause
SgAccCreateClause
SgAccDataStatement
SgAccDefaultClause
SgAccDeleteClause
SgAccDeviceptrClause
SgAccEnterDataStatement
SgAccExitDataStatement
SgAccExpressionClause
SgAccGangClause
SgAccIfClause
SgAccKernelsStatement
SgAccNumGangsClause
SgAccNumWorkersClause
SgAccParallelLoopStatement
SgAccParallelStatement
SgAccPresentClause
SgAccPrivateClause
SgAccReadClause
SgAccReductionClause
SgAccRoutineStatement
SgAccSeqClause
SgAccUpdateClause
SgAccVariablesClause
SgAccVectorClause
SgAccVectorLengthClause
SgAccWaitStatement
SgAccWriteClause
SgAccessLabelStatement
SgAccessModifier
SgActualArgumentExpression
SgAddOp
SgAddressOfOp
SgAggregateInitializer RHS of an array variable declaration with optional assignment.
SgAliasSymbol
SgAlignOfOp
SgAlignmentSpecifier
SgAllocateStatement
SgAndAssignOp
SgAndOp
SgArithmeticIfStatement
SgArrayType
SgArrowExp
SgArrowStarOp
SgAsmOp
SgAsmStmt This class represents the concept of a C Assembler statement.
SgAssignInitializer This class represents the rhs of a variable declaration which includes an optional
SgAssignOp
SgAssignStatement
SgAssignedGotoStatement
SgAssociateStatement
SgAssumedRankExp
SgAsteriskShapeExp
SgAttribute
SgAttributeSpecificationStatement
SgAttributedStatement
SgAutoType
SgAuxiliaryDeclarationList
SgAwaitExpression
SgBFloat16Val
SgBackspaceStatement
SgBaseClass
SgBaseClassModifier
SgBasicBlock This class represents the concept of a block (not a basic block from control flow analysis).
SgBidirectionalGraph
SgBinaryOp This class represents the notion of a binary operator.
SgBitAndOp
SgBitAttribute
SgBitComplementOp
SgBitEqvOp
SgBitOrOp
SgBitXorOp
SgBoolValExp This class represents a boolean value (expression value).
SgBottomUpProcessing
SgBracedInitializer
SgBreakStmt This class represents the notion of a break statement
SgCAFCoExpression
SgCAFImageSelectorExp
SgC_PreprocessorDirectiveStatement
SgCallExpression This class represents the concept of a generic call expression.
SgCapturingCopy Supporting template class for "capturing" copies of the AST.
SgCaseOptionStmt This class represents the concept of a C and C++ case option (used within a switch statement).
SgCastExp This class represents a cast of one type to another.
SgCatchOptionStmt This class represents the concept of a catch within a try-catch construct used in
SgCatchStatementSeq This class represents the concept of a C++ sequence of catch statements.
SgChar16Val
SgChar32Val
SgCharVal
SgChooseExpression
SgClassDecl_attr
SgClassDeclaration This class represents the concept of a class declaration statement. It includes the
SgClassDefinition This class represents the concept of a class definition in C++.
SgClassNameRefExp This class represents the concept of a C++ expression built from a class name.
SgClassSymbol This class represents the concept of a class name within the compiler.
SgClassType
SgClinkageDeclarationStatement
SgClinkageEndStatement
SgClinkageStartStatement Marks the start of a linkage specification region.
SgCloseStatement
SgColonShapeExp
SgCombinedTreeTraversal
SgCommaOpExp
SgCommonBlock
SgCommonBlockObject
SgCommonSymbol
SgComplexVal
SgCompoundAssignOp
SgCompoundLiteralExp
SgCompoundRequirement
SgComputedGotoStatement
SgConcatenationOp
SgConditionalExp This class represents the concept of a C trinary conditional expression (e.g. "test ? true : false")
SgConjugateOp
SgConstVolatileModifier
SgConstructorInitializer This class represents the call of a class constructor to initialize a variable.
SgContainsStatement
SgContinueStmt This class represents the concept of a C or C++ continue statement.
SgCopyHelp Supporting class from copy mechanism within ROSE.
SgCtorInitializerList This class represents the concept of a contructor initializer list (used in
SgCudaKernelCallExp
SgCudaKernelExecConfig
SgCxxArrayInitBinding
SgCxxArrayInitLoop
SgCxxArrayInitReference
SgCxxDecompositionRefExp
SgCxxDefaultInitExp
SgCxxLiteralToken
SgCxxLiteralTokenList
SgCxxSubobjectDestruction
SgDataStatementGroup
SgDataStatementObject
SgDataStatementValue
SgDeadIfDirectiveStatement
SgDeallocateStatement
SgDeclType
SgDeclarationGroupStatement
SgDeclarationModifier This class represents modifiers for SgDeclaration (declaration statements).
SgDeclarationScope
SgDeclarationScopeList
SgDeclarationStatement This class represents the concept of a declaration statement.
SgDefaultOptionStmt This class represents the concept of a C or C++ default case within a switch
SgDefaultSymbol
SgDefineDirectiveStatement
SgDeleteExp This class represents the concept of a C++ call to the delete operator.
SgDerivedTypeStatement
SgDesignatedInitializer
SgDesignator
SgDimensionObject
SgDirectedGraphEdge
SgDirectory This class represents a directory within a projects file structure of files and directories.
SgDirectoryList
SgDivAssignOp
SgDivideOp
SgDoWhileStmt This class represents the concept of a do-while statement.
SgDotExp
SgDotStarOp
SgDoubleVal This class represents the notion of an value (expression value).
SgElaboratedTypeModifier
SgElseDirectiveStatement
SgElseWhereStatement
SgElseifDirectiveStatement
SgEmptyDeclaration
SgEmptyDirectiveStatement
SgEndfileStatement
SgEndifDirectiveStatement
SgEntryStatement
SgEnumDeclaration This class represents the concept of an enum declaration.
SgEnumFieldSymbol
SgEnumSymbol
SgEnumType
SgEnumVal
SgEqualityOp
SgEquivalenceStatement
SgErrorDirectiveStatement
SgExpBaseClass
SgExponentiationAssignOp
SgExponentiationOp
SgExprListExp This class represents the concept of a C and C++ expression list.
SgExprStatement This class represents the concept of a C or C++ statement which contains a
SgExpression This class represents the notion of an expression. Expressions
SgExpressionRoot
SgFile Base class for files in a project. Stores file metadata and command-line options. SgSourceFile owns the global scope of a source file.
SgFileList
SgFloat128Val
SgFloat16Val
SgFloat32Val
SgFloat64Val
SgFloat80Val
SgFloatVal This class represents the notion of an value (expression value).
SgFloatingPointType
SgFlushStatement
SgFoldExpression
SgForAllStatement
SgForInitStatement This class represents the variable declaration or variable initialization withn a
SgForStatement This class represents the concept of a for loop.
SgFormTeamStatement
SgFormatItem
SgFormatItemList
SgFormatStatement
SgFortranBOZVal
SgFortranCommonBlockRefExp
SgFortranContinueStmt
SgFortranDataInitializer
SgFortranDo
SgFortranImplicitRange
SgFortranIncludeLine
SgFriendTypeDeclaration
SgFuncDecl_attr
SgFunctionCallExp This class represents the concept of a C++ function call (which is an expression).
SgFunctionDeclaration
SgFunctionDefinition
SgFunctionModifier
SgFunctionParameterList The ordered parameter declarations of a function.
SgFunctionParameterRefExp
SgFunctionParameterScope
SgFunctionParameterTypeList
SgFunctionRefExp This class represents the function being called and must be assembled in the
SgFunctionSymbol
SgFunctionType This class represents a type for all functions.
SgFunctionTypeArgument
SgFunctionTypeSymbol This class represents the concept of a name and a type. It may be
SgFunctionTypeTable Canonical function types indexed by semantic signatures.
SgGlobal The global scope of a source file.
SgGotoStatement This class represents the concept of a C or C++ goto statement.
SgGraph Documentation for graph class (consider grouping with other API docs).
SgGraphEdge
SgGraphEdgeList
SgGraphNode
SgGraphNodeList
SgGreaterOrEqualOp
SgGreaterThanOp
SgHeaderFileBody
SgIOStatement
SgIdentDirectiveStatement
SgIfDirectiveStatement
SgIfStmt This class represents the concept of an "if" construct.
SgIfdefDirectiveStatement
SgIfndefDirectiveStatement
SgImagPartOp
SgImageControlStatement
SgImplicitStatement
SgImpliedDo
SgImportStatement
SgIncidenceDirectedGraph
SgIncidenceUndirectedGraph
SgIncludeDirectiveStatement
SgIncludeFile
SgIncludeNextDirectiveStatement
SgInheritedAttribute
SgInitializedName This class represents the notion of a declared variable.
SgInitializer This class represents the notion of an initializer for a variable declaration or
SgInquireStatement
SgIntKeyedBidirectionalGraph
SgIntVal
SgInteger128Val
SgIntegerDivideAssignOp
SgIntegerDivideOp
SgIntegralType
SgInterfaceBody
SgInterfaceStatement
SgInterfaceSymbol
SgIntrinsicSymbol
SgIorAssignOp
SgLabelRefExp
SgLabelStatement This class represents the concept of a C or C++ label statement.
SgLabelSymbol
SgLambdaCapture
SgLambdaCaptureList
SgLambdaExp
SgLessOrEqualOp
SgLessThanOp
SgLineDirectiveStatement
SgLinemarkerDirectiveStatement
SgLinkageModifier
SgLocatedNode This class represents the notion of an expression or statement which
SgLocatedNodeSupport
SgLockStatement
SgLongDoubleVal This class represents the notion of an value (expression value).
SgLongIntVal
SgLongLongIntVal
SgLshiftAssignOp
SgLshiftOp
SgMacroExpansionExp
SgMemberAccessExp
SgMemberFunctionDeclaration This class represents the concept of a member function declaration statement.
SgMemberFunctionRefExp This class represents the member function being called and must be assembled in the
SgMemberFunctionSymbol
SgMemberFunctionType
SgMinusAssignOp
SgMinusMinusOp
SgMinusOp This class represents the numeric negation of a value. Not to
SgModAssignOp
SgModOp
SgModifier This class represents the base class of a number of IR nodes define modifiers
SgModifierNodes Holds the modifier-type cache buckets for a base type.
SgModifierType
SgModuleStatement
SgModuleSymbol
SgMultAssignOp
SgMultiplyOp
SgName String-backed name value used by AST nodes.
SgNameGroup
SgNamedType
SgNamelistStatement
SgNamelistSymbol
SgNamespaceAliasDeclarationStatement This class represents the concept of a C++ namespace alias declaration statement.
SgNamespaceDeclarationStatement This class represents the concept of a C++ namespace declaration.
SgNamespaceDefinitionStatement This class represents the concept of a namespace definition.
SgNamespaceSourceFragment
SgNamespaceSymbol This class represents the concept of a namespace name within the compiler.
SgNestedRequirement
SgNewExp This class represents the concept of a C++ call to the new operator.
SgNode This class represents the base class for all IR nodes within Sage III.
SgNoexceptOp
SgNonrealBaseClass
SgNonrealDecl
SgNonrealRefExp
SgNonrealSymbol
SgNonrealType
SgNotEqualOp
SgNotOp
SgNullExpression
SgNullStatement
SgNullifyStatement
SgNullptrValExp
SgOmpAbsentClause
SgOmpAcqRelClause
SgOmpAcquireClause
SgOmpAdjustArgsClause
SgOmpAffinityClause
SgOmpAlignClause
SgOmpAlignedClause
SgOmpAllocateClause
SgOmpAllocateStatement
SgOmpAllocatorClause
SgOmpAppendArgsClause
SgOmpAppendArgsOperation
SgOmpApplyClause
SgOmpApplyTransformation
SgOmpAssumeStatement
SgOmpAssumesStatement
SgOmpAtClause
SgOmpAtomicClause
SgOmpAtomicDefaultMemOrderClause
SgOmpAtomicStatement
SgOmpBarrierStatement
SgOmpBeginAssumesStatement
SgOmpBeginClause
SgOmpBeginDeclareTargetStatement
SgOmpBeginDeclareVariantStatement
SgOmpBindClause
SgOmpBodyStatement
SgOmpCancelStatement
SgOmpCancellationPointStatement
SgOmpCaptureClause
SgOmpClause
SgOmpClauseBodyStatement
SgOmpClauseList
SgOmpClauseStatement
SgOmpCollapseClause
SgOmpCompareClause
SgOmpContainsClause
SgOmpContextSelector
SgOmpContextSelectorProperty
SgOmpContextSelectorSet
SgOmpCopyinClause
SgOmpCopyprivateClause
SgOmpCriticalStatement
SgOmpDeclareMapperStatement
SgOmpDeclareSimdStatement
SgOmpDeclareTargetStatement
SgOmpDeclareVariantStatement
SgOmpDefaultClause
SgOmpDefaultmapClause
SgOmpDependClause
SgOmpDepobjStatement
SgOmpDepobjUpdateClause
SgOmpDestroyClause
SgOmpDetachClause
SgOmpDeviceClause
SgOmpDirectiveKindClause
SgOmpDirectiveLocalRefExp
SgOmpDispatchStatement
SgOmpDistScheduleClause
SgOmpDistributeParallelForSimdStatement
SgOmpDistributeParallelForStatement
SgOmpDistributeSimdStatement
SgOmpDistributeStatement
SgOmpDoStatement
SgOmpDoacrossClause
SgOmpDynamicAllocatorsClause
SgOmpEndAssumeStatement
SgOmpEndAssumesStatement
SgOmpEndClause
SgOmpEndDeclareTargetStatement
SgOmpEndDeclareVariantStatement
SgOmpEnterClause
SgOmpErrorStatement
SgOmpExclusiveClause
SgOmpExecStatement
SgOmpExpressionClause
SgOmpExtImplementationDefinedRequirementClause
SgOmpFailClause
SgOmpFilterClause
SgOmpFinalClause
SgOmpFirstprivateClause
SgOmpFlushStatement
SgOmpForClause
SgOmpForSimdStatement
SgOmpForStatement
SgOmpFromClause
SgOmpFullClause
SgOmpFuseStatement
SgOmpGrainsizeClause
SgOmpGraphIdClause
SgOmpGraphResetClause
SgOmpGroupprivateStatement
SgOmpHasDeviceAddrClause
SgOmpHintClause
SgOmpHoldsClause
SgOmpIfClause
SgOmpInReductionClause
SgOmpInbranchClause
SgOmpInclusiveClause
SgOmpIndirectClause
SgOmpInductionClause
SgOmpInductionItem
SgOmpInitClause
SgOmpInitModifier
SgOmpInitModifierList
SgOmpInterchangeStatement
SgOmpInteropStatement
SgOmpIsDevicePtrClause
SgOmpIteratorDefinition
SgOmpLastprivateClause
SgOmpLinearClause
SgOmpLinkClause
SgOmpLocalClause
SgOmpLoopStatement
SgOmpLooprangeClause
SgOmpMapClause
SgOmpMapDistDataPolicy
SgOmpMapItem
SgOmpMaskedStatement
SgOmpMaskedTaskloopSimdStatement
SgOmpMaskedTaskloopStatement
SgOmpMasterStatement
SgOmpMasterTaskloopSimdStatement
SgOmpMasterTaskloopStatement
SgOmpMatchClause
SgOmpMergeableClause
SgOmpMessageClause
SgOmpMetadirectiveStatement
SgOmpNameExpression
SgOmpNoOpenmpClause
SgOmpNoOpenmpConstructsClause
SgOmpNoOpenmpRoutinesClause
SgOmpNoParallelismClause
SgOmpNocontextClause
SgOmpNogroupClause
SgOmpNontemporalClause
SgOmpNothingStatement
SgOmpNotinbranchClause
SgOmpNovariantsClause
SgOmpNowaitClause
SgOmpNumTasksClause
SgOmpNumTeamsClause
SgOmpNumThreadsClause
SgOmpOrderClause
SgOmpOrderedClause
SgOmpOrderedDependStatement
SgOmpOrderedStatement
SgOmpOtherwiseClause
SgOmpParallelClause
SgOmpParallelLoopStatement
SgOmpParallelMaskedStatement
SgOmpParallelMasterStatement
SgOmpParallelMasterTaskloopSimdStatement
SgOmpParallelMasterTaskloopStatement
SgOmpParallelStatement
SgOmpPartialClause
SgOmpPriorityClause
SgOmpPrivateClause
SgOmpProcBindClause
SgOmpReadClause
SgOmpReductionClause
SgOmpRelaxedClause
SgOmpReleaseClause
SgOmpRequiresStatement
SgOmpReverseOffloadClause
SgOmpReverseStatement
SgOmpSafelenClause
SgOmpSafesyncClause
SgOmpScanStatement
SgOmpScheduleClause
SgOmpScopeStatement
SgOmpSectionStatement
SgOmpSectionsClause
SgOmpSectionsStatement
SgOmpSelfMapsClause
SgOmpSeqCstClause
SgOmpSeverityClause
SgOmpSharedClause
SgOmpSimdClause
SgOmpSimdStatement
SgOmpSimdlenClause
SgOmpSingleStatement
SgOmpSizesClause
SgOmpSourceExpression
SgOmpTargetDataCompositeStatement
SgOmpTargetDataStatement
SgOmpTargetEnterDataStatement
SgOmpTargetExitDataStatement
SgOmpTargetParallelForSimdStatement
SgOmpTargetParallelForStatement
SgOmpTargetParallelLoopStatement
SgOmpTargetParallelStatement
SgOmpTargetSimdStatement
SgOmpTargetStatement
SgOmpTargetTeamsDistributeParallelForSimdStatement
SgOmpTargetTeamsDistributeParallelForStatement
SgOmpTargetTeamsDistributeSimdStatement
SgOmpTargetTeamsDistributeStatement
SgOmpTargetTeamsLoopStatement
SgOmpTargetTeamsStatement
SgOmpTargetTeamsWorkdistributeStatement
SgOmpTargetUpdateStatement
SgOmpTaskReductionClause
SgOmpTaskStatement
SgOmpTaskgraphStatement
SgOmpTaskgroupClause
SgOmpTaskgroupStatement
SgOmpTaskloopSimdStatement
SgOmpTaskloopStatement
SgOmpTaskwaitStatement
SgOmpTaskyieldStatement
SgOmpTeamsDistributeParallelForSimdStatement
SgOmpTeamsDistributeParallelForStatement
SgOmpTeamsDistributeSimdStatement
SgOmpTeamsDistributeStatement
SgOmpTeamsLoopStatement
SgOmpTeamsStatement
SgOmpThreadBodyStatement
SgOmpThreadLimitClause
SgOmpThreadprivateStatement
SgOmpThreadsClause
SgOmpThreadsetClause
SgOmpTileStatement
SgOmpToClause
SgOmpTransparentClause
SgOmpUnifiedAddressClause
SgOmpUnifiedSharedMemoryClause
SgOmpUniformClause
SgOmpUnrollStatement
SgOmpUntiedClause
SgOmpUpdateClause
SgOmpUseClause
SgOmpUseDeviceAddrClause
SgOmpUseDevicePtrClause
SgOmpUsesAllocatorsClause
SgOmpUsesAllocatorsDefination
SgOmpVariablesClause
SgOmpWeakClause
SgOmpWhenClause
SgOmpWorkdistributeStatement
SgOmpWorkshareStatement
SgOmpWriteClause
SgOpaqueValueBinding
SgOpaqueValueReference
SgOpenStatement
SgOpenclAccessModeModifier
SgOptions This class represents an object used to initialize the unparsing.
SgOrOp
SgPackExpansionExpr
SgPlusAssignOp
SgPlusPlusOp
SgPntrArrRefExp
SgPointerAssignOp This class represents a Fortran pointer assignment. It is not
SgPointerDerefExp
SgPointerMemberType
SgPointerType
SgPragma
SgPragmaDeclaration A pragma declaration containing an SgPragma node.
SgPrintStatement
SgProcedureHeaderStatement
SgProcessControlStatement
SgProgramHeaderStatement
SgProject This class represents a source project, with a list of SgFile objects and global
SgPseudoDestructorRefExp
SgPseudoObjectExp
SgRangeBasedForStatement
SgRangeExp
SgReadStatement
SgRealPartOp
SgRefExp This class represents the "&" operator (applied to any lvalue).
SgReferenceType
SgRenamePair
SgRenameSymbol
SgRequirementSubstitutionFailure
SgRequiresExpr
SgReturnStmt A return statement with an optional expression.
SgRewindStatement
SgRshiftAssignOp
SgRshiftOp
SgRvalueReferenceType
SgSIMDAddOp
SgSIMDBinaryOp
SgSIMDBroadcast
SgSIMDDivOp
SgSIMDExplicitGather
SgSIMDFmaOp
SgSIMDGather
SgSIMDLoad
SgSIMDMulOp
SgSIMDPartialStore
SgSIMDScalarStore
SgSIMDScatter
SgSIMDStore
SgSIMDSubOp
SgScopeOp Represents the qualified name in a C++ pseudo-destructor call.
SgScopeStatement This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
SgShallowCopy Supporting class for "Shallow" copies of the AST. This class supports only shallow copies of the AST.
SgShortVal
SgSignedCharVal
SgSignedIntegralType
SgSimpleProcessing
SgSimpleRequirement
SgSizeOfOp This class represents the "sizeof()" operator (applied to any type).
SgSourceFile
SgSourceLocationBuiltinExp
SgSpaceshipOp
SgSpecialFunctionModifier
SgStatement This class represents the notion of a statement.
SgStatementAttribute
SgStatementAttributeList
SgStatementExpression This class represents the GNU extension "statement expression" (thus is
SgStatementFunctionStatement
SgStaticAssertionDeclaration
SgStorageModifier This class represents modifiers specific to storage.
SgStringKeyedBidirectionalGraph
SgStringVal
SgSubscriptExpression
SgSubtractOp
SgSupport This class represents the base class of a numbr of IR nodes that don't otherwise fit
SgSwitchStatement This class represents the concept of a switch.
SgSymbol This class represents the concept of a name within the compiler.
SgSymbolTable This class represents the symbol tables used in both SgScopeStatement and
SgSyncAllStatement
SgSyncImagesStatement
SgSyncMemoryStatement
SgSyncTeamStatement
SgSynthesizedAttribute
SgTemplateArgument This class represents template argument within the use of a template to build an instantiation.
SgTemplateClassDeclaration
SgTemplateClassDefinition
SgTemplateClassSymbol
SgTemplateDeclaration This class represents the concept of a template declaration.
SgTemplateFunctionDeclaration
SgTemplateFunctionDefinition
SgTemplateFunctionRefExp
SgTemplateFunctionSymbol
SgTemplateInstantiationDecl This class represents the concept of an instantiated class template.
SgTemplateInstantiationDefn This class represents the concept of a class definition in C++.
SgTemplateInstantiationDirectiveStatement This class represents the concept of a C++ template instantiation directive.
SgTemplateInstantiationFunctionDecl This class represents the concept of an instantiation of function template.
SgTemplateInstantiationMemberFunctionDecl This class represents the concept of an instantiation of member function template
SgTemplateInstantiationTypedefDeclaration
SgTemplateMemberFunctionDeclaration
SgTemplateMemberFunctionRefExp
SgTemplateMemberFunctionSymbol
SgTemplateParameter
SgTemplateParameterList
SgTemplateParameterVal
SgTemplateSymbol
SgTemplateType
SgTemplateTypedefDeclaration
SgTemplateTypedefSymbol
SgTemplateVariableDeclaration
SgTemplateVariableSymbol
SgThisExp This class represents the "this" operator (can be applied to any member data).
SgThrowOp C++ throw expression or rethrow.
SgToken
SgTopDownBottomUpProcessing
SgTopDownProcessing
SgTreeCopy Supporting class for "Deep" copies of the AST.
SgTreeTraversal
SgTryStmt This class represents the concept of try statement within the try-catch
SgType This class represents the base class for all types.
SgTypeBFloat16
SgTypeBool
SgTypeChar
SgTypeChar16
SgTypeChar32
SgTypeChar8
SgTypeComplex This class represents a C99 complex type.
SgTypeCrayPointer
SgTypeDefault A placeholder type.
SgTypeDependent
SgTypeDouble
SgTypeEllipse
SgTypeExpression
SgTypeFloat
SgTypeFloat128
SgTypeFloat16
SgTypeFloat32
SgTypeFloat32x
SgTypeFloat64
SgTypeFloat64x
SgTypeFloat80
SgTypeFortranAssumed
SgTypeFortranBOZ
SgTypeFortranUnlimitedPolymorphic
SgTypeFp16
SgTypeGlobalVoid
SgTypeIdOp
SgTypeImaginary This class represents a C99 complex type.
SgTypeInt
SgTypeLabel
SgTypeLong
SgTypeLongDouble
SgTypeLongLong
SgTypeModifier
SgTypeNullptr
SgTypeOfType
SgTypeRequirement
SgTypeShort
SgTypeSigned128bitInteger
SgTypeSignedChar
SgTypeSignedInt
SgTypeSignedLong
SgTypeSignedLongLong
SgTypeSignedShort
SgTypeString This class represents a string type used for SgStringVal IR node.
SgTypeTable
SgTypeTargetBuiltin
SgTypeTraitBuiltinOperator
SgTypeUnknown
SgTypeUnsigned128bitInteger
SgTypeUnsignedChar
SgTypeUnsignedInt
SgTypeUnsignedLong
SgTypeUnsignedLongLong
SgTypeUnsignedShort
SgTypeVoid
SgTypeWchar
SgTypedefDeclaration This class represents the notion of a typedef declaration.
SgTypedefSymbol
SgTypedefType
SgUnaryAddOp
SgUnaryOp This class represents the notion of a unary operator.
SgUnaryTransformType
SgUndefDirectiveStatement
SgUndirectedGraphEdge
SgUnlockStatement
SgUnparse_Info
SgUnsignedCharVal
SgUnsignedIntVal
SgUnsignedIntegralType
SgUnsignedLongLongIntVal
SgUnsignedLongVal
SgUnsignedShortVal
SgUseStatement
SgUserDefinedBinaryOp
SgUserDefinedUnaryOp
SgUsingDeclarationStatement This class represents the concept of a C++ using declaration.
SgUsingDirectiveStatement This class represents the concept of a C++ using directive.
SgValue
SgValueExp This class represents the notion of an value (expression value).
SgVarArgCopyOp
SgVarArgEndOp
SgVarArgOp
SgVarArgStartOneOperandOp
SgVarArgStartOp
SgVarRefExp This class represents the variable refernece in expressions.
SgVariableDeclaration This class represents the concept of a C or C++ variable declaration.
SgVariableDefinition This class represents the definition (initialization) of a variable.
SgVariableSymbol This class represents the concept of a variable name within the compiler (a
SgVariantExpression
SgVectorElementExp
SgVoidVal
SgWaitStatement
SgWarningDirectiveStatement
SgWcharVal
SgWhereStatement
SgWhileStmt This class represents a while statement.
SgWriteStatement
SgXorAssignOp
Sg_File_Info This class represents the location of the code associated with the IR node in the
Sg_Options
SideEffectAnalysisInterface
SimpleDirectedGraph This provides some simple support mechanisms to create a graph of SimpleDirectedGraphNodes.
SimpleDirectedGraphNode This is a node in the directed graph. All the connectivity information for the graph is captured in this (by way of the successor and predecessor sets).
SimpleFrontierDetectionForTokenStreamMapping
SimpleFrontierDetectionForTokenStreamMapping_InheritedAttribute
SimpleFrontierDetectionForTokenStreamMapping_SynthesizedAttribute
SimpleReferenceToPointerHandler
SingleIterator
SingleNodeCopyEdge
SingleNodeMoveEdge
SingleStatementToBlockNormalizer
SingleValBound
SinglyLinkedEntryWrap
SinglyLinkedListWrap
SlicingInfo
SourceQualification
SourceQualificationComponent
SplitStmtInfo
SplitStmtInfo2
StackFrameVector
StmtInfoCollect
StmtSideEffectCollect
StmtVarAliasCollect
StringDescriptor A descriptor for an identifier
StructLayoutEntry
StructLayoutInfo
Support
SwapNodeInfo
SwapStmtLoopInfo
SymbolicAnd
SymbolicAstWrap
SymbolicBound
SymbolicBoundAnalysis
SymbolicCond
SymbolicConst
SymbolicConstBoundAnalysis
SymbolicDotExp
SymbolicEq
SymbolicExpr
SymbolicExtendVar
SymbolicFunction
SymbolicFunctionDeclaration A symbolic function declaration with
SymbolicFunctionDeclarationGroup A list of symbolic function declarations, separated by ',', enclosed in '(..)'
SymbolicFunctionPtrCall
SymbolicMultiply
SymbolicNot
SymbolicOperands
SymbolicParamListDescriptor A list of parameter descriptors, separated by ',', enclosed in '(..)'
SymbolicPlus
SymbolicPow
SymbolicSelect
SymbolicSemanticConversion
SymbolicTerm
SymbolicVal
SymbolicValDescriptor SymbolicVal with I/O interface
SymbolicValGenerator * Symbolic Operator interface
SymbolicValImpl
SymbolicVar
SymbolicVisitor
SystemDependenceGraph
TaintAnalysis Taint Flow Analysis
TaintLattice A pointer to a vertex of the static taint lattice.
TerminalNamesType
TestAstAccessToDeclarations
TestAstForCyclesInTypedefs
TestAstForProperlyMangledNames
TestAstForProperlySetDefiningAndNondefiningDeclarations
TestAstForUniqueNodesInAST
TestAstForUniqueStatementsInScopes
TestAstProperties
TestAstPropertiesSA
TestAstSymbolTables
TestAstTemplateProperties
TestChildPointersInMemoryPool This traversal uses the Memory Pool traversal to test parent pointers.
TestExpressionTypes
TestFirstNondefiningDeclarationsForForwardMarking This tests the first non-defining, referenced from each declaration, to make sure that it is not a forward declaration (a non-defining declaration marked to be a forward declaration).
TestForMultipleWaysToSpecifyRestrictKeyword
TestForParentsMatchingASTStructure
TestForProperLanguageAndSymbolTableCaseSensitivity
TestForProperLanguageAndSymbolTableCaseSensitivity_InheritedAttribute
TestForReferencesToDeletedNodes
TestForSourcePosition
TestLValueExpressions
TestMangledNames
TestParentPointersInMemoryPool This traversal uses the Memory Pool traversal to test parent pointers.
TimingPerformance
TokenStreamHalfOpenInterval
TokenStreamMappingConstructionAccess
TokenStreamMappingConstructionKey
TokenStreamMappingContractTestAccess
TokenStreamSequenceToNodeMapping
TokenStreamSequenceToNodeMapping_key
TokenUnparseFrontierContext
TokenUnparseFrontierFileContext
TraceOnlyPerformance
TracingPerformance
TransAnalSCCCreate
TransDepAnalImpl
TransDepGraphCreate
TransInfoGraph ** This is the graph to store the result of transitive analysis. An object of this class is passed as argument to construct a GraphTransAnalysis operator, and as we invoke GraphTransAnalysis::ComputeTransInfo to compute transitive info between nodes of the input graph, the transitive info is stored into TransInfoGraph by calling TransInfoGraph::SetTransInfo. Users of GraphTransAnalysis must implement all three virtual functions defined TransInfoGraph, to record and return transitive information already computed. The template paramter T is the type of transitive information (the result of transitive analysis). It models information regarding transitive paths in the input graph
TransInfoOP
TransLoopDistributable
TransLoopFusible
TransLoopReversible
TransLoopSlicable
TransformAstTree Interface class for processing each AstNode from within the TransformAstTraverse function.
TraverseCallGraph
TraverseCallGraphDataflow
TraverseCallGraphUnordered
TreeNodeImpl
TreeTraversal
TreeTraverse
TypeAnnotCollection
TypeCollection A map storing types and their descriptors, the descriptor could be any instantiated types as a template class.
TypeDescriptor
TypedFusion
TypedFusionOperator
UF_elem
UnaryOPApplicator
UnaryOperator
UniqueArrayCollection
UnparseDelegate
UnparseFormat
UnparseFormatHelp
UnparseFortran_type
UnparseLanguageIndependentConstructs
UnparseQualificationSession
Unparse_Debug
Unparse_ExprStmt
Unparse_MOD_SAGE
Unparse_Type
Unparser Backend C and C++ code generator.
Unparser_Nameq
Unparser_Opt unparser_opt.h This class contains all options we want to have available when generating C++ code
UnstructuredPassInterAnalysis
UnstructuredPassInterDataflow ** UnstructuredPassInterDataflow ***** The trivial inter-procedural dataflow where a intra-procedural ***** dataflow analysis is executed once on every function in the ***** application, with no guarantees about how dataflow information ***** is transmitted across function calls. ***
UnstructuredPassIntraAnalysis **** UnstructuredPassAnalyses *****
UpdateDefUseChainNode
UpdateDepEdgeInfo
UpdateDepInfo
ValTermVisitor
ValueAnnotation
ValuePropagate
ValuePropagateNode
VarInfo
VarUniqueName Class holding a unique name for a variable. Is attached to varRefs as a persistent attribute. This is used to assign absolute names to VarRefExp nodes during VariableRenaming.
VariableRenaming Class that defines an VariableRenaming of a program
VariableStateTransfer
VariantVector
VarsExprsProductLattice
VectorHash
VirtualFunctionAnalysis Virutal Function Analysis and PointerAliasAnalysis are dependent on each other for their accuracy. That's why they are done together
VirtualGraphCreateTemplate
Visitor_R
VoidPtrSet
WriteContainer Output interface of a container
X86_64PrimitiveTypeLayoutGenerator Layout generator for x86-64 primitive types
XOMP_mapped_variable
astDiagnostics AST diagnostics
ast_construction AST construction
attributes User analysis attributes
backendGenerator Backend C and C++ Code Generator
builtinFilter A function object to filter out builtin functions in a call graph (only non-builtin functions will be considered)
defaultConstructorDestructorDocumentationPage Default constructors and destructors
developer_docs Library developers and collaborators
dottable
dummyFilter A function object to be used as a predicate to filter out functions in a call graph: it does not filter out anything.
eqstr Name equality operator support for symbol tables within ROSE.
file_pos_info
frontendSageHighLevelInterface High level AST builders
generateDOTExtended
generateDOTExtended_withIncludes
generateDOTExtendedforMultipleFile
hash_Name Hash name support for symbol tables within ROSE.
heap_object_ownership Ownership of AST nodes and heap-allocated payloads
how_to_document Writing documentation
localNodeQueryLib Local Node Query Library
nameQueryLib Name Query Library
nodeQueryLib Node Query Library
printAnalysisStates
printDataflowInfoPass ** printDataflowInfoPass ***** Prints out the dataflow information associated ***** with a given analysis for every CFG node a ***** function. ***
printable
queryLib Query Library
rex_mainpage REX overview
rose_backend Backend
rose_frontend Frontend
rose_graph_integer_edge_hash_map
rose_graph_integer_edge_hash_multimap
rose_graph_integer_node_hash_map
rose_graph_integerpair_edge_hash_multimap
rose_graph_string_integer_hash_multimap
rose_hash_multimap
rose_midend Midend
stmt_pos
stream_element
subtreeQueryLib Subtree Query Library
token_element
varID

Type Aliases

Name Description
AST_NODE_ID
AstNodeList
AstNodePtrImpl
AstTypeList
AttachedPreprocessingInfoType
BaseGraphEdge
BaseGraphNode
CallGraphExplicitInstantiationSourceIndex
ClangTemplateParameterMap
CompSliceDepGraph
CompSliceDepGraphNodeIterator
DDE
DeclarationPtrList
DepEDD
DepInfoConstIterator
DepInfoConstIteratorImpl
DepInfoEdgeIterator
DepInfoEdgeIteratorImpl
DepInfoSetEdgeIterator
DepInfoSetEdgeIteratorImpl
DomainCondConstIterator
DomainCondConstIteratorImpl
DummyAttribute
FormatOpt
GraphAccessInterface
LexTokenStreamType
LexTokenStreamTypePointer
LoopTreeDepGraph
LoopTreeNodeIterator
LoopTreeNodeIteratorImpl
LoopTreeTransDepGraphCreate
MLOG_LEVEL_t
MacroDirectiveMap
NameGroup a set of names separated by ',', begin with '(', end with ')'
NameQuerySynthesizedAttributeType
NodeQuerySynthesizedAttributeType
NumberQuerySynthesizedAttributeType
OperatorAliasDescriptor A container of std::list<> of elment of NameGroup type
OperatorCollectionBase
ParamDescriptor Paramter names
ParamTypeDescriptor Parameter types
PatternVariables
PrecedenceSpecifier
ROSEAttributesListContainerPtr
RTIReturnType
ReachingDefinitions
ReadOperatorCollection
ReadTypeCollection
RestrictValueDescriptor
RoseTimeType This is a mechanism for reporting the performance of processing of the AST, subtrees, and IR nodes.
SgAccClausePtrList
SgAlignmentSpecifierPtrList
SgAttributePtrList
SgBaseClassPtrList
SgBitVector
SgCharList
SgCommonBlockObjectPtrList
SgCxxLiteralTokenPtrList
SgDataStatementGroupPtrList
SgDataStatementObjectPtrList
SgDataStatementValuePtrList
SgDeclarationScopePtrList
SgDeclarationStatementPtrList
SgDimensionObjectPtrList
SgDirectoryPtrList
SgExpressionPtr
SgExpressionPtrList
SgFileId
SgFileIdList
SgFileLineNumber
SgFileLineNumberList
SgFilePtrList
SgFormatItemPtrList
SgFortranImplicitRangePtrList
SgFunctionTypeArgumentPtrList
SgIncludeFilePtrList
SgInitializedNamePtr
SgInitializedNamePtrList
SgInterfaceBodyPtrList
SgLabelSymbolPtrList
SgLambdaCapturePtrList
SgModifierTypePtrVector
SgNameGroupPtrList
SgNodePtrList
SgNodeSet
SgOmpAppendArgsOperationPtrList
SgOmpApplyTransformationPtrList
SgOmpClausePtrList
SgOmpContextSelectorPropertyPtrList
SgOmpContextSelectorPtrList
SgOmpContextSelectorSetPtrList
SgOmpInductionItemPtrList
SgOmpInitModifierPtrList
SgOmpIteratorDefinitionPtrList
SgOmpMapDistDataPolicyPtrList
SgOmpSectionStatementPtrList
SgOmpUsesAllocatorsDefinationPtrList
SgOpaqueValueBindingPtrList
SgRenamePairPtrList
SgStatementAttributePtrList
SgStatementPtr
SgStatementPtrList
SgStringCodeUnitList
SgStringList
SgTemplateArgumentPtrList
SgTemplateParameterListPtrList
SgTemplateParameterPtrList
SgTokenPtrList
SgTypePtrList
SgUnorderedMapNodeToString
SgUnorderedNodeSet
SgUnsignedCharList
SgVarRefExpPtrList
SliceCFGEdge
SliceCFGNode
SliceDominanceFrontier
SliceDominatorTree
SymbolBasisExactIndex
SymbolStoredNameMap
TypeCollectionBase Instance types for type annotations
UnparsePreprocessingInfoRewriteMap
VariantTList
_DummyAttribute
kmp_sched_t
replacement_map_t
rose_graph_integer_edge_hash_map_base_type Hash table support for graph IR nodes within ROSE (used to lookup edges using edge index values).
rose_graph_integer_edge_hash_multimap_base_type Hash table support for graph IR nodes within ROSE (used to lookup edges using edge index values).
rose_graph_integer_node_hash_map_base_type Hash table support for graph IR nodes within ROSE (used to lookup nodes using node index values).
rose_graph_integerpair_edge_hash_multimap_base_type Hash table support for graph IR nodes within ROSE (used to lookup edges using node index pairs).
rose_graph_string_integer_hash_multimap_base_type Hash table support for looking up graph indices by label.
stmt_pos_list
varIDSet

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

Variables

Name Description
Cxx_GrammarTerminalNames
DDE_head
DDE_tail
ROSE_BUILD_CLANG_INCLUDE_STAGING_DIR
ROSE_BUILD_CPU
ROSE_BUILD_LIB_DIR
ROSE_BUILD_OS
ROSE_BUILD_TREE
ROSE_CONFIGURE_DATE
ROSE_DEBUG
ROSE_INSTALL_CLANG_INCLUDE_DIR
ROSE_INSTALL_INCLUDE_DIR
ROSE_INSTALL_LIB_DIR
ROSE_INSTALL_PREFIX
ROSE_SOURCE_TREE
allVar
analysisDebugLevel
divAnalysisDebugLevel
liveDeadAnalysisDebugLevel
mlogLevel
mlogLevelToString_C
oneVar
p_wildcard Match anything
roseGlobalVariantNameList
rose_ClassHierarchyCastTable
simd_arch
target_outlined_function_list
target_outlined_struct_list
xomp_cuda_prop
xomp_max_num_devices
xomp_num_devices
zeroVar

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

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

AstQueryNamespace::detail namespace

Types

Name
is_invocable
is_invocable_impl
make_void

Type Aliases

Name
invoke_result_t
void_t

Functions

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

AstUtilInterface namespace

Types

Name Description
CollectDependences
CollectTransitiveDependences
DependenceEntry
DependenceTable Stores dependence entries in a table.
SaveOperatorSideEffectInterface
SaveOperatorSideEffectIntoVectors
SelectDependences
WholeProgramDependenceAnalysis

Enums

Name
OperatorSideEffect

Functions

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

CPreproc 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
dump
void dump(Ifs_t const ifs);
dump overloads
extractIfDirectives
void extractIfDirectives( SgNode* root, Ifs_t& ifs);
Extracts the '#if' directive structure from a project.
findIfDirectiveContext
void findIfDirectiveContext( SgLocatedNode const* target, Ifs_t& ifs, If::Case*& top, If::Case*& bottom);
Locate the '#if' directive context at a node.

CallTargetSet namespace

Functions

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

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

DUVariableAnalysisExt namespace

Functions

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

Dbg namespace

Types

Name
dbgBuf
dbgStream

Functions

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

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

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

NewCallGraph namespace

Types

Name
CallGraph
CallGraphEdgeInfo
CallGraphFileStructure
CallGraphNodeInfo

Functions

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

NodeQuery namespace

Type Aliases

Name
QueryDepth
roseFunctionPointerOneParameter

Enums

Name
TypeOfQueryTypeOneParameter

Functions

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

NumberQuery namespace

Type Aliases

Name
roseFunctionPointerOneParameter

Enums

Name
TypeOfQueryTypeOneParameter

Functions

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

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

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

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

ProcessExpression namespace

Functions

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

ROSE_Analysis namespace

Functions

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

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
expressionHasSemanticValueType
bool expressionHasSemanticValueType( VariantT kind, bool unevaluated_string);
namedTypeScopeHasCrossTranslationUnitIdentity
bool namedTypeScopeHasCrossTranslationUnitIdentity(SgScopeStatement* scope);
resolvedClassType
SgClassType* resolvedClassType( SgType* type, bool strip_indirection = false);
selectedDestructorClass
SgClassType* selectedDestructorClass(SgMemberFunctionDeclaration* destructor);
temporaryStorageMatchesOwner
bool temporaryStorageMatchesOwner( SgExpression::temporary_storage_duration_enum storage, VariantT scope, bool static_storage, bool thread_storage);

Rose::AstJson namespace

Types

Name
AggregateConstructionFields
ArrayInitBindingScope
ArrayInitReferenceFields
AsmOperandConstructionFields
AsmStatementConstructionFields
AssignmentInitializerSourceFields
AstFileRecord
CastConstructionFields
CollectionBoundaryGuard
DeclarationFields
DeclarationNameQualificationFields
DeclarationSourceFields
DeserializationProjectGuard
EdgeRecord
ExpectedSymbolTablePreference
ExpressionConstructionFields
ExpressionQualificationFields
ExpressionSourceFields
ExternalClassDeserializationIdentityGuard
ExternalDeclarationFields
ExternalFunctionDeserializationIdentityGuard
ExternalInitializedNameFields
FileInfoFields
FoldConstructionFields
FormatItemFields
FortranInterfaceFields
FullTypeDeserializationIdentityGuard
FullTypeSerializationIdentityGuard
FunctionCallSourceFields
FunctionModifierFields
FunctionReturnTypeSourceFields
FunctionTypeDeserializationIdentityGuard
InitializedNameMetadata
InitializedNameRoles
InlineExpressionConstruction
JsonKey
JsonMember
JsonObject
JsonValue
LabelSymbolFields
LiteralTokenFields
NewConstructionFields
NodeConstructionFlags
NodeRecord
OmpClauseFields
OmpContextPropertyFields
OmpContextSelectorFields
OpaqueBindingScope
OpaqueValueFields
Options
PointerMemberTypeDeserializationIdentityGuard
PointerMemberTypeSerializationIdentityGuard
PreprocessingInfoFields
RecordNodeConstruction
RecordNodeConstructionScope
ReturnStatementFields
SemanticArrayConstruction
SemanticArrayConstructionScope
SerializedSymbolTableConstruction
SerializedSymbolTableEntry
SourceDeclaratorScopeConstruction
SourcePositionFields
SourcePositions
SourceTypeConstruction
SourceTypeConstructionScope
StatementFields
SubtreeBoundaryGuard
SymbolTableEntryJson
TemplateParameterOperands
TemplateParameterSourceFields
TemplateTypeDeserializationIdentityGuard
TypeModifierFields
TypeSerializationContext
TypedefMetadata
UnaryConstructionFields
UnaryTraitSourceFields
VisibilitySymbolFields

Type Aliases

Name
FloatingValueBits
NodeIds
NodeMap
OmpContextPropertyIdentity
OmpContextSelectorIdentity
PreparedAstAttributes
PreparedPreprocessingInfo
SerializedSymbolTableRecords
SymbolConstructionAdvance
SymbolTablePreferenceGroups

Enums

Name
Checkpoint
ExternalFunctionParameterScopeOwner
LabelSymbolBasisKind
OperandRequirementKind

Functions

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

Variables

Name
collectionBoundaryFile
collectionBoundaryRoot
currentDeserializationClassDeclarationCache
currentDeserializationProject
currentTypeSerializationNode
kFormat
kSchemaVersion
serializingTypeOwnedExpression

Rose::Builder namespace

Namespaces

Name
Templates

Rose::Builder::Templates namespace

Functions

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

Rose::BuiltinOperands namespace

Functions

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

Rose::ClangFrontend namespace

Types

Name
ChooseExprOperands

Functions

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

Rose::Cmdline 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
NormalizeIncludePathOptions
std::vector<std::string> NormalizeIncludePathOptions(std::vector<std::string>& argv);
Convert -I <path> to -I<path>
normalizeAndAppendIncludeOption
template< typename IndexType, typename CountType, typename NextArgumentProvider> IncludeOptionParseResult normalizeAndAppendIncludeOption( std::string const& current_arg, IndexType& index, CountType arg_count, NextArgumentProvider&& next_argument, std::vector<std::string>& output_args);

Variables

Name
verbose

Rose::Cmdline::Fortran namespace

Functions

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

Rose::Cmdline::Gnu namespace

Functions

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

Rose::Cmdline::Unparser namespace

Functions

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

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

Rose::FortranLex namespace

Functions

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

Rose::FortranLineWrapSupport namespace

Functions

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

Rose::FortranSource namespace

Types

Name
Context

Enums

Name
EditReason
ProgramUnitBoundary

Functions

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

Rose::Frontend namespace

Functions

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

Rose::MemPool namespace

Functions

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

Rose::OpenMP namespace

Namespaces

Name
Detail

Functions

Name
isNonnegativeConstantInteger
bool isNonnegativeConstantInteger(SgExpression* expression);

Rose::OpenMP::Detail namespace

Types

Name
MapModifierFields

Enums

Name
InitModifierContext

Functions

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

Rose::StringUtility 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.
isContainedIn
bool isContainedIn( std::string const& longString, std::string const& shortString);
Determines whether one string contains another.
isLineTerminated
[[visibility("default")]] bool isLineTerminated(std::string const& s);
Returns true if the string ends with line termination.
join
template<class Container> std::string join( char separator, Container const& container);
join_range
template<class Iterator> std::string join_range( std::string const& separator, Iterator begin, Iterator end);
Join individual items to form a single string.
jsonEscape
[[visibility("default")]] std::string jsonEscape(std::string const&);
Escapes characters that are special inside a JSON string.
leftJustify
[[visibility("default")]] std::string leftJustify( std::string const& input, size_t width, char fill = ' ');
Left justify a string to specified width.
listToString
[[visibility("default")]] std::string listToString( std::list<int> const&, bool separateStrings = false);
listToString overloads
makeOneLine
[[visibility("default")]] std::string makeOneLine( std::string const& s, std::string replacement = " ");
Converts a multi-line string to a single line.
numberToString
[[visibility("default")]] std::string numberToString(__int128 x);
numberToString overloads
operator+
FileWithLineNumbers operator+( FileWithLineNumbers const& a, FileWithLineNumbers const& b);
Concatenate vectors of strings with source location.
operator+=
FileWithLineNumbers& operator+=( FileWithLineNumbers& a, FileWithLineNumbers const& b);
Append strings with source location information to vector of such.
prefixLines
[[visibility("default")]] std::string prefixLines( std::string const& lines, std::string const& prefix, bool prefixAtFront = true, bool prefixAtBack = false);
Insert a prefix string before every line.
readFile
[[visibility("default")]] std::string readFile(std::string const& fileName);
Reads entire text file.
readFileWithPos
[[visibility("default")]] FileWithLineNumbers readFileWithPos(std::string const& fileName);
Reads an entire text file.
removeAnsiEscapes
[[visibility("default")]] std::string removeAnsiEscapes(std::string const&);
Remove ANSI escape characters.
removeRedundantSubstrings
[[visibility("default")]] std::string removeRedundantSubstrings(std::string const&);
Remove redundant and blank lines.
replaceAllCopy
[[visibility("default")]] std::string replaceAllCopy( std::string const& input, std::string const& search, std::string const& replacedWith);
Replace every occurrence of a nonempty pattern in a string.
rightJustify
[[visibility("default")]] std::string rightJustify( std::string const& input, size_t width, char fill = ' ');
Right justify a string to specified width.
signedToHex
template<typename T> std::string signedToHex(T value);
signedToHex2
[[visibility("default")]] std::string signedToHex2( uint64_t value, size_t nbits);
split
[[visibility("default")]] std::vector<std::string> split( char separator, std::string const& str, size_t maxparts = UNLIMITED, bool trim_white_space = false);
Splits strings into parts.
splitStringIntoStrings
[[visibility("default")]] void splitStringIntoStrings( std::string const& inputString, char separator, std::vector<std::string>& stringList);
Splits string into substring based on a separator character.
stringToList
[[visibility("default")]] std::list<std::string> stringToList(std::string const&);
Split a string into substrings at line feeds.
stripDotsFromHeaderFileName
[[visibility("default")]] std::string const stripDotsFromHeaderFileName(std::string const& name);
Remove leading dots.
stripFileSuffixFromFileName
[[visibility("default")]] std::string stripFileSuffixFromFileName(std::string const& fileNameWithSuffix);
Get the file name without the ".suffix".
stripPathFromFileName
[[visibility("default")]] std::string stripPathFromFileName(std::string const& fileNameWithPath);
Returns the last component of a path in a filesystem.
toHex2
[[visibility("default")]] std::string toHex2( uint64_t value, size_t nbits, bool show_unsigned_decimal = true, bool show_signed_decimal = true, uint64_t decimal_threshold = 256);
Convert a number to a hexadecimal and decimal string.
toNumber
template<typename T> NumberParseResult<T> toNumber(std::string const& input);
toString
[[visibility("default")]] std::string toString( FileWithLineNumbers const& strings, std::string const& filename = "<unknown>", int line = 1);
Generate C preprocessor #line directives.
tokenize
[[visibility("default")]] std::list<std::string> tokenize( std::string const&, char delim);
Split a string into a list based on a separator character.
trim
[[visibility("default")]] std::string trim( std::string const& str, std::string const& strip = " \t\r\n", bool at_beginning = true, bool at_end = true);
Trims white space from the beginning and end of a string.
unsignedToHex
template<typename T> std::string unsignedToHex(T value);
unsignedToHex2
[[visibility("default")]] std::string unsignedToHex2( uint64_t value, size_t nbits);
writeFile
[[visibility("default")]] void writeFile( std::string const& outputString, std::string const& fileNameString, std::string const& directoryName);
Create a file.
operator<<
std::ostream& operator<<( std::ostream& os, StringWithLineNumber const& s);
Stream insertion operators

Rose::TestOutput namespace

Namespaces

Name
detail

Functions

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

Rose::TestOutput::detail namespace

Functions

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

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

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

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

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

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

WalrusGraph namespace

Functions

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

cfgUtils namespace

Functions

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

legacy namespace

Namespaces

Name
PRE

Functions

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

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

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
accessTypeToStr
std::string accessTypeToStr(accessType t);
addRWAnnotations
void addRWAnnotations(SgNode* root);
cloneAccessType
void cloneAccessType( SgNode* tgt, SgNode* src);
getAccessType
accessType getAccessType(SgNode* n);

sg namespace

This namespace contains template functions that operate on the ROSE AST

Types

Name
AncestorTypeFinder
DefaultHandler
DispatchHandler
VisitDispatcher

Functions

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

Created with MrDocs