Skip to content

Outliner

Namespaces

Name
Preprocess

Types

Name Description
OutlinedLocalTypeTemplateEntry
OutlinedLocalTypeTemplatePlan
Result Stores the main results of an outlining transformation.

Type Aliases

Name
OutlinedFunctionParameterBindings

Functions

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

Variables

Name Description
AUTOTUNING_LIB_HEADER
DEFAULT_OUTPUT_PATH
FIND_AND_CALL_FUNCP_DLOPEN
FIND_FUNCP_DLOPEN
MASTER_SHARED_LIB_NAME
copy_origFile
enable_classic
enable_debug
enable_liveness
enable_template
exclude_headers
lines
output_path
preproc_only_
select_omp_loop
suppress_autotuning_header
temp_variable A set of flags to control the internal behavior of the outliner
useNewFile
useParameterWrapper
useStructureWrapper
use_dlopen
use_dlopen_simple

Created with MrDocs