docs/SourceLevelDebugging.html

   1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
   2                       "http://www.w3.org/TR/html4/strict.dtd">
   3 <html>
   4 <head>
   5   <title>Source Level Debugging with LLVM</title>
   6   <link rel="stylesheet" href="llvm.css" type="text/css">
   7 </head>
   8 <body>
   9
  10 <div class="doc_title">Source Level Debugging with LLVM</div>
  11
  12 <table border="0" width="100%">
  13 <tr>
  14 <td valign="top">
  15 <ul>
  16
  17   <li><a href="#introduction">Introduction</a>
  18   <ol>
  19     <li><a href="#phil">Philosophy behind LLVM debugging information</a></li>
  20     <li><a href="#debugopt">Debugging optimized code</a></li>
  21     <li><a href="#future">Future work</a></li>
  22   </ol></li>
  23   <li><a href="#llvm-db">Using the <tt>llvm-db</tt> tool</a>
  24   <ol>
  25     <li><a href="#limitations">Limitations of <tt>llvm-db</tt></a></li>
  26     <li><a href="#sample">A sample <tt>llvm-db</tt> session</a></li>
  27     <li><a href="#startup">Starting the debugger</a></li>
  28     <li><a href="#commands">Commands recognized by the debugger</a></li>
  29   </ol></li>
  30
  31   <li><a href="#architecture">Architecture of the LLVM debugger</a>
  32   <ol>
  33     <li><a href="#arch_debugger">The Debugger and InferiorProcess classes</a></li>
  34     <li><a href="#arch_info">The RuntimeInfo, ProgramInfo, and SourceLanguage classes</a></li>
  35     <li><a href="#arch_llvm-db">The <tt>llvm-db</tt> tool</a></li>
  36     <li><a href="#arch_todo">Short-term TODO list</a></li>
  37   </ol></li>
  38
  39   <li><a href="#format">Debugging information format</a>
  40   <ol>
  41     <li><a href="#format_common_anchors">Anchors for global objects</a></li>
  42     <li><a href="#format_common_stoppoint">Representing stopping points in the source program</a></li>
  43     <li><a href="#format_common_lifetime">Object lifetimes and scoping</a></li>
  44     <li><a href="#format_common_descriptors">Object descriptor formats</a>
  45     <ul>
  46       <li><a href="#format_common_source_files">Representation of source files</a></li>
  47       <li><a href="#format_common_program_objects">Representation of program objects</a></li>
  48       <li><a href="#format_common_object_contexts">Program object contexts</a></li>
  49     </ul></li>
  50     <li><a href="#format_common_intrinsics">Debugger intrinsic functions</a></li>
  51     <li><a href="#format_common_tags">Values for debugger tags</a></li>
  52   </ol></li>
  53   <li><a href="#ccxx_frontend">C/C++ front-end specific debug information</a>
  54   <ol>
  55     <li><a href="#ccxx_pse">Program Scope Entries</a>
  56     <ul>
  57       <li><a href="#ccxx_compilation_units">Compilation unit entries</a></li>
  58       <li><a href="#ccxx_modules">Module, namespace, and importing entries</a></li>
  59     </ul></li>
  60     <li><a href="#ccxx_dataobjects">Data objects (program variables)</a></li>
  61   </ol></li>
  62 </ul>
  63 </td>
  64 <td align="right" valign="top">
  65 <img src="img/venusflytrap.jpg" alt="A leafy and green bug eater" width="247"
  66 height="369">
  67 </td>
  68 </tr>
  69 </table>
  70
  71
  72 <!-- *********************************************************************** -->
  73 <div class="doc_section"><a name="introduction">Introduction</a></div> <!--
  74 *********************************************************************** -->
  75
  76 <div class="doc_text">
  77
  78 <p>This document is the central repository for all information pertaining to
  79 debug information in LLVM.  It describes the <a href="#llvm-db">user
  80 interface</a> for the <a href="CommandGuide/llvm-db.html"><tt>llvm-db</tt>
  81 tool</a>, which provides a powerful <a href="#llvm-db">source-level debugger</a>
  82 to users of LLVM-based compilers.  It then describes the <a
  83 href="#architecture">various components</a> that make up the debugger and the
  84 libraries which future clients may use.  Finally, it describes the <a
  85 href="#format">actual format that the LLVM debug information</a> takes,
  86 which is useful for those interested in creating front-ends or dealing directly
  87 with the information.</p>
  88
  89 </div>
  90
  91 <!-- ======================================================================= -->
  92 <div class="doc_subsection">
  93   <a name="phil">Philosophy behind LLVM debugging information</a>
  94 </div>
  95
  96 <div class="doc_text">
  97
  98 <p>The idea of the LLVM debugging information is to capture how the important
  99 pieces of the source-language's Abstract Syntax Tree map onto LLVM code.
 100 Several design aspects have shaped the solution that appears here.  The
 101 important ones are:</p>
 102
 103 <ul>
 104 <li>Debugging information should have very little impact on the rest of the
 105 compiler.  No transformations, analyses, or code generators should need to be
 106 modified because of debugging information.</li>
 107
 108 <li>LLVM optimizations should interact in <a href="#debugopt">well-defined and
 109 easily described ways</a> with the debugging information.</li>
 110
 111 <li>Because LLVM is designed to support arbitrary programming languages,
 112 LLVM-to-LLVM tools should not need to know anything about the semantics of the
 113 source-level-language.</li>
 114
 115 <li>Source-level languages are often <b>widely</b> different from one another.
 116 LLVM should not put any restrictions of the flavor of the source-language, and
 117 the debugging information should work with any language.</li>
 118
 119 <li>With code generator support, it should be possible to use an LLVM compiler
 120 to compile a program to native machine code and standard debugging formats.
 121 This allows compatibility with traditional machine-code level debuggers, like
 122 GDB or DBX.</li>
 123
 124 </ul>
 125
 126 <p>The approach used by the LLVM implementation is to use a small set of <a
 127 href="#format_common_intrinsics">intrinsic functions</a> to define a mapping
 128 between LLVM program objects and the source-level objects.  The description of
 129 the source-level program is maintained in LLVM global variables in an <a
 130 href="#ccxx_frontend">implementation-defined format</a> (the C/C++ front-end
 131 currently uses working draft 7 of the <a
 132 href="http://www.eagercon.com/dwarf/dwarf3std.htm">Dwarf 3 standard</a>).</p>
 133
 134 <p>When a program is debugged, the debugger interacts with the user and turns
 135 the stored debug information into source-language specific information.  As
 136 such, the debugger must be aware of the source-language, and is thus tied to a
 137 specific language of family of languages.  The <a href="#llvm-db">LLVM
 138 debugger</a> is designed to be modular in its support for source-languages.</p>
 139
 140 </div>
 141
 142
 143 <!-- ======================================================================= -->
 144 <div class="doc_subsection">
 145   <a name="debugopt">Debugging optimized code</a>
 146 </div>
 147
 148 <div class="doc_text">
 149
 150 <p>An extremely high priority of LLVM debugging information is to make it
 151 interact well with optimizations and analysis.  In particular, the LLVM debug
 152 information provides the following guarantees:</p>
 153
 154 <ul>
 155
 156 <li>LLVM debug information <b>always provides information to accurately read the
 157 source-level state of the program</b>, regardless of which LLVM optimizations
 158 have been run, and without any modification to the optimizations themselves.
 159 However, some optimizations may impact the ability to modify the current state
 160 of the program with a debugger, such as setting program variables, or calling
 161 function that have been deleted.</li>
 162
 163 <li>LLVM optimizations gracefully interact with debugging information.  If they
 164 are not aware of debug information, they are automatically disabled as necessary
 165 in the cases that would invalidate the debug info.  This retains the LLVM
 166 features making it easy to write new transformations.</li>
 167
 168 <li>As desired, LLVM optimizations can be upgraded to be aware of the LLVM
 169 debugging information, allowing them to update the debugging information as they
 170 perform aggressive optimizations.  This means that, with effort, the LLVM
 171 optimizers could optimize debug code just as well as non-debug code.</li>
 172
 173 <li>LLVM debug information does not prevent many important optimizations from
 174 happening (for example inlining, basic block reordering/merging/cleanup, tail
 175 duplication, etc), further reducing the amount of the compiler that eventually
 176 is "aware" of debugging information.</li>
 177
 178 <li>LLVM debug information is automatically optimized along with the rest of the
 179 program, using existing facilities.  For example, duplicate information is
 180 automatically merged by the linker, and unused information is automatically
 181 removed.</li>
 182
 183 </ul>
 184
 185 <p>Basically, the debug information allows you to compile a program with
 186 "<tt>-O0 -g</tt>" and get full debug information, allowing you to arbitrarily
 187 modify the program as it executes from the debugger.  Compiling a program with
 188 "<tt>-O3 -g</tt>" gives you full debug information that is always available and
 189 accurate for reading (e.g., you get accurate stack traces despite tail call
 190 elimination and inlining), but you might lose the ability to modify the program
 191 and call functions where were optimized out of the program, or inlined away
 192 completely.</p>
 193
 194 </div>
 195
 196 <!-- ======================================================================= -->
 197 <div class="doc_subsection">
 198   <a name="future">Future work</a>
 199 </div>
 200
 201 <div class="doc_text">
 202 <p>There are several important extensions that could be eventually added to the
 203 LLVM debugger.  The most important extension would be to upgrade the LLVM code
 204 generators to support debugging information.  This would also allow, for
 205 example, the X86 code generator to emit native objects that contain debugging
 206 information consumable by traditional source-level debuggers like GDB or
 207 DBX.</p>
 208
 209 <p>Additionally, LLVM optimizations can be upgraded to incrementally update the
 210 debugging information, <a href="#commands">new commands</a> can be added to the
 211 debugger, and thread support could be added to the debugger.</p>
 212
 213 <p>The "SourceLanguage" modules provided by <tt>llvm-db</tt> could be
 214 substantially improved to provide good support for C++ language features like
 215 namespaces and scoping rules.</p>
 216
 217 <p>After working with the debugger for a while, perhaps the nicest improvement
 218 would be to add some sort of line editor, such as GNU readline (but one that is
 219 compatible with the LLVM license).</p>
 220
 221 <p>For someone so inclined, it should be straight-forward to write different
 222 front-ends for the LLVM debugger, as the LLVM debugging engine is cleanly
 223 separated from the <tt>llvm-db</tt> front-end.  A new LLVM GUI debugger or IDE
 224 would be nice. :)</p>
 225
 226 </div>
 227
 228 <!-- *********************************************************************** -->
 229 <div class="doc_section">
 230   <a name="llvm-db">Using the <tt>llvm-db</tt> tool</a>
 231 </div>
 232 <!-- *********************************************************************** -->
 233
 234 <div class="doc_text">
 235
 236 <p>The <tt>llvm-db</tt> tool provides a GDB-like interface for source-level
 237 debugging of programs.  This tool provides many standard commands for inspecting
 238 and modifying the program as it executes, loading new programs, single stepping,
 239 placing breakpoints, etc.  This section describes how to use the debugger.</p>
 240
 241 <p><tt>llvm-db</tt> has been designed to be as similar to GDB in its user
 242 interface as possible.  This should make it extremely easy to learn
 243 <tt>llvm-db</tt> if you already know <tt>GDB</tt>.  In general, <tt>llvm-db</tt>
 244 provides the subset of GDB commands that are applicable to LLVM debugging users.
 245 If there is a command missing that make a reasonable amount of sense within the
 246 <a href="#limitations">limitations of <tt>llvm-db</tt></a>, please report it as
 247 a bug or, better yet, submit a patch to add it. :)</p>
 248
 249 </div>
 250
 251 <!-- ======================================================================= -->
 252 <div class="doc_subsection">
 253   <a name="limitations">Limitations of <tt>llvm-db</tt></a>
 254 </div>
 255
 256 <div class="doc_text">
 257
 258 <p><tt>llvm-db</tt> is designed to be modular and easy to extend.  This
 259 extensibility was key to getting the debugger up-and-running quickly, because we
 260 can start with simple-but-unsophisicated implementations of various components.
 261 Because of this, it is currently missing many features, though they should be
 262 easy to add over time (patches welcomed!).  The biggest inherent limitations of
 263 <tt>llvm-db</tt> are currently due to extremely simple <a
 264 href="#arch_debugger">debugger backend</a> (implemented in
 265 "lib/Debugger/UnixLocalInferiorProcess.cpp") which is designed to work without
 266 any cooperation from the code generators.  Because it is so simple, it suffers
 267 from the following inherent limitations:</p>
 268
 269 <ul>
 270
 271 <li>Running a program in <tt>llvm-db</tt> is a bit slower than running it with
 272 <tt>lli</tt> (i.e., in the JIT).</li>
 273
 274 <li>Inspection of the target hardware is not supported.  This means that you
 275 cannot, for example, print the contents of X86 registers.</li>
 276
 277 <li>Inspection of LLVM code is not supported.  This means that you cannot print
 278 the contents of arbitrary LLVM values, or use commands such as <tt>stepi</tt>.
 279 This also means that you cannot debug code without debug information.</li>
 280
 281 <li>Portions of the debugger run in the same address space as the program being
 282 debugged.  This means that memory corruption by the program could trample on
 283 portions of the debugger.</li>
 284
 285 <li>Attaching to existing processes and core files is not currently
 286 supported.</li>
 287
 288 </ul>
 289
 290 <p>That said, the debugger is still quite useful, and all of these limitations
 291 can be eliminated by integrating support for the debugger into the code
 292 generators, and writing a new <a href="#arch_debugger">InferiorProcess</a>
 293 subclass to use it.  See the <a href="#future">future work</a> section for ideas
 294 of how to extend the LLVM debugger despite these limitations.</p>
 295
 296 </div>
 297
 298
 299 <!-- ======================================================================= -->
 300 <div class="doc_subsection">
 301   <a name="sample">A sample <tt>llvm-db</tt> session</a>
 302 </div>
 303
 304 <div class="doc_text">
 305
 306 <p>TODO: this is obviously lame, when more is implemented, this can be much
 307 better.</p>
 308
 309 <pre>
 310 $ <b>llvm-db funccall</b>
 311 llvm-db: The LLVM source-level debugger
 312 Loading program... successfully loaded 'funccall.bc'!
 313 (llvm-db) <b>create</b>
 314 Starting program: funccall.bc
 315 main at funccall.c:9:2
 316 9 ->            q = 0;
 317 (llvm-db) <b>list main</b>
 318 4       void foo() {
 319 5               int t = q;
 320 6               q = t + 1;
 321 7       }
 322 8       int main() {
 323 9 ->            q = 0;
 324 10              foo();
 325 11              q = q - 1;
 326 12
 327 13              return q;
 328 (llvm-db) <b>list</b>
 329 14      }
 330 (llvm-db) <b>step</b>
 331 10 ->           foo();
 332 (llvm-db) <b>s</b>
 333 foo at funccall.c:5:2
 334 5 ->            int t = q;
 335 (llvm-db) <b>bt</b>
 336 #0 ->   0x85ffba0 in foo at funccall.c:5:2
 337 #1      0x85ffd98 in main at funccall.c:10:2
 338 (llvm-db) <b>finish</b>
 339 main at funccall.c:11:2
 340 11 ->           q = q - 1;
 341 (llvm-db) <b>s</b>
 342 13 ->           return q;
 343 (llvm-db) <b>s</b>
 344 The program stopped with exit code 0
 345 (llvm-db) <b>quit</b>
 346 $
 347 </pre>
 348
 349 </div>
 350
 351
 352
 353 <!-- ======================================================================= -->
 354 <div class="doc_subsection">
 355   <a name="startup">Starting the debugger</a>
 356 </div>
 357
 358 <div class="doc_text">
 359
 360 <p>There are three ways to start up the <tt>llvm-db</tt> debugger:</p>
 361
 362 <p>When run with no options, just <tt>llvm-db</tt>, the debugger starts up
 363 without a program loaded at all.  You must use the <a
 364 href="#c_file"><tt>file</tt> command</a> to load a program, and the <a
 365 href="c_set_args"><tt>set args</tt></a> or <a href="#c_run"><tt>run</tt></a>
 366 commands to specify the arguments for the program.</p>
 367
 368 <p>If you start the debugger with one argument, as <tt>llvm-db
 369 &lt;program&gt;</tt>, the debugger will start up and load in the specified
 370 program.  You can then optionally specify arguments to the program with the <a
 371 href="c_set_args"><tt>set args</tt></a> or <a href="#c_run"><tt>run</tt></a>
 372 commands.</p>
 373
 374 <p>The third way to start the program is with the <tt>--args</tt> option.  This
 375 option allows you to specify the program to load and the arguments to start out
 376 with.  <!-- No options to <tt>llvm-db</tt> may be specified after the
 377 <tt>-args</tt> option. --> Example use: <tt>llvm-db --args ls /home</tt></p>
 378
 379 </div>
 380
 381 <!-- ======================================================================= -->
 382 <div class="doc_subsection">
 383   <a name="commands">Commands recognized by the debugger</a>
 384 </div>
 385
 386 <div class="doc_text">
 387
 388 <p>FIXME: this needs work obviously.  See the <a
 389 href="http://sources.redhat.com/gdb/documentation/">GDB documentation</a> for
 390 information about what these do, or try '<tt>help [command]</tt>' within
 391 <tt>llvm-db</tt> to get information.</p>
 392
 393 <p>
 394 <h2>General usage:</h2>
 395 <ul>
 396 <li>help [command]</li>
 397 <li>quit</li>
 398 <li><a name="c_file">file</a> [program]</li>
 399 </ul>
 400
 401 <h2>Program inspection and interaction:</h2>
 402 <ul>
 403 <li>create (start the program, stopping it ASAP in <tt>main</tt>)</li>
 404 <li>kill</li>
 405 <li>run [args]</li>
 406 <li>step [num]</li>
 407 <li>next [num]</li>
 408 <li>cont</li>
 409 <li>finish</li>
 410
 411 <li>list [start[, end]]</li>
 412 <li>info source</li>
 413 <li>info sources</li>
 414 <li>info functions</li>
 415 </ul>
 416
 417 <h2>Call stack inspection:</h2>
 418 <ul>
 419 <li>backtrace</li>
 420 <li>up [n]</li>
 421 <li>down [n]</li>
 422 <li>frame [n]</li>
 423 </ul>
 424
 425
 426 <h2>Debugger inspection and interaction:</h2>
 427 <ul>
 428 <li>info target</li>
 429 <li>show prompt</li>
 430 <li>set prompt</li>
 431 <li>show listsize</li>
 432 <li>set listsize</li>
 433 <li>show language</li>
 434 <li>set language</li>
 435 <li>show args</li>
 436 <li>set args [args]</li>
 437 </ul>
 438
 439 <h2>TODO:</h2>
 440 <ul>
 441 <li>info frame</li>
 442 <li>break</li>
 443 <li>print</li>
 444 <li>ptype</li>
 445
 446 <li>info types</li>
 447 <li>info variables</li>
 448 <li>info program</li>
 449
 450 <li>info args</li>
 451 <li>info locals</li>
 452 <li>info catch</li>
 453 <li>... many others</li>
 454 </ul>
 455
 456 </div>
 457
 458 <!-- *********************************************************************** -->
 459 <div class="doc_section">
 460   <a name="architecture">Architecture of the LLVM debugger</a>
 461 </div>
 462 <!-- *********************************************************************** -->
 463
 464 <div class="doc_text">
 465 <p>The LLVM debugger is built out of three distinct layers of software.  These
 466 layers provide clients with different interface options depending on what pieces
 467 of they want to implement themselves, and it also promotes code modularity and
 468 good design.  The three layers are the <a href="#arch_debugger">Debugger
 469 interface</a>, the <a href="#arch_info">"info" interfaces</a>, and the <a
 470 href="#arch_llvm-db"><tt>llvm-db</tt> tool</a> itself.</p>
 471 </div>
 472
 473 <!-- ======================================================================= -->
 474 <div class="doc_subsection">
 475   <a name="arch_debugger">The Debugger and InferiorProcess classes</a>
 476 </div>
 477
 478 <div class="doc_text">
 479 <p>The Debugger class (defined in the <tt>include/llvm/Debugger/</tt> directory)
 480 is a low-level class which is used to maintain information about the loaded
 481 program, as well as start and stop the program running as necessary.  This class
 482 does not provide any high-level analysis or control over the program, only
 483 exposing simple interfaces like <tt>load/unloadProgram</tt>,
 484 <tt>create/killProgram</tt>, <tt>step/next/finish/contProgram</tt>, and
 485 low-level methods for installing breakpoints.</p>
 486
 487 <p>
 488 The Debugger class is itself a wrapper around the lowest-level InferiorProcess
 489 class.  This class is used to represent an instance of the program running under
 490 debugger control.  The InferiorProcess class can be implemented in different
 491 ways for different targets and execution scenarios (e.g., remote debugging).
 492 The InferiorProcess class exposes a small and simple collection of interfaces
 493 which are useful for inspecting the current state of the program (such as
 494 collecting stack trace information, reading the memory image of the process,
 495 etc).  The interfaces in this class are designed to be as low-level and simple
 496 as possible, to make it easy to create new instances of the class.
 497 </p>
 498
 499 <p>
 500 The Debugger class exposes the currently active instance of InferiorProcess
 501 through the <tt>Debugger::getRunningProcess</tt> method, which returns a
 502 <tt>const</tt> reference to the class.  This means that clients of the Debugger
 503 class can only <b>inspect</b> the running instance of the program directly.  To
 504 change the executing process in some way, they must use the interces exposed by
 505 the Debugger class.
 506 </p>
 507 </div>
 508
 509 <!-- ======================================================================= -->
 510 <div class="doc_subsection">
 511   <a name="arch_info">The RuntimeInfo, ProgramInfo, and SourceLanguage classes</a>
 512 </div>
 513
 514 <div class="doc_text">
 515 <p>
 516 The next-highest level of debugger abstraction is provided through the
 517 ProgramInfo, RuntimeInfo, SourceLanguage and related classes (also defined in
 518 the <tt>include/llvm/Debugger/</tt> directory).  These classes efficiently
 519 decode the debugging information and low-level interfaces exposed by
 520 InferiorProcess into a higher-level representation, suitable for analysis by the
 521 debugger.
 522 </p>
 523
 524 <p>
 525 The ProgramInfo class exposes a variety of different kinds of information about
 526 the program objects in the source-level-language.  The SourceFileInfo class
 527 represents a source-file in the program (e.g. a .cpp or .h file).  The
 528 SourceFileInfo class captures information such as which SourceLanguage was used
 529 to compile the file, where the debugger can get access to the actual file text
 530 (which is lazily loaded on demand), etc.  The SourceFunctionInfo class
 531 represents a... <b>FIXME: finish</b>.  The ProgramInfo class provides interfaces
 532 to lazily find and decode the information needed to create the Source*Info
 533 classes requested by the debugger.
 534 </p>
 535
 536 <p>
 537 The RuntimeInfo class exposes information about the currently executed program,
 538 by decoding information from the InferiorProcess and ProgramInfo classes.  It
 539 provides a StackFrame class which provides an easy-to-use interface for
 540 inspecting the current and suspended stack frames in the program.
 541 </p>
 542
 543 <p>
 544 The SourceLanguage class is an abstract interface used by the debugger to
 545 perform all source-language-specific tasks.  For example, this interface is used
 546 by the ProgramInfo class to decode language-specific types and functions and by
 547 the debugger front-end (such as <a href="#arch_llvm-db"><tt>llvm-db</tt></a> to
 548 evaluate source-langauge expressions typed into the debugger.  This class uses
 549 the RuntimeInfo &amp; ProgramInfo classes to get information about the current
 550 execution context and the loaded program, respectively.
 551 </p>
 552
 553 </div>
 554
 555 <!-- ======================================================================= -->
 556 <div class="doc_subsection">
 557   <a name="arch_llvm-db">The <tt>llvm-db</tt> tool</a>
 558 </div>
 559
 560 <div class="doc_text">
 561 <p>
 562 The <tt>llvm-db</tt> is designed to be a debugger providing an interface as <a
 563 href="#llvm-db">similar to GDB</a> as reasonable, but no more so than that.
 564 Because the <a href="#arch_debugger">Debugger</a> and <a
 565 href="#arch_info">info</a> classes implement all of the heavy lifting and
 566 analysis, <tt>llvm-db</tt> (which lives in <tt>llvm/tools/llvm-db</tt>) consists
 567 mainly of of code to interact with the user and parse commands.  The CLIDebugger
 568 constructor registers all of the builtin commands for the debugger, and each
 569 command is implemented as a CLIDebugger::[name]Command method.
 570 </p>
 571 </div>
 572
 573
 574 <!-- ======================================================================= -->
 575 <div class="doc_subsection">
 576   <a name="arch_todo">Short-term TODO list</a>
 577 </div>
 578
 579 <div class="doc_text">
 580
 581 <p>
 582 FIXME: this section will eventually go away.  These are notes to myself of
 583 things that should be implemented, but haven't yet.
 584 </p>
 585
 586 <p>
 587 <b>Breakpoints:</b> Support is already implemented in the 'InferiorProcess'
 588 class, though it hasn't been tested yet.  To finish breakpoint support, we need
 589 to implement breakCommand (which should reuse the linespec parser from the list
 590 command), and handle the fact that 'break foo' or 'break file.c:53' may insert
 591 multiple breakpoints.  Also, if you say 'break file.c:53' and there is no
 592 stoppoint on line 53, the breakpoint should go on the next available line.  My
 593 idea was to have the Debugger class provide a "Breakpoint" class which
 594 encapsulated this messiness, giving the debugger front-end a simple interface.
 595 The debugger front-end would have to map the really complex semantics of
 596 temporary breakpoints and 'conditional' breakpoints onto this intermediate
 597 level. Also, breakpoints should survive as much as possible across program
 598 reloads.
 599 </p>
 600
 601 <p>
 602 <b>UnixLocalInferiorProcess.cpp speedup</b>: There is no reason for the debugged
 603 process to code gen the globals corresponding to debug information.  The
 604 IntrinsicLowering object could instead change descriptors into constant expr
 605 casts of the constant address of the LLVM objects for the descriptors.  This
 606 would also allow us to eliminate the mapping back and forth between physical
 607 addresses that must be done.</p>
 608
 609 <p>
 610 <b>Process deaths</b>: The InferiorProcessDead exception should be extended to
 611 know "how" a process died, i.e., it was killed by a signal.  This is easy to
 612 collect in the UnixLocalInferiorProcess, we just need to represent it.</p>
 613
 614 </div>
 615
 616 <!-- *********************************************************************** -->
 617 <div class="doc_section">
 618   <a name="format">Debugging information format</a>
 619 </div>
 620 <!-- *********************************************************************** -->
 621
 622 <div class="doc_text">
 623
 624 <p>LLVM debugging information has been carefully designed to make it possible
 625 for the optimizer to optimize the program and debugging information without
 626 necessarily having to know anything about debugging information.  In particular,
 627 the global constant merging pass automatically eliminates duplicated debugging
 628 information (often caused by header files), the global dead code elimination
 629 pass automatically deletes debugging information for a function if it decides to
 630 delete the function, and the linker eliminates debug information when it merges
 631 <tt>linkonce</tt> functions.</p>
 632
 633 <p>To do this, most of the debugging information (descriptors for types,
 634 variables, functions, source files, etc) is inserted by the language front-end
 635 in the form of LLVM global variables.  These LLVM global variables are no
 636 different from any other global variables, except that they have a web of LLVM
 637 intrinsic functions that point to them.  If the last references to a particular
 638 piece of debugging information are deleted (for example, by the
 639 <tt>-globaldce</tt> pass), the extraneous debug information will automatically
 640 become dead and be removed by the optimizer.</p>
 641
 642 <p>The debugger is designed to be agnostic about the contents of most of the
 643 debugging information.  It uses a <a href="#arch_info">source-language-specific
 644 module</a> to decode the information that represents variables, types,
 645 functions, namespaces, etc: this allows for arbitrary source-language semantics
 646 and type-systems to be used, as long as there is a module written for the
 647 debugger to interpret the information.</p>
 648
 649 <p>To provide basic functionality, the LLVM debugger does have to make some
 650 assumptions about the source-level language being debugged, though it keeps
 651 these to a minimum.  The only common features that the LLVM debugger assumes
 652 exist are <a href="#format_common_source_files">source files</a>, and <a
 653 href="#format_program_objects">program objects</a>.  These abstract objects are
 654 used by the debugger to form stack traces, show information about local
 655 variables, etc.</p>
 656
 657 <p>This section of the documentation first describes the representation aspects
 658 common to any source-language.  The <a href="#ccxx_frontend">next section</a>
 659 describes the data layout conventions used by the C and C++ front-ends.</p>
 660
 661 </div>
 662
 663 <!-- ======================================================================= -->
 664 <div class="doc_subsection">
 665   <a name="format_common_anchors">Anchors for global objects</a>
 666 </div>
 667
 668 <div class="doc_text">
 669 <p>One important aspect of the LLVM debug representation is that it allows the
 670 LLVM debugger to efficiently index all of the global objects without having the
 671 scan the program.  To do this, all of the global objects use "anchor" globals of
 672 type "<tt>{}</tt>", with designated names.  These anchor objects obviously do
 673 not contain any content or meaning by themselves, but all of the global objects
 674 of a particular type (e.g., source file descriptors) contain a pointer to the
 675 anchor.  This pointer allows the debugger to use def-use chains to find all
 676 global objects of that type.</p>
 677
 678 <p>So far, the following names are recognized as anchors by the LLVM
 679 debugger:</p>
 680
 681 <pre>
 682   %<a href="#format_common_source_files">llvm.dbg.translation_units</a> = linkonce global {} {}
 683   %<a href="#format_program_objects">llvm.dbg.globals</a>         = linkonce global {} {}
 684 </pre>
 685
 686 <p>Using anchors in this way (where the source file descriptor points to the
 687 anchors, as opposed to having a list of source file descriptors) allows for the
 688 standard dead global elimination and merging passes to automatically remove
 689 unused debugging information.  If the globals were kept track of through lists,
 690 there would always be an object pointing to the descriptors, thus would never be
 691 deleted.</p>
 692
 693 </div>
 694
 695 <!-- ======================================================================= -->
 696 <div class="doc_subsection">
 697   <a name="format_common_stoppoint">
 698      Representing stopping points in the source program
 699   </a>
 700 </div>
 701
 702 <div class="doc_text">
 703
 704 <p>LLVM debugger "stop points" are a key part of the debugging representation
 705 that allows the LLVM to maintain simple semantics for <a
 706 href="#debugopt">debugging optimized code</a>.  The basic idea is that the
 707 front-end inserts calls to the <tt>%llvm.dbg.stoppoint</tt> intrinsic function
 708 at every point in the program where the debugger should be able to inspect the
 709 program (these correspond to places the debugger stops when you "<tt>step</tt>"
 710 through it).  The front-end can choose to place these as fine-grained as it
 711 would like (for example, before every subexpression evaluated), but it is
 712 recommended to only put them after every source statement that includes
 713 executable code.</p>
 714
 715 <p>Using calls to this intrinsic function to demark legal points for the
 716 debugger to inspect the program automatically disables any optimizations that
 717 could potentially confuse debugging information.  To non-debug-information-aware
 718 transformations, these calls simply look like calls to an external function,
 719 which they must assume to do anything (including reading or writing to any part
 720 of reachable memory).  On the other hand, it does not impact many optimizations,
 721 such as code motion of non-trapping instructions, nor does it impact
 722 optimization of subexpressions, code duplication transformations, or basic-block
 723 reordering transformations.</p>
 724
 725 <p>An important aspect of the calls to the <tt>%llvm.dbg.stoppoint</tt>
 726 intrinsic is that the function-local debugging information is woven together
 727 with use-def chains.  This makes it easy for the debugger to, for example,
 728 locate the 'next' stop point.  For a concrete example of stop points, see the
 729 example in <a href="#format_common_lifetime">the next section</a>.</p>
 730
 731 </div>
 732
 733
 734 <!-- ======================================================================= -->
 735 <div class="doc_subsection">
 736   <a name="format_common_lifetime">Object lifetimes and scoping</a>
 737 </div>
 738
 739 <div class="doc_text">
 740 <p>In many languages, the local variables in functions can have their lifetime
 741 or scope limited to a subset of a function.  In the C family of languages, for
 742 example, variables are only live (readable and writable) within the source block
 743 that they are defined in.  In functional languages, values are only readable
 744 after they have been defined.  Though this is a very obvious concept, it is also
 745 non-trivial to model in LLVM, because it has no notion of scoping in this sense,
 746 and does not want to be tied to a language's scoping rules.</p>
 747
 748 <p>In order to handle this, the LLVM debug format uses the notion of "regions"
 749 of a function, delineated by calls to intrinsic functions.  These intrinsic
 750 functions define new regions of the program and indicate when the region
 751 lifetime expires.  Consider the following C fragment, for example:</p>
 752
 753 <pre>
 754 1.  void foo() {
 755 2.    int X = ...;
 756 3.    int Y = ...;
 757 4.    {
 758 5.      int Z = ...;
 759 6.      ...
 760 7.    }
 761 8.    ...
 762 9.  }
 763 </pre>
 764
 765 <p>Compiled to LLVM, this function would be represented like this (FIXME: CHECK
 766 AND UPDATE THIS):</p>
 767
 768 <pre>
 769 void %foo() {
 770     %X = alloca int
 771     %Y = alloca int
 772     %Z = alloca int
 773     <a name="#icl_ex_D1">%D1</a> = call {}* %llvm.dbg.func.start(<a href="#format_program_objects">%lldb.global</a>* %d.foo)
 774     %D2 = call {}* <a href="#format_common_stoppoint">%llvm.dbg.stoppoint</a>({}* %D1, uint 2, uint 2, <a href="#format_common_source_files">%lldb.compile_unit</a>* %file)
 775
 776     %D3 = call {}* %llvm.dbg.DEFINEVARIABLE({}* %D2, ...)
 777     <i>;; Evaluate expression on line 2, assigning to X.</i>
 778     %D4 = call {}* <a href="#format_common_stoppoint">%llvm.dbg.stoppoint</a>({}* %D3, uint 3, uint 2, <a href="#format_common_source_files">%lldb.compile_unit</a>* %file)
 779
 780     %D5 = call {}* %llvm.dbg.DEFINEVARIABLE({}* %D4, ...)
 781     <i>;; Evaluate expression on line 3, assigning to Y.</i>
 782     %D6 = call {}* <a href="#format_common_stoppoint">%llvm.dbg.stoppoint</a>({}* %D5, uint 5, uint 4, <a href="#format_common_source_files">%lldb.compile_unit</a>* %file)
 783
 784     <a name="#icl_ex_D1">%D7</a> = call {}* %llvm.region.start({}* %D6)
 785     %D8 = call {}* %llvm.dbg.DEFINEVARIABLE({}* %D7, ...)
 786     <i>;; Evaluate expression on line 5, assigning to Z.</i>
 787     %D9 = call {}* <a href="#format_common_stoppoint">%llvm.dbg.stoppoint</a>({}* %D8, uint 6, uint 4, <a href="#format_common_source_files">%lldb.compile_unit</a>* %file)
 788
 789     <i>;; Code for line 6.</i>
 790     %D10 = call {}* %llvm.region.end({}* %D9)
 791     %D11 = call {}* <a href="#format_common_stoppoint">%llvm.dbg.stoppoint</a>({}* %D10, uint 8, uint 2, <a href="#format_common_source_files">%lldb.compile_unit</a>* %file)
 792
 793     <i>;; Code for line 8.</i>
 794     <a name="#icl_ex_D1">%D12</a> = call {}* %llvm.region.end({}* %D11)
 795     ret void
 796 }
 797 </pre>
 798
 799 <p>This example illustrates a few important details about the LLVM debugging
 800 information.  In particular, it shows how the various intrinsics used are woven
 801 together with def-use and use-def chains, similar to how <a
 802 href="#format_common_anchors">anchors</a> are used with globals.  This allows
 803 the debugger to analyze the relationship between statements, variable
 804 definitions, and the code used to implement the function.</p>
 805
 806 <p>In this example, two explicit regions are defined, one with the <a
 807 href="#icl_ex_D1">definition of the <tt>%D1</tt> variable</a> and one with the
 808 <a href="#icl_ex_D7">definition of <tt>%D7</tt></a>.  In the case of
 809 <tt>%D1</tt>, the debug information indicates that the function whose <a
 810 href="#format_program_objects">descriptor</a> is specified as an argument to the
 811 intrinsic.  This defines a new stack frame whose lifetime ends when the region
 812 is ended by <a href="#icl_ex_D12">the <tt>%D12</tt> call</a>.</p>
 813
 814 <p>Using regions to represent the boundaries of source-level functions allow
 815 LLVM interprocedural optimizations to arbitrarily modify LLVM functions without
 816 having to worry about breaking mapping information between the LLVM code and the
 817 and source-level program.  In particular, the inliner requires no modification
 818 to support inlining with debugging information: there is no explicit correlation
 819 drawn between LLVM functions and their source-level counterparts (note however,
 820 that if the inliner inlines all instances of a non-strong-linkage function into
 821 its caller that it will not be possible for the user to manually invoke the
 822 inlined function from the debugger).</p>
 823
 824 <p>Once the function has been defined, the <a
 825 href="#format_common_stoppoint">stopping point</a> corresponding to line #2 of
 826 the function is encountered.  At this point in the function, <b>no</b> local
 827 variables are live.  As lines 2 and 3 of the example are executed, their
 828 variable definitions are automatically introduced into the program, without the
 829 need to specify a new region.  These variables do not require new regions to be
 830 introduced because they go out of scope at the same point in the program: line
 831 9.</p>
 832
 833 <p>In contrast, the <tt>Z</tt> variable goes out of scope at a different time,
 834 on line 7.  For this reason, it is defined within <a href="#icl_ex_D7">the
 835 <tt>%D7</tt> region</a>, which kills the availability of <tt>Z</tt> before the
 836 code for line 8 is executed.  In this way, regions can support arbitrary
 837 source-language scoping rules, as long as they can only be nested (ie, one scope
 838 cannot partially overlap with a part of another scope).</p>
 839
 840 <p>It is worth noting that this scoping mechanism is used to control scoping of
 841 all declarations, not just variable declarations.  For example, the scope of a
 842 C++ using declaration is controlled with this, and the <tt>llvm-db</tt> C++
 843 support routines could use this to change how name lookup is performed (though
 844 this is not implemented yet).</p>
 845
 846 </div>
 847
 848 <!-- ======================================================================= -->
 849 <div class="doc_subsection">
 850   <a name="format_common_descriptors">Object descriptor formats</a>
 851 </div>
 852
 853 <div class="doc_text">
 854 <p>The LLVM debugger expects the descriptors for program objects to start in a
 855 canonical format, but the descriptors can include additional information
 856 appended at the end that is source-language specific.  All LLVM debugging
 857 information is versioned, allowing backwards compatibility in the case that the
 858 core structures need to change in some way.  Also, all debugging information
 859 objects start with a <a href="#format_common_tags">tag</a> to indicate what type
 860 of object it is.  The source-language is allows to define its own objects, by
 861 using unreserved tag numbers.</p>
 862
 863 <p>The lowest-level descriptor are those describing <a
 864 href="#format_common_source_files">the files containing the program source
 865 code</a>, as most other descriptors (sometimes indirectly) refer to them.
 866 </p>
 867 </div>
 868
 869
 870 <!-- ------------------------------------------------------------------------ ->
 871 <div class="doc_subsubsection">
 872   <a name="format_common_source_files">Representation of source files</a>
 873 </div>
 874
 875 <div class="doc_text">
 876 <p>
 877 Source file descriptors are patterned after the Dwarf "compile_unit" object.
 878 The descriptor currently is defined to have at least the following LLVM
 879 type entries:</p>
 880
 881 <pre>
 882 %lldb.compile_unit = type {
 883        uint,                 <i>;; Tag: <a href="#tag_compile_unit">LLVM_COMPILE_UNIT</a></i>
 884        ushort,               <i>;; LLVM debug version number</i>
 885        ushort,               <i>;; Dwarf language identifier</i>
 886        sbyte*,               <i>;; Filename</i>
 887        sbyte*,               <i>;; Working directory when compiled</i>
 888        sbyte*                <i>;; Producer of the debug information</i>
 889 }
 890 </pre>
 891
 892 <p>
 893 These descriptors contain the version number for the debug info, a source
 894 language ID for the file (we use the Dwarf 3.0 ID numbers, such as
 895 <tt>DW_LANG_C89</tt>, <tt>DW_LANG_C_plus_plus</tt>, <tt>DW_LANG_Cobol74</tt>,
 896 etc), three strings describing the filename, working directory of the compiler,
 897 and an identifier string for the compiler that produced it.  Note that actual
 898 compile_unit declarations must also include an <a
 899 href="#format_common_anchors">anchor</a> to <tt>llvm.dbg.translation_units</tt>,
 900 but it is not specified where the anchor is to be located.  Here is an example
 901 descriptor:
 902 </p>
 903
 904 <p><pre>
 905 %arraytest_source_file = internal constant %lldb.compile_unit {
 906     <a href="#tag_compile_unit">uint 17</a>,                                                      ; Tag value
 907     ushort 0,                                                     ; Version #0
 908     ushort 1,                                                     ; DW_LANG_C89
 909     sbyte* getelementptr ([12 x sbyte]* %.str_1, long 0, long 0), ; filename
 910     sbyte* getelementptr ([12 x sbyte]* %.str_2, long 0, long 0), ; working dir
 911     sbyte* getelementptr ([12 x sbyte]* %.str_3, long 0, long 0), ; producer
 912     {}* %llvm.dbg.translation_units                               ; Anchor
 913 }
 914 %.str_1 = internal constant [12 x sbyte] c"arraytest.c\00"
 915 %.str_2 = internal constant [12 x sbyte] c"/home/sabre\00"
 916 %.str_3 = internal constant [12 x sbyte] c"llvmgcc 3.4\00"
 917 </pre></p>
 918
 919 <p>
 920 Note that the LLVM constant merging pass should eliminate duplicate copies of
 921 the strings that get emitted to each translation unit, such as the producer.
 922 </p>
 923
 924 </div>
 925
 926
 927 <!-- ----------------------------------------------------------------------- -->
 928 <div class="doc_subsubsection">
 929   <a name="format_program_objects">Representation of program objects</a>
 930 </div>
 931
 932 <div class="doc_text">
 933 <p>
 934 The LLVM debugger needs to know about some source-language program objects, in
 935 order to build stack traces, print information about local variables, and other
 936 related activities.  The LLVM debugger differentiates between three different
 937 types of program objects: subprograms (functions, messages, methods, etc),
 938 variables (locals and globals), and others.  Because source-languages have
 939 widely varying forms of these objects, the LLVM debugger expects only a few
 940 fields in the descriptor for each object:
 941 </p>
 942
 943 <pre>
 944 %lldb.object = type {
 945        uint,                  <i>;; <a href="#format_common_tag">A tag</a></i>
 946        <i>any</i>*,                  <i>;; The <a href="#format_common_object_contexts">context</a> for the object</i>
 947        sbyte*                 <i>;; The object 'name'</i>
 948 }
 949 </pre>
 950
 951 <p>The first field contains a tag for the descriptor.  The second field contains
 952 either a pointer to the descriptor for the containing <a
 953 href="#format_common_source_files">source file</a>, or it contains a pointer to
 954 another program object whose context pointer eventually reaches a source file.
 955 Through this <a href="#format_common_object_contexts">context</a> pointer, the
 956 LLVM debugger can establish the debug version number of the object.</p>
 957
 958 <p>The third field contains a string that the debugger can use to identify the
 959 object if it does not contain explicit support for the source-language in use
 960 (ie, the 'unknown' source language handler uses this string).  This should be
 961 some sort of unmangled string that corresponds to the object, but it is a
 962 quality of implementation issue what exactly it contains (it is legal, though
 963 not useful, for all of these strings to be null).</p>
 964
 965 <p>Note again that descriptors can be extended to include
 966 source-language-specific information in addition to the fields required by the
 967 LLVM debugger.  See the <a href="#ccxx_descriptors">section on the C/C++
 968 front-end</a> for more information.  Also remember that global objects
 969 (functions, selectors, global variables, etc) must contain an <a
 970 href="format_common_anchors">anchor</a> to the <tt>llvm.dbg.globals</tt>
 971 variable.</p>
 972 </div>
 973
 974
 975 <!-- ======================================================================= -->
 976 <div class="doc_subsection">
 977   <a name="format_common_object_contexts">Program object contexts</a>
 978 </div>
 979
 980 <div class="doc_text">
 981 <pre>
 982 Allow source-language specific contexts, use to identify namespaces etc
 983 Must end up in a source file descriptor.
 984 Debugger core ignores all unknown context objects.
 985 </pre>
 986 </div>
 987
 988 <!-- ======================================================================= -->
 989 <div class="doc_subsection">
 990   <a name="format_common_intrinsics">Debugger intrinsic functions</a>
 991 </div>
 992
 993 <div class="doc_text">
 994 <pre>
 995 Define each intrinsics, as an extension of the language reference manual.
 996
 997 llvm.dbg.stoppoint
 998 llvm.dbg.region.start
 999 llvm.dbg.region.end
1000 llvm.dbg.function.start
1001 llvm.dbg.declare
1002 </pre>
1003 </div>
1004
1005 <!-- ======================================================================= -->
1006 <div class="doc_subsection">
1007   <a name="format_common_tags">Values for debugger tags</a>
1008 </div>
1009
1010 <div class="doc_text">
1011
1012 <p>Happen to be the same value as the similarly named Dwarf-3 tags, this may
1013 change in the future.</p>
1014
1015 <pre>
1016   <a name="tag_compile_unit">LLVM_COMPILE_UNIT</a>     : 17
1017   <a name="tag_subprogram">LLVM_SUBPROGRAM</a>       : 46
1018   <a name="tag_variable">LLVM_VARIABLE</a>         : 52
1019 <!--  <a name="tag_formal_parameter">LLVM_FORMAL_PARAMETER :  5-->
1020 </pre>
1021 </div>
1022
1023
1024
1025 <!-- *********************************************************************** -->
1026 <div class="doc_section">
1027   <a name="ccxx_frontend">C/C++ front-end specific debug information</a>
1028 </div>
1029
1030 <div class="doc_text">
1031
1032 <p>The C and C++ front-ends represent information about the program in a format
1033 that is effectively identical to <a
1034 href="http://www.eagercon.com/dwarf/dwarf3std.htm">Dwarf 3.0</a> in terms of
1035 information content.  This allows code generators to trivially support native
1036 debuggers by generating standard dwarf information, and contains enough
1037 information for non-dwarf targets to translate it as needed.</p>
1038
1039 <p>The basic debug information required by the debugger is (intentionally)
1040 designed to be as minimal as possible.  This basic information is so minimal
1041 that it is unlikely that <b>any</b> source-language could be adequately
1042 described by it.  Because of this, the debugger format was designed for
1043 extension to support source-language-specific information.  The extended
1044 descriptors are read and interpreted by the <a
1045 href="#arch_info">language-specific</a> modules in the debugger if there is
1046 support available, otherwise it is ignored.</p>
1047
1048 <p>This section describes the extensions used to represent C and C++ programs.
1049 Other languages could pattern themselves after this (which itself is tuned to
1050 representing programs in the same way that Dwarf 3 does), or they could choose
1051 to provide completely different extensions if they don't fit into the Dwarf
1052 model.  As support for debugging information gets added to the various LLVM
1053 source-language front-ends, the information used should be documented here.</p>
1054
1055 </div>
1056
1057 <!-- ======================================================================= -->
1058 <div class="doc_subsection">
1059   <a name="ccxx_pse">Program Scope Entries</a>
1060 </div>
1061
1062 <div class="doc_text">
1063 <p>TODO</p>
1064 </div>
1065
1066 <!-- -------------------------------------------------------------------------->
1067 <div class="doc_subsubsection">
1068   <a name="ccxx_compilation_units">Compilation unit entries</a>
1069 </div>
1070
1071 <div class="doc_text">
1072 <p>
1073 Translation units do not add any information over the standard <a
1074 href="#format_common_source_files">source file representation</a> already
1075 expected by the debugger.  As such, it uses descriptors of the type specified,
1076 with a trailing <a href="#format_common_anchors">anchor</a>.
1077 </p>
1078 </div>
1079
1080 <!-- -------------------------------------------------------------------------->
1081 <div class="doc_subsubsection">
1082   <a name="ccxx_modules">Module, namespace, and importing entries</a>
1083 </div>
1084
1085 <div class="doc_text">
1086 <p>TODO</p>
1087 </div>
1088
1089 <!-- ======================================================================= -->
1090 <div class="doc_subsection">
1091   <a name="ccxx_dataobjects">Data objects (program variables)</a>
1092 </div>
1093
1094 <div class="doc_text">
1095 <p>TODO</p>
1096 </div>
1097
1098
1099 <!-- *********************************************************************** -->
1100
1101 <hr>
1102 <address>
1103   <a href="http://jigsaw.w3.org/css-validator/check/referer"><img
1104   src="http://jigsaw.w3.org/css-validator/images/vcss" alt="Valid CSS!"></a>
1105   <a href="http://validator.w3.org/check/referer"><img
1106   src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!"></a>
1107
1108   <a href="mailto:sabre@nondot.org">Chris Lattner</a><br>
1109   <a href="http://llvm.cs.uiuc.edu">LLVM Compiler Infrastructure</a><br>
1110   Last modified: $Date$
1111 </address>
1112
1113 </body>
1114 </html>