Types

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

AstDiagnosticsClasses

AST Diagnostics

AstInheritedAttribute

AstIntAttribute

AstInterface

provides an abstract interface to access/modify AST nodes.

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

AstProperties

AST Properties (Consistency Tests)

AstRegExAttribute

Attribute containing a regex expression as a string.

AstRestructure

AstReverseBranchInhProcessing

AstReverseBranchInhSynProcessing

///////////////////////////////////////////////////////////////////////////////////////

AstReverseBranchSimpleProcessing

///////////////////////////////////////////////////////////////////////////////////////

AstReverseBranchSynProcessing

AstReversePrefixInhProcessing

///////////////////////////////////////////////////////////////////////////////////////

AstReversePrefixInhSynProcessing

AstReversePrefixSimpleProcessing

///////////////////////////////////////////////////////////////////////////////////////

AstReversePrefixSynProcessing

AstSgNodeAttribute

Attribute storing an SgNode.

AstSimpleProcessing

Class for traversing the AST.

AstSuccessorsSelectors

AstSynthesizedAttribute

AstTerm

AstTests

AstTextAttribute

AstTextAttributesHandling

AstTopDownBottomUpProcessing

Attribute evaluator for inherited and synthesized attributes.

AstTopDownProcessing

Attribute evaluator for inherited attributes.

AstTreeDepGraphAnal

AstTreeDepGraphBuildImpl

AstTreeReplaceVar

AstUnparseAttribute

AstValueAttribute

IR node attribute that stores a copyable value.

AstWarnings

This is a mechanism for reporting warnings about the AST, subtrees, and IR nodes.

AttachAllPreprocessingInfoTreeTrav

AttachPreprocessingInfoTreeTrav

AttachPreprocessingInfoTreeTraversalInheritedAttrribute

AttachPreprocessingInfoTreeTraversalSynthesizedAttribute

AutoTuningInterface

BaseGraphCreate

BaseGraphCreateWrap

BetterReuseFusionAnal

BitVectorRepr

BitVectorReprBase

BitVectorReprBase<basic_string<char>, pair<AstNodePtr, AstNodePtr>>

BitVectorReprGenerator

*** Commonly used lattices ****

BoolDescriptor

BooleanQuery

Simplifies development of queries on the AST resulting in a single boolean value.

BooleanQueryInheritedAttributeType

BooleanQueryReverseTraversalInheritedAttribute

BooleanQueryReverseTraversalSynthesizedAttribute

BooleanSafeKeeper

BottomUpTraversalLivenessIN

BottomUpTraversalLivenessOUT

BreakupStatement

BuildAstTreeDepGraph

BuildCFGConfig

BuildCFGTraverse

BuildListOfConnectedNodesInAST

BuildListOfNodesInAST

ChainableTypeLayoutGenerator

Basic type layout engine ‐‐ handles bookkeeping, plus handing typedefs and

ClangToDotNextPreprocessorToInsert

ClangToDotPreprocessorInserter

ClangToDotPreprocessorRecord

ClangToDotTranslator

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

CodeVar

Collect2Object

CollectAliasRelations

Helper class to collect Alias Relations

CollectDoublyLinkedList

CollectFunctions

CollectObject

CollectPair

A pair of items separated by 'sep'

CollectSinglyLinkedList

CollectTemplateInstantiationsMarkedForOutput

CollectionHelper

CompReprBase

CompReprPtr

A Shared Pointer Wrapper for CompactRepresentation

CompSlice

CompSliceAlignInfo

CompSliceDeleteInfo

CompSliceDepGraphCreate

CompSliceDepGraphNode

CompSliceFuseInfo

CompSliceImpl

CompSliceLocalityAnal

CompSliceLocalityRegistry

CompSliceLoop

CompSliceNest

CompSliceNestAlignEntryInfo

CompSliceNestDeleteEntryInfo

CompSliceNestDeleteInfo

CompSliceNestDuplicateEntryInfo

CompSliceNestFusionInfo

CompSliceNestObserveInfo

CompSliceNestObserver

CompSliceNestSwapInfo

CompSliceObserveInfo

CompactRepresentation

CompareObject

CompilerOutputParser

CompilerOutputReader

ConstrGraph

ConstrGraphAnalysis

ContainerDescriptor

ContextInsensitiveInterProceduralDataflow

ControlDependenceGraph

CopyArrayConfig

CopyArrayOperator

CopyArraySpec

CopyArrayUnderSizeLimit

CustomAstDOTGeneration

CustomAstDOTGenerationData

CustomAstDOTGenerationEdgeType

CustomAstDOTGenerationNodeType

CustomMemoryPoolDOTGeneration

CustomMemoryPoolDOTGenerationData

CustomizedPrimitiveTypeLayoutGenerator

Layout generator for customized primitive types.

CxxCodeGenerator

Backend Cxx Code Generator

DAG

DAG<DAGBaseNodeImpl, DAGBaseEdgeImpl>

DAGEdge<DAGBaseNodeImpl, DAGBaseEdgeImpl>

DAGNode

DAGNode<DAGBaseNodeImpl, DAGBaseEdgeImpl>

**

stl graph class for directed and undirected graphs

DOTGraphNode

**

DOTInheritedAttribute

DOTRepresentation

DOTRepresentation<SgNode*>

DOTSubgraphRepresentation

dot file representation with subgraphs

DOTSynthesizedAttribute

DS

DataDependenceGraph

DefUseAnalysisAbstract

DefineVariableDescriptor

DeleteEmptyOperatorNodes

DepCompAstRefGraphCreate

DepCompAstRefGraphNode

DepCompCopyArrayCollect

DepCompCopyArrayToBuffer

DepCompDistributeLoop

DepEDD

Extended dependence matrix:

DepInfo

DepInfoAlignLoop

DepInfoAnal

DepInfoAnalInterface

DepInfoEdge

DepInfoEdgeConstInfoIterator

DepInfoRestrictDomain

DepInfoSet

DepInfoSetEdge

DepInfoSetGenerator

DepInfoSetGraphCreate

DetectMacroOrIncludeFileExpansions

DetectMacroOrIncludeFileExpansionsInheritedAttribute

DetectMacroOrIncludeFileExpansionsSynthesizedAttribute

DetectTransformations

There sould not be any IR nodes marked as a transformation coming from the legacy frontend/ROSE translation. This test enforces this.

DirectedEdgeInterface

DirectedGraph

DirectedGraph<DAGBaseNodeImpl, DAGBaseEdgeImpl>

DirectedGraph<DGBaseNodeImpl, DGBaseEdgeImpl>

DirectedGraphEdge

DirectedGraphEdge<DAGBaseNodeImpl, DAGBaseEdgeImpl>

DirectedGraphEdge<DGBaseNodeImpl, DGBaseEdgeImpl>

DirectedGraphNode

DirectedGraphNode<DAGBaseNodeImpl, DAGBaseEdgeImpl>

DirectedGraphNode<DGBaseNodeImpl, DGBaseEdgeImpl>

DistNodeInfo

DistributedMemoryAnalysisPostTraversal

DistributedMemoryAnalysisPreTraversal

DivAnalysis

DivAnalysisTransfer

DoublyLinkedEntryWrap

DoublyLinkedListWrap

DoublyLinkedListWrap<CopyArrayUnit>

DoublyLinkedListWrap<DataEntry>

DoublyLinkedListWrap<SymbolicTerm>

DoublyLinkedListWrap<DAGBaseEdgeImpl*>

DoublyLinkedListWrap<DAGBaseNodeImpl*>

DoublyLinkedListWrap<DGBaseEdgeImpl*>

DoublyLinkedListWrap<DGBaseNodeImpl*>

DoublyLinkedListWrap<LoopTreeNode*>

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

FindAllNodesAnalysis

FiniteLattice

FiniteProductLattice

FiniteVariablesProductLattice

FiniteVarsExprsProductLattice

FixUpGlobalFunctionTypeTable

FixupAstDeclarationScope

FixupAstDefiningAndNondefiningDeclarations

FixupAstSymbolTables

FixupAstSymbolTablesToSupportAliasedSymbols

FixupDeclarations

Initialize the definingDeclaration and firstNondefiningDeclaration pointers in SgDeclarationStatement consistantly for all declarations. Also fixup special case of multiple forward declaration where only the first one (the firstNondefiningDeclaration) get a valid pointer to the defining declaration if it exists.

FixupEnumValues

This traversal uses the Memory Pool traversal to fixup the enum declarations referenced in the enum values (SgEnumVal).

FixupFortranReferences

FixupFortranUseDeclarations

FixupFriendDeclarations

This traversal uses the Memory Pool traversal to fixup the friend specifications on all declarations.

FixupFriendTemplateDeclarations

FixupFunctionDefaultArguments

FixupFunctionDefaultArgumentsInheritedAttribute

Inherited attribute required for FixupFunctionDefaultArguments class.

FixupFunctionDefinitions

FixupInClassDataInitialization

Modified const double variable initialized in‐class to be static const double with initializer.

FixupInitializersUsingIncludeFilesInheritedAttribute

Inherited attribute required for FixupInitializers class.

FixupInitializersUsingIncludeFilesSynthesizedAttribute

FixupInitializersUsingIncludeFilesTraversal

Fixup known ways in which inlcude files are used to initialized variable.

FixupNullPointersInAST

Fixup pointers in the AST that user's may have left as NULL, but should not be NULL.

FixupPrettyFunctionVariables

This traversal uses inherited attributes to fixup the variables put into the AST that match the function name (a legacy frontend quirk to signal that the variable name is "*PRETTY_FUNCTION*").

FixupPrettyFunctionVariablesInheritedAttribute

FixupSelfReferentialMacrosInAST

Fixup known macros that reference themselves and cause recursive macro expansion in the generated (unparsed) code.

FixupSourcePositionConstructs

This traversal uses the Memory Pool traversal to fixup the source position constructs.

FixupSourcePositionInformation

FixupSourcePositionInformationInheritedAttribute

FixupSourcePositionInformationSynthesizedAttribute

FixupStorageAccessOfForwardTemplateDeclarations

Fixup the storage access of all compiler‐generated forward declarations (non‐defining declarations) to match that of the defining declaration.

FixupTemplateArguments

FixupTemplateDeclarations

FixupTemplateInstantiations

FixupTypeReferencesOnMemoryPool

FixupforGnuBackendCompiler

Recognize and eliminate redundent calls to the same casting operator (or constructor initializer)

FortranCodeGeneration_locatedNode

FortranCodeGenerator

Backend Fortran Code Generator

FrontierDetectionForTokenStreamMapping

FrontierDetectionForTokenStreamMappingAttribute

FrontierDetectionForTokenStreamMapping_InheritedAttribute

FrontierDetectionForTokenStreamMapping_SynthesizedAttribute

FrontierNode

Function

FunctionAliasInterface

FunctionCallInfo

Stores a function call expression, along with associated information about its context.

FunctionCallInheritedAttribute

FunctionCallNormalization

FunctionData

FunctionDependenceGraph

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

FuseLoopInfo

FusionInfo

GetOneFuncDeclarationPerFunction

GlobalVarAnalysis

GraphAccess

GraphAccessTemplate

GraphAccessTemplate<void, void>

GraphAccessWrapTemplate

GraphCrossEdgeIterator

GraphDotOutput

GraphEdgeIterator

GraphGetNodeReachable

GraphNodePredecessorIterator

GraphNodeSuccessorIterator

GraphReverseEdge

GraphSelect

GraphTransAnalysis

Graph_TokenMappingTraversal

HoldAncesLoopObserver

HoldLoopAlignObserver

HoldTreeNodeObserver

I386PrimitiveTypeLayoutGenerator

Layout generator for i386 primitive types

I386_VSPrimitiveTypeLayoutGenerator

Slight modification for Visual Studio ‐‐ doubles are 8‐byte aligned

IRCallsiteIterator

IRCallsiteParamIterator

IncludedFilesUnparser

IncludingPreprocessingInfosCollector

InfiniteLattice

InfiniteProductLattice

InfiniteVariablesProductLattice

InfiniteVarsExprsProductLattice

InitDataflowState

InitializeExplicitScopes

Support for initialization of explicit scopes (located only at specific IR nodes).

InnerLoopReuseBlocking

InnermostLoopFission

InsertFortranContainsStatement

InterProcDataFlowAnalysis

InterProcVariableUniqueRepr

InterProceduralAnalysis

InterProceduralDataflow

* Dataflow Analyses **

IntermediateRepresentationNodeGraph

InterproceduralInfo

IntraBWDataflow

IntraDFTransferVisitor

Apply an analysis A's transfer function at a particular AST node type

IntraFWDataflow

IntraPartitionDataflow

IntraPartitionDataflowCheckpoint

IntraPartitionFWDataflow

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

JavaCodeGenerator

Backend Java Code Generator

LDVAExpressionTransfer

Visits live expressions ‐ helper to LiveDeadVarsTransfer

LanguageIndependentCodeGenerator

Backend Language Independent Code Generator

Lattice

LatticeElemList

LatticeElemList<SymbolicTerm>

LatticeElemMerge

LinearizeAST

LinearizeInheritedAttribute

LiveDeadVarsAnalysis

LiveDeadVarsTransfer

LoopTransformInterface

*QY: Singular interface class which remembers configurations for loop optimizations**

LoopTransformOptions

LoopTreeBlockLoop

LoopTreeBlockLoopNode

LoopTreeBuild

LoopTreeCodeGenInfo

LoopTreeCopyArray

LoopTreeCopyArrayToBuffer

LoopTreeCreate

LoopTreeDepComp

LoopTreeDepCompCreate

LoopTreeDepCompSubtree

LoopTreeDepGraphCreate

LoopTreeDepGraphNode

LoopTreeDepGraphSubtree

LoopTreeDistributeNode

LoopTreeDummyNode

LoopTreeEmbedStmt

LoopTreeGetVarBound

LoopTreeGetVarConstBound

LoopTreeIfCond

LoopTreeInterface

LoopTreeLocalityAnal

LoopTreeLoopNode

LoopTreeMergeLoop

LoopTreeMergeStmtLoop

LoopTreeNode

LoopTreeNodeDepMap

LoopTreeObserveImpl

LoopTreeObserveInfo

LoopTreeObserver

LoopTreeRelateLoopIvar

LoopTreeReplAst

LoopTreeReplLoopVar

LoopTreeReplaceAst

LoopTreeRestrLoopRange

LoopTreeRoot

LoopTreeShadowCreate

LoopTreeShadowNode

LoopTreeShadowSelect

LoopTreeSplitStmt

LoopTreeStmtNode

LoopTreeSwapNodePos

LoopTreeTransform

LoopTreeTraverse

LoopTreeTraverseSelectLoop

LoopTreeTraverseSelectStmt

MakeUniqueVarGetBound

MarkAsCompilerGenerated

Mark an AST subtree as compiler generated (used for instatiated templates generated by ROSE as specializations).

MarkBackendSpecificFunctionsAsCompilerGenerated

Supporting traversal to mark an backend specific functions as compiler generated.

MarkForOutputInCodeGeneration

Mark an AST subtree as compiler generated and to be output in the source file (code generation phase).

MarkLhsValues

Explicitly mark lhs operands of specific operators as lvalues.

MarkOverloadedTemplateInstantiations

Mark any template instatiations that are overloaded (we can't output these since g++ can't resolve them).

MarkSharedDeclarationsForOutputInCodeGeneration

Mark an AST subtree to be unparsed using an alternative file (for multi‐file unparsing).

MarkSharedDeclarationsInheritedAttribute

MarkTemplateInstantiationsForOutput

Class implementing template instantiation details in Sage III.

MarkTemplateInstantiationsForOutputSupport

MarkTemplateInstantiationsForOutputSupportInheritedAttribute

Inherited attribute required for MarkTemplateSpecializationsForOutputSupport class.

MarkTemplateInstantiationsForOutputSupportSynthesizedAttribute

Synthesized attribute required for MarkTemplateSpecializationsForOutputSupport class.

MarkTemplateSpecializationsForOutput

MarkTemplateSpecializationsForOutputInheritedAttribute

Inherited attribute required for MarkTemplateSpecializationsForOutput class.

MarkTransformationsForOutput

MarkTransformationsForOutputInheritedAttribute

Inherited attribute required for MarkTemplateSpecializationsForOutput class.

Matrix

MergeAllReturnStates

MergeLoopInfo

MergeStmtLoopInfo

MergedDependenceGraph

MetricAttribute

Attribute corresponding to a metric.

MissingTemplateHeaderFixupAttribute

ModifyVariableMap

MultiGraphCreate

MultiGraphDeleteEdgeInfo

MultiGraphDeleteNodeInfo

MultiGraphElem

MultiGraphElemTemplate

MultiGraphObserveEdgeTemplate

MultiGraphObserveNodeTemplate

NameQualificationInheritedAttribute

NameQualificationSynthesizedAttribute

NameQualificationTraversal

NameQueryInheritedAttributeType

Inherited attribute for NameQuery class.

NextPreprocessorToInsert

NoCopyArrayOperator

NoFunctionAliasAnalysis

NoFunctionSideEffectAnalysis

NodeFact

* NodeFact * A fact associated with a CFG node by * some analysis thatis not evolved as part * of a dataflow analysis (i.e. it should * stay constant throughout the analysis). **

NodeID

NodeQueryInheritedAttributeType

Inherited attribute for NodeQuery class.

NodeState

NonpackedTypeLayoutGenerator

Layout generator for i386 ABI‐like struct layout

NormalizeTypedefSequenceLists

This traversal uses the Memory Pool traversal to fixup the lists of typedef using this base type.

NormalizeTypedefSequenceLists_CopyList

NotApplicator

NotSelectPtrSet

NumberQueryInheritedAttributeType

Inherited attribute for NumberQuery class.

OperatorAliasAnnotation

OperatorAliasCollection

OperatorAllowAliasCollection

OperatorAnnotCollection

OperatorCallInfoCollection

OperatorDeclaration

Representation for an operator (function)

OperatorInlineAnnotation

OperatorInlineDescriptor

OperatorInlineRewrite

OperatorKillInfoCollection

OperatorModInfoCollection

OperatorReadInfoCollection

OperatorSideEffectAnnotation

OperatorSideEffectDescriptor

OptSpec

OrigLoopFusionAnal

OuterLoopReuseBlocking

PDFGeneration

PDFInheritedAttribute

POETCode

POETProgram

ParLoopSpec

ParallelizeBlocking

ParallelizeLoop

ParameterDeclaration

Representation for function parameter names and types.

ParameterizeBlocking

ParameterizeCopyArray

PartitionedAnalysis

Pattern

Abstract interface for a pattern which can match ASTs

PatternActionRule

A rule which changes one pattern of code to another

PerfectLoopReversible

PerfectLoopSlicable

PrePostOrderTraversal

PrePostTransformation

PreprocessingInfo

For preprocessing information including source comments, include , if, define, etc

PreprocessorInserter

PreviousAndNextAttribute

PreviousAndNextNodeData

PrivatizeScalar

ProcessAstNode

Interface class for processing each AstNode from within the ReadAstTraverse function.

ProcessAstTree

ProcessAstTreeBase

ProcessTemplateHandlingOptions

ProcessingPhase

ProductLattice

PropagateHiddenListData

PropagateHiddenListDataInheritedAttribute

Inherited attribute required for hidden list propagation to child scopes.

PtrAliasAnalysis

PtrAliasAnalysis computes Alias Information, which is used for Virtual Function Resolving.

PtrAnal

PtrMapWrap

PtrSetWrap

PtrSetWrap<AstObserver>

PtrSetWrap<CompSliceNestObserver>

PtrSetWrap<CompSliceObserver>

PtrSetWrap<LoopTreeObserver>

PtrSetWrap<MultiGraphObserver>

PtrSetWrap<void>

ROSEAttributesList

ROSEAttributesListContainer

ROSEHPCT

ROSE HPCToolkit Module

ROSEHPCT_EXAMPLES

ROSE‐HPCT examples

ROSE_3rdPartyLibrariesGroup

ROSE 3rd Party Libraries

ROSE_AST_InliningGroup

Inlining Transformations

ROSE_FrontEndGroup

ROSE Frontend Group

ROSE_MemoryUsage

ROSE_ProgramTransformationGroup

ROSE Program Transformations

ReachingDefNode

ReachingDefinitionAnalysis

ReachingDefinitionBase

ReachingDefinitionFacade

ReachingDefinitionGenerator

ReadAnnotCollection

ReadAnnotation

An interface to read into type(class) and operator(function) annotations

ReadContainer

ReadContainerWrap

ReadError

ReadSymbolicFunctionDeclaration

RemoveInitializedNamePtr

RemoveInitializedNamePtrInheritedAttribute

ReplaceParams

ResetContructorInitilizerLists

This traversal uses the Memory Pool traversal to fixup names of template classes that appear in constructor preinitialization lists.

ResetEmptyNames

This traversal uses the Memory Pool traversal to fixup names ofdeclarations that are inconsistant (e.g SgclassDeclarations).

ResetFileInfoParentPointersInMemoryPool

This traversal uses the Memory Pool traversal to fixup remaining parent pointers in Sg_File_Info objects.

ResetInconsistantNames

This traversal uses the Memory Pool traversal to fixup names ofdeclarations that are inconsistant (e.g SgclassDeclarations).

ResetParentPointers

This traversal implements the mechanism to reset all parent pointers (back edges in the AST graph)

ResetParentPointersInMemoryPool

This traversal uses the Memory Pool traversal to fixup remaining parent pointers.

ResetParentPointersInheritedAttribute

Inherited attribute required for ResetParentPointers class.

ResetParentPointersOfClassAndNamespaceDeclarations

This traversal implements the mechanism to reset all parent pointers (back edges in the AST graph)

ResetTemplateNames

Sets names of template classes.

ResetTemplateNamesOnMemoryPool

ResetTypes

This traversal uses the Memory Pool traversal to fixup types indeclarations that can be shared but are not. (e.g SgclassDeclarations).

RestrictValueOpCollection

RestrictValueOpDescriptor

RewriteArrayModOp

RewriteConstructArrayAccess

RewriteFragmentIdentificationTraversal

AST Rewrite fragment identification traversal

RewriteFromArrayAst

RewriteMechanism

AST Rewrite Mechanism

RewriteNestedClasses

AST Rewrite nested classes

RewriteRule

Definition of a rewrite rule on a given SgNode. The rule modifies the node and/or its children in‐place, and then returns true for success or false for failure.

RewriteRuleCombiner

Combine several rules into one, doing the constituents in order

RewriteToArrayAst

RoseAst

Interface for iterating over an AST.

RoseClangPathRoots

RoseOpenMPPragmaCallback

SCCGroupGraphOperator

SDGLibraryExtender

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

* SaveDotAnalysis **

SelectApplicatorWithBound

Similar to CollectPair, but the second item may start with 'sel' without 'sep' in front of it.

SgAggregateInitializer

RHS of an array variable declaration with optional assignment.

SgAsmBlock

Binary AST block node.

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

SgBasicBlock

This class represents the concept of a block (not a basic block from control flow analysis).

SgBinaryNode

This class represents the base class for all IR nodes supporting the binary

SgBinaryOp

This class represents the notion of a binary operator.

SgBoolValExp

This class represents a boolean value (expression value).

SgBottomUpProcessing

SgBreakStmt

This class represents the notion of a break statement

SgCallExpression

This class represents the concept of a generic call expression.

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.

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.

SgClinkageStartStatement

This class represents the concept of a C style extern "C" declaration. But

SgCombinedTreeTraversal

SgConditionalExp

This class represents the concept of a C trinary conditional expression (e.g. "test ? true : false")

SgConstructorInitializer

This class represents the call of a class constructor to initialize a variable.

SgContinueStmt

This class represents the concept of a C or C++ continue statement.

SgCtorInitializerList

This class represents the concept of a contructor initializer list (used in

SgDeclarationModifier

This class represents modifiers for SgDeclaration (declaration statements).

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

SgDeleteExp

This class represents the concept of a C++ call to the delete operator.

SgDirectedGraphEdge

SgDirectory

This class represents a directory within a projects file structure of files and directories.

SgDoWhileStmt

This class represents the concept of a do‐while statement.

SgDotExp

SgDoubleVal

This class represents the notion of an value (expression value).

SgEnumDeclaration

This class represents the concept of an enum declaration.

SgExecStatement

This class represents the concept of the dynamic execution of a string,

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

SgFile

This class represents a source file for a project (which may contian

SgFloatVal

This class represents the notion of an value (expression value).

SgForInitStatement

This class represents the variable declaration or variable initialization withn a

SgForStatement

This class represents the concept of a for loop.

SgFunctionCallExp

This class represents the concept of a C++ function call (which is an expression).

SgFunctionDeclaration

This class represents the concept of a function declaration statement.

SgFunctionDefinition

This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).

SgFunctionParameterList

This class represents the concept of a declaration list.

SgFunctionRefExp

This class represents the function being called and must be assembled in the

SgFunctionSymbol

SgFunctionType

This class represents a type for all functions.

SgFunctionTypeSymbol

This class represents the concept of a name and a type. It may be

SgFunctionTypeTable

This class represents the function type table (stores all function types so that

SgGlobal

This class represents the concept of a namespace definition.

SgGotoStatement

This class represents the concept of a C or C++ goto statement.

SgGraphNode

SgIfStmt

This class represents the concept of an "if" construct.

SgIncidenceDirectedGraph

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

SgIsNotOp

This class represents the physical disequality (often called pointer disequality) operator

SgIsOp

This class represents the physical equality (often called pointer equality) operator

SgLabelRefExp

SgLabelStatement

This class represents the concept of a C or C++ label statement.

SgLabelSymbol

SgLambdaRefExp

This class represents a lambda expression.

SgListExp

This class represents a list display.

SgLocatedNode

This class represents the notion of an expression or statement which

SgLongDoubleVal

This class represents the notion of an value (expression value).

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

SgMinusOp

This class represents the numeric negation of a value. Not to

SgModifier

This class represents the base class of a number of IR nodes define modifiers

SgModifierNodes

This class is not used in ROSE, but is intended to represent a list of SgModifierTypes

SgName

This class represents strings within the IR nodes.

SgNamedType

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.

SgNamespaceSymbol

This class represents the concept of a namespace name within the compiler.

SgNaryBooleanOp

This class represents the notion of an n‐ary boolean operation.

SgNaryComparisonOp

This class represents the notion of an n‐ary comparison operation.

SgNaryOp

This class represents the notion of an n‐ary operator.

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.

SgOmpBarrierStatement

SgOmpBodyStatement

SgOmpClause

SgOmpClauseBodyStatement

SgOmpDeclareSimdStatement

SgOmpDefaultClause

SgOmpExpressionClause

SgOmpFlushStatement

SgOmpScheduleClause

SgOmpTaskwaitStatement

SgOmpThreadBodyStatement

SgOmpVariablesClause

SgOptions

This class represents an object used to initialize the unparsing.

SgPointerAssignOp

This class represents a Fortran pointer assignment. It is not

SgPointerType

SgPragmaDeclaration

This class represents the concept of a C Assembler statement (untested).

SgProject

This class represents a source project, with a list of SgFile objects and global

SgPythonGlobalStmt

This class represents the concept of a 'global' stmt in Python

SgQualifiedName

This class represents a OLD concept of the structure require

SgQualifiedNameType

This class represents a OLD concept of the structure require

SgRefExp

This class represents the "&" operator (applied to any lvalue).

SgReferenceType

SgReturnStmt

This class represents the concept of a C Assembler statement (untested).

SgRvalueReferenceType

SgScopeOp

This class was part of CC++ support from a long time ago.

SgScopeStatement

This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).

SgSimpleProcessing

SgSizeOfOp

This class represents the "sizeof()" operator (applied to any type).

SgSourceFile

SgSpawnStmt

This class is part of the older CC++ concept. It is not a part of C or C++ (this IR

SgStatement

This class represents the notion of a statement.

SgStatementExpression

This class represents the GNU extension "statement expression" (thus is

SgStmtDeclarationStatement

This class is intended to be a wrapper around SgStatements, allowing

SgStorageModifier

This class represents modifiers specific to storage.

SgStringConversion

This class represents the conversion of an arbitrary expression to

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

SgSynthesizedAttribute

SgTemplateArgument

This class represents template argument within the use of a template to build an instantiation.

SgTemplateDeclaration

This class represents the concept of a template declaration.

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

SgTemplateParameter

SgTemplateParameterList

SgThisExp

This class represents the "this" operator (can be applied to any member data).

SgThrowOp

This class represents the C++ throw expression (handled as a unary operator).

SgTopDownBottomUpProcessing

SgTopDownProcessing

SgTreeTraversal

Temporary traversal base class (do not use).

SgTryStmt

This class represents the concept of try statement within the try‐catch

SgTupleExp

This class represents a tuple display.

SgType

This class represents the base class for all types.

SgTypeComplex

This class represents a C99 complex type.

SgTypeDefault

This class represents a default type used for some IR nodes (see below).

SgTypeImaginary

This class represents a C99 complex type.

SgTypeString

This class represents a string type used for SgStringVal IR node.

SgTypedefDeclaration

This class represents the notion of a typedef declaration.

SgTypedefSeq

This class represents a list of associated typedefs for the SgType IR nodes which

SgUnaryOp

This class represents the notion of a unary operator.

SgUnparse_Info

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).

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

SgWhileStmt

This class represents the concept of a do‐while statement.

Sg_File_Info

This class represents the location of the code associated with the IR node in the

SgnAnalysis

SgnLattice

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

SingleIterator

SingleNodeCopyEdge

SingleNodeMoveEdge

SingleStatementToBlockNormalizer

SingleValBound

SinglyLinkedEntryWrap

SinglyLinkedListWrap

StmtSideEffectCollect

StmtVarAliasCollect

StringDescriptor

A descriptor for an identifier

StructCustomizedSizes

Support for cross compilation or customized primitive type layouts.

SymbolicBoundAnalysis

SymbolicCond

SymbolicConst

SymbolicConstBoundAnalysis

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 '(..)'

SymbolicValDescriptor

SymbolicVal with I/O interface

SymbolicValGenerator

* Symbolic Operator interface **

SymbolicValImpl

SymbolicVar

SymbolicVisitor

SystemDependenceGraph

SystemPrimitiveTypeLayoutGenerator

Layout generator for the native system (uses sizeof)

TaintAnalysis

Taint Flow Analysis******

TaintLattice

A pointer to a vertex of the static taint lattice.

TestAstAccessToDeclarations

TestAstCompilerGeneratedNodes

TestAstForCyclesInTypedefs

TestAstForProperlyMangledNames

TestAstForProperlySetDefiningAndNondefiningDeclarations

TestAstForUniqueNodesInAST

TestAstForUniqueStatementsInScopes

TestAstNullPointers

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).

TestForDisconnectedAST

TestForMultipleWaysToSpecifyRestrictKeyword

TestForParentsMatchingASTStructure

TestForProperLanguageAndSymbolTableCaseSensitivity

TestForProperLanguageAndSymbolTableCaseSensitivity_InheritedAttribute

TestForReferencesToDeletedNodes

TestForSourcePosition

TestLValueExpressions

TestLValues

TestMangledNames

TestMappingOfDeclarationsInMemoryPoolToSymbols

This traversal uses the Memory Pool traversal to test declarations and if their associated symbol can be located.

TestMultiFileConsistancy

TestParentPointersInMemoryPool

This traversal uses the Memory Pool traversal to test parent pointers.

TimingPerformance

TokenStreamSequenceToNodeMapping

TokenStreamSequenceToNodeMapping_key

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

TraverseCallGraphBottomUp

TraverseCallGraphDataflow

TraverseCallGraphTopDown

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

Backend C and C++ code generator.

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

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

VariablesProductLattice

VariantVector

VarsExprsProductLattice

VectorCmdOptions

VectorHash

VirtualFunctionAnalysis

Virutal Function Analysis and PointerAliasAnalysis are dependent on each other for their accuracy. That's why they are done together

VirtualGraphCreateTemplate

VoidPtrMap

VoidPtrSet

WriteContainer

Output interface of a container

X86_64PrimitiveTypeLayoutGenerator

Layout generator for x86‐64 primitive types

X86_64_VSPrimitiveTypeLayoutGenerator

Slight modification for Visual Studio ‐‐ long is 4 bytes, not 8

XformVar

affineInequalitiesPlacer

affineInequality

affineInequalityFact

* affineInequalityFact **

arrayElt

astDiagnostics

Description of AST Diagnostics within ROSE

ast_construction

AST construction

attributes

Working with attributes

backendGenerator

Backend C and C++ Code Generator

binary_analysis_mainpage

Binary analysis main page

binary_tutorial

Binary analysis tutorial

booleanQueryLib

Boolean Query Library

builtinFilter

A function object to filter out builtin functions in a call graph (only non‐builtin functions will be considered)

commit_messages

Writing Git commit messages

defaultConstructorDestructorDocumentationPage

Default constructors and destructors

deleteDFAnalysisState

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.

file_pos_info

frontendSageHighLevelInterface

High level AST builders

funcSideEffectUses

genUID

generateDOTExtended

generateDOTExtended_withIncludes

generateDOTExtendedforMultipleFile

heap_object_ownership

Ownership of heap‐allocated objects

how_to_document

How to install Zlib * Instructions for installing Zlib, a ROSE software dependency. */ struct installation_dependencies_zlib {}; `

library_general_principles

Library general principles

localNodeQueryLib

Local Node Query Library

Name Query Library

Node Query Library

numCallersAttribute

* numCallersAnnotator * Annotates every function's SgFunctionDefinition * node with a numCallersAttribute that contains the * number of functions that call the given function. ****

partSplit

partitionDFAnalysisState

placeUniqueIDs

printAnalysisStates

printDataflowInfoPass

** printDataflowInfoPass * Prints out the dataflow information associated * with a given analysis for every CFG node a * function. *****

Query Library

Backend

Frontend

ROSE overview

Midend

Subtree Query Library

token_element

tooldev

Developing ROSE‐based tools

tooldev_makefile

Build systems

tooldev_page

Developing ROSE‐based tools

transformationSupportLib

Transformation Support Library

unionDFAnalysisStatePartitions

utilityClasses

General Utility Functions

varAffineInequality

varID

variable

wrap_data_used_by_AttachPreprocessingInfoTreeTrav_t

AttachedPreprocessingInfoType

BaseGraphEdge

BaseGraphNode

BooleanQuerySynthesizedAttributeType

CompSliceDepGraph

CompSliceDepGraphNodeIterator

DepInfoConstIterator

DepInfoConstIteratorImpl

DepInfoEdgeIterator

DepInfoEdgeIteratorImpl

DepInfoSetEdgeIterator

DepInfoSetEdgeIteratorImpl

DepInfoUpdateIterator

DepInfoUpdateIteratorImpl

DepType

DomainCondConstIterator

DomainCondConstIteratorImpl

DomainCondUpdateIterator

DomainCondUpdateIteratorImpl

GraphAccessInterface

LeafHandle

LexTokenStreamType

LexTokenStreamTypePointer

LoopTreeDepGraph

LoopTreeNodeIterator

LoopTreeNodeIteratorImpl

LoopTreeTransDepGraphCreate

MLOG_LEVEL_t

Mandatory logging are those critial msgs of the runtime including three levels of severity: MLOG_LEVEL_WARN: warning of likely problem, but the results might be ok MLOG_LEVEL_ERROR: error of runtime execution, program can continue, results will be wrong, but still useful MLOG_LEVEL_FATAL: fatal errors of runtime, program cannot continue.

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