Some requirements for architectural support of software debugging
ASPLOS I Proceedings of the first international symposium on Architectural support for programming languages and operating systems
The why and wherefore of the Cornell Program Synthesizer
Proceedings of the ACM SIGPLAN SIGOA symposium on Text manipulation
Source language debugging tools.
Source language debugging tools.
A new modula compiler for the LSI-11
ACM SIGPLAN Notices
A window based visual debugger for a real time Ada tasking environment
WADAS '88 Proceedings of the fifth Washington Ada symposium on Ada
Proceedings of the 22nd annual ACM SIGPLAN conference on Object-oriented programming systems and applications
Hi-index | 0.00 |
This note describes RED, a remotely executed debugger capable of generating a real-time source level trace history of a high level language program executing on a microprocessor. The trace history consists of a display of the source statements of each basic block executed, annotated by the time at which execution of that block began. Basic blocks are traced rather than statements to reduce sampling bandwidth requirements while still retaining the ability to record the essential logical flow of programs. RED is intended to assist in debugging stand-alone high level language process control programs with real-time constraints. We outline two possible implementation schemes for generating the real-time trace history. In both, a “debugging co-processor” collects in a history buffer the values of the program counter (PC) and the corresponding value of a clock as each basic block begins execution. The debugger, which runs on the processor hosting the compiler and has access to the co-processor over a fast link, reconstructs a source level trace from the PC-time pairs in the history buffer. In one scheme, the language compiler emits an extra instruction at the beginning of each basic block in the program to output the value of the program counter to a parallel port connected to the debug processor. The second method makes use of an extended target memory space to provide tag bits denoting basic blocks. When an instruction is fetched, the debug processor detects the presence of the tag bits and buffers up the value of the corresponding program counter and time. The first method is simpler to implement, requiring only conventional, usually straightforward hardware additions to the target, but requires the execution overhead of the extra instructions. In both cases the debugger itself runs on the host processor and has access to tables generated during compile time of the source program.