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