Data processing: software development – installation – and managem – Software program development tool – Translation of code
Reexamination Certificate
1998-09-24
2001-08-21
Powell, Mark (Department: 2122)
Data processing: software development, installation, and managem
Software program development tool
Translation of code
C717S152000, C703S023000
Reexamination Certificate
active
06279149
ABSTRACT:
BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention relates to analysis of computer programs.
2. Description of the Related Art
Many algorithms for static analysis of imperative programs make the simplifying assumption that the data manipulated by a program consists of simple atomic values, when in reality aggregates such as arrays and records are usually predominant. By “atomic value” (also referred to as an “atom” or “scalar”) we mean a value that is treated as an indivisible (single logical) unit by the program. As an example, a program might treat a person's age as an atomic value. An aggregate, by contrast, consists of two or more logical units of information, and the program might refer to or manipulate one of these units of information independent of the other units of information. For example, a program may treat a person's date-of-birth as an aggregate consisting of three logical units of information: the year-of-birth, the month-of-birth, and the day-of-birth. In particular, a statement in the program may make use of the year-of-birth, ignoring the month and day information.
There are several straightforward approaches to adapting analysis algorithms designed for scalars to operate on aggregates:
1. Treat each aggregate as a single scalar value.
2. Decompose each aggregate into a collection of scalars, each of which represents one of the bytes (or bits) comprising the aggregate.
3. Use the declarations (variable and type declarations) in the program to break up each aggregate into a collection of scalars, each of which represents a declared component of the aggregate containing no additional substructures of its own.
Unfortunately, each of these approaches has drawbacks. The first approach can yield very imprecise results. While the second approach is likely to produce precise results, it can be prohibitively expensive. Finally, the third approach appears at first blush to be the obvious solution. However, it is unsatisfactory in weakly-typed languages such as Cobol, where a variable need not be explicitly declared as an aggregate in order for it to contain composite data. Even in more strongly-typed languages, declarative information alone can be insufficient because loopholes in the type system (such as typecasts) may permit aggregate values to interoperate with non-aggregate values; untagged unions also complicate matters. Moreover, the third approach may produce unnecessarily many scalar components when the program only accesses a subset of those components. Finally, in languages where aggregate components may overlap one another in storage inexactly, checks for storage disjointness (which tend to occur in inner loops of analysis algorithms) may prove expensive.
SUMMARY OF THE INVENTION
The present invention is a computer-implemented method for lazily decomposing aggregates into simpler components based on the access patterns specific to a given program. This process allows us both to identify implicit aggregate structure not evident from declarative information, and to simplify the representation of declared aggregates when references are made only to a subset of their components. In particular, the method analyzes the statements in the program and identifies the different logical units of information (referred to as “atoms” below) in each aggregate that are utilized by the program. In terms of the date-of-birth example given above, the date-of-birth may be treated as an atom if the program never makes use of the year, month, or day information independently. Thus, the method determines which variables may be treated as atoms based on how the program accesses information in the variables. Further, if a variable is to be treated as an aggregate, the method also determines the “structure” of the aggregate variable: that is, the set of atoms that make up this aggregate variable. We refer to this as “atomization” of the aggregate.
Thus, after atomization, each reference to an aggregate can be expressed as a set of references to disjoint atoms. The resulting atoms may then be treated as scalars for the purposes of analysis, and checks for overlapping storage reduce to equality tests on atoms.
The method can be exploited to yield: (i) a fast type analysis method applicable to program maintenance applications (such as date usage inference for the Year 2000 problem); and (ii) an efficient method for atomization of aggregates. More specifically, aggregate atomization decomposes all of the data that can be manipulated by the program into a set of disjoint atoms such that each data reference can be modeled as one or more references to atoms without loss of semantic information.
Aggregate atomization can be used to adapt program analyses and representations designed for scalar data to aggregate data. In particular, atomization can be used to build more precise versions of program representations such as SSA form or PDGs. Such representations can in turn yield more accurate results for problems such as program slicing. Our techniques are especially useful in weakly-typed languages such as Cobol (where a variable need not be declared as an aggregate to store an aggregate value) and in languages where references to statically-defined sub-ranges of data such as arrays or strings are allowed.
REFERENCES:
patent: 5432930 (1995-07-01), Song
patent: 5485616 (1996-01-01), Burke et al.
patent: 5490249 (1996-02-01), Miller
patent: 5652835 (1997-07-01), Miller
patent: 5675803 (1997-10-01), Preisler et al.
patent: 5790859 (1998-08-01), Sarkar
patent: 5797012 (1998-08-01), Blainey et al.
patent: 5832271 (1998-11-01), Devanbu
patent: 5896537 (1999-04-01), Landi et al.
patent: 5983020 (1999-11-01), Sweeney et al.
Gopal, “Dynamic program slicing based on dependence realtions”, IEEE, pp 191-200, Aug. 1991.*
Agrawl et al., “Dynamic program slicing”, ACM SIGPLAN PLDI, pp 246-256, Jun. 1990.*
Korel et al., “Dynamic program slicing in understanding of program execution”, IEEE, pp 80-89, 1997.*
Ashida et al., “Slicing methods using static and dynamic analysis onfromation”, IEEE pp 344-350, 1999.*
Song et al., “Forward dynamic object orienetd progarm slicing”, IEEE, pp 230-237, Feb. 1999.*
Korel et al, “Program slicing in undersatnding of large program”, IEEE pp 145-152, Mar. 1998.*
Jiang et al., “Program slicing for C the problem in implementation”, IEEE pp 182-190, Aug. 1991.*
Venkatesh, “The semantic approach to program slicing”, ACM SIGPLAN PLDI, pp 107-119, Jun. 1991.*
Sinha et al, “System dependence graph based slicing of program with arbitaray interprocedural control flow”, ACMICSE, pp 432-441, 1999.*
Binkey et al, “An empircal study of amorphous slicing as a program comprehension support tool”, IEEE, pp 161-170, 2000.*
Zhao, “A slicing based approach to extracting reusable software architecturs”, IEEE, pp 1-9, 2000.*
Visser et al, “Modle checking programs”, IEEE, pp 3-11, 2000.*
Weiser, M., “Program Slices: Formal, Psychological, and Practical Investigations of an Automatic Program Abstraction Method”, UMI Dissertation Services, Degree Date: 1979.
Weiser, M., “Program Slicing”, IEEE Transactions on Software Engineering, vol. SE-10, No. 4, Jul. 1984, p. 352-357.
Aiken, A. et al., “The Complexity of Set Constraints”, Computer Science Logic. 7th Workshop, CSL '93 Selected Papers 1994, p. 1-17.
Cytron, R. et al., “Efficiently Computing Static Single Assignment Form and the Control Dependence Graph”, ACM Transactions on Programming Languages & Systems, vol. 13, No. 4, Oct. 1991, p. 451-490.
Fahndrich, M. et al., “Program Analysis Using Mixed Term and Set Constraints”, Static Analysis. 4th Int'l. Symposium, SAS '97 Proceedings 1997, p. 114-126.
Ferrante, J. et al., “The Program Dependence Graph and Its Use in Optimization”, ACM Transactions on Programming Languages & Systems, vol. 9, No. 3, Jul. 1987, p. 319-349.
Knight, K., “Unification: A Multidisciplinary Survey”, ACM Computing Surveys, vol. 21, No. 1, Mar. 1989, p. 93-124.
Milner, R., “A Theory of Type Polymorphism in Programming”, Journal of Computer & System Sciences 17, 1978, p. 348-375.
Field John H.
Ramalingam Ganesan
Tip Frank
August Casey P.
International Business Machines - Corporation
Khatri Anil
Powell Mark
Scully Scott Murphy & Presser
LandOfFree
Aggregate structure identification and its application to... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Aggregate structure identification and its application to..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Aggregate structure identification and its application to... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-2544146