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