Interprocedural Constant Propagation Research Articles

Trimmer: An Automated System for Configuration-Based Software Debloating

Software bloat has negative implications for security, reliability, and performance. To counter bloat, we propose <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Trimmer</small> , a static analysis-based system for pruning unused functionality. <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Trimmer</small> removes code that is unused with respect to user-provided command-line arguments and application-specific configuration files. <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Trimmer</small> uses concrete memory tracking and a custom inter-procedural constant propagation analysis that facilitates dead code elimination. Our system supports both context-sensitive and context-insensitive constant propagation. We show that context-sensitive constant propagation is important for effective software pruning in most applications. We introduce <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">sparse constant propagation</i> that performs constant propagation only for configuration-hosting variables and show that it performs better (higher code size reductions) compared to constant propagation for all program variables. Overall, our results show that <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Trimmer</small> reduces binary sizes for real-world programs with reasonable analysis times. Across 20 evaluated programs, we observe a mean binary size reduction of 22.7 percent and a maximum reduction of 62.7 percent. For 5 programs, we observe performance speedups ranging from 5 to 53 percent. Moreover, we show that winnowing software applications can reduce the program attack surface by removing code that contains exploitable vulnerabilities. We find that debloating using <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Trimmer</small> removes CVEs in 4 applications.

Interprocedural constant propagation

In a compiling system that attempts to improve code for a whole program by optimizing across procedures, the compiler can generate better code for a specific procedure if it knows which variables will have constant values, and what those values will be, when the procedure is invoked. This paper presents a general algorithm for determining for each procedure in a given program the set of inputs that will have known constant values at run time. The precision of the answers provided by this method are dependent on the precision of the local analysis of individual procedures in the program. Since the algorithm is intended for use in a sophisticated software development environment in which local analysis would be provided by the source editor, the quality of the answers will depend on the amount of work the editor performs. Several reasonable strategies for local analysis with different levels of complexity and precision are suggested and the results of a prototype implementation in a vectorizing Fortran compiler are presented.

Precise interprocedural dataflow analysis with applications to constant propagation

This paper concerns interprocedural dataflow-analysis problems in which the dataflow information at a program point is represented by an environment (i.e., a mapping from symbols to values), and the effect of a program operation is represented by a distributive environment transformer. We present two efficient algorithms that produce precise solutions: an exhaustive algorithm that finds values for all symbols at all program points, and a demand algorithm that finds the value for an individual symbol at a particular program point. Two interesting problems that can be handled by our algorithms are (decidable) variants of the interprocedural constant-propagation problem: copy-constant propagation and linear-constant propagation. The former interprets program statements of the form x ≔ 7 and x ≔ y. The latter also interprets statements of the form x ≔ 5 * y + 17. Experimental results on C programs have shown that • Although solving constant-propagation problems precisely (i.e., finding the meet-over-all- valid-paths solution, rather than the meet-over- all-paths solution) resulted in a slowdown by a factor ranging from 2.2 to 4.5, the precise algorithm found additional constants in 7 of 38 test programs. • In contrast to previous results for numeric Fortran programs, linear-constant propagation found more constants than copy-constant propagation in 6 of 38 test programs. • The demand algorithm, when used to demand values for all uses of scalar integer variables, was faster than the exhaustive algorithm by a factor ranging from 1.14 to about 6.

Interprocedural constant range propagation and alias analysis by multiple version method

A set of methods for interprocedural analysis is proposed. First, an approach for interprocedural constant propagation is given. Then the concept of constant propagation is extended so as to meet the needs of data dependence analysis. Besides certain constant, constant range can also be propagated. The related propagating rules are introduced, and an idea for computing Return function is given. This approach can solve almost all interprocedural constant propagation problems with non-recursive calls. Second, a multiple-version parallelizing technique is also proposed for alias problem. The work related to this paper has been implemented on a shared-memory parallel computer.

Flow-sensitive interprocedural constant propagation

We present a flow-sensitive interprocedural constant propagation algorithm, which supports recursion while only performing one flow-sensitive analysis of each procedure. We present experimental results which show that this method finds substantially more constants than previous methods and is efficient in practice. We introduce new metrics for evaluating interprocedural constant propagation algorithms which measure the number of interprocedural constant values that are propagated. We use these metrics to provide further experimental results for our algorithm.

Interprocedural type propagation for object-oriented languages

This paper presents a flow-sensitive interprocedural method for type propagation in an object-oriented language. The primary goal of this method is to obtain a precise call graph in the presence of late binding for function names. Thus, it can be viewed as a preliminary step to interprocedural constant propagation and/or procedure integration in an object-oriented language. It uses a new efficient form of symbolic interpretation in order to limit the amount of intraprocedural analysis required to a single pre-pass over each function. The cost of both this pre-pass and the interprocedural propagation itself is linear in the program size. Furthermore, the output of symbolic interpretation lends itself to efficient incremental computation and can be reused for other tasks, such as constant propagation or code motion.

Interprocedural constant propagation

An implementation of interprocedural constant propagation must model the transmission of values through each procedure. In the framework proposed by Callahan, Cooper, Kennedy, and Torczon in 1986, this intraprocedural propagation is modeled with a jump function . While Callahan et al. propose several kinds of jump functions, they give no data to help choose between them. This paper reports on a comparative study of jump function implementations. It shows that different jump functions produce different numbers of useful constants; it suggests a particular function, called the pass-through parameter jump function , as the most cost-effective in practice.

Interprocedural constant propagation

Constant propagation is an optimization that substitutes values for names. Interprocedural constant propagation performs this substitution throughout an entire program, propagating constant values across procedure boundaries. CONVEX Computer Corporation has developed an interprocedural optimizer for imperative languages, which is available to users of its C-series supercomputers. An aggressive interprocedural constant propagation algorithm, such as the one implemented in this optimizer, can find many constants to propagate into procedures in scientific FORTRAN applications. Detailed statistics derived from compiling a large set of real scientific applications characterize both the opportunities for interprocedural constant propagation in these codes and the effectivenss of algorithm described. These statistics include the frequency of interprocedural constant propagation, the different types of interprocedural constant propagation, which constants are most frequently propagated, and the relationship between interprocedural constant propagation and other interprocedural optimizations.

Interprocedural constant propagation

In a compiling system that attempts to improve code for a whole program by optimizing across procedures, the compiler can generate better code for a specific procedure if it knows which variables will have constant values, and what those values will be, when the procedure is invoked. This paper presents a general algorithm for determining for each procedure in a given program the set of inputs that will have known constant values at run time. The precision of the answers provided by this method are dependent on the precision of the local analysis of individual procedures in the program. Since the algorithm is intended for use in a sophisticated software development environment in which local analysis would be provided by the source editor, the quality of the answers will depend on the amount of work the editor performs. Several reasonable strategies for local analysis with different levels of complexity and precision are suggested and the results of a prototype implementation in a vectorizing Fortran compiler are presented.