Explicitly stated program invariants can help programmers by identifying program properties that must be preserved when modifying code. In practice, however, these invari-ants are usually implicit. An alternative to expecting pro-grammers to fully annotate code with invariants is to au-tomatically infer invariants from the program itself. This research focuses on dynamic techniques for discovering in-variants from execution traces. This paper reports two results. First, it describes techniques for dynamically discovering invariants, along with an instru-menter and an inference engine that embody these tech-niques. Second, it reports on the application of the engine to two sets of target programs. In programs from Gries’s work on program derivation, we rediscovered predefined in-variants. In a C program lacking explicit invariants, we dis-covered invariants that assisted a software evolution task.

Abstract not found

dotty is a customizable graph editor. Its main components are a programmable viewer (lefty) and graph layout generators (dot and neato). dotty can run stand-alone, but more importantly, it can be programmed to act as a front-end for other applications. Some interesting examples are ciao, a program source code database browser, vdbx, a visual extension to dbx for displaying data structures as graphs, and vpm, an interactive distributed process monitor. Keywords: graph browser, visual debugger, process monitor, software information system. 1 Introduction Graph drawings are one of the best ways to present technical information. Such diagrams are particularly appropriate for showing relations between objects. Finite state machines, networks, program call graphs, and various kinds of object to object dependencies are a few examples of information that can be made easier to understand when presented as graphs. It is therefore important to have a good set of tools for displaying and manipul...

Acid is an unusual source-level symbolic debugger for Plan 9. It is implemented as a language interpreter with specialized primitives that provide debugger support. Programs written in the language manipulate one or more target processes; variables in the language represent the symbols, state, and resources of those processes. This structure allows complex interaction between the debugger and the target program and provides a convenient method of parameterizing differences between machine architectures. Although some effort is required to learn the debugging language, the richness and flexibility of the debugging environment encourages new ways of reasoning about the way programs run and the conditions under which they fail. 1.

cdb is a simple, source-level debugger for ANSI C programs compiled by lcc, a retargetable C compiler. cdb is completely independent of its target architecture. This independence is achieved by embedding a small amount of itself --- a `nub' --- in the program to be debugged and by having the compiler emit machine-independent symbol-table data and related code. This paper describes the design of a nub interface for debugging, a target-independent implementation of this interface for cdb, and the implementation of cdb itself. When compared to platform-specific debuggers, cdb's implementation is minuscule: the nub, debugger, and associated communications routines take about 1500 lines of C, and fewer than 600 lines were added to lcc's front end to emit symbol tables and breakpoint hooks. All this code is machine independent. Introduction Source-level debuggers are notoriously machine-dependent programs. Most debuggers depend not only on the machine on which they run, but also depend...

Automatic software instrumentation is usually done at the machine level or is targeted at specific program behavior for use with a particular monitoring application. This paper describes CCI, an automatic software instrumentation tool for ANSI C designed to serve a broad range of program execution monitors. CCI supports high level instrumentation for both application-specific behavior as well as standard libraries and data types. The event generation mechanism is defined by the execution monitor which uses CCI, providing flexibility for different monitors' execution models. Code explosion and the runtime cost of instrumentation are reduced by declarative configuration facilities that allow the monitor to select specific events to be instrumented. Higher level events can be defined by combining lower level events with information obtained from semantic analysis of the instrumented program. 1 Introduction Program execution monitoring is an important tool for use in debugging, performanc...

As computer systems are becoming increasingly complex, directing tools are gaining in importance. Directing denotes two classes of activities, monitoring and controlling. Monitoring is used for collecting information about the program behavior. Controlling is used to modify the program state in order to change program's future behavior. Some characteristic directing tools are debuggers and performance monitors. Dynascope is a directing platform, which provides basic monitoring and controlling primitives. These primitives are used in building advanced directing applications for networked and heterogeneous environments. Dynascope is integrated with existing programming tools and uses only generic operating system and networking primitives. This paper describes the design and implementation of the directing server, the central component of Dynascope. Dynascope is being used in several applications, including relative debugging, steering agents, and simulator testing. 1 Introduction Incre...

Debugging is a laborious, manual activity that often involves the repetition of common operations. Ideally, users should be able to describe these repetitious operations as little programs. Debuggers should therefore be programmable, or scriptable. The operating environment of these scripts, however, imposes interesting design challenges on the programming language in which these scripts will be written. This paper presents our design of a language for scripting debuggers. The language offers powerful primitives that can precisely and concisely capture many important debugging and comprehension metaphors. The paper also describes a debugger for the Java language built in accordance with these principles. We have implemented this debugger to run alongside the Java Virtual Machine. The paper includes concrete examples of applying this debugger to programs. 1.

One of the most difficult aspects of dynamic analysis is extrapolating behavioral information from the program to be debugged or visualized. This thesis describes the design and implementation of a Configurable C Instrumentation tool, called CCI, which addresses this difficulty. CCI inserts event generation code into a program while preserving the original run-time behavior, other than reducing its speed. The event generation mechanism is user-defined by the framework which uses CCI. CCI addresses the fact that inserting code causes code explosion and reduced execution speeds by providing configuration facilities. Through a simple event set grammar, the user can specify instrumentation for those events they are interested in. Moreover, the user can create new high level events from pre-existing low-level events. Configurability is the major research contribution of CCI: it reduces code explosion and the total number of generated events while increasing the speed of the instrumented cod...

Directors are reactive systems that monitor the runtime environment and react to the emitted events. Typical examples of directors are debuggers and tools for program analysis and software visualization. In this paper we describe a cross-platform virtual machine that provides advanced facilities for implementing directors with low e#ort.