SgRvalueReferenceType

Synopsis

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

class SgRvalueReferenceType
    : public SgType

Base Classes

Name	Description
SgType	This class represents the base class for all types.

Friends

Name	Description
isSgRvalueReferenceType	Casts pointer from base class to derived class (for const pointers)
isSgRvalueReferenceType	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.
get_type_name	returns the name of type t
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::isConstObj	Returns 'true' if the specified type is a 'const' object.
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::buildAlignOfOp	Build alignof() expression with a type parameter
SageBuilder::buildArrayType	Build ArrayType
SageBuilder::buildArrayType	Build an ArrayType based on dimension information. Note, the index member variable will be set to a NullExpression.
SageBuilder::buildComplexType	Build a complex type
SageBuilder::buildConstType	Build a const type.
SageBuilder::buildConstVolatileType	Build a const volatile type.
SageBuilder::buildFortranKindType	Build a type based on the Fortran kind mechanism
SageBuilder::buildFunctionParameterTypeList	Build an SgFunctionParameterTypeList from SgTypes. To build an
SageBuilder::buildFunctionType	Build function type from return type and parameter list
SageBuilder::buildFunctionType	Build function type from return type and parameter type list
SageBuilder::buildImaginaryType	Build an imaginary type
SageBuilder::buildMemberFunctionType	DQ (8/19/2012): Refactored some of the code supporting construction of the SgMemberFunctionType.
SageBuilder::buildModifierType	Build a modifier type.
SageBuilder::buildPointerMemberType	Pei‐Hung (06/30/2023): support for SgPointerMemberType
SageBuilder::buildPointerType	Build a pointer type
SageBuilder::buildReferenceType	Build a reference type
SageBuilder::buildRestrictType	Build a restrict type.
SageBuilder::buildRvalueReferenceType	Build a rvalue reference type
SageBuilder::buildSizeOfOp	Build sizeof() expression with a type parameter
SageBuilder::buildTypeExpression	DQ (7/24/2014): Adding support for c11 generic operands.
SageBuilder::buildVolatileType	Build a volatile type.
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::IsClass	strip off typedef and modifer types, then check if a type is a class type, excluding union type.
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::containsUnknownType	Check if a type (or any nested type) is unknown/incomplete.
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::findFunctionType	Find the function type matching a function signature plus a given return type
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::getArrayElementType	Get the element type of an array. It recursively find the base type for multi‐dimension array types
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::getDimensionCount	Get the number of dimensions of an array type
SageInterface::getElementType	Get the element type of an array, pointer or string, or NULL if not applicable. This function only check one level base type. No recursion.
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::getTypeName	Get the string representing the type name
SageInterface::get_name	Generate a useful name to describe the SgNode
SageInterface::get_name	Generate a useful name to describe the SgType
SageInterface::hasTrivialDestructor	Does a type have a trivial (built‐in) destructor?
SageInterface::isAncestor	check if node1 is a strict ancestor of node 2. (a node is not considered its own ancestor)
SageInterface::isAssignable	Is a type assignable? This may not quite work properly.
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::isCopyConstructible	Is a type copy constructible? This may not quite work properly.
SageInterface::isDefaultConstructible	Is a type default constructible? This may not quite work properly.
SageInterface::isEquivalentType	Test for equivalence of types independent of access permissions (private or protected modes for members of classes).
SageInterface::isMain	Check if a SgNode is a main() function declaration
SageInterface::isNonconstReference	Is this type a non‐constant reference type? (Handles typedefs correctly)
SageInterface::isOmpStatement	Check if a node is SgOmp*Statement
SageInterface::isPointerToNonConstType	Is this a pointer to a non‐const type? Note that this function will return true for const pointers pointing to non‐const types. For example, (int* const y) points to a modifiable int, so this function returns true. Meanwhile, it returns false for (int const * x) and (int const * const x) because these types point to a const int. Also, only the outer layer of nested pointers is unwrapped. So the function returns true for (const int ** y), but returns false for const (int * const * x)
SageInterface::isPointerType	Is this type a pointer type? (Handles typedefs correctly)
SageInterface::isPureVirtualClass	Check if a class type is a pure virtual class. True means that there is at least one pure virtual function that has not been overridden. In the case of an incomplete class type (forward declaration), this function returns false.
SageInterface::isReferenceType	Is this type a const or non‐const reference type? (Handles typedefs correctly)
SageInterface::isRestrictType	Is this a restrict type?
SageInterface::isScalarType	Is this a scalar type? We define the following SgType as scalar types: char, short, int, long , void, Wchar, Float, double, long long, string, bool, complex, imaginary
SageInterface::isStrictIntegerType	Check if a type is an integral type, only allowing signed/unsigned short, int, long, long long./!/! There is another similar function named SgType::isIntegerType(), which allows additional types char, wchar, and bool to be treated as integer types
SageInterface::isStructDeclaration	Check if a SgNode is a declaration for a structure
SageInterface::isStructType	Check if a type is a struct type (a special SgClassType in ROSE). Typedef and modifier types are not stripped off. Only direct struct type is returned as true.
SageInterface::isUnionDeclaration	Check if a SgNode is a declaration for a union
SageInterface::isVolatileType	Is this a volatile type?
SageInterface::mangleScalarType	Generate mangled scalar type names according to Itanium C++ ABI, the input type should pass isScalarType() in ROSE
SageInterface::mangleType	Generate a mangled string for a given type based on Itanium C++ ABI
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::removeConst	Remove const (if present) from a type. stripType() cannot do this because it removes all modifiers.
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.

Created with MrDocs