SgNode

This class represents the base class for all IR nodes within Sage III.

Synopsis

Declared in <src/frontend/SageIII/Cxx_Grammar.h>

class SgNode;

Friends

Name

Description

isSgNode

Casts pointer from base class to derived class (for const pointers)

isSgNode

Casts pointer from base class to derived class

Non-Member Functions

Name

Description

AstPostProcessing

This does all post‐processing fixup and translation of the Sage III AST.

addPrototypesForTemplateInstantiations

Fixups transformations that have added template instantiations or caused template instantiations to be output so that there is a proper prototype declaration before the template instantation is called.

changeAllMembersToPublic

Change all members in a program to be public. There should really be a smarter procedure for this that only changes members used by inlined code.

checkIsCompilerGeneratedFlag

Checks whether appropriate nodes of an AST are marked as compiler‐generated.

checkIsFrontendSpecificFlag

Checks whether appropriate nodes of an AST are marked as front‐end specific.

checkPhysicalSourcePosition

Checks whether the physical source position information is consistant in the Sg_File_Info object

checkTransformedFlagsVisitor

Check for consistancy of isTransformation flags for nodes marked as a transformation.

cleanupInlinedCode

Combined procedure for cleaning up code after inlining. Does not do variable renaming or block flattening, however.

detectTransformations

Detect nodes marked as transformations (should not be present coming out of the frontend translation).

edgePointerReplacement

Traverse the AST root looking for the edges in the replacement map. If a match is found the edge is updated.

findVariablesUsedInRegion

Find all variables referenced in a region

fixReturnStatements

Workaround for ROSE bug. Should be used whenever expressions in a program are modified.

fixupAstDeclarationScope

Fixup all SgDeclarationStatement to have a consistant scope (between the defining and all non‐defining declarations).

fixupAstDefiningAndNondefiningDeclarations

Fixup all SgDeclarationStatement references to defining and non‐defining declarations.

fixupAstSymbolTables

Fixup global and local symbol tables.

fixupAstSymbolTablesToSupportAliasedSymbols

Fixup C++ symbol tables to use aliasing symbols for using declarations.

fixupDeclarations

Fixup definingDeclaration and firstNondefiningDeclaration pointers in SgDeclarationStatement.

fixupFileInfoInconsistanties

Checks and fixes up inconsistanties in the settings of Sg_File_Info flags (e.g. isTransformation flag) in the Sg_File_Info object

fixupFortranReferences

Fixup Fortran array vs. function references.

fixupFortranUseDeclarations

Fixup Fortran Use declarations.

fixupNullPointersInAST

Fixup specific pointers in the AST that we would like to not have be NULL.

fixupSelfReferentialMacrosInAST

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

fixupStorageAccessOfForwardTemplateDeclarations

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

fixupTemplateInstantiations

Fixups template specializations generated by ROSE from template instantiations.

flattenBlocks

Flatten nested blocks of code in a program. This code requires that variable names in the region being processed are already distinct, and it may extend variable lifetimes to the end of the outer block of code.

getStatementOfExpression

Get the statement of an expression. Somewhat smarter than the standard version of this routine, but needs to be merged.

initializeExplicitScopeSupport

Initialize explicit scopes (support function should not be called).

initializeExplicitScopes

Initialize explicit scopes (located only at specific IR nodes).

insertFortranContainsStatement

Insert Fortran "CONTAINS" statement.

isMemberVariable

Internal routine to check whether a given variable declaration is a member variable.

isSgExpression

Casts pointer from base class to derived class (for const pointers)

isSgExpression

Casts pointer from base class to derived class

isSgInitializedName

Casts pointer from base class to derived class (for const pointers)

isSgInitializedName

Casts pointer from base class to derived class

isSgStatement

Casts pointer from base class to derived class

isSgStatement

Casts pointer from base class to derived class (for const pointers)

markAsCompilerGenerated

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

markBackendSpecificFunctionsAsCompilerGenerated

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

Mark relavant expressions as l‐values explicitly.

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

markTemplateInstantiationsForOutput

Fixups template instantiations generated by ROSE from template declarations.

markTransformationsForOutput

Fixups transformations (which are often marked at a high level and need to be marked properly through their subtree).

moveForDeclaredVariables

Move variables declared in a for statement to just outside that statement.

postProcessingSupport

Postprocessing that is not likely to be handled in the legacy frontend/Sage III translation.

processTemplateHandlingOptions

Fixup template instantiations to unmark them for output followingsemantics of gnu template options

propagateHiddenListData

Propagate hidden list information for variables, types, and class elaboration.

rebindVariableAndLabelReferences

Change all variable and label references to point to new symbols, created to point to the matching declaration found in the program. This needs to be moved into somewhere in FixSgTree.

removeNullStatements

Remove all null statements (those with only an integer constant or a null expression)

removeUnusedVariables

Remove unused variables in a scope

renameLabels

Rename all labels in a block of code.

renameVariables

Rename all variables in a block of code, and ensure that all variable references point to the correct declarations.

replaceChild

Replace a child of a node.

resetConstantFoldedValues

This function acts in two different ways

resetParentPointers

Interface function to reset parent pointers.

resetParentPointersInMemoryPool

This traversal calles ResetParentPointersInMemoryPool Memory Pool traversal.

resetParentPointersOfClassOrNamespaceDeclarations

This is a top level function not called recursively.

resetTemplateNames

Sets names of template classes (calls custom traversal).

simpleCopyAndConstantPropagation

In code with declarations such as "int foo = bar", where foo and bar are not modified, replace "foo" with "bar" and remove the declaration

simpleIndexFiniteDifferencing

Do a simple form of finite differencing on all functions contained within root (which should be a project, file, or function definition).

topLevelResetParentPointer

This is a top level function not called recursively.

ASTtools::deepCopy

Create a deep‐copy of an SgNode

ASTtools::isC99

Returns 'true' if this node is contained in a C99‐only project.

ASTtools::setSourcePositionAsTransformation

Reset source position as transformation for the current node only

ASTtools::setSourcePositionAtRootAndAllChildrenAsTransformation

Reset source position as transformation recursively

AstQueryNamespace::querySubTree

**** The function Result querySubTree ( SgNode * subTree, _Result (__x)(SgNode_,_Arg), Arg x_arg, AstQueryNamespace::QueryDepth defineQueryType =AstQueryNamespace::AllNodes ) will query the subtree of the IR node in the first argument for nodessatisfying the criteria specified in and returned by the function pointer inthe second argument.**

AstQueryNamespace::querySubTree

** The function Result querySubTree ( SgNode * subTree, _Result (__x)(SgNode_), AstQueryNamespace::QueryDepth defineQueryType =AstQueryNamespace::AllNodes )* will query the subtree of the IR node in the first argument for nodessatisfying the criteria specified in and returned by the function pointer inthe second argument.**

AstQueryNamespace::querySubTree

**** The function std::list<ListElement> querySubTree<ListElement>(SgNode* node,Predicate& _pred) will query the subtree of the IR node in the first argumentfor nodes satisfying the criteria specified in and returned by the predicatein the second argument.**

AstUtilInterface::CollectSideEffectVariables

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.

AstUtilInterface::ComputeAstSideEffects

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.

CPreproc::extractIfDirectives

Extracts the '#if' directive structure from a project.

CallTargetSet::solveFunctionPointerCallsFunctional

Checks if the functionDeclaration (node) matches functionType

ConstantFolding::constantFoldingOptimization

This is the external interface of constant folding:

NameQuery::querySubTree

****

NameQuery::querySubTree

****

NameQuery::querySubTree

****

NameQuery::querySubTree

****

NodeQuery::queryMemoryPool

** The function NodeQuerySynthesizedAttributeType queryMemoryPool ( SgNode * subTree, Result (*x)(SgNode*,_Arg), Arg x_arg, VariantVector ){ will on every node of the memory pool which has a corresponding variant inVariantVector performa the action specified by the second argument and returna NodeQuerySynthesizedAttributeType.*

NodeQuery::queryMemoryPool

** The function Result queryMemoryPool ( SgNode * subTree, SgNode, TypeOfQueryTypeTwoParameters, VariantVector* ){ will on every node of the memory pool which has a corresponding variant inVariantVector performa the predefined action specified by the second argumentand return a NodeQuerySynthesizedAttributeType.**

NodeQuery::queryMemoryPool

** The function Result queryMemoryPool ( SgNode * subTree, _Result (__x)(SgNode_), VariantVector* ){ will on every node of the memory pool which has a corresponding variant inVariantVector performa the action specified by the second argument and returna NodeQuerySynthesizedAttributeType.**

NodeQuery::querySubTree

****

NodeQuery::querySubTree

****

NodeQuery::querySubTree

****

NodeQuery::querySubTree

The function querySubTree (SgNode * subTree, VariantVector targetVariantVector, AstQueryNamespace::QueryDepth defineQueryType =AstQueryNamespace::AllNodes); reutnrs a list of all SgNodes us the ASTsub‐tree of the variable 'subTree' conforming to the variants inVariantVector.*****

NodeQuery::querySubTree

****

NodeQuery::querySubTree

****

NodeQuery::querySubTree

****

NumberQuery::querySubTree

****

NumberQuery::querySubTree

****

NumberQuery::querySubTree

****

NumberQuery::querySubTree

****

OmpSupport::generateOutlinedTask

A helper function to generate implicit or explicit task for either omp parallel or omp task

OmpSupport::getEnclosingRegionOrFuncDefinition

Find an enclosing parallel region or function definition's body

OmpSupport::replaceVariableReferences

Replace references to oldVar within root with references to newVar, return the number of references replaced.

OmpSupport::replaceVariableReferences

Replace variable references within root based on a map from old symbols to new symbols

OmpSupport::replaceVariablesWithPointerDereference

Replace all variable references in a set by pointers to the variable

OmpSupport::transOmpAtomic

Translate omp atomic

OmpSupport::transOmpBarrier

Translate omp barrier

OmpSupport::transOmpCritical

Translate omp critical

OmpSupport::transOmpFlush

Translate omp flush

OmpSupport::transOmpLoop

Translate omp for or omp do loops

OmpSupport::transOmpMaster

Translate omp master

OmpSupport::transOmpMetadirective

Translate omp metadirective

OmpSupport::transOmpOrdered

Translate the ordered directive (not the ordered clause)

OmpSupport::transOmpParallel

Translate omp parallel

OmpSupport::transOmpSections

Translate omp sections

OmpSupport::transOmpSimd

Translate omp simd

OmpSupport::transOmpSingle

Translate omp single

OmpSupport::transOmpTarget

Translate "omp target"

OmpSupport::transOmpTargetData

Translate "omp target data"

OmpSupport::transOmpTargetLoop

Translate omp for or omp do loops affected by the "omp target" directive, using naive 1‐to‐1 mapping Liao 1/28/2013

OmpSupport::transOmpTargetLoop_RoundRobin

Translate omp for or omp do loops affected by the "omp target" directive, using a round robin‐scheduler Liao 7/10/2014

OmpSupport::transOmpTargetParallel

Translate omp parallel under "omp target"

OmpSupport::transOmpTask

Translate omp task

OmpSupport::transOmpTaskwait

Translate omp taskwait

OmpSupport::transOmpThreadprivate

Translate omp threadprivate

OmpSupport::transOmpTile

Translate omp tile

OmpSupport::transOmpUnroll

Translate omp unroll

ProcessExpression::processLHS

Helper Function to process Left Hand Side of an Expression

ProcessExpression::processRHS

Helper Function to process Right Hand Side of an Expression

SageBuilder::errorCheckingTargetAST

Error checking the inserted snippet AST.

SageBuilder::fixupSharingSourcePosition

Sharing IR nodes requires that the file id be added to the fileIDsToUnparse held in the Sg_File_Info object.

SageInterface::addTextForUnparser

Add a string to be unparsed to support code generation for back‐end specific tools or compilers.

SageInterface::addVarRefExpFromArrayDimInfo

Find all SgPntrArrRefExp under astNode, then add SgVarRefExp (if any) of SgPntrArrRefExp's dim_info into NodeList_t

SageInterface::astIntersection

Compute the intersection set for two ASTs.

SageInterface::changeAllBodiesToBlocks

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.

SageInterface::clearUnusedVariableSymbols

Clear those variable symbols with unknown type (together with initialized names) which are also not referenced by any variable references or declarations under root. If root is NULL, all symbols with unknown type will be deleted.

SageInterface::collectModifiedLocatedNodes

This collects the SgLocatedNodes that are marked as modified (a flag automatically set by all set_* generated functions) (useful in debugging).

SageInterface::collectModifiedStatements

This collects the statements that are marked as modified (a flag automatically set by all set_* generated functions) (useful in debugging).

SageInterface::collectTransformedStatements

This collects the statements that are marked as transformed (useful in debugging).

SageInterface::computeUniqueNameForUseAsIdentifier

Traversal to set the global map of names to node and node to names.collisions to support generateUniqueNameForUseAsIdentifier() function.

SageInterface::constantFolding

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.

SageInterface::convertFunctionDefinitionsToFunctionPrototypes

XXX This function operates on the new file used to support outlined function definitions. We use a copy of the file where the code will be outlined FROM, so that if there are references to declarations in the outlined code we can support the outpiled code with those references. This approach has the added advantage of also supporting the same include file tree as the original file where the outlined code is being taken from.

SageInterface::convertRefToInitializedName

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.

SageInterface::deepCopyNode

Deep copy an arbitrary subtree

SageInterface::deepDelete

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

SageInterface::deleteExpressionTreeWithOriginalExpressionSubtrees

Special purpose function for deleting AST expression tress containing valid original expression trees in constant folded expressions (for internal use only).

SageInterface::dumpInfo

Dump information about a SgNode for debugging

SageInterface::findDeclarationStatement

Topdown traverse a subtree from root to find the first declaration given its name, scope (optional, can be NULL), and defining or nondefining flag.

SageInterface::findFunctionDeclaration

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

SageInterface::findMain

top‐down traversal from current node to find the main() function declaration

SageInterface::findUnusedLabels

Find unused labels which are not targets of any goto statements

SageInterface::fixVariableReferences

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.

SageInterface::generateUniqueName

Generate unique name from C and C++ constructs. The name may contain space.

SageInterface::getAssociatedType

Get the enclosing type of this associated node, not used other than in ./src/backend/unparser/nameQualificationSupport.C

SageInterface::getBoolType

Get the right bool type according to C or C++ language input

SageInterface::getEnclosingClassDeclaration

Get the closest class declaration enclosing the specified AST node,

SageInterface::getEnclosingClassDefinition

Get the closest class definition enclosing the specified AST node,

SageInterface::getEnclosingExprListExp

Get the enclosing SgExprListExp (used as part of function argument index evaluation in subexpressions).

SageInterface::getEnclosingFileNode

get the SgFile node from current node

SageInterface::getEnclosingFunctionDeclaration

Find the enclosing function declaration, including its derived instances like isSgProcedureHeaderStatement, isSgProgramHeaderStatement, and isSgMemberFunctionDeclaration.

SageInterface::getEnclosingModuleStatement

Get the closest module statement enclosing the specified AST node,

SageInterface::getEnclosingNode

Find a node by type using upward traversal.

SageInterface::getEnclosingProcedure

Find the function definition

SageInterface::getEnclosingScope

Get the enclosing scope from a node n

SageInterface::getEnclosingSourceFile

Find enclosing source file node

SageInterface::getEnclosingStatement

Find the closest enclosing statement, including the given node

SageInterface::getGlobalScope

Traverse back through a node's parents to find the enclosing global scope

SageInterface::getLoopIndexVariable

Return the loop index variable for a for loop

SageInterface::getProject

SageInterface::getScope

Get the closest scope from astNode. Return astNode if it is already a scope.

SageInterface::getTemplateDeclaration

Get the enclosing TemplateDeclaration statement

SageInterface::get_name

Generate a useful name to describe the SgNode

SageInterface::isAncestor

check if node1 is a strict ancestor of node 2. (a node is not considered its own ancestor)

SageInterface::isAssignmentStatement

Check if a SgNode _s is an assignment statement (any of =,+=,‐=,&=,/=, ˆ=, etc)

SageInterface::isCanonicalForLoop

Check if a for‐loop has a canonical form, return loop index, bounds, step, and body if requested

SageInterface::isMain

Check if a SgNode is a main() function declaration

SageInterface::isOmpStatement

Check if a node is SgOmp*Statement

SageInterface::isStructDeclaration

Check if a SgNode is a declaration for a structure

SageInterface::isUnionDeclaration

Check if a SgNode is a declaration for a union

SageInterface::normalizeArrowExpWithAddressOfLeftOperand

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.

SageInterface::outputLocalSymbolTables

Output the local symbol tables.

SageInterface::printAST

Pretty print AST horizontally, output to std output.

SageInterface::printAST

Pretty print AST horizontally, output to a specified file, a simpiler interface than printAST2TextFile()

SageInterface::printAST2TextFile

Pretty print AST horizontally, output to a specified text file. If printType is set to false, don't print out type info.

SageInterface::printAST2TextFile

Pretty print AST horizontally, output to a specified text file. If printType is set to false, don't print out types info.

SageInterface::querySubTree

Query a subtree to get all nodes of a given type, with an appropriate downcast.

SageInterface::recursivePrintCurrentAndParent

Recursively print current and parent nodes. used within gdb to probe the context of a node.

SageInterface::removeAllOriginalExpressionTrees

Set original expression trees to NULL for SgValueExp or SgCastExp expressions, so you can change the value and have it unparsed correctly.

SageInterface::removeConsecutiveLabels

Remove consecutive labels

SageInterface::removeJumpsToNextStatement

Remove jumps whose label is immediately after the jump. Used to clean up inlined code fragments.

SageInterface::removeLabeledGotos

Remove labeled goto statements

SageInterface::removeUnusedLabels

Remove labels which are not targets of any goto statements: its child statement is also removed by default.

SageInterface::replaceWithPattern

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.

SageInterface::saveToPDF

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.

SageInterface::serialize

we have two serialize() functions, one for a single node, the other for a list of pointers

SageInterface::setLoopLowerBound

Set the lower bound of a loop header for (i=lb; ...)

SageInterface::setLoopStride

Set the stride(step) of a loop 's incremental expression, regardless the expression types (i+=s; i= i+s, etc)

SageInterface::setLoopUpperBound

Set the upper bound of a loop header,regardless the condition expression type. for (i=lb; i op up, ...)

SageInterface::setOneSourcePositionForTransformation

Set current node's source position as transformation generated

SageInterface::setOneSourcePositionNull

Set current node's source position as NULL

SageInterface::setSourcePosition

Set the source code positon for the current (input) node.

SageInterface::setSourcePositionAsTransformation

DQ (5/1/2012): New function with improved name.

SageInterface::setSourcePositionAtRootAndAllChildren

Set the source code positon for the subtree (including the root).

SageInterface::setSourcePositionForTransformation

Recursively set source position info(Sg_File_Info) as transformation generated

SageInterface::whereAmI

Diagnostic function for tracing back through the parent list to understand at runtime where in the AST a failure happened.

SgNodeHelper::abbreviatedLocationToString

returns location (consisting of filename, line, column) Abbreviates fileName if too long, max file name length can be set

SgNodeHelper::correspondingSgFunctionDefinition

this function should only be called for a node in the subtree of a SgFunctionDefinition node. For a given 'node' it determines the correspondnig functionDefinition node when searching upwards in the AST for such a SgFunctionDefinition node. It is useful as a simple lookup function from inside the AST subtree of a SgFunctionDefinition. Returns 0 if no SgFunctionDefinition is found (e.g. global scope).

SgNodeHelper::determineChildIndex

computes for a given node the index number of it from the parent. e.g. node1(node2,node3,node4) : node4 has index 2 (starting at 0) For the root node of an AST (e.g. SgProject) this function returns ‐1.

SgNodeHelper::determineVariablesInSubtree

determines all VarRefExp in the subtree of 'node'. The order in the vector corresponds to the traversal order on the AST.

SgNodeHelper::findFunctionDeclarationWithFunctionSymbol

returns the function declaration statement found for a given function symbol.

SgNodeHelper::findVariableDeclarationWithVariableSymbol

returns the declaration statement found for a given variable symbol.

SgNodeHelper::getCond

returns the root node representing the AST of the condition of If, While, DoWhile, For, CondOperator, switch.

SgNodeHelper::getExprRootChild

returns the child of SgExpressionRoot (which is guaranteed to be unique and to exist)

SgNodeHelper::getExprStmtChild

returns the child of SgExprStatement (which is guaranteed to be unique and to exist)

SgNodeHelper::getFalseBranch

returns the root node representing the AST of the false branch of If, CondOperator.

SgNodeHelper::getFirstChild

returns the first child of an arbitrary AST node (throws exception if numChildren==0)

SgNodeHelper::getFirstOfBlock

returns the first Statement of SgBasicBlock (throws exception if numChildren==0)

SgNodeHelper::getForIncExpr

returns the incr/derc‐expr of For.

SgNodeHelper::getForInitList

returns the initializer‐list of For.

SgNodeHelper::getFunctionCallActualParameterList

return a function‐call's argument list

SgNodeHelper::getFunctionDefinitionFormalParameterList

return a function‐definition's list of formal paramters

SgNodeHelper::getFunctionName

returns function name of SgFunctionDefinition, SgFunctionDeclaration, SgFunctionCall.

SgNodeHelper::getFunctionReturnType

return a function‐definition's return type

SgNodeHelper::getLabelName

returns the label name of a SgLabelStatement without trailing ":"

SgNodeHelper::getLastOfBlock

returns the last Statement of SgBasicBlock (throws exception if numChildren==0)

SgNodeHelper::getLhs

return lhs of a binary node (if it is not a binary node it throws an exception)

SgNodeHelper::getLoopBody

returns the root node representing the AST of the loop body of While, DoWhile, For.

SgNodeHelper::getParent

returns the parent of a node. Essentially a wrapper function of the ROSE get_parent() function, but throws an exception if no parent exists. For SgProject node no exception is thrown if no parent exists because it is the root node of a ROSE AST.

SgNodeHelper::getRhs

return rhs of a binary node (if it is not a binary node it throws an exception)

SgNodeHelper::getTrueBranch

returns the root node representing the AST of the true branch of If, CondOperator.

SgNodeHelper::getUnaryOpChild

returns the child of a SgUnaryExp (which is guaranteed to be unique and to exist)

SgNodeHelper::isArrayElementAssignment

checks whether the expression 'node' represents an assignment to an array's element considers all assignment operators and arrays of any size

SgNodeHelper::isAstRoot

checks whether the node 'node' is the root node of the AST by using the get_parent function.

SgNodeHelper::isCond

is true if 'node' is the root node of the AST representing the condition of If, While, DoWhile, For, switch, CondExp.

SgNodeHelper::isCondInBranchStmt

is true if 'node' is the root node of the AST representing the condition of If, While, DoWhile, For, switch.

SgNodeHelper::isCondStmt

is true if 'node' is the root node of the AST representing If, While, DoWhile, For, switch.

SgNodeHelper::isCondStmtOrExpr

is true if 'node' is the root node of the AST representing If, While, DoWhile, For, switch, CondExp.

SgNodeHelper::isForIncExpr

determines whether a node is the root node of an AST representing the inc‐expr in a SgForStatement. This function is helpful to deal with this special case in the ROSE AST where an expression does not have a root node which can be easily determined to be a root node of an expression (i.e. here it can be any binary or unary node in constrast to all other expressions in the ROSE AST which are either a SgExprStatement or have a SgExpressionRoot node.

SgNodeHelper::isForwardFunctionDeclaration

Determines whether a provided function declaration is a forward declaration

SgNodeHelper::isFunctionParameterVariableSymbol

checks whether a SgVariableSymbol is representing a function parameter (this does not apply for forward declarations)

SgNodeHelper::isLastChildOf

checks whether 'elem' is the last child (in traversal order) of node 'parent'.

SgNodeHelper::isLoopCond

is true if 'node' is the root node of the AST representing the condition of a Loop construct (While, DoWhile, For).

SgNodeHelper::isLoopStmt

is true if 'node' is the root node of the AST representing a Loop construct (While, DoWhile, For).

SgNodeHelper::isPostfixIncDecOp

returns true for Expr‐‐ and Expr‐‐, otherwise false;

SgNodeHelper::isPrefixIncDecOp

returns true for ‐‐Expr and ++Expr, otherwise false.

SgNodeHelper::isVariableSymbolInFunctionForwardDeclaration

checks whether a SgVariableSymbol is representing a variable in

SgNodeHelper::lineColumnAndSourceCodeToString

returns line, column, and unparsed node in one string.

SgNodeHelper::lineColumnPair

returns a std::pair of line and column number. If no file info exists at this node it returns (‐1,‐1).

SgNodeHelper::locationAndSourceCodeToString

returns location (consisting of filename, line, column) and source code of unparsed node in one string. Abbreviates fileName and unparsed source if too long (defaults are 30,20)

SgNodeHelper::locationToString

returns location (consisting of filename, line, column)

SgNodeHelper::loopRelevantBreakStmtNodes

returns a set of SgNode where each node is a break node, but properly excludes all nested loops.

SgNodeHelper::matchExtendedNormalizedCall

matches C and C++ function calls (also ctor and dtor)

SgNodeHelper::nodeToString

returns a string representing the node (excluding the subtree)

SgNodeHelper::numChildren

returns the number of children as int (intentionally not as t_size) ensures that the number of children fits into an int, otherwise throws exception.

SgNodeHelper::replaceAstWithString

replaces the ast with root 'node' with the string 's'. The string is attached to the AST and the unparser uses string s instead of unparsing this substree. This function can be used to generate C++ extensions.

SgNodeHelper::scopeNestingLevel

computes for a given node at which scope nesting level this node is in its AST

SgNodeHelper::scopeSequenceNumber

computes for a given node at which scope nesting level this node is in its AST

SgNodeHelper::sourceFilenameLineColumnToString

returns filename+line+column information of AST fragment in format "filename:line:column". Used for generating readable output

SgNodeHelper::sourceFilenameToString

returns filename as stored in AST node. Used for generating readable output.

SgNodeHelper::sourceLineColumnToString

returns filename followed by line:column in one string. Used for generating readable output.

SgNodeHelper::sourceLineColumnToString

returns filename followed by line, separator, and column in one string. Used for generating readable output.

SgNodeHelper::switchRelevantCaseStmtNodes

collects all case labels from the switch it started in (excludes nested switch stmts). This function also works for Duff's device code where 'case' labels can be inside nested loop/if constructs.

SgNodeHelper::switchRelevantDefaultStmtNode

returns the default stmt if it exists. Otherwise return 0 and can be used to test whether a default stmt exists in a given switch stmt. This function also works for Duff's device code. code where 'default' labels can be inside nested loop/if constructs.

SgNodeHelper::uniqueLongVariableName

Creates a long unique variable name for a given node of type SgVariableDeclaration or SgVarRefExp

SgNodeHelper::unparseCond

returns the string representing the condition (removes trailing ';')

TransformationTracking::registerAstSubtreeIds

Assign Ids and save current File Info.

VirtualCFG::cfgBeginningOfConstruct

The first CFG node for a construct (before the construct starts to execute)

VirtualCFG::cfgEndOfConstruct

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

VirtualCFG::cfgIndexForEndWrapper

VirtualCFG::cfgToDot

Dump the filtered dot graph of a virtual control flow graph starting from SgNode (start)

VirtualCFG::cfgToDotForDebugging

Dump the full dot graph of a virtual control flow graph starting from SgNode (start)

VirtualCFG::interestingCfgToDot

Dump a CFG with only interesting nodes for a SgNode

VirtualCFG::makeCfg

Returns CFG node for just before start

VirtualCFG::prependToScopeStmt

* CALL‐BACK FUNCTIONS FOR cfgRWTransaction::transform() **

cfgUtils::isAssignment

/ SgExpression that is that/ assignment (effectively a type cast) or NULL otherwise

sg::ancestor

finds an ancestor node with a given type

sg::assert_sage_type

asserts that n has type SageNode

sg::assume_sage_type

unchecked down cast from SgNode to SageNode

sg::assume_sage_type

SgNodeHelper::Pattern::matchAssertExpr

tests pattern for an assert

SgNodeHelper::Pattern::matchExprStmtAssignOpVarRefExpFunctionCallExp

tests pattern SgExprStatement(SgAssignOp(VarRefExp,FunctionCallExp)) and returns pointer to FunctionCallExp otherwise 0.

SgNodeHelper::Pattern::matchExprStmtFunctionCallExp

tests pattern SgExprStatement(FunctionCallExp) and returns pointer to FunctionCallExp, otherwise 0.

SgNodeHelper::Pattern::matchFunctionCall

tests several patterns and returns pointer to FunctionCallExp inside that matched pattern, otherwise 0.

SgNodeHelper::Pattern::matchFunctionCallExpInVariableDeclaration

tests pattern for function call in variable declaration and returns pointer to FunctionCallExp otherwise 0.

SgNodeHelper::Pattern::matchReturnStmtFunctionCallExp

tests pattern SgReturnStmt(FunctionCallExp) and returns pointer to FunctionCallExp, otherwise 0.

SgNodeHelper::Pattern::matchSingleVarFPrintf

tests pattern SgFunctionCall(...) where the name of the function is fprintf with 3 params

SgNodeHelper::Pattern::matchSingleVarPrintf

tests pattern SgFunctionCall(...) where the name of the function is printf with 2 params

SgNodeHelper::Pattern::matchSingleVarScanf

tests pattern SgFunctionCall(...) where the name of the function is scanf with 2 params

SgNodeHelper::Pattern::matchVariableDeclarationWithFunctionCall

checks variable declaration with function call, returns variable declaration. Otherwise 0. e.g. int x=f();

SgNodeHelper::Pattern::matchVariableDeclarationWithFunctionCall2

checks variable declaration with function call, returns both in a pair, or a with (0,0).

legacy::PRE::getFunctionDefinition

Get the function definition containing a given node

legacy::PRE::partialRedundancyElimination

Do partial redundancy elimination on all functions within the scope n.

Derived Classes

Name

Description

SgLocatedNode

This class represents the notion of an expression or statement which

SgSupport

This class represents the base class of a numbr of IR nodes that don't otherwise fit

SgSymbol

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

SgType

This class represents the base class for all types.

Description

This class is used as a base class for all IR nodes in Sage III. ‐ Note: AST attributes should not be used for the following IR nodes: ‐# SgName ‐# SgModifier (and all derived modifier IR nodes) ‐# SgUnparse_Info ‐# SgSymbolTable ‐ Internal: Need to remove unused error() and variant() functions. ‐ Todo: The "AstAttributeMechanism attribute;" field should be fixed: ‐ The attribute within this class is not added using ROSETTA and is one of the last (if not the last) variable to NOT be added to the IR nodes using ROSETTA. Because it is not added using ROSETTA, it is a special case (and we hate special cases) in the file I/O (by Jochen) and perhaps elsewhere. This variable should be added using ROSETTA! ‐ Access functions need to be built for the "AstAttributeMechanism attribute;" field and it needs to be moved to be a private data member. ‐ It should be moved to only those IR nodes were it makes sense, e.g. excluded from: ‐# SgName ‐# SgModifier (and all derived modifier IR nodes) ‐# SgUnparse_Info ‐# SgSymbolTable ‐ Todo: Consider eliminating the set_freepointer() function since only the internal memory allocation mechanisms should use it (and they are forced to access the data member directly since they traverse the memory pools directly and member function can onl be called on allocated object initialized vi the new operator (with a proper constructor call, so that the this pointer is set properly)). Perhaps we don't need access functions for this data member at all. ‐ See also: Example of using a SgNode object ‐ See also: Enforced AST Properties

Data members

#### SgNode::attribute This is the new attribute mechanism. This is part of a new attribute mechanism. It is difference from the one originally used by Sage II.

#### SgNode::p_parent This is the pointer to the parent IR node in the AST. This is the pointer to the parent IR node. It is a valid pointer on all nodes that are traversed (SgExpressions, SgStatements, SgInitializedName, etc.) However it is not set on SgTypes and SgSymbols,both of which are shared internally. This pointer is mostly set in post processing of the Sage III AST, until this point it is not reliable.

#### SgNode::p_isVisited This the visit flag previously used by the AST traversals. This the visit flag previously used by the AST traversals. It is no longer used in the AST traversals, though the traversals can be set at compile‐time to alternatively use this visit flag. The visit flag is part of an older design of the AST traversal, it was problematic by design, because it had to be reset after each traversal. It also placed requirements on any newly added IR nodes within the AST (they had to be set so just right so that they could be properly reset). The AST traversals are greatly simplified as a result of no longer requiring this visit flag. This variable will be removed in the future. ‐ Deprecated: Old traversal supporting mechanism (will be removed).

#### SgNode::p_freepointer This is the pointer to the chain of previously freed objects. ‐ Internal: This is part of the support for memory pools within ROSE. The freepointer is only manipulated by the delete operator which constructs a chain of previously freed objects embedded within the memory pools. The chain of objects link by the freepointer variables are traversed by the new operator to allocate (reuse) previously deleted objects. The new operator does not reset the freepointers since once allocated the freepointer is ignored.

#### SgNode::p_isModified Records if IR node has been modified (data members reset). This is part of an internal mechanism that records if IR nodes have been modified, either by a transformation or a access function to set a value on the IR node. All access functions that set IR node data members are automatically generated (except the ones for this data member) and include code to set this boolean flag to true. This is also part of the support for copy based code generation where source file is copied except where the AST was modified an for these subtrees new code is generated from the AST. ‐ Internal: true if IR node has been modified, else false.

#### SgNode::p_globalFunctionTypeTable Pointer to symbol table specific to function types. ‐ Internal: Always a valid pointer.

#### SgNode::p_globalMangledNameMap Cache of mangled names to avoid regeneration of previously build mangled names or parts of mangled names. This is a performance optimization. ‐ Internal: This cache should be cleared automatically where required.

#### SgNode::p_shortMangledNameCache STL map used as a cache to shorten generated mangled names. This is mostly a space optimization ofr mangled names of templates. ‐ Internal: This cache should be cleared before regenerating mangled names.

Member functions

#### SgNode::copy(const SgCopyHelp & help ) const This function clones the current IR node object recursively or not, depending on the argument This function performs a copy based on the specification of the input parameter. The input parameter is used to determin which data members are copied by reference and which are copied by value. ‐ Param help: ‐ If this argument is of type SgTreeCopy, then the IR node is cloned recursively. If its of type SgShallowCopy only the first level of the IR node is copied, everything else is left pointing to the the original IR node's object's data members. ‐ Return: a pointer to the new clone. ‐ Internal: It appears the the copy functions don't set the parents of anything that they do a deep copy of! This can cause AST tests to fail. In particular some functions that require the parent pointers to be valid will return NULL pointers (e.g. SgInitializedName::get_declaration()). It might be that we should allow this to be done as part of the SgCopyHelp::clone function or perhaps another member function of SgCopyHelp would be useful for this support. It is not serious if the AST post processing is done since that will set any NULL pointers that are found within its traversal. ‐ Exception: none No exceptions are thrown by this function.

#### SgNode::SgNode() This is the constructor This constructor builds a SgNode, always used as a base class. All Sage III IR nodes are derived from this class. ‐ See also: Example:create an SgNode object

#### SgNode::~SgNode() This is the destructor. There is nothing to delete in this object.

#### SgNode::sage_class_name() const generates string representing the class name: (e.g. for SgNode returns "SgNode"). This function is useful for debugging and error reporting. It returns the name of the IR node. ‐ Deprecated: Use class_name() which returns a C++ string object. ‐ Return: a char* pointer to a C style string.

#### string SgNode::class_name() const generates string representing the class name: (e.g. for SgNode returns "SgNode"). This function is useful for debugging and error reporting. It returns the name of the IR node. ‐ Return: a C++ string object.

#### SgNode::variant() const Older version function returns enum value "NODE" This function is an older version of the variant function. This function is useful for debugging and error reporting. It returns the name of the IR node. ‐ Return: an int value. ‐ Deprecated: Use variantT() instead. Older enum values have inconsistant names and are being removed.

#### SgNode::getVariant() const Older version function returns enum value "NODE" This function is an older version of the variant function. This function is useful for debugging and error reporting. It returns the name of the IR node. ‐ Return: an int value. ‐ Deprecated: Use variantT() instead. Older enum values have inconsistant names and are being removed.

#### SgNode::variantT() const returns enum value "V_SgNode" This function is useful for debugging and error reporting. It returns the name of the IR node. Once the variant() function is removed this function will be deprecated and replaced by a new function named "variant()". The new "variant()" function will return the new enum type (with consistant naming convention in place). The name of the enum type might be changed to make it more clear. ‐ Return: an enum value (type: VariantT).

#### SgNode::get_isModified() const FOR INTERNAL USE All nodes in the AST contain a isModified flag. This flag can be set but this is typically an internal function used to track the updates to AST. ‐ Return: Returns bool; true if IR node has been modified.

#### SgNode::set_isModified(bool isModified) Acess function for isModified flag. This flag records if the current IR node has been modified. It is set to false after and ROSE front‐end processing.

#### SgNode::get_isVisited() const DOCS IN SgNode.docs: Access function for p_isVisited flag used previously by the AST traversals. ‐ Deprecated: This function is not used and will be removed. ‐ Return: Returns bool; true if previously visited within current AST traversal.

#### SgNode::set_isVisited(bool isVisited) DOCS IN SgNode.docs: Access function for p_isVisited flag used previously by the AST traversals. ‐ Deprecated: This function is not used and will be removed.

#### SgNode::isSgNode (SgNode *s) Cast function (from derived class to SgNode pointer). This functions returns a SgNode pointer for any input of a pointer to an object derived from a SgNode. ‐ Return: Returns valid pointer to SgNode if input is derived from a SgNode.

#### SgNode::isSgNode (const SgNode *s) Cast function (from derived class to SgNode pointer). This functions returns a SgNode pointer for any input of a pointer to an object derived from a SgNode. ‐ Return: Returns valid pointer to SgNode if input is derived from a SgNode.

#### SgNode::set_parent (SgNode *parent) Sets parent node for any IR node. The parent node in the AST can be set but this is typically an internal function used to build the AST. ‐ Param parent: ‐ Pointer to parent node to store within the current IR node. ‐ Return: returns void.

#### SgNode::get_parent() const Access function for parent node in AST. The parent node in the AST can be accessed, in general only the project node, symbols and types should be NULL. Since parent nodes are set within post processing (and using the ROSE AST traveral mechanism) the parents are guarenteed to match the traversal, and no other concept of what could be a parent within the AST (e.g a parent concept based on scope). Because the traversal is based on the source code layout, what is a parent is similarly based on the source code layout and not any concept of scope. Note that the scope of relavant IR nodes is stored explicitly in the AST, precisely because it is not always related to the layout of the source code (and thus not related to the concept of parent in the AST). ‐ Return: Returns pointer to SgNode

#### SgNode::unparseToString( SgUnparse_Info* info ) This function unparses the AST node (source code only, excluding comments and white space) ‐ Param info: is optional (used only to specify code generation options). This function is useful for converting AST nodes to strings as part of general debugging or the construction of other strings for use as input to the AST rewrite mechansims which accepts source code strings. See tutorial for examples of this. This function uses the SgUnparse_Info as an inherited attribute internally and using this attribute it will correctly handled many subtle details that will be ignored if the attribute is not provided. For example, the SgUnparse_Info can record if the statement is in a conditional and if so then the trailing ";" will be omitted in the generated code. See the SgUnparse_Info documentation for the numerous other internal settings that can effect the generated code. Because of these details, the unparseToString() function can not always be used to generate compiliable code. ‐ Return: Returns std::string

#### SgNode::unparseToCompleteString() This function unparses the AST node (including comments and white space) This function is a complement to the unparseToString() function and includes any associated comments and preprocessor control directives. Because C preprocessor control directive can be included string generated using this function may or may not be appropriate for use as input to the AST rewrite mechanism. ‐ Todo: This function needs a better name since it is unclear what the "complete" string is. ‐ Return: Returns std::string

#### SgNode::get_traversalSuccessorContainer() FOR INTERNAL USE within ROSE traverals mechanism only. This function builds and returns a copy of ordered container holding pointers to children of this node in a traversal. It is associated with the definition of a tree that is travered by the AST traversal mechanism; a tree that is embeded in the AST (which is a more general graph). This function is used within the implementation of the AST traversal and has a semantics may change in subtle ways that makes it difficult to use in user code. It can return unexpected data members and thus the order and the number of elements is unpredicable and subject to change. ‐ Warning: This function can return unexpected data members and thus the order and the number of elements is unpredicable and subject to change. ‐ Return: Returns ordered STL Container of pointers to children nodes in AST.

#### SgNode::get_traversalSuccessorNamesContainer() FOR INTERNAL USE within ROSE traverals mechanism only. This function builds and returns a copy of ordered container holding strings used to name data members that are traversed in the IR node. It is associated with the definition of a tree that is travered by the AST traversal mechanism; a tree that is embeded in the AST (which is a more general graph). This function is used within the implementation of the AST traversal and has a semantics may change in subtle ways that makes it difficult to use in user code. It can return unexpected data members and thus the order and the number of elements is unpredicable and subject to change. ‐ Warning: This function can return unexpected data members and thus the order and the number of elements is unpredicable and subject to change. Each string is a name of a member variable holding a pointer to a child in the AST. The names are the same as used in the generated enums for accessing attributes in a traversal. The order is the same in which they are traversed and the same in which the access enums are defined. Therefore this method can be used to get the corresponding name (string) of an access enum which allows to produce more meaningful messages for attribute computations. ‐ Return: Returns ordered STL container of names (strings) of access names to children nodes in AST.

#### SgNode::roseRTI () FOR INTERNAL USE Access to Runtime Type Information (RTI) for this IR nodes. This function provides runtime type information for accessing the structure of the current node. It is useful for generating code which would dump out or rebuild IR nodes. ‐ Return: Returns a RTIReturnType object (runtime type information).