Effective function merging in the SSA form

Abstract

Function merging is an important optimization for reducing code size. This technique eliminates redundant code across functions by merging them into a single function. While initially limited to identical or trivially similar functions, the most recent approach can identify all merging opportunities in arbitrary pairs of functions. However, this approach has a serious limitation which prevents it from reaching its full potential. Because it cannot handle phi-nodes, the state-of-the-art applies register demotion to eliminate them before applying its core algorithm. While a superficially minor workaround, this has a threefold negative effect: by artificially lengthening the instruction sequences to be aligned, it hinders the identification of mergeable instruction; it prevents a vast number of functions from being profitably merged; it increases compilation overheads, both in terms of compile-time and memory usage. We present SalSSA, a novel approach that fully supports the SSA form, removing any need for register demotion. By doing so, we notably increase the number of profitably merged functions. We implement SalSSA in LLVM and apply it to the SPEC 2006 and 2017 suites. Experimental results show that our approach delivers on average, 7.9% to 9.7% reduction on the final size of the compiled code. This translates to around 2× more code size reduction over the state-of-theart. Moreover, as a result of aligning shorter sequences of instructions and reducing the number of wasteful merge operations, our new approach incurs an average compile-time overhead of only 5%, 3× less than the state-of-the-art, while also reducing memory usage by over 2×.

Loop Rolling for Code Size Reduction

“…The cost of each instruction comes from querying this compiler's built-in cost model, which provides a cost estimation that approximates the size of an IR instruction when lowered to the target machine. We use the code-size cost model provided by LLVM's targettransformation interface (TTI), which is used in the decision making of most optimizations [11], [25].…”

An Approach for Detecting Feasible Paths Based on Minimal SSA Representation and Symbolic Execution

“…Infeasible paths are also caused by the conflicting clauses found within certain paths. Moreover, infeasible paths could potentially be associated with conditional statements specific to a variable (which is also one of the major causes of the inability to access specific aspects of a program [19,20]). Therefore, to improve the outcomes of the static analysis, a detection stage of the feasible paths within the source code should be in place.…”

“…However, this representation introduces a complication at join points of different flow branches. To solve this problem, a φ function is used in places where we could not pinpoint the exact variable "version" [19,20]. A code corresponding to the φ function usage and a simplified graph excerpt are shown in Figure 2b.…”

Early DSE and Automatic Generation of Coarse Grained Merged Accelerators

“…FMSA and SalSSa [21,22] were recently introduced as LLVM [14] compilation transformations that target code reduction for embedded devices. Work prior to FMSA is only able to merge equal functions whereas FMSA is able to merge functions with different argument lists, returned values and references as well as differing control flow.…”

“…Finally, neither FMSA nor other function merging approaches have been used for accelerator merging. Both the function merging and the Early-DSE related-work [11,21,22] demonstrate their results on the SPEC CPU2006 suite, and we include these applications in this paper for comparison.…”