References of Static_Data_Flow_Analysis

@Unpublished{	  antoniol.fiutem.ea:program,
  author	= {G. Antoniol and R. Fiutem and G. Lutteri and P. Tonella
		  and S. Zanfei},
  title		= {Program Understanding and Maintenance with the CANTO
		  environment},
  year		= {1998},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis,
		  Recovery_of_Software_Architecture}
}

@InProceedings{	  beck.eichmann:program,
  author	= {J. Beck and D. Eichmann},
  title		= {Program and interface slicing for reverse engineering},
  pages		= {509--519},
  booktitle	= {Proceedings of the 15th  International Conference on
		  Software Engineering },
  year		= {1993},
  publisher	= {IEEE Computer Society Press},
  month		= apr,
  abstract	= {Reverse engineering involves a great deal of effort in
		  comprehension of the current implementation of a software
		  system and the ways in which it differs from the original
		  design. Automated support tools are critical to the success
		  of such efforts. Wh show how program slicing techniques can
		  be employed to assist in the comprehension of large
		  software systems, through traditional slicing techniques at
		  the statement level, and through a new technique, interface
		  slicing, at the module level.},
  note		= {Describes the use of program slicing for the reverse
		  engineering of Ada packages},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis, Program_Slicing}
}

@Article{	  canfora.cimitile.ea:logic-based,
  key		= {Canfora et al.},
  author	= {G. Canfora and Aniello Cimitile and G. de Carlini},
  title		= {A Logic-Based Approach to Reverse Engineering Tools
		  Production},
  year		= {1992},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {1053--1064},
  volume	= {18},
  number	= {12},
  month		= dec,
  abstract	= {This paper analyzes difficulties arising in the use of
		  documents produces by Reverse Engineering tools. With
		  reference to inter-modula data flow analysis for Pascal
		  software systems, an interactive and evolutionary is
		  proposed. The tool is based on: i) the production of
		  inter-modular data flow information by static analysis of
		  code; ii) its representaton in a Prolog program dictionary;
		  iii) a Prolog abstractor that allows the specific queries
		  to be answered.},
  location	= {CMU E \&{} S Library},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code,
		  Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  cheung.kramer:integrated,
  author	= {S. C. Cheung and J. Kramer},
  title		= {An integrated method for effective behaviour analysis of
		  distributed systems},
  pages		= {309--322},
  booktitle	= {Proceedings of the 16th  International Conference on
		  Software Engineering },
  year		= {1994},
  publisher	= {IEEE Computer Society Press},
  month		= may,
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@Article{	  cytron.ferrante.ea:efficiently,
  author	= {Ron Cytron and Jeanne Ferrante and Barry K. Rosen and Mark
		  N. Wegman and F. Kenneth Zadeck},
  title		= {Efficiently Computing Static Single Assignment Form and
		  the Control Dependence Graph},
  journal	= {ACS Transaction on Programming Languages and Systems},
  year		= {1991},
  volume	= {13},
  number	= {4},
  pages		= {451-490},
  month		= {October},
  abstract	= {In optimizing compilers, data structure choices directly
		  influence the power and efficiency of practical program
		  optimization. A poor choice of data structure can inhibit
		  optimization or slow compilation to the point that advanced
		  optimization features become undesirable. Recently, static
		  single assignment form and the control dependence graph
		  have been proposed to represent data flow and control flow
		  propertiee of programs. Each of these previously unrelated
		  techniques lends efficiency and power to a useful class of
		  program optimization. Although both of these structures are
		  attractive, the difficulty of their construction and their
		  potential size have discouraged their use. We present new
		  algorithms that efficiently compute these data structures
		  for arbitrary control flow graphs. The algorithms use
		  dominance frontiers, a new concept that may have other
		  applications. We also give analytical and experimental
		  evidence that all of these data structures are usually
		  linear in the size of the original program. This paper thus
		  presents strong evidence that these structures can be of
		  practical use in optimization.},
  keywords	= {algorithms languages control dependence control flow graph
		  def-use chain dominator optimizing compilers ssa},
  class		= {Software_Reverse_Engineering Static_Data_Flow_Analysis
		  Reverse_Design Static_Control_Flow_Analysis
		  Fundamental_Methods_in_Reverse_Design Static_Analysis }
}

@InProceedings{	  devanbu:genoa,
  author	= {P. T. Devanbu},
  title		= {{GENOA} - {A} Customizable, language- and Front-end
		  Independent Code Analyzer},
  booktitle	= {Proceedings of the 14th  International Conference on
		  Software Engineering },
  pages		= {307--317},
  month		= may,
  year		= {1992},
  abstract	= {Programmers working on large software systems spend a
		  great deal of time examining code and trying to understand
		  it. Code analysis tools (e.g. cross referencing tools such
		  as CIA and Cscope) can be very helpful in this process.
		  This paper describes GENOA, an application generator that
		  can produce a whole range of useful code analysis tools.
		  GENOA is designed to be language- and front-end
		  independent; it can be interfaced to any front-end for any
		  language that produces an attributed parse tree, simply by
		  writing an interface specification. While GENOA programs
		  can perform arbitrary analyses on the parse tree, the GENOA
		  language has special, compact iteration operators that are
		  tuned for expressing simple, polynomial time analysis
		  programs. It describes the system, provides several
		  practical examples, and presents complexity and
		  expressivity results for the above-mentioned sublanguage of
		  GENOA.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@Article{	  forgacs:double,
  key		= {Forgacs, 1994},
  author	= {Istv\'an Forg\'acs},
  title		= {Double Iterative Framework for Flow-Sensitive
		  Interprocedural Data Flow Analysis},
  journal	= { ACM  Transactions on Software Engineering and
		  Methodology},
  year		= {1994},
  volume	= {3},
  number	= {1},
  pages		= {29-55},
  month		= jan,
  abstract	= {Compiler optimization, parallel processing, data flow
		  testing, and symbolic debugging can benefit from
		  interprocedural data flow analysis. However, the live,
		  reaching definition, and most summary data flow problems
		  are theoretically intractable in the interprocedural case.
		  A method is presented that reduces the exponential time
		  bound with the help of an algorithm that solves the problem
		  in polynomial time. Either the resulting sets contain
		  precise results or the missing (or additional) results do
		  not cause any problems during their use. The authors also
		  introduce the double iterative framework, where one
		  procedure is processed at a time. The results of the
		  intraprocedural analysis of procedures the propagates along
		  the edges of the call multi-graph. In this way the intra
		  and interprocedural analyses are executed alternately until
		  there is no change in any result set. This method can be
		  applied to any known interprocedural data flow problem.
		  Here the algorithms for the kill, live variables, and
		  reaching definitions problems are presented. Besides for
		  precision, the algorithms can be used for very large
		  programs, and since inter and intraprocedural analyses can
		  be optimized separately, the method is fast as well.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  g-snelting.tip:reengineering,
  author	= {G. Snelting, and F. Tip},
  title		= {Reengineering Class Hierarchies using Concept Analysis},
  booktitle	= {Proc. SIGSOFT Symposium on Foundations of Software
		  Engineering},
  publisher	= {ACM},
  year		= {1998},
  key		= {Concept Analysis},
  class		= {Inhertiance_Hierarchies_Restructuring
		  Software_Reverse_Engineering Static_Data_Flow_Analysis
		  Reverse_Design Re-Design Static_Control_Flow_Analysis
		  Fundamental_Methods_in_Reverse_Design Alteration
		  Static_Analysis }
}

@Article{	  gallagher.lyle:using,
  author	= {Keith Brian Gallagher and James R. Lyle},
  title		= {Using Program Slicing in Software Maintenance},
  journal	= {IEEE Transactions on Software Engineering},
  year		= {1991},
  volume	= {17},
  number	= {8},
  pages		= {751-761},
  month		= aug,
  abstract	= {Program slicing, introduces by Weiser, is known to help
		  programmers in understanding foreign code and in debugging.
		  We apply program slicing to the maintenance problem by
		  extending the notion of a program slice (that orginally
		  required both a variable and line number) to a
		  decomposition slice, one that captures all computation on a
		  given variable; i.e., is independent of line numbers. Using
		  the lattice of single variable decomposition slices ordered
		  by set inclusion, we demonstrate how to form a slice-based
		  decomposition for programs. We are then able to delineate
		  the effects of a proposed change by isolating those effects
		  in a single component of the decomposition. This gives
		  maintainers a straightforward technique for determining
		  those statements and variables which may be modified in a
		  component and those which may not. Using the decomposition,
		  we provide a set of principles to prohibit changes which
		  will interfere with unmodified components. These
		  semantically consistent changes can then be merged back
		  into the original program in linear time. Moreover, the
		  maintainer can test the changes in the component with the
		  assurance that there are no linkages into other components.
		  Thus decomposition slicing induces a new software
		  maintenance process model which eliminates the need for
		  regression testing.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis, Program_Slicing}
}

@InProceedings{	  gopal.schach:using,
  author	= {Rajeev Gopal and Stephan R. Schach},
  title		= {Using Automatic Program Decomposition Techniques in
		  Software Maintenance Tools},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  pages		= {132-141},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Program decomposition can assist maintenance programmers
		  in all three phses of maintenance, namely comprehension,
		  modification and debugging. Visibility flow graphs are
		  introduced to represent the information about the static
		  semantics of a program. Using static analysis of programs,
		  it is possible to approximate their dynamic behaviour. More
		  precise analysis is possible if the program is monitored
		  during its execution. For dynamic semantics, dependence
		  relations are used that reflect the dependency of
		  statements on the input value of variables and of the
		  output value of variables on the statements. These
		  relations are generated both at static analysis time, and
		  also during program execution. Some sample sessions with a
		  prototype program analyzer for a subset of Ada are also
		  included.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs,
		  Reverse_Design, Fundamental_Methods_in_Reverse_Design,
		  Static_Analysis, Static_Data_Flow_Analysis,
		  Dyanmic_Analysis, Dynamic_Data_Flow_Analysis}
}

@Book{		  hecht:flow,
  title		= {Flow analysis of computer programs},
  author	= {M. Hecht},
  publisher	= { Elsevier North-Holland},
  year		= {1977},
  note		= { A classical book on the theory and implementation of
		  algorithms for data flow analysis},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  johnson.ornburn.ea:quick,
  author	= {Bret Johnson and Stephen B. Ornburn and Spencer Rugaber},
  title		= {A Quick Tools Strategy for Program Analysis and Software
		  Maintenance},
  pages		= {206-213},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {Most software maintenance tasks are driven by specific
		  customer requests for program corrections or enhancements.
		  These often require detailed analyses of specific code
		  segments. Monolithic tools may not be flexible enough to
		  deal with such specific requests. This paper describes a
		  strategy for quickly producing new special-purpose tools.
		  The strategy combines existing tools including simple,
		  off-the-shelf text processing tools; rule-based,
		  language-specific analysis tools; and a commercial CASE
		  tool.},
  ftp		= {ftp.cc.gatech.edu//pub/groups/reverse/repository/quick.ps}
		  ,
  class		= {Software_Reverse_Engineering,
		  Software_Reverse_Engineering_Tools, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  livadas.roy:program,
  author	= {Panos E. Livadas and Prabal K. Roy},
  title		= {Program Dependence Analysis},
  pages		= {356-365},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1992},
  year		= {1992},
  publisher	= {IEEE Computer Society Press},
  month		= nov,
  abstract	= {It is generally recognized that one of the reasons that
		  software maintenance is so costly is that each modification
		  to a program must take into account the numerous complex
		  interrelationships in the existing software; an
		  understanding of program dependences is fundamental to
		  efficient software change. Such dependences can be of the
		  following types, data flow, calling, and functional
		  dependences. Furthermore, as the software community
		  gradually begins to move toward a more object-oriented
		  perspective on software development, it will become
		  increasingly important to be able to 'objectify' existing
		  software systems. Successful maintenance requires precise
		  knowledge of the data items in a system, the ways these
		  items are created and modified, and their relationships
		  between one another.
		  
		  In this paper the authors address these two issues. First,
		  they will discuss three methods of identifying objects the
		  first two of which were suggested by Liu and Wilde; the
		  third method is one that is proposed in this paper and is
		  based on the determination of the receiver of a procedure.
		  We believe that the latter method is one that is more
		  natural and precise than the former two. Second, algorithms
		  that perform precise interprocedural flow-sensitive
		  dependency analysis, as well as algorithms that identify
		  'objects', are introduced. Furthermore, the internal
		  program representation that we emply, the parse-tree-based
		  system dependence graph (SDG), is briefly discussed.
		  Finally, a unique tool that we have developed is presented
		  that accepts a subset of ANSI C (or Pascal) as input and
		  which implements all algorithms discussed in this paper.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs,
		  Static_Analysis, Static_Data_Flow_Analysis,
		  Software_Reverse_Engineering, Re-Use}
}

@Article{	  marlowe.ryder:properties,
  author	= {Marlowe and Ryder},
  title		= {Properties of Data Flow Frameworks. {A} Unified Model},
  journal	= {Acta Informatica},
  publisher	= {Springer-Verlag},
  volume	= {28},
  year		= {1990},
  pages		= {121-163},
  note		= { An overview of data flow frameworks and their
		  characterizing properties is given. Contains many
		  references to the field of data flow analysis},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  ryder:ismm,
  author	= {Barbara G. Ryder},
  title		= {ISMM: The Incremental Software Maintenance Manager},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  pages		= {142-157},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {ISMM, the Incremental Software Maintenance Manager, is a
		  prototype software maintenance tool which uses incremental
		  static analysis to assess the scope of proposed source code
		  changes. These effects can be predicted a priori, that is
		  without actually having to perform the software change,
		  thus anabling maintainers to choose between alternative
		  enhancements or bug fixes on the basis of their predicted
		  system impact. Incremental analysis efficiently updates
		  data flow information describing the definition, use and
		  sharing of data in an evolving software system, keeping
		  this information consistent with the current system state.
		  ISMM addresses problems in maintenance, program
		  understanding enhancement, system restructuring and
		  intelligent code reuse for C systems. Recently, ISMM has
		  provided the basis for an empirical study of the calling
		  structure of C systems. ISMM has also been used to profile
		  the on the average performance of our incremental analysis
		  algorithms; it clearly validates their usefulness,
		  especially for large systems. This paper describes the
		  design and implementation of ISMM and summarizes our
		  empirical studies.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  sametinger:tool,
  author	= {Johannes Sametinger},
  title		= {A Tool for the Maintenance of C++ Programs},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1990},
  year		= {1990},
  pages		= {54-59},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {This paper describes a tool that helps programmers
		  understand object-oriented software systems written in C++,
		  a language that is expected to gain widespread use in
		  industry. This task is accomplished by providing
		  information about the set of classes and files comprising
		  the system and the relationships among them. The tool
		  described enables its users to easily browse through the
		  system based on the relations amoung its classes, files and
		  even identifiers. In addition, the flexible use of global
		  text styles enhances the readability of the source code.
		  
		  The second part of the paper describes some details about
		  the implementation of the tool. In particular, problems are
		  mentioned that arise when performing static analysis of C++
		  programs. This analysis is necessary for obtaining
		  information needed about the program system.
		  
		  The primary goal of developing the tool has been to support
		  software maintenance, but its use is in no way limited to
		  that process},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  tonella.antoniol.ea:variable,
  author	= {Paolo Tonella and Giuliano Antoniol and Roberto Fiutem and
		  Ettore Merlo},
  title		= {Variable Precision Reaching definitions Analysis for
		  Software Maintenance},
  booktitle	= {1st  European Conference on Software Maintenance and
		  Reengineering 97},
  month		= mar,
  year		= {1997},
  publisher	= {IEEE Computer Society Press},
  abstract	= {A flow analyzer can be very helpful in the process of
		  program understanding, by providing the programmer with
		  different views of the code. As the documentation is often
		  incomplete or inconsistent, it is extremely useful to
		  extract the information a programmer may need directly from
		  the code. Program understanding activities are interactive,
		  thus program analysis tools may be asked for quick answers
		  by the maintainer. Therefore the control on the trade-off
		  between accuracy and efficiency should be given to the user.
		  
		  This paper presents an approach to interprocedural reaching
		  definitions flow analysis based on three levels of
		  precision depending on the sensitivity to the calling
		  context and the control flow. A lower precision degree
		  produces an overestimate of the data dependences in a
		  program. The result is anyhow conservative (all dependences
		  which hold are surely reported), and definitely faster than
		  the more accurate counterparts. A tool supporting reaching
		  definition analysis in the three variants has been
		  developed. The results on a test suite show that three
		  orders of magnitude can be gained in execution times by the
		  less accurate analysis, but 57.4 % extra dependences are on
		  average added. The intermediate variant is much more
		  precise (1.6 % extra dependences), but gains less in times
		  (one order of magnitude). },
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  vanek.culp:static,
  author	= {Leonard I. Vanek and Mark N. Culp},
  title		= {Static Analysis of Program Source Code using EDSA},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  pages		= {192-199},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {ESDA is a tool that uses static analysis of source code to
		  help gain an understanding of existing code. This may be
		  for the purpose of tracking down a bug or to determine in
		  advance whether an intended change will have any
		  undesirable side effects. In either case, the phase of the
		  development life cycle that will most benefit from a tool
		  like EDSA is the maintenance phase.
		  
		  ESDA provides three kinds of facilities. It helps to browse
		  through code following either the control flow or data flow
		  rather than the order in which the code happens to be
		  written. It displays code with unimportant source lines
		  elided, so that the user can get a more global view of the
		  program. Finally, it provides search management to make it
		  easier to examine all possibilities when browsing.},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}

@InProceedings{	  wilde.huitt.ea:dependence,
  author	= {Norman Wilde and Ross Huitt and Scott Huitt},
  title		= {Dependence Analysis Tools: Reusable Components for
		  Software Maintenance},
  booktitle	= {Proceedings of the  International Conference on Software
		  Maintenance ~1989},
  year		= {1989},
  pages		= {126-131},
  organization	= {IEEE},
  publisher	= {IEEE Computer Society Press},
  abstract	= {Software Maintenance is costly because of the many complex
		  interrelationships in a large software system; an
		  understanding of these program dependencies is fundamentral
		  to efficient software change. This paper describes a
		  general purpose toolset that is now being developed to
		  capture and analyze software dependencies. The tools are
		  designed to serve as reusable components. They may be used
		  not only to aid programmers directly in understanding
		  programs but also as a basis from which other specialized
		  tools can be constructed.
		  
		  The tools use the concept of a dependency graph as a basic
		  abstraction to simplify the understanding of software
		  relationships. Definitional, calling, functional and
		  data-flow dependencies are analyzed. An external dependency
		  graph for each function is developed to encapsulate the
		  effects of function calls.},
  class		= {Software_Reverse_Engineering,
		  Intermediate_Representations_of_Source_Code, Using_graphs,
		  Reverse_Design, Fundamental_Methods_in_Reverse_Design,
		  Static_Analysis, Static_Data_Flow_Analysis}
}

@Article{	  wolf.clarke.ea:adapic,
  key		= {Wolf et al.},
  author	= {A. L. Wolf and L. A. Clarke and J. C. Wileden},
  title		= {The AdaPIC Tool Set: Supporting Interface Control and
		  Analysis Throughout the Software Development Process},
  journal	= {IEEE Transactions on Software Engineering},
  pages		= {250--263},
  volume	= {15},
  number	= {3},
  month		= mar,
  year		= {1989},
  location	= {CMU E & S Library},
  class		= {Software_Reverse_Engineering, Reverse_Design,
		  Fundamental_Methods_in_Reverse_Design, Static_Analysis,
		  Static_Data_Flow_Analysis}
}