J.R. Larus and P.N. Hilfinger. Detecting conflicts between structure accesses. In SIGPLAN Conference on Programming Languages Design and Implementation, pages 21--34, New York, NY, 1988. ACM Press.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....and constructs found in real world programming languages, 20 Years of the ACM SIGPLAN Conference on Programming Language Design and Implementation (1979 1999) A Selection, 2003. Copyright 2003 ACM 1 58113 623 4 . 5.00. including arrays [4, 50, 29, 18, 32] reference parameters [20] pointers [28, 19, 10], non structured control flow [2, 11, 1, 46, 27] and threads [26, 15, 30] Context Sensitive Program Analysis Nowadays the interprocedural slicing method of the PLDI 88 paper would be termed a context sensitive interprocedural slicing method. In general, a context sensitive analysis is one in ....

J.R. Larus and P.N. Hilfinger. Detecting conflicts between structure accesses. In Conf. on Prog. Lang. Design and Impl., pages 21--34, New York, NY, 1988. ACM Press.

....for programs with general control flow, strengthening the consequence of Rice s theorem [28] to the case where all program statements are reachable. In contrast, our result shows that local analysis of a single statement is undecidable. Most shape analysis algorithms are non compositional [5, 16, 23, 30, 31] and many of them were originally used for program optimization. In such an analysis, the imprecision in heap property entailment can cause the analysis to perform some extra fixpoint iterations but may lead to a result that is su#ciently precise for program optimization. We choose a compositional ....

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In Proc. ACM PLDI, Atlanta, GA, June 1988.

....and does not attempt to extract properties that are fundamental to our goals (e.g. identifying disjoint data structure instances) Due to limited space, we focus on techniques whose goals are similar to ours. The most powerful class of related algorithms are those referred to as shape analysis [13, 10, 19]. These algorithms are strictly more powerful than ours, allowing additional queries such as is a given data structure instance a singlylinked list However, this extra power comes at very significant cost in speed and scalability, particularly due to the need for flow sensitivity, ....

J. R. Larus and P. N. Hilfinger. Detecting conflicts between structure accesses. pages 21--34, July 1988.

....pools. We use an analysis described in Section 2 to identify logically disjoint data structures, and use it to compute a representation we call the Disjoint Data Structure Graph. Our analysis to construct these graphs is similar to previous work on heap connection analysis and shape analysis [18, 17, 14, 30, 22], but differs from that work in a few key ways (discussed in more detail in Section 6) We perform the data structure analysis and subsequent transformations entirely at link time, using a compilation framework called LLVM, described briefly in subsection 1.1. Link time is an appropriate place for ....

....WORK There is a rich literature on pointer analysis techniques and on shape analysis of data structures in programs. Our disjoint data structure analysis is most similar to previous work on computing heap approximations such as path matrices [17] and static shape graphs for heap storage (e.g. [14, 18, 22]) One key difference between all these previous analyses and ours is that the previous approaches are flow sensitive they compute a heap approximation (e.g. one or more shape graphs) for each program point. In contrast, we only compute a single summary graph for an entire procedure. This ....

[Article contains additional citation context not shown here]

J. R. Larus and P. N. Hilfinger. Detecting conflicts between structure accesses. In SIGPLAN Conference on Programming Language Design and Implementation, pages 21--34, July 1988.

....component of any optimizer because aliasing increases the likelihood that a side effect will foil an optimization. Much work on alias analysis has been restricted to languages that do not allow pointers [3, 10] or that restrict pointers to at most one level of indirection [43] Some exceptions are [7, 29, 33], which use interprocedural analysis. The alias analysis techniques in [7, 29, 33] annotate each edge in a FG with a summary graph approximating the data structures at that point in the program. Because the size of the summary graphs must be bounded at compile time even though the program s data ....

....will foil an optimization. Much work on alias analysis has been restricted to languages that do not allow pointers [3, 10] or that restrict pointers to at most one level of indirection [43] Some exceptions are [7, 29, 33] which use interprocedural analysis. The alias analysis techniques in [7, 29, 33] annotate each edge in a FG with a summary graph approximating the data structures at that point in the program. Because the size of the summary graphs must be bounded at compile time even though the program s data structures are unbounded at run time, a single node in the summary graph must ....

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In Proceedings of the 1988.

....might now be reachable from x s object, so that x s object also might not be contained, even though the invocation of did not mention x. To determine when two variables may be aliases to objects that are reachable from one another, we adapt Larus and Hilfinger s alias graph construction algorithm[41]. Briefly, alias graph construction is a data flow computation that produces a conservative approximation of the aliases visible at any point in a program. The roots of an alias graph are variables names and the interior nodes represent storage areas. Edges are added (or deleted) by applying ....

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In Proceedings of the SIGPLAN '88 Conference on Programming Language Design and Implementation, pages 21--34, Atlanta, GA, June 1988.

.... which is designed to discover when a data structure has a certain shape such as a tree or list [4, 19, 8] Several researchers have used shape analysis algorithms as the basis for compilers that automatically parallelize divide and conquer programs that manipulate linked data structures [9, 13, 14]. We are aware, however, of no previous research on parallelizing compilers for divide and conquer programs (such as those in our benchmark set) that use pointers to access disjoint regions of large, contiguously allocated blocks of memory. Several researchers have developed symbolic analysis ....

J. Larus and P. Hilfinger. Detecting conflicts between structure accesses. In Proceedings of the SIGPLAN '88 Conference on Program Language Design and Implementation, Atlanta, GA, June 1988. ACM, New York.

....of the individual loop iterations. 8. 2 Data Dependence Analysis Research on automatically parallelizing serial computations that manipulate pointer based data structures has focused on techniques that precisely represent the run time topology of the heap [Chase et al. 1990; Hendren et al. 1992; Larus and Hilfinger 1988; Plevyak et al. 1993] The idea is that the analysis can use this precise representation to discover independent pieces of code. To recognize independent pieces of code, the compiler must understand the global topology of the manipulated data structures [Hendren et al. 1992; Larus and Hilfinger ....

....and Hilfinger 1988; Plevyak et al. 1993] The idea is that the analysis can use this precise representation to discover independent pieces of code. To recognize independent pieces of code, the compiler must understand the global topology of the manipulated data structures [Hendren et al. 1992; Larus and Hilfinger 1988]. It must therefore analyze the code that builds the data structures and propagate the results of this analysis through the program to the section that uses the data. A limitation of these techniques is an inherent inability to parallelize computations that manipulate graphs. The aliases present ....

LARUS, J. AND HILFINGER, P. 1988. Detecting conflicts between structure accesses. In Proceedings of the SIGPLAN '88 Conference on Program Language Design and Implementation. ACM Press, Atlanta, GA.

....contains the object or array rather than a pointer to the object or array. Modula 3 has implicit pointer dereferences, but at the intermediate representation level all pointer dereferences are explicit. We call a non empty string of memory references, for example a. b[i] c, an access path (AP ) [Larus and Hilfinger 1988] and assume that object fields have different names. We define: Type(p) The static type of AP p. Subtypes(T) The set of subtypes of type T, which includes T. REF T: A pointer to an object of type T. In Modula 3 and other type safe languages, a variable of type REF T can legally point to ....

.... on alias analysis uses only static properties, such as the size of the may alias and points to sets [Banning 1979; Burke et al. 1994; Hind et al. 1999; Chatterjee et al. 1999; Chase et al. 1990; Choi et al. 1993; Cooper and Kennedy 1989; Deutsch 1994; Emami et al. 1994; Landi and Ryder 1991; 1992; Larus and Hilfinger 1988; Shapiro and Horwitz 1997b; Steensgaard 1996; Weihl 1980] A few researchers recently have used dynamic evaluation such as measuring the execution time improvement due to an optimization that uses alias analysis [Hummel et al. 1994; Wilson and Lam 1995; Cooper and Lu 1997; Ghiya and Hendren 1998; ....

[Article contains additional citation context not shown here]

LARUS, J. R. AND HILFINGER, P. N. 1988. Detecting conflicts between structure accesses. In Proceedings of the ACM SIGPLAN '88 Conference on Programming Language Design and Implementation. Atlanta, GA, 21--34.

....p.f Field access Field f of class instance to which p refers p[i] Array access Component with subscript i of array to which p refers an array access expression refers to a component of an array. Table I summarizes the two kinds of access expressions in Java. We adopt the term access path [2,4] to mean a non empty sequence of accesses. For example, the Java expression a.b[i] c is an access path. Without loss of generality, our notation assumes that distinct fields within an object have different names (i.e. fields that override inherited fields of the same name from superclasses are ....

Larus JR, Hilfinger PN. Detecting conflicts between structure accesses. Proceedings of the ACM Conference on Programming Language Design and Implementation, Atlanta, Georgia, June 1988; 21--34.

....object names obtainable by following links in a recursive data structure, only maintaining the first k dereferences, a process known as k limiting. Others have suggested less naive ways of restricting the namespace while obtaining more accurate aliases of heap stored objects [CWZ90, Deu94, HPR89, LH88, HN90, HHN92, GH96a, GH96b, SRW98] One di#culty with k limiting is that it loses information about the su#x of an object name. With 2 limiting, the alias #p f g h, x# is represented by #p f g#, x#. However this klimited object name also represents a set of object names, e.g. ....

....paper is the MODC schema, the recent work in pointer analysis is merely summerized here. Recently, there have been many investigations of pointer aliasing algorithms which vary in cost and precision. Several concentrate on aliases in heap storage [HPR89, CWZ90, Deu94, HN90, GH96a, GH96b, JM82a, LH88, SRW98] Others calculate flow insensitive aliases with recent emphasis on algorithm scalability on very large programs (i.e. one million lines of code) Cou86, Gua88, BCCH94, And94, SH97b, Ste96b, Wei80, ZRL96, HP98, LH99, RC00, Das00, FRD00, FFA00] There are flow sensitive techniques as well ....

J. R. Larus and P. N. Hilfinger. Detecting conflicts between structure accesses. In Proceedings of the SIGPLAN '88 Conference on Programming Language Design and Implementation, pages 21--34, July 1988. SIGPLAN NOTICES, Vol. 23, No. 7.

....techniques for extracting or verifying this kind of information. There are two broad categories: analyses that characterize the accessed regions of dense matrices [8, 53, 7, 50, 77, 9, 5, 38, 47, 84] and analyses that extract or verify reachability properties of linked data structures [60, 19, 51, 43, 85]. Although many of these analyses were originally developed for the automatic parallelization of sequential programs, the basic approaches should generalize to handle the appropriate kinds of multithreaded programs. Researchers have also developed dynamic race detection algorithms, which monitor a ....

....parts of the same data structure. Over the years researchers have developed many sophisticated techniques for extracting or verifying this kind of information, both for programs that access dense matrices [8, 53, 7, 50, 77, 9, 5, 38, 47, 84] and for programs that manipulate linked data structures [60, 19, 51, 43, 85]. Parallel computing programs may also use reductions and commuting operations, in which case it may be important to generalize algorithms from the field of automatic parallelization to verify that the program executes deterministically [39, 44, 48, 80] In general, the programmer can reasonably ....

J. Larus and P. Hilfinger. Detecting conflicts between structure accesses. In Proceedings of the SIGPLAN '88 Conference on Program Language Design and Implementation, Atlanta, GA, June 1988. ACM, New York.

....implement a theorem prover to check the safety of programs. Consequently, we have found it straightforward to integrate alias types with our Typed Assembly Language implementation [38] There are also similarities between our research and work on alias analysis techniques for imperative languages [18, 21, 11, 12, 33]. Our type system appears most closely related to the shape analysis developed by Sagiv, Reps, and Wilhelm (SRW) 33] which has also been used to develop sophisticated pointer logics [34, 4] Although the precise relationship is currently unknown to us, it is clear that several of the key ....

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In ACM Conference on Programming Language Design and Implementation, pages 24--31, June 1988.

....addresses determining alias or points to relations. Such information can be used to compute the may definitions of an assignment in static program slicing or to verify the independence of two pointer references to enable an optimization. Precise pointer analysis is computationally difficult [LH88, LR92] The high cost of flow sensitive approaches [Wei80, JM81, JM82, CWZ90, HN90, LR92, HEGV93] has led to the development of flow insensitive techniques [Ste96, And94, SH97] which are often nearly as precise for a fraction of the cost [HP98] Shape analysis is a static analysis that infers ....

....Shape analysis is a static analysis that infers properties of pointer structures that could be used by programmers as invariants. In particular, shape analysis produces a graph structure for a structure pointer reference that summarizes the abstract memory locations that it can reach [JM81, LH88, CWZ90, HHN92, SRW99] ADDS, for example, uses traditional gen kill analysis to propagate descriptions like pointer dimensionality and reachability through a program [GH96] permitting the determination of tree, dag, and cyclic properties. The necessity to summarize actual properties in static ....

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In PLDI, pages 21--34, Atlanta, Georgia, June 1988.

....(such as C and Java) where arrays might themselves be aliased. Analysis and optimization algorithms in the second category face the daunting challenge of dealing with pointer induced aliases in a weakly typed language. A large body of work has considered pointer analysis techniques (e.g. [17, 6, 13, 16, 7, 12]) that include powerful methods to track pointer references both intraand inter procedurally. However, many of these techniques have limited effectiveness for large real world programs because the underlying language semantics force highly conservative default assumptions. In addition, these ....

.... points to analysis before pointer references can be classified as stack directed or heapdirected and any effective optimization can be performed [12] To address this challenge, there has been a large body of research on flow sensitive pointerinduced alias analysis in weakly typed languages e.g. [17, 6, 13, 16, 7]. However, these algorithms are too complex for use in efficient analysis of strongly typed languages, compared to the algorithms presented in this paper. Specifically, our algorithms analyze object references in the same SSA framework that has been used in the past for efficient scalar analysis. ....

J. R. Larus and P. N. Hilfinger. Detecting conflicts between structure accesses. Proceedings of the ACM SIGPLAN '88 Conference on Programming Language Design and Implementation, 23(7):21--34, July 1988.

....unless the dataflow information accounts for the effects of aliases 1 caused by reference parameters and pointer variables. Some techniques for interprocedural analysis[3] represent all invocation paths in the program, causing them to be potentially exponential in time and space. Other techniques[1, 2, 6, 7] use some type of summary information to avoid potential exponential growth, but with some loss of precision. However, all of these techniques require a complete program on which to perform the analysis, which for large systems may be prohibitive in both time and space. Software engineering ....

.... may alias introductions [3] if N is a call statement or an assignment to a pointer then [4] add conditional may aliases introduced by N to W orklist and CondMayAlias [5] while W orklist is not empty do compute conditional may aliases [6] remove [ N; AA) PA] from W orklist [7] propagate at successors of N ; update W orklist and CondMayAlias [8] foreach [ N; AA) PA] in CondMayAlias do compute may aliases [9] add [N; PA] to MayAlias end Figure 1: Landi and Ryder s algorithm for computing may alias information. N on which a and b may reference the same object. ....

[Article contains additional citation context not shown here]

J. R. Larus and P. N. Hilfinger. Detecting conflicts between structure accesses. Proceedings of the ACM SIGPLAN'88 Conference on Programming Language Design and Implementation, pages 21--34, June 1988. 14

....will not change. Such assumptions limit the extent that transfromations can be performed. Techniques are available to extract more detailed information: to determine parameter aliasing and effects of procedures on global variables, see [7, 8, 9, 19, 37, 42] to determine pointer aliasing, see [14, 15, 27, 29, 33, 34, 44]. When a sophisticated analysis technique is applied, the usual result is that there are few side effects and the tuples (both LHS and RHS) are small. Small tuples can be represented directly. Sophisticated analysis, however, is often unavailable. Many compilers do no interprocedural analysis at ....

J. R. Larus and P. N. Hilfinger. Detecting conflicts between structure accesses. Proc. SIGPLAN'88 Symp. on Compiler Construction, pages 21--34, July 1988. Published as SIGPLAN Notices Vol. 23, No. 7.

....features. Although the SPMD execution approach exploits implicit parallelism present in sequential programs, it can benefit from information regarding parallelism present in a program. The inclusion of parallel looping constructs [18] in the language and automatic parallelism detection techniques [12, 20, 6, 16] in the compiler can further enhance performance. The information regarding parallelism in a program can be used by the compiler to determine a data distribution appropriate for parallel execution. However, it should be noted that most of the techniques presented in this paper are required ....

Larus, J.R., and Hilfinger, P.N. Detecting conflicts between structure accesses. Proc. ACM SIGPLAN Conference on Programming language Design and Implementation. Atlanta, Georgia, 1988, pp. 21-34.

....and transformation techniques for various processors. The user describes the target processor using a mixture of RTL and C language. A program written in assembly code can then be analyzed and modified using an interface in C . SALTO has already implemented some kind of conflict analysis [12], but their approach only determines address based dependences between register accesses and assumes memory to be one cell. When analyzing data dependences in assembly code we must distinguish between accesses to registers and those to memory. In both cases we derive data dependence from reaching ....

J. R. Larus and P. N. Hilfinger. Detecting conflicts between structure accesses. ACM SIGPLAN Notices, 23(7):21--34, July 1988.

....for C have been proposed [Coo89, LR92, CBC93, MLR 93, EGH94, WL95, Ruf95, HA90, SFRW90] Recently, there have been many investigations of pointer aliasing algorithms which vary in cost and precision. Several concentrate on aliases in heap storage [HPR89, CWZ90, Deu94, HN90, EGH94, JM82, LH88, SRW96] Others calculate program wide (flow insensitive) aliases [Cou86, Gua88, BCCH94, And94, SH97, Ste95, Wei80, ZRL96] Still other work concentrated on aliases in higher order functional languages [Deu90, NPD87] Incremental algorithms update data flow information after a program change ....

J. R. Larus and P. N. Hilfinger. Detecting conflicts between structure accesses. In Proceedings of the SIGPLAN '88 Conference on Programming Language Design and Implementation, pages 21--34, July 1988. SIGPLAN NOTICES, Vol. 23, No. 7.

....understanding, particularly for programmers reading code which they did not write. Our focus in this paper is on the efficient and practical solution of the pointer aliasing problem to facilitate these applications. Many techniques for compile time pointer aliasing analysis have been proposed [3, 4, 6, 7, 8, 9, 11, 14, 15, 22, 26, 27, 32, 36, 37, 39, 40]. Some of them are more appropriate for aliases involving accesses to heap locations [6, 8, 11, 14, 15, 26, 36] others for aliases involving accesses to stack locations [9, 39] Still others handle both in a similar fashion [3, 4, 7, 22, 27, 32, 37, 40] All of these methods vary in the precision ....

....of the pointer aliasing problem to facilitate these applications. Many techniques for compile time pointer aliasing analysis have been proposed [3, 4, 6, 7, 8, 9, 11, 14, 15, 22, 26, 27, 32, 36, 37, 39, 40] Some of them are more appropriate for aliases involving accesses to heap locations [6, 8, 11, 14, 15, 26, 36]; others for aliases involving accesses to stack locations [9, 39] Still others handle both in a similar fashion [3, 4, 7, 22, 27, 32, 37, 40] All of these methods vary in the precision of the aliasing information calculated and their cost. For compile time pointer aliasing analysis, a program ....

[Article contains additional citation context not shown here]

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In Proceedings of SIGPLAN'88 Conference on Programming Language Design and Implementation, pages 21--34, June 1988.

.... which is designed to discover when a data structure has a certain shape such as a tree or list [8, 33, 17] Several researchers have used shape analysis algorithms as the basis for compilers that automatically parallelize divide and conquer programs that manipulate linked data structures [18, 23, 25]. Commutativity analysis is an alternative to shape analysis for divide and conquer programs that access linked data structures [30] This technique views the computation as a sequence of operations on objects, generating parallel code if all pairs of operations commute. We view both ....

J. Larus and P. Hilfinger. Detecting conflicts between structure accesses. In Proceedings of the SIGPLAN '88 Conference on Program Language Design and Implementation, Atlanta, GA, June 1988. ACM, New York.

....be presented. This work was sponsored in part by NSF (ASC 9213821 and CDA9401151) 1 Introduction Dependence analysis is the key technique behind parallelization and optimizationson programs with pointers or recursive data structures. There have been several algorithms proposed by researchers [7, 8, 9, 10, 14]. It is a considerably complicated problem, since it involves other pointer analysis techniques as well, such as alias analysis [2, 4, 5, 12, 20] side effect analysis [2, 13] and even shape analysis [1, 6, 16, 18] These proposed dependence analysis techniques first identify aliases of pointer ....

....of locations written by statement S. Statements S 1 and S 2 have access conflicts if (Write(S 1 ) Read(S 2 ) Write(S 2 ) Write(S 2 ) Read(S 1 ) Write(S 1 ) 6= In contrast to other techniques, this approach does not build graphs or matrices to represent connection information [8, 14]. It assumes that each unique path expression leads to a distinct location. Consequently, 4 elements of Read and Write sets can be represented by path expressions. To determine if two path expressions can reach same locations, comparison operations similar to the Match operation defined in ....

[Article contains additional citation context not shown here]

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. SIGPLAN Notices, 23(7):21--34, July 1988. Proceedings of the ACM SIGPLAN '88 Conference on Programming Language Design and Implementation. 16

....for variables, since it must deal not only with an unbounded number of paths through the program, like traditional data flow analyses, but it must handle an unbounded number of paths through an unbounded collection of data. Many algorithms for alias analysis have been suggested in the literature [9, 14, 26, 29, 25, 45, 62, 68, 69, 72, 96, 111, 112] , and the key difference between the algorithms stem from where and how they approximate the unbounded control paths and data (Chapter 9) The approximation determines the precision and efficiency of the algorithm. Indeed, alias analyses proposed in the literature range from precise ....

....the algorithm. Indeed, alias analyses proposed in the literature range from precise exponential time algorithms to less precise nearly linear time algorithms. Despite the plethora of available alias analysis algorithms, the tradeoffs between the different techniques are not understood. Prior work [9, 14, 26, 29, 25, 45, 68, 69, 72, 96, 111] , with two exception [62, 112] uses static metrics (if anything at all) to evaluate alias analysis. Static metrics are insufficient for evaluating an analysis since they do not measure the impact of the analysis on performance. Also, the evaluation in prior work does not measure if there is room ....

[Article contains additional citation context not shown here]

Larus, J. R. and Hilfinger, P. N. Detecting conflicts between structure accesses. In Proceedings of the ACM SIGPLAN '88 Conference on Programming Language Design and Implementation, pages 21--34, Atlanta, GA, June 1988. 133

No context found.

J.R. Larus and P.N. Hilfinger. Detecting conflicts between structure accesses. In SIGPLAN Conference on Programming Languages Design and Implementation, pages 21--34, New York, NY, 1988. ACM Press.

No context found.

J.R. Larus and P.N. Hilfinger. Detecting conflicts between structure accesses. In Prog. Lang. Design and Impl., pages 21--34, 1988.

No context found.

J.R. Larus and P.N. Hilfinger. Detecting conflicts between structure accesses. In SIGPLAN Conference on Programming Languages Design and Implementation, pages 21--34, New York, NY, 1988. ACM Press.

No context found.

J. Larus and P. Hilfinger. Detecting conflicts between structure accesses. In Proceedings of the Conference on Programming Language Design and Implementation, pp. 21--34, ACM, 1988.

No context found.

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In Proc. ACM PLDI, Atlanta, GA, June 1988.

No context found.

J. Larus and P. Hilfinger. Detecting conflicts between structure accesses. In Proc. ACM SIGPLAN Conf. on Programming Language Design and Implementation, pages 21--34, New York, NY, 1988. ACM Press.

No context found.

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In Proc. ACM PLDI, Atlanta, GA, June 1988. 7

No context found.

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In ACM Conference on Programming Language Design and Implementation, pages 24-- 31, June 1988.

No context found.

J. Larus and P. Hilfinger. Detecting conflicts between structure accesses. In Proc. ACM SIGPLAN Conf. on Programming Language Design and Implementation, pages 21--34, New York, NY, 1988. ACM Press.

No context found.

J. Larus and P. Hilfinger. Detecting conflicts between structure accesses. In Proc. ACM SIGPLAN Conf. on Programming Language Design and Implementation, pages 21--34, New York, NY, 1988. ACM Press.

No context found.

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In ACM Conference on Programming Language Design and Implementation, pages 24-- 31, June 1988.

No context found.

J. R. Larus and P. N. Hilfinger. Detecting conflicts between structure accesses. In SIGPLAN Conference on Programming Language Design and Implementation, pages 21--34, July 1988.

No context found.

J. Larus and P. Hilfinger. Detecting conflicts between structure accesses. In Implementation, Atlanta, GA, June 1988. ACM, New York.

No context found.

J. Larus and P. Hilfinger. Detecting conflicts between structure accesses. In Proceedings of the SIGPLAN '88 Conference on Program Language Design and Implementation, Atlanta, GA, June 1988.

No context found.

J. Larus and P. Hilfinger. Detecting conflicts between structure accesses. In Proceedings of the ACM SIGPLAN '88 Conference on Program Language Design and Implementation, pages 21--34, New York, NY, June 1988. ACM Press.

No context found.

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In Proc. ACM PLDI, Atlanta, GA, June 1988.

No context found.

J. Larus and P. Hilfinger. Detecting conflicts between structure accesses. In Proceedings of the SIGPLAN '88 Conference on Program Language Design and Implementation, Atlanta, GA, June 1988. ACM, New York.

No context found.

J. R. Larus and P. N. Hilfinger. Detecting conflicts between structure accesses. In Proc. of the ACM SIGPLAN'88 Conf. on Programming Language Design and Implementation (PLDI), pages 21--34, July 1988. 16

No context found.

Larus, J.R. and Hilfinger, P.N., "Detecting conflicts between structure accesses," Proceedings of the SIGPLAN 88 Conference on Programming Language Design and Implementation, (Atlanta, GA, June 2224, 1988), pp. 21-34 (June 1988).

No context found.

J. R. Larus and P. N. Hilfinger. Detecting conflicts between structure accesses. In ACM Conf. Prog. Lang. Design and Implementation, pages 21--34, July 1988.

No context found.

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In Proc. ACM PLDI, Atlanta, GA, June 1988.

No context found.

J. Larus and P. Hilfinger. Detecting conflicts between structure accesses. In In Proceedings of the SIGPLAN '88 Conference on Program Language Design and Implementation, Atlanta, GA, june 1988.

No context found.

James R. Larus and Paul N. Hilfinger. Detecting conflicts between structure accesses. In PLDI [PLDI1988], pages 21--34.

No context found.

LARUS,J.R.AND HILFINGER, P. N. 1988. Detecting conflicts between structure accesses. In Proceedings of the ACM Conference on Programming Language Design and Implementation (Atlanta, Georgia, June). ACM SIGPLAN Notices, 21--34.

No context found.

J. R. Larus and P. N. Hilfinger, Detecting Conflicts Between Structure Accesses, Proc. SIGPLAN '88 Symp. on Compiler Construction, July 1988. Published as SIGPLAN Notices Vol 23, Num. 7.

No context found.

J. R. Larus and P. N. Hilfinger, Detecting Conflicts Between Structure Accesses, Proc. SIGPLAN '88 Symp. on Compiler Construction, July 1988. Published as SIGPLAN Notices Vol 23, Num. 7.

First 50 documents  Next 50

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC