Outliner

Namespaces

Name

Preprocess

Types

Name

Description

Result

Stores the main results of an outlining transformation.

Functions

Name

Description

appendIndividualFunctionCallArgs
void appendIndividualFunctionCallArgs(ASTtools::VarSymSet_t const& syms, std::set<SgInitializedName*> const varUsingOriginalType, SgExprListExp* e_list);

Generates a function call parameter list using a set of symbols

collectVars
void collectVars(SgStatement const* s, ASTtools::VarSymSet_t& syms);

Computes the set of variables in 's' that need to be passed to the outlined routine (semantically equivalent to shared variables in OpenMP)

commandLineProcessing
void commandLineProcessing(std::vector<std::string>& argvList);

Accept a set of command line options to adjust internal behaviors

generateCall
SgStatement* generateCall(SgFunctionDeclaration* out_func, ASTtools::VarSymSet_t const& syms, std::set<SgInitializedName*> const readOnlyVars, std::string wrapper_arg_name, SgScopeStatement* scope);

Generates a call to an outlined function.

generateFuncArgName
std::string generateFuncArgName(SgStatement const* stmt);

Create a unique outlined‐function's wrapper argument name for the specified statement.

generateFuncName
std::string generateFuncName(SgStatement const* stmt);

Create a unique outlined‐function name for the specified statement.

generateFunction
SgFunctionDeclaration* generateFunction(SgBasicBlock* s, std::string const& func_name_str, ASTtools::VarSymSet_t const& syms, ASTtools::VarSymSet_t const& pdSyms, std::set<SgInitializedName*> const& restoreVars, SgClassDeclaration* struct_decl, SgScopeStatement* scope);

generateLibSourceFileName
std::string generateLibSourceFileName(SgBasicBlock* target);

the lib source file's name convention is rose_input_lib.[c|cxx].

generateNewSourceFile
SgSourceFile* generateNewSourceFile(SgBasicBlock* target, std::string const& file_name);

Generate a new source file under the same SgProject as target, the file's base name is file_name_str. Suffix is automatically generated according to the file suffix of s

generatePackingStatements
std::string generatePackingStatements(SgStatement* target, ASTtools::VarSymSet_t& syms, ASTtools::VarSymSet_t& pdsyms, SgClassDeclaration* struct_decl = NULL);

Generate packing (wrapping) statements for the variables to be passed

generateParameterStructureDeclaration
SgClassDeclaration* generateParameterStructureDeclaration(SgBasicBlock* s, std::string const& func_name_str, ASTtools::VarSymSet_t const& syms, ASTtools::VarSymSet_t& pdSyms, SgScopeStatement* func_scope);

Generate a struct declaration to wrap all variables to be passed to the outlined function There are two ways to wrap a variable: Using its value vs. Using its address (pointer type)

getLibSourceFile
SgSourceFile* getLibSourceFile(SgBasicBlock* target);

Obtain the file handle to the separated source file storing outlined functions. This file will be compiled to .so dynamically loadable library. target is the input code block for outlining. It provides SgProject and input file name info. the lib source file's name convention is rose_input_lib.[c|cxx].

insert
SageInterface::DeferredTransformation insert(SgFunctionDeclaration* func, SgScopeStatement* scope, SgBasicBlock* outlining_target);

isFortranModuleDefinitionScope
bool isFortranModuleDefinitionScope(SgScopeStatement const* scope);

isOutlineable
bool isOutlineable(SgStatement const* s, bool verbose = false);

Returns true iff the statement is "outlineable."

isValidOutliningScope
bool isValidOutliningScope(SgScopeStatement const* scope);

outline
Result outline(SgPragmaDeclaration* s);

outline overloads

outlineAll
size_t outlineAll(SgProject*);

Outlines all regions marked by outlining pragmas.

outlineBlock
Result outlineBlock(SgBasicBlock* b, std::string const& name);

Outlines the given basic block into a function named 'name'.

preprocess
SgBasicBlock* preprocess(SgPragmaDeclaration* s);