ROSE Compiler Framework/ROSE API

The goal of this page is to collect discussions for refactoring ROSE API

Original version is the direct copy&past from 1.22 ROSE API Refactoring of the ROSE developer's Guide

This is the outline of the API, add API functions to the next section. This a draft design for a new High Level ROSE API where high level function interfaces will be located that call mechanisms for analysis, transformation, and expected user level support for ROSE tools. This support is presently spread around in ROSE and this API would centralize it and make ROSE more clear to users. There are four levels:

ROSE Frontend
Generation of Abstract Syntax Tree (AST) from source code or binary executable. The AST holds structural representations of the input software.

ROSE Midend
Analysis and transformation support for ROSE-based tools.

ROSE Analysis API
This would include intra-procedural analysis, inter-procedural analysis, and whole program analysis (which over comes the issues of separate compilation). This analysis can handle either source code analysis, binary analysis, or both. Program analysis on source code includes:

Program analyses on source code include:
 * Call Graph Analysis
 * Class Hierarchy Analysis
 * Control Flow Analysis
 * Def-Use Analysis
 * Dominance Analysis
 * Dominator Trees And Dominance Frontiers Analysis (old)
 * Connection of Open Analysis (old)
 * Pointer Analysis
 * Procedural Slicing (old; not used)
 * Side-Effect Analysis
 * Value Propagation Analysis
 * Static Interprocedural Slicing (replaces Procedural Slicing)
 * Liveness Analysis
 * Dependence Analysis
 * AST Interpreter (Interpretation of Concrete Semantics using AST)

Program analyses on binaries include:
 * Call Graph Analysis
 * Control Flow Analysis
 * Constant Propogation
 * Data Flow Analysis
 * InstructionSemantics
 * Library Identification (FLIRT)
 * Dwarf Debug Format
 * Analysis of the Binary File Format

ROSE Transformation API
Modifications of the AST can be organized as: i. Instrumentation

ii. Optimization These include a range of optimizations relevant for general performance optimization of scientific applications.
 * Inlining
 * Loop optimizations:fusion, fisson, unrolling, blocking, loop interchange, array copy, etc.
 * Constant Folding
 * Finite Differencing
 * Partial Redundancy Elimination

iii. General Transformations These include outlining, deep or shallow copying via a single function. language declarations to support whole program analysis. Duplicate parts of the merged AST are deleted. this work.
 * Outlining
 * ImplicitCodeGeneration: This work makes C++ implicit semantics explicit for C style analysis.
 * FunctionCallNormalization: This is a library of function call normizations to support binary analysis.
 * AST Copy support: This support permits arbitrary subtrees (or the whole AST) to be copied with control over
 * AST Merge support: This work permits the merging of separate AST’s and the sharing of their identically names
 * Static Binary Rewriting A restricted set of transformations are possible on a binary executable, this section details

AST Traversals
ROSE provides a number of different techniques to define traversals of the AST and associated graphs formed from the AST.

ROSE Backend
The backend contains functions for code generation from the AST (unparsing) and for optionally calling the backend compiler. ROSE includes a number of features specific to the code generation phase: Users can generate code from subsets of the AST as part of support for custom code generation. This section contains support for the output of arbitrary text in the code generation phase. For example, it is useful for generating code for specialized GPU tools, etc. Some control is possible with respect to the format of the generated code.
 * Code Generation from Arbitrary Subtrees of the AST
 * Generation of Arbitrary Tests with Generated Code
 * Code Generation Format Control

ROSE Utilities
Useful utility functions for ROSE-based tools. AST support for visualization includes representations as PDF, DOT, and a more colorful representation of the whole graph that includes AST plus type attributes (not typically as part of an AST). This work includes support for dot2gml translation (in roseIndependentSupport/dot2gml). this is where interfaces to possible OGDF (Open Graph Drawing Framework) could be put. The AST Query mechanism is a simple approach to getting list of IR nodes. It is typically used within analysis or transformations. The consistency tests validate that the AST is correctly formed. Note that this is not a test that the code that will be generated is leagal code. This section provides support to measure both space and time complexity for ROSE based tools. AST postprocessing is the step used to fix the AST after user modification to output a correctly formed AST. Not all modifications to the AST can be corrected using this step. This section contains the support for writing and reading the AST to and from files. Binary file I/O is used and is designed for performance in both space and time. This section contains support for generating unique names for language constructs and handling mangled and unmangled names for use in ROSE based tools. This section contains the support for reading and writing comments and CPP directives within the AST. This section contains the support for building GUI based tools using ROSE. This section contains the support for using IDA Pro with ROSE for Binary Analysis. This section contains the support for building tools that use SQLite Database. This section contains the support for building custom graphs to represent static and dynamic analysis and graph analysis algorithms to support of analyses of these graphs. This section contains the support for dynamically derived information to be written into the AST (performance inforamtion to support analysis and optimization tools). This section contains the support for building abstract handles into source code. This work is used in the autotuning and also other tools that pass references to source code as part of an interface. This is currently in the ROSE/projects directory and should perhaps be a part of the ROSE API. This is the command line handling used internally by ROSE and made available so that users can process the command line for their specific ROSE based tools. These functions support common operations on strings used within ROSE and useful for ROSE based tools. These are a collection of functions useful for handling directory structures in ROSE-based tools. Output of usage information, ROSE version number support, etc.
 * AST Visualization
 * AST Query
 * AST Consistancy Tests
 * Performance Monitoring
 * AST Postprocessing
 * AST File I/O Support
 * Language Specific Name Support
 * Support For Comments and CPP Directives
 * GUI Support
 * Binary Analysis Connection to IDA PRO
 * Database Support
 * Graphs and Graph Analysis
 * Performance Metric Annotation
 * Abstract Handles
 * Macro Rewrapper
 * Command-line Processing Support
 * Common String Support
 * Common File and Path Support
 * Miscellaneous Support