Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.
About 1,514 papers for “alias analysis”
Yu Yang, Greg Szubzda, Xiaofang Chen et al. · 2011
�Affected 50 million people �Had $6 billion cost �Causes? The alarm system was stalled due to a concurrency bug! This part will not be traversed if backtrack naively! dependent visited state Naïve backtracking does not work!
Cited by 0
Jyothi Vedurada, V. Krishna Nandivada · 2019
Many program-analysis based tools require precise points-to/alias information only for some program variables. To meet this requirement efficiently, there have been many works on demand-driven analyses that perform only the work necessary to compute the points-to or alias information on the requested variables (queries). However, these demand-driven analyses can be very expensive when applied on large systems where the number of queries can be significant. Such a blow-up in analysis time is unacceptable in cases where scalability with real-time constraints is crucial; for example, when program analysis tools are plugged into an IDE (Integrated Development Environment). In this paper, we propose schemes to improve the scalability of demand-driven analyses without compromising on precision. Our work is based on novel ideas for eliminating irrelevant and redundant data-flow paths for the given queries. We introduce the idea of batch analysis, which can answer multiple given queries in batch mode. Batch analysis suits the environments with strict time constraints, where the queries come in batch. We present a batch alias analysis framework that can be used to speed up given demand-driven alias analysis. To show the effectiveness of this framework, we use two demand-driven alias analyses (1) the existing best performing demand-driven alias analysis tool for race-detection clients and (2) an optimized version thereof that avoids irrelevant computation. Our evaluations on a simulated data-race client, and on a recent program-understanding tool, show that batch analysis leads to significant performance gains, along with minor gains in precision.
Cited by 10
Patrick W. Sathyanathan, Monica S. Lam, John C et al. · 2001
Storage Graph . . . . . . . . . . . . . . . . . . . . . . . . . 124 6.4.2 Dataow Lattice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 6.5 Transfer Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 ix 6.5.1 Labeling execution instances . . . . . . . . . . . . . . . . . . . . . . 125 6.5.2 LTFs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 6.6 Intraprocedural Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 6.6.1 Malloc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 6.6.2 Assignment Statements . . . . . . . . . . . . . . . . . . . . . . . . . 127 6.7 Interprocedural Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 6.7.1 Processing SCCs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 7 An elimination algorithm for interprocedural alias analysis 136 7.1.1 Alias Abstractions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 7.1.2 Elimination algorithms for interprocedural pointer analysis . . . . . 138 7.1.3 An Example Program . . . . . . . . . . . . . . . . . . . . . . . . . . 138 7.2 Induction variable introduction . . . . . . . . . . . . . . . . . . . . . . . . . 139 7.2.1 Iterative control structures . . . . . . . . . . . . . . . . . . . . . . . 140 7.2.2 Interprocedural context . . . . . . . . . . . . . . . . . . . . . . . . . 142 7.3 Sequence Tokens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 7.3.1 Dynamic Sequence Tokens . . . . . . . . . . . . . . . . . . . . . . . . 144 7.3.2 Interprocedural sequence tokens . . . . . . . . . . . . . . . . . . . . 145 7.4 Data types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 7.4.1 A Layout dependent represe...
Cited by 0
Sheng-Hsiu Lin · Lehigh Preserve · 2015
Alias analysis is a study of the relations between pointers. It has important applications in code optimization and security. This research introduces the fundamental concepts of alias analysis. It explains different approaches of alias analysis with examples. It provides a survey of some very important pointer analysis algorithms. LLVM interface is introduced along with the alias analyses that are currently available on it. This research implementes a Steensgaard's pointer analysis on LLVM. The philosophy of this implementation is explained in detail. Evaluations of rule based basic alias analysis, Andersen's pointer analysis, Steensgaard's pointer analysis and data structure analysis are provided with experimental results on their precision, time and memory usage.
Cited by 0Open access
Keith D. Cooper, Ken Kennedy · 1989
We present a new algorithm for computing interprocedural aliases due to passing parameters by reference. This algorithm runs in O(N2+NE) time and, when combined with algorithms for alias-free, flow-insensitive data-flow problems, yields algorithms for solution of the general flow-insensitive problems that also run in O(N2+NE) time.
Cited by 114Open access
Amer Diwan, Kathryn S. McKinley, J. Eliot B. Moss · ACM SIGPLAN Notices · 1998
This paper evaluates three alias analyses based on programming language types. The first analysis uses type compatibility to determine aliases. The second extends the first by using additional high-level information such as field names. The third extends the second with a flow-insensitive analysis. Although other researchers suggests using types to disambiguate memory references, none evaluates its effectiveness. We perform both static and dynamic evaluations of type-based alias analyses for Modula-3, a statically-typed type-safe language. The static analysis reveals that type compatibility alone yields a very imprecise alias analysis, but the other two analyses significantly improve alias precision. We use redundant load elimination (RLE) to demonstrate the effectiveness of the three alias algorithms in terms of the opportunities for optimization, the impact on simulated execution times, and to compute an upper bound on what a perfect alias analysis would yield. We show modest dynamic improvements for (RLE), and more surprisingly, that on average our alias analysis is within 2.5% of a perfect alias analysis with respect to RLE on 8 Modula-3 programs. These results illustrate that to explore thoroughly the effectiveness of alias analyses, researchers need static, dynamic, and upper-bound analysis. In addition, we show that for type-safe languages like Modula-3 and Java, a fast and simple alias analysis may be sufficient for many applications.
Cited by 41Open access
Michael Burke, Paul R. Carini, Jong-Deok Choi et al. · 1997
Cited by 0
Amer Diwan, Kathryn S. McKinley, J. Eliot B. Moss · 1998
This paper evaluates three alias analyses based on programming language types. The first analysis uses type compatibility to determine aliases. The second extends the first by using additional high-level information such as field names. The third extends the second with a flow-insensitive analysis. Although other researchers suggests using types to disambiguate memory references, none evaluates its effectiveness. We perform both static and dynamic evaluations of type-based alias analyses for Modula-3, a statically-typed type-safe language. The static analysis reveals that type compatibility alone yields a very imprecise alias analysis, but the other two analyses significantly improve alias precision. We use redundant load elimination (RLE) to demonstrate the effectiveness of the three alias algorithms in terms of the opportunities for optimization, the impact on simulated execution times, and to compute an upper bound on what a perfect alias analysis would yield. We show modest dynamic improvements for (RLE), and more surprisingly, that on average our alias analysis is within 2.5% of a perfect alias analysis with respect to RLE on 8 Modula-3 programs. These results illustrate that to explore thoroughly the effectiveness of alias analyses, researchers need static, dynamic, and upper-bound analysis. In addition, we show that for type-safe languages like Modula-3 and Java, a fast and simple alias analysis may be sufficient for many applications.
Cited by 164
Moss, Eliot B. · ScholarWorks@UMassAmherst (University of Massachusetts Amherst) · 1998
This paper evaluates three alias analyses based on programming language types. The first analysis uses type compatibility to determine aliases. The second extends the lirst by using additional high-level information such as field names. The third extends the second with a flow-insensitive analysis. Although other researchers suggests using types to disambiguate memory references, none evaluates its effectiveness. We perform both static and dynamic evaluations of type-based alias analyses for Modula-3, a statically-typed type-safe language. The static analysis reveals that type compatibility alone yields a very imprecise alias analysis, but the other two analyses significantly improve alias precision. We use redundant load elimination (RLE) to demonstrate the effectiveness of the three alias algorithms in terms of the opportunities for optimization, the impact on simulated execution times, and to compute an upper bound on what a perfect alias analysis would yield. We show modest dynamic improvements for (RLE), and more surprisingly, that on average our alias analysis is within 2.5% of a perfect alias analysis with respect to RLE on 8 Modula-3 programs. These results illustrate that to explore thoroughly the effectiveness of alias analyses, researchers need static, dynamic, and upper-bound analysis. In addition, we show that for type-safe languages like Modula-3 and Java, a fast and simple alias analysis may be sufficient for many applications.
Cited by 0
Amer Diwan Kathryn, Kinley J. Eliot, B. Moss · 1998
This paper evaluates three alias analyses based on programming language types. The first analysis uses type compatibility to determine aliases. The second extends the first by using additional high-level information such as field names. The third extends the second with a flow-insensitive analysis. Although other researchers suggests using types to disambiguate memory references, none evaluates its effectiveness. We perform both static and dynamic evaluations of type-based alias analyses for Modula-3, a statically-typed type-safe language. The static analysis reveals that type compatibility alone yields a very imprecise alias analysis, but the other two analyses significantly improve alias precision. We use redundant load elimination (RLE) to demonstrate the effectiveness of the three alias algorithms in terms of the opportunities for optimization, the impact on simulated execution times, and to compute an upper bound on what a perfect alias analysis would yield. We show modest dynamic...
Cited by 0
Erik Ruf · ACM SIGPLAN Notices · 1995
Recent work on alias analysis in the presence of pointers has concentrated on context-sensitive interprocedural analyses, which treat multiple calls to a single procedure independently rather than constructing a single approximation to a procedure's effect on all of its callers. While context-sensitive modeling offers the potential for greater precision by considering only realizable call-return paths, its empirical benefits have yet to be measured. This paper compares the precision of a simple, efficient, context-insensitive points-to analysis for the C programming language with that of a maximally context-sensitive version of the same analysis. We demonstrate that, for a number of pointer-intensive benchmark programs, context-insensitivity exerts little to no precision penalty. We also describe techniques for using the output of context-insensitive analysis to improve the efficiency of context-sensitive analysis without affecting precision.
Cited by 33
Tasneem Kaochar · 2012
I hereby grant to the University of Arizona Librarv the nonexclusive worldrdde rffi Io reproduce and distiibute my thesis an'd abstract (herein, the "licensei [ materiils'), in whole or in pait, in any and all media of distribution and in any format in existence nbw or devel6ped in the future. I represent and warrairt to the Universiw of Arizona'that the fcensed miterials are my original work. that I am fhe sole owner of all riehts in and to the licensed?natelids, and that none of the licensed materials'infringe or violate the riehts of others. I firrther reDresent that I have obtaine? dl necessary.i$tr to permit the University^of Arizona Library to reproduce and distribrlte any^nonpublic third paitv software necesiary ro access. display run, or print my thesis. I ackirowledee that Universiw of Arizoni Ubraiy may elect not to distribute my theiis in digital forrhat if, in its
Cited by 0
Sanjiv K. Gupta, Naveen Sharma · 2003
Most existing alias analysis techniques are formulated in terms of high-level language constructs and are unable to cope with pointer arithmetic. For machines that do not have ’base + offset ’ addressing mode, pointer arithmetic is necessary to compute a pointer to the desired address. Most state of the art compilers such as GCC lack the mechanism to determine aliasing between such computed pointers. Few other existing alias analysis techniques described for executable code can handle pointer arithmetic but require large memory when applied to intermediate languages such as RTL. In this paper, we describe a method of disambiguating the computed pointers within a procedure at the intermediate code level. The method is similar to the techniques described for executable code but requires significantly less amount of memory. We have experimented our method with the GCC RTL and it reduces the code size of array manipulating benchmarks by approximately 4-7 % for the machines that do not have ’base + offset ’ addressing mode. 1
Cited by 0
Bolvanský, Dávid · Brno University of Technology Digital Library (Brno University of Technology) · 2018
This thesis is dedicated to the problem of alias analysis and possibilities of its improvement in the LLVM framework. The goal of this thesis is to improve the accuracy, which was achieved by extending the existing implementation of Andresen algorithm to be field sensitive. The terms related to alias analysis and algorithms of the alias analysis available in LLVM are explained. These algorithms are compared according to their base idea, features, and limitations. The implementation of the field sensitivity has been tested using compiler test suites. Its impact on program compilation speed and performance has been analyzed. The measured results show an increase in the accuracy of alias analysis in the LLVM framework.
Cited by 0
Manu Sridharan · Lecture notes in computer science · 2013
Cited by 0
Deborah S. Coutant · 1986
All optimizing compilers must deal with the problem of aliases arising due to the presence of multiple names that reference the same memory areas. Presented in this paper is a staged, high-level alias analysis methodology that provides detailed alias information to a global optimizer implemented at any level in the compilation process. The framework provides easy portability of optimizing compilers to new architectures, as well as the easy addition, of new compilers to an already existing family of optimizing compilers. The method involves the application of a set of language-specific alias rules to the source code in order to gather alias information. A language-independent component then performs a transitive closure of this information and transforms it into a presentation more suitable for use by a global optimizer. Each stage of the methodology is detailed. Results are given for an implemented family of compilers targeted for a reduced instruction set computer.
Cited by 43Open access
Amer Diwan, Kathryn S. Mckinley, J. Eliot et al. · 2008
This paper evaluates three alias analyses based on programming language types. The first analysis uses type compatibility to determine aliases. The second extends the first by using additional high-level information such as field names. The third extends the second with a flow-insensitive analysis. Although other researchers suggests using types to disambiguate memory references, none evaluates its effectiveness. We perform both static and dynamic evaluations of type-based alias analyses for Modula-3, a statically-typed type-safe language. The static analysis reveals that type compatibility alone yields a very imprecise alias analysis, but the other two analyses significantly improve alias precision. We use redundant load elimination (RLE) to demonstrate the effectiveness of the three alias algorithms in terms of the opportunities for optimization, the impact on simulated execution times, and to compute an upper bound on what a perfect alias analysis would yield. We show modest dynamic improvements for (RLE), and more surprisingly, that on average our alias analysis is within 2.5 % of a perfect alias analysis with respect to RLE on 8 Modula-3 programs. These results illustrate that to explore thoroughly the effectiveness of alias analyses, researchers need static, dynamic, and upper-bound analysis. In addition, we show that for type-safe languages like Modula-3 and Java, a fast and simple alias analysis may be sufficient for many applications. 1
Cited by 0
Wen Chen, Alan Wassyng, Tom Maibaum · Lecture notes in business information processing · 2014
This work is concerned with localizing and analyzing the potential impact of changes to large-scale enterprise systems, and, in particular, how to incorporate reachability analysis and aliasing/pointer analysis to minimise false-positives and eliminate false-negatives. It is a continuation of our previous work, which included static analysis [1] and dynamic analysis [2] of changes to systems containing hundreds of thousands of classes and millions of methods. This current work adds: reachability analysis that examines the program to see “whether a given path in a program representation corresponds to a possible execution path”, such that infeasible paths of mis-matched calls and returns can be filtered out from the estimated impact set; and alias analysis to identify paths that are feasible but cannot be affected. Using our approach, organizations can focus on a much smaller, relevant subset of the test suite instead of performing their entire suite of tests without any idea as to whether any test is necessary. Also, in the future, we hope to be able to help testers to augment the test suite with new tests that cover the impacted methods/paths not already subjected to testing. We include a case study that illustrates the savings that can be attained.
Cited by 1Open access
2008
Most alias analyses produce approximate results in the pres-ence of array slices. This may lead to inefficient code which is of concern, especially, in languages like Fortrango. In this paper, we present an overview of a static alias analysis that gives accurate results in the presence of array slices in Fortran90. 1
Cited by 0
2008
Optimizations performed at link time or directly applied to final program executables have received increased attention in recent years. Such low-level optimizations can benefit greatly from pointer alias information. However, as almost all existing alias analyses are formulated in terms of source language constructs, they turn out to be of limited utility at the machine code level. This paper describes two different approaches to highquality, low-cost, speculative may-alias analysis, to be applied in the context of link-time or executable code optimizers. The key idea behind our proposals is the introduction of unsafe speculations at analysis-time, which increases alias precision on important portions of code, and keeps the analysis reasonably cost-efficient. Experimental results indicate that introducing speculation at analysis-time is clearly beneficial: precision increases up to 83 % in average, against a baseline precision of 16%. Furthermore, the percentage of dynamic misspeculations is typically about 2%, which shows that our technique can be used even for scenarios where speculation recovery is expensive. 1.
Cited by 0