Add ISPC to the external projects list.
[oota-llvm.git] / docs / SourceLevelDebugging.html
index 71c74a19381f69c4612100cc8e1dd1c75197bfeb..6eaaa240c143033c127cae0ac61b258c4d79bbf8 100644 (file)
@@ -2,12 +2,13 @@
                       "http://www.w3.org/TR/html4/strict.dtd">
 <html>
 <head>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
   <title>Source Level Debugging with LLVM</title>
   <link rel="stylesheet" href="llvm.css" type="text/css">
 </head>
 <body>
 
-<div class="doc_title">Source Level Debugging with LLVM</div>
+<h1>Source Level Debugging with LLVM</h1>
 
 <table class="layout" style="width:100%">
   <tr class="layout">
   <li><a href="#introduction">Introduction</a>
   <ol>
     <li><a href="#phil">Philosophy behind LLVM debugging information</a></li>
+    <li><a href="#consumers">Debug information consumers</a></li>
     <li><a href="#debugopt">Debugging optimized code</a></li>
-    <li><a href="#future">Future work</a></li>
   </ol></li>
-  <li><a href="#llvm-db">Using the <tt>llvm-db</tt> tool</a>
-  <ol>
-    <li><a href="#limitations">Limitations of <tt>llvm-db</tt></a></li>
-    <li><a href="#sample">A sample <tt>llvm-db</tt> session</a></li>
-    <li><a href="#startup">Starting the debugger</a></li>
-    <li><a href="#commands">Commands recognized by the debugger</a></li>
-  </ol></li>
-
-  <li><a href="#architecture">Architecture of the LLVM debugger</a>
-  <ol>
-    <li><a href="#arch_debugger">The Debugger and InferiorProcess classes</a></li>
-    <li><a href="#arch_info">The RuntimeInfo, ProgramInfo, and SourceLanguage classes</a></li>
-    <li><a href="#arch_llvm-db">The <tt>llvm-db</tt> tool</a></li>
-    <li><a href="#arch_todo">Short-term TODO list</a></li>
-  </ol></li>
-
   <li><a href="#format">Debugging information format</a>
   <ol>
-    <li><a href="#format_common_anchors">Anchors for global objects</a></li>
-    <li><a href="#format_common_stoppoint">Representing stopping points in the source program</a></li>
-    <li><a href="#format_common_lifetime">Object lifetimes and scoping</a></li>
-    <li><a href="#format_common_descriptors">Object descriptor formats</a>
+    <li><a href="#debug_info_descriptors">Debug information descriptors</a>
     <ul>
-      <li><a href="#format_common_source_files">Representation of source files</a></li>
-      <li><a href="#format_common_program_objects">Representation of program objects</a></li>
-      <li><a href="#format_common_object_contexts">Program object contexts</a></li>
+      <li><a href="#format_compile_units">Compile unit descriptors</a></li>
+      <li><a href="#format_files">File descriptors</a></li>
+      <li><a href="#format_global_variables">Global variable descriptors</a></li>
+      <li><a href="#format_subprograms">Subprogram descriptors</a></li>
+      <li><a href="#format_blocks">Block descriptors</a></li>
+      <li><a href="#format_basic_type">Basic type descriptors</a></li>
+      <li><a href="#format_derived_type">Derived type descriptors</a></li>
+      <li><a href="#format_composite_type">Composite type descriptors</a></li>
+      <li><a href="#format_subrange">Subrange descriptors</a></li>
+      <li><a href="#format_enumeration">Enumerator descriptors</a></li>
+      <li><a href="#format_variables">Local variables</a></li>
+    </ul></li>
+    <li><a href="#format_common_intrinsics">Debugger intrinsic functions</a>
+      <ul>
+      <li><a href="#format_common_declare">llvm.dbg.declare</a></li>
+      <li><a href="#format_common_value">llvm.dbg.value</a></li>
     </ul></li>
-    <li><a href="#format_common_intrinsics">Debugger intrinsic functions</a></li>
-    <li><a href="#format_common_tags">Values for debugger tags</a></li>
   </ol></li>
+  <li><a href="#format_common_lifetime">Object lifetimes and scoping</a></li>
   <li><a href="#ccxx_frontend">C/C++ front-end specific debug information</a>
   <ol>
-    <li><a href="#ccxx_pse">Program Scope Entries</a>
-    <ul>
-      <li><a href="#ccxx_compilation_units">Compilation unit entries</a></li>
-      <li><a href="#ccxx_modules">Module, namespace, and importing entries</a></li>
-    </ul></li>
-    <li><a href="#ccxx_dataobjects">Data objects (program variables)</a></li>
+    <li><a href="#ccxx_compile_units">C/C++ source file information</a></li>
+    <li><a href="#ccxx_global_variable">C/C++ global variable information</a></li>
+    <li><a href="#ccxx_subprogram">C/C++ function information</a></li>
+    <li><a href="#ccxx_basic_types">C/C++ basic types</a></li>
+    <li><a href="#ccxx_derived_types">C/C++ derived types</a></li>
+    <li><a href="#ccxx_composite_types">C/C++ struct/union types</a></li>
+    <li><a href="#ccxx_enumeration_types">C/C++ enumeration types</a></li>
   </ol></li>
 </ul>
 </td>
@@ -67,1049 +62,1758 @@ height="369">
 </tr></table>
 
 <div class="doc_author">
-  <p>Written by <a href="mailto:sabre@nondot.org">Chris Lattner</a></p>
+  <p>Written by <a href="mailto:sabre@nondot.org">Chris Lattner</a>
+            and <a href="mailto:jlaskey@mac.com">Jim Laskey</a></p>
 </div>
 
 
 <!-- *********************************************************************** -->
-<div class="doc_section"><a name="introduction">Introduction</a></div> 
+<h2><a name="introduction">Introduction</a></h2>
 <!-- *********************************************************************** -->
 
-<div class="doc_text">
+<div>
 
 <p>This document is the central repository for all information pertaining to
-debug information in LLVM.  It describes the <a href="#llvm-db">user
-interface</a> for the <tt>llvm-db</tt> tool, which provides a 
-powerful <a href="#llvm-db">source-level debugger</a>
-to users of LLVM-based compilers.  It then describes the <a
-href="#architecture">various components</a> that make up the debugger and the
-libraries which future clients may use.  Finally, it describes the <a
-href="#format">actual format that the LLVM debug information</a> takes,
-which is useful for those interested in creating front-ends or dealing directly
-with the information.</p>
-
-</div>
+   debug information in LLVM.  It describes the <a href="#format">actual format
+   that the LLVM debug information</a> takes, which is useful for those
+   interested in creating front-ends or dealing directly with the information.
+   Further, this document provides specific examples of what debug information
+   for C/C++ looks like.</p>
 
 <!-- ======================================================================= -->
-<div class="doc_subsection">
+<h3>
   <a name="phil">Philosophy behind LLVM debugging information</a>
-</div>
+</h3>
 
-<div class="doc_text">
+<div>
 
 <p>The idea of the LLVM debugging information is to capture how the important
-pieces of the source-language's Abstract Syntax Tree map onto LLVM code.
-Several design aspects have shaped the solution that appears here.  The
-important ones are:</p>
+   pieces of the source-language's Abstract Syntax Tree map onto LLVM code.
+   Several design aspects have shaped the solution that appears here.  The
+   important ones are:</p>
 
 <ul>
-<li>Debugging information should have very little impact on the rest of the
-compiler.  No transformations, analyses, or code generators should need to be
-modified because of debugging information.</li>
+  <li>Debugging information should have very little impact on the rest of the
+      compiler.  No transformations, analyses, or code generators should need to
+      be modified because of debugging information.</li>
 
-<li>LLVM optimizations should interact in <a href="#debugopt">well-defined and
-easily described ways</a> with the debugging information.</li>
+  <li>LLVM optimizations should interact in <a href="#debugopt">well-defined and
+      easily described ways</a> with the debugging information.</li>
 
-<li>Because LLVM is designed to support arbitrary programming languages,
-LLVM-to-LLVM tools should not need to know anything about the semantics of the
-source-level-language.</li>
+  <li>Because LLVM is designed to support arbitrary programming languages,
+      LLVM-to-LLVM tools should not need to know anything about the semantics of
+      the source-level-language.</li>
 
-<li>Source-level languages are often <b>widely</b> different from one another.
-LLVM should not put any restrictions of the flavor of the source-language, and
-the debugging information should work with any language.</li>
-
-<li>With code generator support, it should be possible to use an LLVM compiler
-to compile a program to native machine code and standard debugging formats.
-This allows compatibility with traditional machine-code level debuggers, like
-GDB or DBX.</li>
+  <li>Source-level languages are often <b>widely</b> different from one another.
+      LLVM should not put any restrictions of the flavor of the source-language,
+      and the debugging information should work with any language.</li>
 
+  <li>With code generator support, it should be possible to use an LLVM compiler
+      to compile a program to native machine code and standard debugging
+      formats.  This allows compatibility with traditional machine-code level
+      debuggers, like GDB or DBX.</li>
 </ul>
 
-<p>The approach used by the LLVM implementation is to use a small set of <a
-href="#format_common_intrinsics">intrinsic functions</a> to define a mapping
-between LLVM program objects and the source-level objects.  The description of
-the source-level program is maintained in LLVM global variables in an <a
-href="#ccxx_frontend">implementation-defined format</a> (the C/C++ front-end
-currently uses working draft 7 of the <a
-href="http://www.eagercon.com/dwarf/dwarf3std.htm">Dwarf 3 standard</a>).</p>
+<p>The approach used by the LLVM implementation is to use a small set
+   of <a href="#format_common_intrinsics">intrinsic functions</a> to define a
+   mapping between LLVM program objects and the source-level objects.  The
+   description of the source-level program is maintained in LLVM metadata
+   in an <a href="#ccxx_frontend">implementation-defined format</a>
+   (the C/C++ front-end currently uses working draft 7 of
+   the <a href="http://www.eagercon.com/dwarf/dwarf3std.htm">DWARF 3
+   standard</a>).</p>
 
-<p>When a program is debugged, the debugger interacts with the user and turns
-the stored debug information into source-language specific information.  As
-such, the debugger must be aware of the source-language, and is thus tied to a
-specific language of family of languages.  The <a href="#llvm-db">LLVM
-debugger</a> is designed to be modular in its support for source-languages.</p>
+<p>When a program is being debugged, a debugger interacts with the user and
+   turns the stored debug information into source-language specific information.
+   As such, a debugger must be aware of the source-language, and is thus tied to
+   a specific language or family of languages.</p>
 
 </div>
 
+<!-- ======================================================================= -->
+<h3>
+  <a name="consumers">Debug information consumers</a>
+</h3>
+
+<div>
+
+<p>The role of debug information is to provide meta information normally
+   stripped away during the compilation process.  This meta information provides
+   an LLVM user a relationship between generated code and the original program
+   source code.</p>
+
+<p>Currently, debug information is consumed by DwarfDebug to produce dwarf
+   information used by the gdb debugger.  Other targets could use the same
+   information to produce stabs or other debug forms.</p>
+
+<p>It would also be reasonable to use debug information to feed profiling tools
+   for analysis of generated code, or, tools for reconstructing the original
+   source from generated code.</p>
+
+<p>TODO - expound a bit more.</p>
+
+</div>
 
 <!-- ======================================================================= -->
-<div class="doc_subsection">
+<h3>
   <a name="debugopt">Debugging optimized code</a>
-</div>
+</h3>
 
-<div class="doc_text">
+<div>
 
 <p>An extremely high priority of LLVM debugging information is to make it
-interact well with optimizations and analysis.  In particular, the LLVM debug
-information provides the following guarantees:</p>
+   interact well with optimizations and analysis.  In particular, the LLVM debug
+   information provides the following guarantees:</p>
 
 <ul>
-
-<li>LLVM debug information <b>always provides information to accurately read the
-source-level state of the program</b>, regardless of which LLVM optimizations
-have been run, and without any modification to the optimizations themselves.
-However, some optimizations may impact the ability to modify the current state
-of the program with a debugger, such as setting program variables, or calling
-function that have been deleted.</li>
-
-<li>LLVM optimizations gracefully interact with debugging information.  If they
-are not aware of debug information, they are automatically disabled as necessary
-in the cases that would invalidate the debug info.  This retains the LLVM
-features making it easy to write new transformations.</li>
-
-<li>As desired, LLVM optimizations can be upgraded to be aware of the LLVM
-debugging information, allowing them to update the debugging information as they
-perform aggressive optimizations.  This means that, with effort, the LLVM
-optimizers could optimize debug code just as well as non-debug code.</li>
-
-<li>LLVM debug information does not prevent many important optimizations from
-happening (for example inlining, basic block reordering/merging/cleanup, tail
-duplication, etc), further reducing the amount of the compiler that eventually
-is "aware" of debugging information.</li>
-
-<li>LLVM debug information is automatically optimized along with the rest of the
-program, using existing facilities.  For example, duplicate information is
-automatically merged by the linker, and unused information is automatically
-removed.</li>
-
+  <li>LLVM debug information <b>always provides information to accurately read
+      the source-level state of the program</b>, regardless of which LLVM
+      optimizations have been run, and without any modification to the
+      optimizations themselves.  However, some optimizations may impact the
+      ability to modify the current state of the program with a debugger, such
+      as setting program variables, or calling functions that have been
+      deleted.</li>
+
+  <li>As desired, LLVM optimizations can be upgraded to be aware of the LLVM
+      debugging information, allowing them to update the debugging information
+      as they perform aggressive optimizations.  This means that, with effort,
+      the LLVM optimizers could optimize debug code just as well as non-debug
+      code.</li>
+
+  <li>LLVM debug information does not prevent optimizations from
+      happening (for example inlining, basic block reordering/merging/cleanup,
+      tail duplication, etc).</li>
+
+  <li>LLVM debug information is automatically optimized along with the rest of
+      the program, using existing facilities.  For example, duplicate
+      information is automatically merged by the linker, and unused information
+      is automatically removed.</li>
 </ul>
 
 <p>Basically, the debug information allows you to compile a program with
-"<tt>-O0 -g</tt>" and get full debug information, allowing you to arbitrarily
-modify the program as it executes from the debugger.  Compiling a program with
-"<tt>-O3 -g</tt>" gives you full debug information that is always available and
-accurate for reading (e.g., you get accurate stack traces despite tail call
-elimination and inlining), but you might lose the ability to modify the program
-and call functions where were optimized out of the program, or inlined away
-completely.</p>
+   "<tt>-O0 -g</tt>" and get full debug information, allowing you to arbitrarily
+   modify the program as it executes from a debugger.  Compiling a program with
+   "<tt>-O3 -g</tt>" gives you full debug information that is always available
+   and accurate for reading (e.g., you get accurate stack traces despite tail
+   call elimination and inlining), but you might lose the ability to modify the
+   program and call functions where were optimized out of the program, or
+   inlined away completely.</p>
+
+<p><a href="TestingGuide.html#quicktestsuite">LLVM test suite</a> provides a
+   framework to test optimizer's handling of debugging information. It can be
+   run like this:</p>
+
+<div class="doc_code">
+<pre>
+% cd llvm/projects/test-suite/MultiSource/Benchmarks  # or some other level
+% make TEST=dbgopt
+</pre>
+</div>
+
+<p>This will test impact of debugging information on optimization passes. If
+   debugging information influences optimization passes then it will be reported
+   as a failure. See <a href="TestingGuide.html">TestingGuide</a> for more
+   information on LLVM test infrastructure and how to run various tests.</p>
 
 </div>
 
-<!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="future">Future work</a>
 </div>
 
-<div class="doc_text">
-<p>There are several important extensions that could be eventually added to the
-LLVM debugger.  The most important extension would be to upgrade the LLVM code
-generators to support debugging information.  This would also allow, for
-example, the X86 code generator to emit native objects that contain debugging
-information consumable by traditional source-level debuggers like GDB or
-DBX.</p>
+<!-- *********************************************************************** -->
+<h2>
+  <a name="format">Debugging information format</a>
+</h2>
+<!-- *********************************************************************** -->
 
-<p>Additionally, LLVM optimizations can be upgraded to incrementally update the
-debugging information, <a href="#commands">new commands</a> can be added to the
-debugger, and thread support could be added to the debugger.</p>
+<div>
 
-<p>The "SourceLanguage" modules provided by <tt>llvm-db</tt> could be
-substantially improved to provide good support for C++ language features like
-namespaces and scoping rules.</p>
+<p>LLVM debugging information has been carefully designed to make it possible
+   for the optimizer to optimize the program and debugging information without
+   necessarily having to know anything about debugging information.  In
+   particular, the use of metadata avoids duplicated debugging information from
+   the beginning, and the global dead code elimination pass automatically 
+   deletes debugging information for a function if it decides to delete the 
+   function. </p>
 
-<p>After working with the debugger for a while, perhaps the nicest improvement
-would be to add some sort of line editor, such as GNU readline (but one that is
-compatible with the LLVM license).</p>
+<p>To do this, most of the debugging information (descriptors for types,
+   variables, functions, source files, etc) is inserted by the language
+   front-end in the form of LLVM metadata. </p>
 
-<p>For someone so inclined, it should be straight-forward to write different
-front-ends for the LLVM debugger, as the LLVM debugging engine is cleanly
-separated from the <tt>llvm-db</tt> front-end.  A new LLVM GUI debugger or IDE
-would be nice.</p>
+<p>Debug information is designed to be agnostic about the target debugger and
+   debugging information representation (e.g. DWARF/Stabs/etc).  It uses a
+   generic pass to decode the information that represents variables, types, 
+   functions, namespaces, etc: this allows for arbitrary source-language 
+   semantics and type-systems to be used, as long as there is a module 
+   written for the target debugger to interpret the information. </p>
 
-</div>
+<p>To provide basic functionality, the LLVM debugger does have to make some
+   assumptions about the source-level language being debugged, though it keeps
+   these to a minimum.  The only common features that the LLVM debugger assumes
+   exist are <a href="#format_files">source files</a>,
+   and <a href="#format_global_variables">program objects</a>.  These abstract
+   objects are used by a debugger to form stack traces, show information about
+   local variables, etc.</p>
 
-<!-- *********************************************************************** -->
-<div class="doc_section">
-  <a name="llvm-db">Using the <tt>llvm-db</tt> tool</a>
+<p>This section of the documentation first describes the representation aspects
+   common to any source-language.  The <a href="#ccxx_frontend">next section</a>
+   describes the data layout conventions used by the C and C++ front-ends.</p>
+
+<!-- ======================================================================= -->
+<h3>
+  <a name="debug_info_descriptors">Debug information descriptors</a>
+</h3>
+
+<div>
+
+<p>In consideration of the complexity and volume of debug information, LLVM
+   provides a specification for well formed debug descriptors. </p>
+
+<p>Consumers of LLVM debug information expect the descriptors for program
+   objects to start in a canonical format, but the descriptors can include
+   additional information appended at the end that is source-language
+   specific. All LLVM debugging information is versioned, allowing backwards
+   compatibility in the case that the core structures need to change in some
+   way.  Also, all debugging information objects start with a tag to indicate
+   what type of object it is.  The source-language is allowed to define its own
+   objects, by using unreserved tag numbers.  We recommend using with tags in
+   the range 0x1000 through 0x2000 (there is a defined enum DW_TAG_user_base =
+   0x1000.)</p>
+
+<p>The fields of debug descriptors used internally by LLVM 
+   are restricted to only the simple data types <tt>i32</tt>, <tt>i1</tt>,
+   <tt>float</tt>, <tt>double</tt>, <tt>mdstring</tt> and <tt>mdnode</tt>. </p>
+
+<div class="doc_code">
+<pre>
+!1 = metadata !{
+  i32,   ;; A tag
+  ...
+}
+</pre>
 </div>
-<!-- *********************************************************************** -->
 
-<div class="doc_text">
+<p><a name="LLVMDebugVersion">The first field of a descriptor is always an
+   <tt>i32</tt> containing a tag value identifying the content of the
+   descriptor.  The remaining fields are specific to the descriptor.  The values
+   of tags are loosely bound to the tag values of DWARF information entries.
+   However, that does not restrict the use of the information supplied to DWARF
+   targets.  To facilitate versioning of debug information, the tag is augmented
+   with the current debug version (LLVMDebugVersion = 8 &lt;&lt; 16 or
+   0x80000 or 524288.)</a></p>
+
+<p>The details of the various descriptors follow.</p>  
+
+<!-- ======================================================================= -->
+<h4>
+  <a name="format_compile_units">Compile unit descriptors</a>
+</h4>
+
+<div>
+
+<div class="doc_code">
+<pre>
+!0 = metadata !{
+  i32,       ;; Tag = 17 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> 
+             ;; (DW_TAG_compile_unit)
+  i32,       ;; Unused field. 
+  i32,       ;; DWARF language identifier (ex. DW_LANG_C89) 
+  metadata,  ;; Source file name
+  metadata,  ;; Source file directory (includes trailing slash)
+  metadata   ;; Producer (ex. "4.0.1 LLVM (LLVM research group)")
+  i1,        ;; True if this is a main compile unit. 
+  i1,        ;; True if this is optimized.
+  metadata,  ;; Flags
+  i32        ;; Runtime version
+  metadata   ;; List of enums types
+  metadata   ;; List of retained types
+  metadata   ;; List of subprograms
+  metadata   ;; List of global variables
+}
+</pre>
+</div>
 
-<p>The <tt>llvm-db</tt> tool provides a GDB-like interface for source-level
-debugging of programs.  This tool provides many standard commands for inspecting
-and modifying the program as it executes, loading new programs, single stepping,
-placing breakpoints, etc.  This section describes how to use the debugger.</p>
+<p>These descriptors contain a source language ID for the file (we use the DWARF
+   3.0 ID numbers, such as <tt>DW_LANG_C89</tt>, <tt>DW_LANG_C_plus_plus</tt>,
+   <tt>DW_LANG_Cobol74</tt>, etc), three strings describing the filename,
+   working directory of the compiler, and an identifier string for the compiler
+   that produced it.</p>
 
-<p><tt>llvm-db</tt> has been designed to be as similar to GDB in its user
-interface as possible.  This should make it extremely easy to learn
-<tt>llvm-db</tt> if you already know <tt>GDB</tt>.  In general, <tt>llvm-db</tt>
-provides the subset of GDB commands that are applicable to LLVM debugging users.
-If there is a command missing that make a reasonable amount of sense within the
-<a href="#limitations">limitations of <tt>llvm-db</tt></a>, please report it as
-a bug or, better yet, submit a patch to add it.</p>
+<p>Compile unit descriptors provide the root context for objects declared in a
+   specific compilation unit. File descriptors are defined using this context.
+   These descriptors are collected by a named metadata 
+   <tt>!llvm.dbg.cu</tt>. Compile unit descriptor keeps track of subprograms,
+   global variables and type information.
 
 </div>
 
 <!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="limitations">Limitations of <tt>llvm-db</tt></a>
+<h4>
+  <a name="format_files">File descriptors</a>
+</h4>
+
+<div>
+
+<div class="doc_code">
+<pre>
+!0 = metadata !{
+  i32,       ;; Tag = 41 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> 
+             ;; (DW_TAG_file_type)
+  metadata,  ;; Source file name
+  metadata,  ;; Source file directory (includes trailing slash)
+  metadata   ;; Unused
+}
+</pre>
 </div>
 
-<div class="doc_text">
+<p>These descriptors contain information for a file. Global variables and top
+   level functions would be defined using this context.k File descriptors also
+   provide context for source line correspondence. </p>
 
-<p><tt>llvm-db</tt> is designed to be modular and easy to extend.  This
-extensibility was key to getting the debugger up-and-running quickly, because we
-can start with simple-but-unsophisicated implementations of various components.
-Because of this, it is currently missing many features, though they should be
-easy to add over time (patches welcomed!).  The biggest inherent limitations of
-<tt>llvm-db</tt> are currently due to extremely simple <a
-href="#arch_debugger">debugger backend</a> (implemented in
-"lib/Debugger/UnixLocalInferiorProcess.cpp") which is designed to work without
-any cooperation from the code generators.  Because it is so simple, it suffers
-from the following inherent limitations:</p>
+<p>Each input file is encoded as a separate file descriptor in LLVM debugging
+   information output. </p>
 
-<ul>
+</div>
 
-<li>Running a program in <tt>llvm-db</tt> is a bit slower than running it with
-<tt>lli</tt> (i.e., in the JIT).</li>
+<!-- ======================================================================= -->
+<h4>
+  <a name="format_global_variables">Global variable descriptors</a>
+</h4>
 
-<li>Inspection of the target hardware is not supported.  This means that you
-cannot, for example, print the contents of X86 registers.</li>
+<div>
 
-<li>Inspection of LLVM code is not supported.  This means that you cannot print
-the contents of arbitrary LLVM values, or use commands such as <tt>stepi</tt>.
-This also means that you cannot debug code without debug information.</li>
+<div class="doc_code">
+<pre>
+!1 = metadata !{
+  i32,      ;; Tag = 52 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> 
+            ;; (DW_TAG_variable)
+  i32,      ;; Unused field.
+  metadata, ;; Reference to context descriptor
+  metadata, ;; Name
+  metadata, ;; Display name (fully qualified C++ name)
+  metadata, ;; MIPS linkage name (for C++)
+  metadata, ;; Reference to file where defined
+  i32,      ;; Line number where defined
+  metadata, ;; Reference to type descriptor
+  i1,       ;; True if the global is local to compile unit (static)
+  i1,       ;; True if the global is defined in the compile unit (not extern)
+  {}*       ;; Reference to the global variable
+}
+</pre>
+</div>
 
-<li>Portions of the debugger run in the same address space as the program being
-debugged.  This means that memory corruption by the program could trample on
-portions of the debugger.</li>
+<p>These descriptors provide debug information about globals variables.  The
+provide details such as name, type and where the variable is defined. All
+global variables are collected by named metadata <tt>!llvm.dbg.gv</tt>.</p>
 
-<li>Attaching to existing processes and core files is not currently
-supported.</li>
+</div>
 
-</ul>
+<!-- ======================================================================= -->
+<h4>
+  <a name="format_subprograms">Subprogram descriptors</a>
+</h4>
 
-<p>That said, the debugger is still quite useful, and all of these limitations
-can be eliminated by integrating support for the debugger into the code
-generators, and writing a new <a href="#arch_debugger">InferiorProcess</a>
-subclass to use it.  See the <a href="#future">future work</a> section for ideas
-of how to extend the LLVM debugger despite these limitations.</p>
+<div>
 
+<div class="doc_code">
+<pre>
+!2 = metadata !{
+  i32,      ;; Tag = 46 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a>
+            ;; (DW_TAG_subprogram)
+  i32,      ;; Unused field.
+  metadata, ;; Reference to context descriptor
+  metadata, ;; Name
+  metadata, ;; Display name (fully qualified C++ name)
+  metadata, ;; MIPS linkage name (for C++)
+  metadata, ;; Reference to file where defined
+  i32,      ;; Line number where defined
+  metadata, ;; Reference to type descriptor
+  i1,       ;; True if the global is local to compile unit (static)
+  i1,       ;; True if the global is defined in the compile unit (not extern)
+  i32,      ;; Virtuality, e.g. dwarf::DW_VIRTUALITY__virtual
+  i32,      ;; Index into a virtual function
+  metadata, ;; indicates which base type contains the vtable pointer for the 
+            ;; derived class
+  i1,       ;; isArtificial
+  i1,       ;; isOptimized
+  Function *,;; Pointer to LLVM function
+  metadata, ;; Lists function template parameters
+  metadata  ;; Function declaration descriptor
+  metadata  ;; List of function variables
+}
+</pre>
 </div>
 
+<p>These descriptors provide debug information about functions, methods and
+   subprograms.  They provide details such as name, return types and the source
+   location where the subprogram is defined.
+   All subprogram descriptors are collected by a named metadata 
+   <tt>!llvm.dbg.sp</tt>.
+</p>
 
-<!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="sample">A sample <tt>llvm-db</tt> session</a>
 </div>
 
-<div class="doc_text">
+<!-- ======================================================================= -->
+<h4>
+  <a name="format_blocks">Block descriptors</a>
+</h4>
 
-<p>TODO: this is obviously lame, when more is implemented, this can be much
-better.</p>
+<div>
 
+<div class="doc_code">
 <pre>
-$ <b>llvm-db funccall</b>
-llvm-db: The LLVM source-level debugger
-Loading program... successfully loaded 'funccall.bc'!
-(llvm-db) <b>create</b>
-Starting program: funccall.bc
-main at funccall.c:9:2
-9 ->            q = 0;
-(llvm-db) <b>list main</b>
-4       void foo() {
-5               int t = q;
-6               q = t + 1;
-7       }
-8       int main() {
-9 ->            q = 0;
-10              foo();
-11              q = q - 1;
-12
-13              return q;
-(llvm-db) <b>list</b>
-14      }
-(llvm-db) <b>step</b>
-10 ->           foo();
-(llvm-db) <b>s</b>
-foo at funccall.c:5:2
-5 ->            int t = q;
-(llvm-db) <b>bt</b>
-#0 ->   0x85ffba0 in foo at funccall.c:5:2
-#1      0x85ffd98 in main at funccall.c:10:2
-(llvm-db) <b>finish</b>
-main at funccall.c:11:2
-11 ->           q = q - 1;
-(llvm-db) <b>s</b>
-13 ->           return q;
-(llvm-db) <b>s</b>
-The program stopped with exit code 0
-(llvm-db) <b>quit</b>
-$
+!3 = metadata !{
+  i32,     ;; Tag = 11 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> (DW_TAG_lexical_block)
+  metadata,;; Reference to context descriptor
+  i32,     ;; Line number
+  i32,     ;; Column number
+  metadata,;; Reference to source file
+  i32      ;; Unique ID to identify blocks from a template function
+}
 </pre>
+</div>
+
+<p>This descriptor provides debug information about nested blocks within a
+   subprogram. The line number and column numbers are used to dinstinguish
+   two lexical blocks at same depth. </p>
 
+<div class="doc_code">
+<pre>
+!3 = metadata !{
+  i32,     ;; Tag = 11 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> (DW_TAG_lexical_block)
+  metadata ;; Reference to the scope we're annotating with a file change
+  metadata,;; Reference to the file the scope is enclosed in.
+}
+</pre>
 </div>
 
+<p>This descriptor provides a wrapper around a lexical scope to handle file
+   changes in the middle of a lexical block.</p>
 
+</div>
 
 <!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="startup">Starting the debugger</a>
-</div>
+<h4>
+  <a name="format_basic_type">Basic type descriptors</a>
+</h4>
 
-<div class="doc_text">
+<div>
 
-<p>There are three ways to start up the <tt>llvm-db</tt> debugger:</p>
+<div class="doc_code">
+<pre>
+!4 = metadata !{
+  i32,      ;; Tag = 36 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> 
+            ;; (DW_TAG_base_type)
+  metadata, ;; Reference to context 
+  metadata, ;; Name (may be "" for anonymous types)
+  metadata, ;; Reference to file where defined (may be NULL)
+  i32,      ;; Line number where defined (may be 0)
+  i64,      ;; Size in bits
+  i64,      ;; Alignment in bits
+  i64,      ;; Offset in bits
+  i32,      ;; Flags
+  i32       ;; DWARF type encoding
+}
+</pre>
+</div>
 
-<p>When run with no options, just <tt>llvm-db</tt>, the debugger starts up
-without a program loaded at all.  You must use the <a
-href="#c_file"><tt>file</tt> command</a> to load a program, and the <a
-href="#c_set_args"><tt>set args</tt></a> or <a href="#c_run"><tt>run</tt></a>
-commands to specify the arguments for the program.</p>
+<p>These descriptors define primitive types used in the code. Example int, bool
+   and float.  The context provides the scope of the type, which is usually the
+   top level.  Since basic types are not usually user defined the context
+   and line number can be left as NULL and 0.  The size, alignment and offset
+   are expressed in bits and can be 64 bit values.  The alignment is used to
+   round the offset when embedded in a
+   <a href="#format_composite_type">composite type</a> (example to keep float
+   doubles on 64 bit boundaries.) The offset is the bit offset if embedded in
+   a <a href="#format_composite_type">composite type</a>.</p>
 
-<p>If you start the debugger with one argument, as <tt>llvm-db
-&lt;program&gt;</tt>, the debugger will start up and load in the specified
-program.  You can then optionally specify arguments to the program with the <a
-href="#c_set_args"><tt>set args</tt></a> or <a href="#c_run"><tt>run</tt></a>
-commands.</p>
+<p>The type encoding provides the details of the type.  The values are typically
+   one of the following:</p>
 
-<p>The third way to start the program is with the <tt>--args</tt> option.  This
-option allows you to specify the program to load and the arguments to start out
-with.  <!-- No options to <tt>llvm-db</tt> may be specified after the
-<tt>-args</tt> option. --> Example use: <tt>llvm-db --args ls /home</tt></p>
+<div class="doc_code">
+<pre>
+DW_ATE_address       = 1
+DW_ATE_boolean       = 2
+DW_ATE_float         = 4
+DW_ATE_signed        = 5
+DW_ATE_signed_char   = 6
+DW_ATE_unsigned      = 7
+DW_ATE_unsigned_char = 8
+</pre>
+</div>
 
 </div>
 
 <!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="commands">Commands recognized by the debugger</a>
-</div>
+<h4>
+  <a name="format_derived_type">Derived type descriptors</a>
+</h4>
 
-<div class="doc_text">
+<div>
 
-<p>FIXME: this needs work obviously.  See the <a
-href="http://sources.redhat.com/gdb/documentation/">GDB documentation</a> for
-information about what these do, or try '<tt>help [command]</tt>' within
-<tt>llvm-db</tt> to get information.</p>
+<div class="doc_code">
+<pre>
+!5 = metadata !{
+  i32,      ;; Tag (see below)
+  metadata, ;; Reference to context
+  metadata, ;; Name (may be "" for anonymous types)
+  metadata, ;; Reference to file where defined (may be NULL)
+  i32,      ;; Line number where defined (may be 0)
+  i64,      ;; Size in bits
+  i64,      ;; Alignment in bits
+  i64,      ;; Offset in bits
+  metadata, ;; Reference to type derived from
+  metadata, ;; (optional) Name of the Objective C property assoicated with 
+            ;; Objective-C an ivar 
+  metadata, ;; (optional) Name of the Objective C property getter selector.
+  metadata, ;; (optional) Name of the Objective C property setter selector.
+  i32       ;; (optional) Objective C property attributes.
+}
+</pre>
+</div>
 
-<p>
-<h2>General usage:</h2>
-<ul>
-<li>help [command]</li>
-<li>quit</li>
-<li><a name="c_file">file</a> [program]</li>
-</ul>
+<p>These descriptors are used to define types derived from other types.  The
+value of the tag varies depending on the meaning.  The following are possible
+tag values:</p>
 
-<h2>Program inspection and interaction:</h2>
-<ul>
-<li>create (start the program, stopping it ASAP in <tt>main</tt>)</li>
-<li>kill</li>
-<li>run [args]</li>
-<li>step [num]</li>
-<li>next [num]</li>
-<li>cont</li>
-<li>finish</li>
-
-<li>list [start[, end]]</li>
-<li>info source</li>
-<li>info sources</li>
-<li>info functions</li>
-</ul>
+<div class="doc_code">
+<pre>
+DW_TAG_formal_parameter = 5
+DW_TAG_member           = 13
+DW_TAG_pointer_type     = 15
+DW_TAG_reference_type   = 16
+DW_TAG_typedef          = 22
+DW_TAG_const_type       = 38
+DW_TAG_volatile_type    = 53
+DW_TAG_restrict_type    = 55
+</pre>
+</div>
 
-<h2>Call stack inspection:</h2>
-<ul>
-<li>backtrace</li>
-<li>up [n]</li>
-<li>down [n]</li>
-<li>frame [n]</li>
-</ul>
+<p><tt>DW_TAG_member</tt> is used to define a member of
+   a <a href="#format_composite_type">composite type</a>
+   or <a href="#format_subprograms">subprogram</a>.  The type of the member is
+   the <a href="#format_derived_type">derived
+   type</a>. <tt>DW_TAG_formal_parameter</tt> is used to define a member which
+   is a formal argument of a subprogram.</p>
+
+<p><tt>DW_TAG_typedef</tt> is used to provide a name for the derived type.</p>
+
+<p><tt>DW_TAG_pointer_type</tt>,<tt>DW_TAG_reference_type</tt>,
+   <tt>DW_TAG_const_type</tt>, <tt>DW_TAG_volatile_type</tt>
+   and <tt>DW_TAG_restrict_type</tt> are used to qualify
+   the <a href="#format_derived_type">derived type</a>. </p>
+
+<p><a href="#format_derived_type">Derived type</a> location can be determined
+   from the context and line number.  The size, alignment and offset are
+   expressed in bits and can be 64 bit values.  The alignment is used to round
+   the offset when embedded in a <a href="#format_composite_type">composite
+   type</a> (example to keep float doubles on 64 bit boundaries.) The offset is
+   the bit offset if embedded in a <a href="#format_composite_type">composite
+   type</a>.</p>
+
+<p>Note that the <tt>void *</tt> type is expressed as a type derived from NULL.
+</p>
 
+</div>
 
-<h2>Debugger inspection and interaction:</h2>
-<ul>
-<li>info target</li>
-<li>show prompt</li>
-<li>set prompt</li>
-<li>show listsize</li>
-<li>set listsize</li>
-<li>show language</li>
-<li>set language</li>
-<li>show args</li>
-<li>set args [args]</li>
-</ul>
+<!-- ======================================================================= -->
+<h4>
+  <a name="format_composite_type">Composite type descriptors</a>
+</h4>
 
-<h2>TODO:</h2>
-<ul>
-<li>info frame</li>
-<li>break</li>
-<li>print</li>
-<li>ptype</li>
-
-<li>info types</li>
-<li>info variables</li>
-<li>info program</li>
-
-<li>info args</li>
-<li>info locals</li>
-<li>info catch</li>
-<li>... many others</li>
-</ul>
+<div>
 
+<div class="doc_code">
+<pre>
+!6 = metadata !{
+  i32,      ;; Tag (see below)
+  metadata, ;; Reference to context
+  metadata, ;; Name (may be "" for anonymous types)
+  metadata, ;; Reference to file where defined (may be NULL)
+  i32,      ;; Line number where defined (may be 0)
+  i64,      ;; Size in bits
+  i64,      ;; Alignment in bits
+  i64,      ;; Offset in bits
+  i32,      ;; Flags
+  metadata, ;; Reference to type derived from
+  metadata, ;; Reference to array of member descriptors
+  i32       ;; Runtime languages
+}
+</pre>
 </div>
 
-<!-- *********************************************************************** -->
-<div class="doc_section">
-  <a name="architecture">Architecture of the LLVM debugger</a>
-</div>
-<!-- *********************************************************************** -->
+<p>These descriptors are used to define types that are composed of 0 or more
+elements.  The value of the tag varies depending on the meaning.  The following
+are possible tag values:</p>
 
-<div class="doc_text">
-<p>The LLVM debugger is built out of three distinct layers of software.  These
-layers provide clients with different interface options depending on what pieces
-of they want to implement themselves, and it also promotes code modularity and
-good design.  The three layers are the <a href="#arch_debugger">Debugger
-interface</a>, the <a href="#arch_info">"info" interfaces</a>, and the <a
-href="#arch_llvm-db"><tt>llvm-db</tt> tool</a> itself.</p>
+<div class="doc_code">
+<pre>
+DW_TAG_array_type       = 1
+DW_TAG_enumeration_type = 4
+DW_TAG_structure_type   = 19
+DW_TAG_union_type       = 23
+DW_TAG_vector_type      = 259
+DW_TAG_subroutine_type  = 21
+DW_TAG_inheritance      = 28
+</pre>
 </div>
 
-<!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="arch_debugger">The Debugger and InferiorProcess classes</a>
-</div>
-
-<div class="doc_text">
-<p>The Debugger class (defined in the <tt>include/llvm/Debugger/</tt> directory)
-is a low-level class which is used to maintain information about the loaded
-program, as well as start and stop the program running as necessary.  This class
-does not provide any high-level analysis or control over the program, only
-exposing simple interfaces like <tt>load/unloadProgram</tt>,
-<tt>create/killProgram</tt>, <tt>step/next/finish/contProgram</tt>, and
-low-level methods for installing breakpoints.</p>
-
-<p>
-The Debugger class is itself a wrapper around the lowest-level InferiorProcess
-class.  This class is used to represent an instance of the program running under
-debugger control.  The InferiorProcess class can be implemented in different
-ways for different targets and execution scenarios (e.g., remote debugging).
-The InferiorProcess class exposes a small and simple collection of interfaces
-which are useful for inspecting the current state of the program (such as
-collecting stack trace information, reading the memory image of the process,
-etc).  The interfaces in this class are designed to be as low-level and simple
-as possible, to make it easy to create new instances of the class.
-</p>
+<p>The vector flag indicates that an array type is a native packed vector.</p>
+
+<p>The members of array types (tag = <tt>DW_TAG_array_type</tt>) or vector types
+   (tag = <tt>DW_TAG_vector_type</tt>) are <a href="#format_subrange">subrange
+   descriptors</a>, each representing the range of subscripts at that level of
+   indexing.</p>
+
+<p>The members of enumeration types (tag = <tt>DW_TAG_enumeration_type</tt>) are
+   <a href="#format_enumeration">enumerator descriptors</a>, each representing
+   the definition of enumeration value for the set. All enumeration type
+   descriptors are collected by named metadata <tt>!llvm.dbg.enum</tt>.</p>
+
+<p>The members of structure (tag = <tt>DW_TAG_structure_type</tt>) or union (tag
+   = <tt>DW_TAG_union_type</tt>) types are any one of
+   the <a href="#format_basic_type">basic</a>,
+   <a href="#format_derived_type">derived</a>
+   or <a href="#format_composite_type">composite</a> type descriptors, each
+   representing a field member of the structure or union.</p>
+
+<p>For C++ classes (tag = <tt>DW_TAG_structure_type</tt>), member descriptors
+   provide information about base classes, static members and member
+   functions. If a member is a <a href="#format_derived_type">derived type
+   descriptor</a> and has a tag of <tt>DW_TAG_inheritance</tt>, then the type
+   represents a base class. If the member of is
+   a <a href="#format_global_variables">global variable descriptor</a> then it
+   represents a static member.  And, if the member is
+   a <a href="#format_subprograms">subprogram descriptor</a> then it represents
+   a member function.  For static members and member
+   functions, <tt>getName()</tt> returns the members link or the C++ mangled
+   name.  <tt>getDisplayName()</tt> the simplied version of the name.</p>
+
+<p>The first member of subroutine (tag = <tt>DW_TAG_subroutine_type</tt>) type
+   elements is the return type for the subroutine.  The remaining elements are
+   the formal arguments to the subroutine.</p>
+
+<p><a href="#format_composite_type">Composite type</a> location can be
+   determined from the context and line number.  The size, alignment and
+   offset are expressed in bits and can be 64 bit values.  The alignment is used
+   to round the offset when embedded in
+   a <a href="#format_composite_type">composite type</a> (as an example, to keep
+   float doubles on 64 bit boundaries.) The offset is the bit offset if embedded
+   in a <a href="#format_composite_type">composite type</a>.</p>
 
-<p>
-The Debugger class exposes the currently active instance of InferiorProcess
-through the <tt>Debugger::getRunningProcess</tt> method, which returns a
-<tt>const</tt> reference to the class.  This means that clients of the Debugger
-class can only <b>inspect</b> the running instance of the program directly.  To
-change the executing process in some way, they must use the interces exposed by
-the Debugger class.
-</p>
 </div>
 
 <!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="arch_info">The RuntimeInfo, ProgramInfo, and SourceLanguage classes</a>
-</div>
-
-<div class="doc_text">
-<p>
-The next-highest level of debugger abstraction is provided through the
-ProgramInfo, RuntimeInfo, SourceLanguage and related classes (also defined in
-the <tt>include/llvm/Debugger/</tt> directory).  These classes efficiently
-decode the debugging information and low-level interfaces exposed by
-InferiorProcess into a higher-level representation, suitable for analysis by the
-debugger.
-</p>
+<h4>
+  <a name="format_subrange">Subrange descriptors</a>
+</h4>
 
-<p>
-The ProgramInfo class exposes a variety of different kinds of information about
-the program objects in the source-level-language.  The SourceFileInfo class
-represents a source-file in the program (e.g. a .cpp or .h file).  The
-SourceFileInfo class captures information such as which SourceLanguage was used
-to compile the file, where the debugger can get access to the actual file text
-(which is lazily loaded on demand), etc.  The SourceFunctionInfo class
-represents a... <b>FIXME: finish</b>.  The ProgramInfo class provides interfaces
-to lazily find and decode the information needed to create the Source*Info
-classes requested by the debugger.
-</p>
+<div>
 
-<p>
-The RuntimeInfo class exposes information about the currently executed program,
-by decoding information from the InferiorProcess and ProgramInfo classes.  It
-provides a StackFrame class which provides an easy-to-use interface for
-inspecting the current and suspended stack frames in the program.
-</p>
+<div class="doc_code">
+<pre>
+!42 = metadata !{
+  i32,    ;; Tag = 33 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> (DW_TAG_subrange_type)
+  i64,    ;; Low value
+  i64     ;; High value
+}
+</pre>
+</div>
 
-<p>
-The SourceLanguage class is an abstract interface used by the debugger to
-perform all source-language-specific tasks.  For example, this interface is used
-by the ProgramInfo class to decode language-specific types and functions and by
-the debugger front-end (such as <a href="#arch_llvm-db"><tt>llvm-db</tt></a> to
-evaluate source-langauge expressions typed into the debugger.  This class uses
-the RuntimeInfo &amp; ProgramInfo classes to get information about the current
-execution context and the loaded program, respectively.
+<p>These descriptors are used to define ranges of array subscripts for an array
+   <a href="#format_composite_type">composite type</a>.  The low value defines
+   the lower bounds typically zero for C/C++.  The high value is the upper
+   bounds.  Values are 64 bit.  High - low + 1 is the size of the array.  If low
+   > high the array bounds are not included in generated debugging information.
 </p>
 
 </div>
 
 <!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="arch_llvm-db">The <tt>llvm-db</tt> tool</a>
-</div>
-
-<div class="doc_text">
-<p>
-The <tt>llvm-db</tt> is designed to be a debugger providing an interface as <a
-href="#llvm-db">similar to GDB</a> as reasonable, but no more so than that.
-Because the <a href="#arch_debugger">Debugger</a> and <a
-href="#arch_info">info</a> classes implement all of the heavy lifting and
-analysis, <tt>llvm-db</tt> (which lives in <tt>llvm/tools/llvm-db</tt>) consists
-mainly of of code to interact with the user and parse commands.  The CLIDebugger
-constructor registers all of the builtin commands for the debugger, and each
-command is implemented as a CLIDebugger::[name]Command method.
-</p>
+<h4>
+  <a name="format_enumeration">Enumerator descriptors</a>
+</h4>
+
+<div>
+
+<div class="doc_code">
+<pre>
+!6 = metadata !{
+  i32,      ;; Tag = 40 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> 
+            ;; (DW_TAG_enumerator)
+  metadata, ;; Name
+  i64       ;; Value
+}
+</pre>
 </div>
 
+<p>These descriptors are used to define members of an
+   enumeration <a href="#format_composite_type">composite type</a>, it
+   associates the name to the value.</p>
 
-<!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="arch_todo">Short-term TODO list</a>
 </div>
 
-<div class="doc_text">
+<!-- ======================================================================= -->
+<h4>
+  <a name="format_variables">Local variables</a>
+</h4>
 
-<p>
-FIXME: this section will eventually go away.  These are notes to myself of
-things that should be implemented, but haven't yet.
-</p>
+<div>
 
-<p>
-<b>Breakpoints:</b> Support is already implemented in the 'InferiorProcess'
-class, though it hasn't been tested yet.  To finish breakpoint support, we need
-to implement breakCommand (which should reuse the linespec parser from the list
-command), and handle the fact that 'break foo' or 'break file.c:53' may insert
-multiple breakpoints.  Also, if you say 'break file.c:53' and there is no
-stoppoint on line 53, the breakpoint should go on the next available line.  My
-idea was to have the Debugger class provide a "Breakpoint" class which
-encapsulated this messiness, giving the debugger front-end a simple interface.
-The debugger front-end would have to map the really complex semantics of
-temporary breakpoints and 'conditional' breakpoints onto this intermediate
-level. Also, breakpoints should survive as much as possible across program
-reloads.
-</p>
+<div class="doc_code">
+<pre>
+!7 = metadata !{
+  i32,      ;; Tag (see below)
+  metadata, ;; Context
+  metadata, ;; Name
+  metadata, ;; Reference to file where defined
+  i32,      ;; 24 bit - Line number where defined
+            ;; 8 bit - Argument number. 1 indicates 1st argument.
+  metadata, ;; Type descriptor
+  i32,      ;; flags
+  metadata  ;; (optional) Reference to inline location
+}
+</pre>
+</div>
+
+<p>These descriptors are used to define variables local to a sub program.  The
+   value of the tag depends on the usage of the variable:</p>
+
+<div class="doc_code">
+<pre>
+DW_TAG_auto_variable   = 256
+DW_TAG_arg_variable    = 257
+DW_TAG_return_variable = 258
+</pre>
+</div>
 
-<p>
-<b>UnixLocalInferiorProcess.cpp speedup</b>: There is no reason for the debugged
-process to code gen the globals corresponding to debug information.  The
-IntrinsicLowering object could instead change descriptors into constant expr
-casts of the constant address of the LLVM objects for the descriptors.  This
-would also allow us to eliminate the mapping back and forth between physical
-addresses that must be done.</p>
+<p>An auto variable is any variable declared in the body of the function.  An
+   argument variable is any variable that appears as a formal argument to the
+   function.  A return variable is used to track the result of a function and
+   has no source correspondent.</p>
 
-<p>
-<b>Process deaths</b>: The InferiorProcessDead exception should be extended to
-know "how" a process died, i.e., it was killed by a signal.  This is easy to
-collect in the UnixLocalInferiorProcess, we just need to represent it.</p>
+<p>The context is either the subprogram or block where the variable is defined.
+   Name the source variable name.  Context and line indicate where the
+   variable was defined. Type descriptor defines the declared type of the
+   variable.</p>
 
 </div>
 
-<!-- *********************************************************************** -->
-<div class="doc_section">
-  <a name="format">Debugging information format</a>
 </div>
-<!-- *********************************************************************** -->
 
-<div class="doc_text">
+<!-- ======================================================================= -->
+<h3>
+  <a name="format_common_intrinsics">Debugger intrinsic functions</a>
+</h3>
 
-<p>LLVM debugging information has been carefully designed to make it possible
-for the optimizer to optimize the program and debugging information without
-necessarily having to know anything about debugging information.  In particular,
-the global constant merging pass automatically eliminates duplicated debugging
-information (often caused by header files), the global dead code elimination
-pass automatically deletes debugging information for a function if it decides to
-delete the function, and the linker eliminates debug information when it merges
-<tt>linkonce</tt> functions.</p>
+<div>
 
-<p>To do this, most of the debugging information (descriptors for types,
-variables, functions, source files, etc) is inserted by the language front-end
-in the form of LLVM global variables.  These LLVM global variables are no
-different from any other global variables, except that they have a web of LLVM
-intrinsic functions that point to them.  If the last references to a particular
-piece of debugging information are deleted (for example, by the
-<tt>-globaldce</tt> pass), the extraneous debug information will automatically
-become dead and be removed by the optimizer.</p>
-
-<p>The debugger is designed to be agnostic about the contents of most of the
-debugging information.  It uses a <a href="#arch_info">source-language-specific
-module</a> to decode the information that represents variables, types,
-functions, namespaces, etc: this allows for arbitrary source-language semantics
-and type-systems to be used, as long as there is a module written for the
-debugger to interpret the information.</p>
+<p>LLVM uses several intrinsic functions (name prefixed with "llvm.dbg") to
+   provide debug information at various points in generated code.</p>
 
-<p>To provide basic functionality, the LLVM debugger does have to make some
-assumptions about the source-level language being debugged, though it keeps
-these to a minimum.  The only common features that the LLVM debugger assumes
-exist are <a href="#format_common_source_files">source files</a>, and <a
-href="#format_program_objects">program objects</a>.  These abstract objects are
-used by the debugger to form stack traces, show information about local
-variables, etc.</p>
+<!-- ======================================================================= -->
+<h4>
+  <a name="format_common_declare">llvm.dbg.declare</a>
+</h4>
 
-<p>This section of the documentation first describes the representation aspects
-common to any source-language.  The <a href="#ccxx_frontend">next section</a>
-describes the data layout conventions used by the C and C++ front-ends.</p>
+<div>
+<pre>
+  void %<a href="#format_common_declare">llvm.dbg.declare</a>(metadata, metadata)
+</pre>
 
+<p>This intrinsic provides information about a local element (ex. variable.) The
+   first argument is metadata holding alloca for the variable. The
+   second argument is metadata containing description of the variable. </p>
 </div>
 
 <!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="format_common_anchors">Anchors for global objects</a>
+<h4>
+  <a name="format_common_value">llvm.dbg.value</a>
+</h4>
+
+<div>
+<pre>
+  void %<a href="#format_common_value">llvm.dbg.value</a>(metadata, i64, metadata)
+</pre>
+
+<p>This intrinsic provides information when a user source variable is set to a
+   new value.  The first argument is the new value (wrapped as metadata).  The
+   second argument is the offset in the user source variable where the new value
+   is written.  The third argument is metadata containing description of the
+   user source variable. </p>
+</div>
+
 </div>
 
-<div class="doc_text">
-<p>One important aspect of the LLVM debug representation is that it allows the
-LLVM debugger to efficiently index all of the global objects without having the
-scan the program.  To do this, all of the global objects use "anchor" globals of
-type "<tt>{}</tt>", with designated names.  These anchor objects obviously do
-not contain any content or meaning by themselves, but all of the global objects
-of a particular type (e.g., source file descriptors) contain a pointer to the
-anchor.  This pointer allows the debugger to use def-use chains to find all
-global objects of that type.</p>
+<!-- ======================================================================= -->
+<h3>
+  <a name="format_common_lifetime">Object lifetimes and scoping</a>
+</h3>
+
+<div>
+<p>In many languages, the local variables in functions can have their lifetimes
+   or scopes limited to a subset of a function.  In the C family of languages,
+   for example, variables are only live (readable and writable) within the
+   source block that they are defined in.  In functional languages, values are
+   only readable after they have been defined.  Though this is a very obvious
+   concept, it is non-trivial to model in LLVM, because it has no notion of
+   scoping in this sense, and does not want to be tied to a language's scoping
+   rules.</p>
+
+<p>In order to handle this, the LLVM debug format uses the metadata attached to
+   llvm instructions to encode line number and scoping information. Consider
+   the following C fragment, for example:</p>
+
+<div class="doc_code">
+<pre>
+1.  void foo() {
+2.    int X = 21;
+3.    int Y = 22;
+4.    {
+5.      int Z = 23;
+6.      Z = X;
+7.    }
+8.    X = Y;
+9.  }
+</pre>
+</div>
 
-<p>So far, the following names are recognized as anchors by the LLVM
-debugger:</p>
+<p>Compiled to LLVM, this function would be represented like this:</p>
 
+<div class="doc_code">
 <pre>
-  %<a href="#format_common_source_files">llvm.dbg.translation_units</a> = linkonce global {} {}
-  %<a href="#format_program_objects">llvm.dbg.globals</a>         = linkonce global {} {}
+define void @foo() nounwind ssp {
+entry:
+  %X = alloca i32, align 4                        ; &lt;i32*&gt; [#uses=4]
+  %Y = alloca i32, align 4                        ; &lt;i32*&gt; [#uses=4]
+  %Z = alloca i32, align 4                        ; &lt;i32*&gt; [#uses=3]
+  %0 = bitcast i32* %X to {}*                     ; &lt;{}*&gt; [#uses=1]
+  call void @llvm.dbg.declare(metadata !{i32 * %X}, metadata !0), !dbg !7
+  store i32 21, i32* %X, !dbg !8
+  %1 = bitcast i32* %Y to {}*                     ; &lt;{}*&gt; [#uses=1]
+  call void @llvm.dbg.declare(metadata !{i32 * %Y}, metadata !9), !dbg !10
+  store i32 22, i32* %Y, !dbg !11
+  %2 = bitcast i32* %Z to {}*                     ; &lt;{}*&gt; [#uses=1]
+  call void @llvm.dbg.declare(metadata !{i32 * %Z}, metadata !12), !dbg !14
+  store i32 23, i32* %Z, !dbg !15
+  %tmp = load i32* %X, !dbg !16                   ; &lt;i32&gt; [#uses=1]
+  %tmp1 = load i32* %Y, !dbg !16                  ; &lt;i32&gt; [#uses=1]
+  %add = add nsw i32 %tmp, %tmp1, !dbg !16        ; &lt;i32&gt; [#uses=1]
+  store i32 %add, i32* %Z, !dbg !16
+  %tmp2 = load i32* %Y, !dbg !17                  ; &lt;i32&gt; [#uses=1]
+  store i32 %tmp2, i32* %X, !dbg !17
+  ret void, !dbg !18
+}
+
+declare void @llvm.dbg.declare(metadata, metadata) nounwind readnone
+
+!0 = metadata !{i32 459008, metadata !1, metadata !"X", 
+                metadata !3, i32 2, metadata !6}; [ DW_TAG_auto_variable ]
+!1 = metadata !{i32 458763, metadata !2}; [DW_TAG_lexical_block ]
+!2 = metadata !{i32 458798, i32 0, metadata !3, metadata !"foo", metadata !"foo", 
+               metadata !"foo", metadata !3, i32 1, metadata !4, 
+               i1 false, i1 true}; [DW_TAG_subprogram ]
+!3 = metadata !{i32 458769, i32 0, i32 12, metadata !"foo.c", 
+                metadata !"/private/tmp", metadata !"clang 1.1", i1 true, 
+                i1 false, metadata !"", i32 0}; [DW_TAG_compile_unit ]
+!4 = metadata !{i32 458773, metadata !3, metadata !"", null, i32 0, i64 0, i64 0, 
+                i64 0, i32 0, null, metadata !5, i32 0}; [DW_TAG_subroutine_type ]
+!5 = metadata !{null}
+!6 = metadata !{i32 458788, metadata !3, metadata !"int", metadata !3, i32 0, 
+                i64 32, i64 32, i64 0, i32 0, i32 5}; [DW_TAG_base_type ]
+!7 = metadata !{i32 2, i32 7, metadata !1, null}
+!8 = metadata !{i32 2, i32 3, metadata !1, null}
+!9 = metadata !{i32 459008, metadata !1, metadata !"Y", metadata !3, i32 3, 
+                metadata !6}; [ DW_TAG_auto_variable ]
+!10 = metadata !{i32 3, i32 7, metadata !1, null}
+!11 = metadata !{i32 3, i32 3, metadata !1, null}
+!12 = metadata !{i32 459008, metadata !13, metadata !"Z", metadata !3, i32 5, 
+                 metadata !6}; [ DW_TAG_auto_variable ]
+!13 = metadata !{i32 458763, metadata !1}; [DW_TAG_lexical_block ]
+!14 = metadata !{i32 5, i32 9, metadata !13, null}
+!15 = metadata !{i32 5, i32 5, metadata !13, null}
+!16 = metadata !{i32 6, i32 5, metadata !13, null}
+!17 = metadata !{i32 8, i32 3, metadata !1, null}
+!18 = metadata !{i32 9, i32 1, metadata !2, null}
 </pre>
+</div>
 
-<p>Using anchors in this way (where the source file descriptor points to the
-anchors, as opposed to having a list of source file descriptors) allows for the
-standard dead global elimination and merging passes to automatically remove
-unused debugging information.  If the globals were kept track of through lists,
-there would always be an object pointing to the descriptors, thus would never be
-deleted.</p>
+<p>This example illustrates a few important details about LLVM debugging
+   information. In particular, it shows how the <tt>llvm.dbg.declare</tt>
+   intrinsic and location information, which are attached to an instruction,
+   are applied together to allow a debugger to analyze the relationship between
+   statements, variable definitions, and the code used to implement the
+   function.</p>
 
+<div class="doc_code">
+<pre>
+call void @llvm.dbg.declare(metadata, metadata !0), !dbg !7   
+</pre>
 </div>
 
-<!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="format_common_stoppoint">
-     Representing stopping points in the source program
-  </a>
+<p>The first intrinsic
+   <tt>%<a href="#format_common_declare">llvm.dbg.declare</a></tt>
+   encodes debugging information for the variable <tt>X</tt>. The metadata
+   <tt>!dbg !7</tt> attached to the intrinsic provides scope information for the
+   variable <tt>X</tt>.</p>
+
+<div class="doc_code">
+<pre>
+!7 = metadata !{i32 2, i32 7, metadata !1, null}
+!1 = metadata !{i32 458763, metadata !2}; [DW_TAG_lexical_block ]
+!2 = metadata !{i32 458798, i32 0, metadata !3, metadata !"foo", 
+                metadata !"foo", metadata !"foo", metadata !3, i32 1, 
+                metadata !4, i1 false, i1 true}; [DW_TAG_subprogram ]   
+</pre>
 </div>
 
-<div class="doc_text">
+<p>Here <tt>!7</tt> is metadata providing location information. It has four
+   fields: line number, column number, scope, and original scope. The original
+   scope represents inline location if this instruction is inlined inside a
+   caller, and is null otherwise. In this example, scope is encoded by
+   <tt>!1</tt>. <tt>!1</tt> represents a lexical block inside the scope
+   <tt>!2</tt>, where <tt>!2</tt> is a
+   <a href="#format_subprograms">subprogram descriptor</a>. This way the
+   location information attached to the intrinsics indicates that the
+   variable <tt>X</tt> is declared at line number 2 at a function level scope in
+   function <tt>foo</tt>.</p>
 
-<p>LLVM debugger "stop points" are a key part of the debugging representation
-that allows the LLVM to maintain simple semantics for <a
-href="#debugopt">debugging optimized code</a>.  The basic idea is that the
-front-end inserts calls to the <tt>%llvm.dbg.stoppoint</tt> intrinsic function
-at every point in the program where the debugger should be able to inspect the
-program (these correspond to places the debugger stops when you "<tt>step</tt>"
-through it).  The front-end can choose to place these as fine-grained as it
-would like (for example, before every subexpression evaluated), but it is
-recommended to only put them after every source statement that includes
-executable code.</p>
+<p>Now lets take another example.</p>
 
-<p>Using calls to this intrinsic function to demark legal points for the
-debugger to inspect the program automatically disables any optimizations that
-could potentially confuse debugging information.  To non-debug-information-aware
-transformations, these calls simply look like calls to an external function,
-which they must assume to do anything (including reading or writing to any part
-of reachable memory).  On the other hand, it does not impact many optimizations,
-such as code motion of non-trapping instructions, nor does it impact
-optimization of subexpressions, code duplication transformations, or basic-block
-reordering transformations.</p>
+<div class="doc_code">
+<pre>
+call void @llvm.dbg.declare(metadata, metadata !12), !dbg !14
+</pre>
+</div>
 
-<p>An important aspect of the calls to the <tt>%llvm.dbg.stoppoint</tt>
-intrinsic is that the function-local debugging information is woven together
-with use-def chains.  This makes it easy for the debugger to, for example,
-locate the 'next' stop point.  For a concrete example of stop points, see the
-example in <a href="#format_common_lifetime">the next section</a>.</p>
+<p>The second intrinsic
+   <tt>%<a href="#format_common_declare">llvm.dbg.declare</a></tt>
+   encodes debugging information for variable <tt>Z</tt>. The metadata 
+   <tt>!dbg !14</tt> attached to the intrinsic provides scope information for
+   the variable <tt>Z</tt>.</p>
 
+<div class="doc_code">
+<pre>
+!13 = metadata !{i32 458763, metadata !1}; [DW_TAG_lexical_block ]
+!14 = metadata !{i32 5, i32 9, metadata !13, null}
+</pre>
 </div>
 
+<p>Here <tt>!14</tt> indicates that <tt>Z</tt> is declared at line number 5 and
+   column number 9 inside of lexical scope <tt>!13</tt>. The lexical scope
+   itself resides inside of lexical scope <tt>!1</tt> described above.</p>
+
+<p>The scope information attached with each instruction provides a
+   straightforward way to find instructions covered by a scope.</p>
 
-<!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="format_common_lifetime">Object lifetimes and scoping</a>
 </div>
 
-<div class="doc_text">
-<p>In many languages, the local variables in functions can have their lifetime
-or scope limited to a subset of a function.  In the C family of languages, for
-example, variables are only live (readable and writable) within the source block
-that they are defined in.  In functional languages, values are only readable
-after they have been defined.  Though this is a very obvious concept, it is also
-non-trivial to model in LLVM, because it has no notion of scoping in this sense,
-and does not want to be tied to a language's scoping rules.</p>
+</div>
 
-<p>In order to handle this, the LLVM debug format uses the notion of "regions"
-of a function, delineated by calls to intrinsic functions.  These intrinsic
-functions define new regions of the program and indicate when the region
-lifetime expires.  Consider the following C fragment, for example:</p>
+<!-- *********************************************************************** -->
+<h2>
+  <a name="ccxx_frontend">C/C++ front-end specific debug information</a>
+</h2>
+<!-- *********************************************************************** -->
 
+<div>
+
+<p>The C and C++ front-ends represent information about the program in a format
+   that is effectively identical
+   to <a href="http://www.eagercon.com/dwarf/dwarf3std.htm">DWARF 3.0</a> in
+   terms of information content.  This allows code generators to trivially
+   support native debuggers by generating standard dwarf information, and
+   contains enough information for non-dwarf targets to translate it as
+   needed.</p>
+
+<p>This section describes the forms used to represent C and C++ programs. Other
+   languages could pattern themselves after this (which itself is tuned to
+   representing programs in the same way that DWARF 3 does), or they could
+   choose to provide completely different forms if they don't fit into the DWARF
+   model.  As support for debugging information gets added to the various LLVM
+   source-language front-ends, the information used should be documented
+   here.</p>
+
+<p>The following sections provide examples of various C/C++ constructs and the
+   debug information that would best describe those constructs.</p>
+
+<!-- ======================================================================= -->
+<h3>
+  <a name="ccxx_compile_units">C/C++ source file information</a>
+</h3>
+
+<div>
+
+<p>Given the source files <tt>MySource.cpp</tt> and <tt>MyHeader.h</tt> located
+   in the directory <tt>/Users/mine/sources</tt>, the following code:</p>
+
+<div class="doc_code">
 <pre>
-1.  void foo() {
-2.    int X = ...;
-3.    int Y = ...;
-4.    {
-5.      int Z = ...;
-6.      ...
-7.    }
-8.    ...
-9.  }
+#include "MyHeader.h"
+
+int main(int argc, char *argv[]) {
+  return 0;
+}
 </pre>
+</div>
 
-<p>Compiled to LLVM, this function would be represented like this (FIXME: CHECK
-AND UPDATE THIS):</p>
+<p>a C/C++ front-end would generate the following descriptors:</p>
 
+<div class="doc_code">
 <pre>
-void %foo() {
-    %X = alloca int
-    %Y = alloca int
-    %Z = alloca int
-    <a name="#icl_ex_D1">%D1</a> = call {}* %llvm.dbg.func.start(<a href="#format_program_objects">%lldb.global</a>* %d.foo)
-    %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)
-
-    %D3 = call {}* %llvm.dbg.DEFINEVARIABLE({}* %D2, ...)
-    <i>;; Evaluate expression on line 2, assigning to X.</i>
-    %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)
-
-    %D5 = call {}* %llvm.dbg.DEFINEVARIABLE({}* %D4, ...)
-    <i>;; Evaluate expression on line 3, assigning to Y.</i>
-    %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)
-
-    <a name="#icl_ex_D1">%D7</a> = call {}* %llvm.region.start({}* %D6)
-    %D8 = call {}* %llvm.dbg.DEFINEVARIABLE({}* %D7, ...)
-    <i>;; Evaluate expression on line 5, assigning to Z.</i>
-    %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)
-
-    <i>;; Code for line 6.</i>
-    %D10 = call {}* %llvm.region.end({}* %D9)
-    %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)
-
-    <i>;; Code for line 8.</i>
-    <a name="#icl_ex_D1">%D12</a> = call {}* %llvm.region.end({}* %D11)
-    ret void
+...
+;;
+;; Define the compile unit for the main source file "/Users/mine/sources/MySource.cpp".
+;;
+!2 = metadata !{
+  i32 524305,    ;; Tag
+  i32 0,         ;; Unused
+  i32 4,         ;; Language Id
+  metadata !"MySource.cpp", 
+  metadata !"/Users/mine/sources", 
+  metadata !"4.2.1 (Based on Apple Inc. build 5649) (LLVM build 00)", 
+  i1 true,       ;; Main Compile Unit
+  i1 false,      ;; Optimized compile unit
+  metadata !"",  ;; Compiler flags
+  i32 0}         ;; Runtime version
+
+;;
+;; Define the file for the file "/Users/mine/sources/MySource.cpp".
+;;
+!1 = metadata !{
+  i32 524329,    ;; Tag
+  metadata !"MySource.cpp", 
+  metadata !"/Users/mine/sources", 
+  metadata !2    ;; Compile unit
+}
+
+;;
+;; Define the file for the file "/Users/mine/sources/Myheader.h"
+;;
+!3 = metadata !{
+  i32 524329,    ;; Tag
+  metadata !"Myheader.h"
+  metadata !"/Users/mine/sources", 
+  metadata !2    ;; Compile unit
 }
-</pre>
 
-<p>This example illustrates a few important details about the LLVM debugging
-information.  In particular, it shows how the various intrinsics used are woven
-together with def-use and use-def chains, similar to how <a
-href="#format_common_anchors">anchors</a> are used with globals.  This allows
-the debugger to analyze the relationship between statements, variable
-definitions, and the code used to implement the function.</p>
-
-<p>In this example, two explicit regions are defined, one with the <a
-href="#icl_ex_D1">definition of the <tt>%D1</tt> variable</a> and one with the
-<a href="#icl_ex_D7">definition of <tt>%D7</tt></a>.  In the case of
-<tt>%D1</tt>, the debug information indicates that the function whose <a
-href="#format_program_objects">descriptor</a> is specified as an argument to the
-intrinsic.  This defines a new stack frame whose lifetime ends when the region
-is ended by <a href="#icl_ex_D12">the <tt>%D12</tt> call</a>.</p>
-
-<p>Using regions to represent the boundaries of source-level functions allow
-LLVM interprocedural optimizations to arbitrarily modify LLVM functions without
-having to worry about breaking mapping information between the LLVM code and the
-and source-level program.  In particular, the inliner requires no modification
-to support inlining with debugging information: there is no explicit correlation
-drawn between LLVM functions and their source-level counterparts (note however,
-that if the inliner inlines all instances of a non-strong-linkage function into
-its caller that it will not be possible for the user to manually invoke the
-inlined function from the debugger).</p>
-
-<p>Once the function has been defined, the <a
-href="#format_common_stoppoint">stopping point</a> corresponding to line #2 of
-the function is encountered.  At this point in the function, <b>no</b> local
-variables are live.  As lines 2 and 3 of the example are executed, their
-variable definitions are automatically introduced into the program, without the
-need to specify a new region.  These variables do not require new regions to be
-introduced because they go out of scope at the same point in the program: line
-9.</p>
-
-<p>In contrast, the <tt>Z</tt> variable goes out of scope at a different time,
-on line 7.  For this reason, it is defined within <a href="#icl_ex_D7">the
-<tt>%D7</tt> region</a>, which kills the availability of <tt>Z</tt> before the
-code for line 8 is executed.  In this way, regions can support arbitrary
-source-language scoping rules, as long as they can only be nested (ie, one scope
-cannot partially overlap with a part of another scope).</p>
-
-<p>It is worth noting that this scoping mechanism is used to control scoping of
-all declarations, not just variable declarations.  For example, the scope of a
-C++ using declaration is controlled with this, and the <tt>llvm-db</tt> C++
-support routines could use this to change how name lookup is performed (though
-this is not implemented yet).</p>
+...
+</pre>
+</div>
 
+<p>llvm::Instruction provides easy access to metadata attached with an 
+instruction. One can extract line number information encoded in LLVM IR
+using <tt>Instruction::getMetadata()</tt> and 
+<tt>DILocation::getLineNumber()</tt>.
+<pre>
+ if (MDNode *N = I->getMetadata("dbg")) {  // Here I is an LLVM instruction
+   DILocation Loc(N);                      // DILocation is in DebugInfo.h
+   unsigned Line = Loc.getLineNumber();
+   StringRef File = Loc.getFilename();
+   StringRef Dir = Loc.getDirectory();
+ }
+</pre>
 </div>
 
 <!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="format_common_descriptors">Object descriptor formats</a>
-</div>
-
-<div class="doc_text">
-<p>The LLVM debugger expects the descriptors for program objects to start in a
-canonical format, but the descriptors can include additional information
-appended at the end that is source-language specific.  All LLVM debugging
-information is versioned, allowing backwards compatibility in the case that the
-core structures need to change in some way.  Also, all debugging information
-objects start with a <a href="#format_common_tags">tag</a> to indicate what type
-of object it is.  The source-language is allows to define its own objects, by
-using unreserved tag numbers.</p>
-
-<p>The lowest-level descriptor are those describing <a
-href="#format_common_source_files">the files containing the program source
-code</a>, as most other descriptors (sometimes indirectly) refer to them.
-</p>
+<h3>
+  <a name="ccxx_global_variable">C/C++ global variable information</a>
+</h3>
+
+<div>
+
+<p>Given an integer global variable declared as follows:</p>
+
+<div class="doc_code">
+<pre>
+int MyGlobal = 100;
+</pre>
 </div>
 
+<p>a C/C++ front-end would generate the following descriptors:</p>
+
+<div class="doc_code">
+<pre>
+;;
+;; Define the global itself.
+;;
+%MyGlobal = global int 100
+...
+;;
+;; List of debug info of globals
+;;
+!llvm.dbg.gv = !{!0}
+
+;;
+;; Define the global variable descriptor.  Note the reference to the global
+;; variable anchor and the global variable itself.
+;;
+!0 = metadata !{
+  i32 524340,              ;; Tag
+  i32 0,                   ;; Unused
+  metadata !1,             ;; Context
+  metadata !"MyGlobal",    ;; Name
+  metadata !"MyGlobal",    ;; Display Name
+  metadata !"MyGlobal",    ;; Linkage Name
+  metadata !3,             ;; Compile Unit
+  i32 1,                   ;; Line Number
+  metadata !4,             ;; Type
+  i1 false,                ;; Is a local variable
+  i1 true,                 ;; Is this a definition
+  i32* @MyGlobal           ;; The global variable
+}
+
+;;
+;; Define the basic type of 32 bit signed integer.  Note that since int is an
+;; intrinsic type the source file is NULL and line 0.
+;;    
+!4 = metadata !{
+  i32 524324,              ;; Tag
+  metadata !1,             ;; Context
+  metadata !"int",         ;; Name
+  metadata !1,             ;; File
+  i32 0,                   ;; Line number
+  i64 32,                  ;; Size in Bits
+  i64 32,                  ;; Align in Bits
+  i64 0,                   ;; Offset in Bits
+  i32 0,                   ;; Flags
+  i32 5                    ;; Encoding
+}
+
+</pre>
+</div>
 
-<!-- ------------------------------------------------------------------------ ->
-<div class="doc_subsubsection">
-  <a name="format_common_source_files">Representation of source files</a>
 </div>
 
-<div class="doc_text">
-<p>
-Source file descriptors are patterned after the Dwarf "compile_unit" object.
-The descriptor currently is defined to have at least the following LLVM
-type entries:</p>
+<!-- ======================================================================= -->
+<h3>
+  <a name="ccxx_subprogram">C/C++ function information</a>
+</h3>
+
+<div>
 
+<p>Given a function declared as follows:</p>
+
+<div class="doc_code">
 <pre>
-%lldb.compile_unit = type {
-       uint,                 <i>;; Tag: <a href="#tag_compile_unit">LLVM_COMPILE_UNIT</a></i>
-       ushort,               <i>;; LLVM debug version number</i>
-       ushort,               <i>;; Dwarf language identifier</i>
-       sbyte*,               <i>;; Filename</i>
-       sbyte*,               <i>;; Working directory when compiled</i>
-       sbyte*                <i>;; Producer of the debug information</i>
+int main(int argc, char *argv[]) {
+  return 0;
 }
 </pre>
+</div>
 
-<p>
-These descriptors contain the version number for the debug info, a source
-language ID for the file (we use the Dwarf 3.0 ID numbers, such as
-<tt>DW_LANG_C89</tt>, <tt>DW_LANG_C_plus_plus</tt>, <tt>DW_LANG_Cobol74</tt>,
-etc), three strings describing the filename, working directory of the compiler,
-and an identifier string for the compiler that produced it.  Note that actual
-compile_unit declarations must also include an <a
-href="#format_common_anchors">anchor</a> to <tt>llvm.dbg.translation_units</tt>,
-but it is not specified where the anchor is to be located.  Here is an example
-descriptor:
-</p>
+<p>a C/C++ front-end would generate the following descriptors:</p>
 
-<p><pre>
-%arraytest_source_file = internal constant %lldb.compile_unit {
-    <a href="#tag_compile_unit">uint 17</a>,                                                      ; Tag value
-    ushort 0,                                                     ; Version #0
-    ushort 1,                                                     ; DW_LANG_C89
-    sbyte* getelementptr ([12 x sbyte]* %.str_1, long 0, long 0), ; filename
-    sbyte* getelementptr ([12 x sbyte]* %.str_2, long 0, long 0), ; working dir
-    sbyte* getelementptr ([12 x sbyte]* %.str_3, long 0, long 0), ; producer
-    {}* %llvm.dbg.translation_units                               ; Anchor
+<div class="doc_code">
+<pre>
+;;
+;; Define the anchor for subprograms.  Note that the second field of the
+;; anchor is 46, which is the same as the tag for subprograms
+;; (46 = DW_TAG_subprogram.)
+;;
+!6 = metadata !{
+  i32 524334,        ;; Tag
+  i32 0,             ;; Unused
+  metadata !1,       ;; Context
+  metadata !"main",  ;; Name
+  metadata !"main",  ;; Display name
+  metadata !"main",  ;; Linkage name
+  metadata !1,       ;; File
+  i32 1,             ;; Line number
+  metadata !4,       ;; Type
+  i1 false,          ;; Is local 
+  i1 true,           ;; Is definition
+  i32 0,             ;; Virtuality attribute, e.g. pure virtual function
+  i32 0,             ;; Index into virtual table for C++ methods
+  i32 0,             ;; Type that holds virtual table.
+  i32 0,             ;; Flags
+  i1 false,          ;; True if this function is optimized
+  Function *,        ;; Pointer to llvm::Function
+  null               ;; Function template parameters
 }
-%.str_1 = internal constant [12 x sbyte] c"arraytest.c\00"
-%.str_2 = internal constant [12 x sbyte] c"/home/sabre\00"
-%.str_3 = internal constant [12 x sbyte] c"llvmgcc 3.4\00"
-</pre></p>
-
-<p>
-Note that the LLVM constant merging pass should eliminate duplicate copies of
-the strings that get emitted to each translation unit, such as the producer.
-</p>
+;;
+;; Define the subprogram itself.
+;;
+define i32 @main(i32 %argc, i8** %argv) {
+...
+}
+</pre>
+</div>
 
 </div>
 
+<!-- ======================================================================= -->
+<h3>
+  <a name="ccxx_basic_types">C/C++ basic types</a>
+</h3>
 
-<!-- ----------------------------------------------------------------------- -->
-<div class="doc_subsubsection">
-  <a name="format_program_objects">Representation of program objects</a>
-</div>
+<div>
 
-<div class="doc_text">
-<p>
-The LLVM debugger needs to know about some source-language program objects, in
-order to build stack traces, print information about local variables, and other
-related activities.  The LLVM debugger differentiates between three different
-types of program objects: subprograms (functions, messages, methods, etc),
-variables (locals and globals), and others.  Because source-languages have
-widely varying forms of these objects, the LLVM debugger expects only a few
-fields in the descriptor for each object:
-</p>
+<p>The following are the basic type descriptors for C/C++ core types:</p>
+
+<!-- ======================================================================= -->
+<h4>
+  <a name="ccxx_basic_type_bool">bool</a>
+</h4>
+
+<div>
 
+<div class="doc_code">
 <pre>
-%lldb.object = type {
-       uint,                  <i>;; <a href="#format_common_tag">A tag</a></i>
-       <i>any</i>*,                  <i>;; The <a href="#format_common_object_contexts">context</a> for the object</i>
-       sbyte*                 <i>;; The object 'name'</i>
+!2 = metadata !{
+  i32 524324,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"bool",  ;; Name
+  metadata !1,       ;; File
+  i32 0,             ;; Line number
+  i64 8,             ;; Size in Bits
+  i64 8,             ;; Align in Bits
+  i64 0,             ;; Offset in Bits
+  i32 0,             ;; Flags
+  i32 2              ;; Encoding
 }
 </pre>
+</div>
 
-<p>The first field contains a tag for the descriptor.  The second field contains
-either a pointer to the descriptor for the containing <a
-href="#format_common_source_files">source file</a>, or it contains a pointer to
-another program object whose context pointer eventually reaches a source file.
-Through this <a href="#format_common_object_contexts">context</a> pointer, the
-LLVM debugger can establish the debug version number of the object.</p>
+</div>
+
+<!-- ======================================================================= -->
+<h4>
+  <a name="ccxx_basic_char">char</a>
+</h4>
 
-<p>The third field contains a string that the debugger can use to identify the
-object if it does not contain explicit support for the source-language in use
-(ie, the 'unknown' source language handler uses this string).  This should be
-some sort of unmangled string that corresponds to the object, but it is a
-quality of implementation issue what exactly it contains (it is legal, though
-not useful, for all of these strings to be null).</p>
+<div>
 
-<p>Note again that descriptors can be extended to include
-source-language-specific information in addition to the fields required by the
-LLVM debugger.  See the <a href="#ccxx_descriptors">section on the C/C++
-front-end</a> for more information.  Also remember that global objects
-(functions, selectors, global variables, etc) must contain an <a
-href="#format_common_anchors">anchor</a> to the <tt>llvm.dbg.globals</tt>
-variable.</p>
+<div class="doc_code">
+<pre>
+!2 = metadata !{
+  i32 524324,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"char",  ;; Name
+  metadata !1,       ;; File
+  i32 0,             ;; Line number
+  i64 8,             ;; Size in Bits
+  i64 8,             ;; Align in Bits
+  i64 0,             ;; Offset in Bits
+  i32 0,             ;; Flags
+  i32 6              ;; Encoding
+}
+</pre>
 </div>
 
+</div>
 
 <!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="format_common_object_contexts">Program object contexts</a>
+<h4>
+  <a name="ccxx_basic_unsigned_char">unsigned char</a>
+</h4>
+
+<div>
+
+<div class="doc_code">
+<pre>
+!2 = metadata !{
+  i32 524324,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"unsigned char", 
+  metadata !1,       ;; File
+  i32 0,             ;; Line number
+  i64 8,             ;; Size in Bits
+  i64 8,             ;; Align in Bits
+  i64 0,             ;; Offset in Bits
+  i32 0,             ;; Flags
+  i32 8              ;; Encoding
+}
+</pre>
+</div>
+
 </div>
 
-<div class="doc_text">
+<!-- ======================================================================= -->
+<h4>
+  <a name="ccxx_basic_short">short</a>
+</h4>
+
+<div>
+
+<div class="doc_code">
 <pre>
-Allow source-language specific contexts, use to identify namespaces etc
-Must end up in a source file descriptor.
-Debugger core ignores all unknown context objects.
+!2 = metadata !{
+  i32 524324,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"short int",
+  metadata !1,       ;; File
+  i32 0,             ;; Line number
+  i64 16,            ;; Size in Bits
+  i64 16,            ;; Align in Bits
+  i64 0,             ;; Offset in Bits
+  i32 0,             ;; Flags
+  i32 5              ;; Encoding
+}
 </pre>
 </div>
 
+</div>
+
 <!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="format_common_intrinsics">Debugger intrinsic functions</a>
+<h4>
+  <a name="ccxx_basic_unsigned_short">unsigned short</a>
+</h4>
+
+<div>
+
+<div class="doc_code">
+<pre>
+!2 = metadata !{
+  i32 524324,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"short unsigned int",
+  metadata !1,       ;; File
+  i32 0,             ;; Line number
+  i64 16,            ;; Size in Bits
+  i64 16,            ;; Align in Bits
+  i64 0,             ;; Offset in Bits
+  i32 0,             ;; Flags
+  i32 7              ;; Encoding
+}
+</pre>
+</div>
+
 </div>
 
-<div class="doc_text">
+<!-- ======================================================================= -->
+<h4>
+  <a name="ccxx_basic_int">int</a>
+</h4>
+
+<div>
+
+<div class="doc_code">
 <pre>
-Define each intrinsics, as an extension of the language reference manual.
+!2 = metadata !{
+  i32 524324,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"int",   ;; Name
+  metadata !1,       ;; File
+  i32 0,             ;; Line number
+  i64 32,            ;; Size in Bits
+  i64 32,            ;; Align in Bits
+  i64 0,             ;; Offset in Bits
+  i32 0,             ;; Flags
+  i32 5              ;; Encoding
+}
+</pre></div>
+
+</div>
 
-llvm.dbg.stoppoint
-llvm.dbg.region.start
-llvm.dbg.region.end
-llvm.dbg.function.start
-llvm.dbg.declare
+<!-- ======================================================================= -->
+<h4>
+  <a name="ccxx_basic_unsigned_int">unsigned int</a>
+</h4>
+
+<div>
+
+<div class="doc_code">
+<pre>
+!2 = metadata !{
+  i32 524324,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"unsigned int",
+  metadata !1,       ;; File
+  i32 0,             ;; Line number
+  i64 32,            ;; Size in Bits
+  i64 32,            ;; Align in Bits
+  i64 0,             ;; Offset in Bits
+  i32 0,             ;; Flags
+  i32 7              ;; Encoding
+}
 </pre>
 </div>
 
+</div>
+
 <!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="format_common_tags">Values for debugger tags</a>
+<h4>
+  <a name="ccxx_basic_long_long">long long</a>
+</h4>
+
+<div>
+
+<div class="doc_code">
+<pre>
+!2 = metadata !{
+  i32 524324,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"long long int",
+  metadata !1,       ;; File
+  i32 0,             ;; Line number
+  i64 64,            ;; Size in Bits
+  i64 64,            ;; Align in Bits
+  i64 0,             ;; Offset in Bits
+  i32 0,             ;; Flags
+  i32 5              ;; Encoding
+}
+</pre>
 </div>
 
-<div class="doc_text">
+</div>
+
+<!-- ======================================================================= -->
+<h4>
+  <a name="ccxx_basic_unsigned_long_long">unsigned long long</a>
+</h4>
 
-<p>Happen to be the same value as the similarly named Dwarf-3 tags, this may
-change in the future.</p>
+<div>
 
+<div class="doc_code">
 <pre>
-  <a name="tag_compile_unit">LLVM_COMPILE_UNIT</a>     : 17
-  <a name="tag_subprogram">LLVM_SUBPROGRAM</a>       : 46
-  <a name="tag_variable">LLVM_VARIABLE</a>         : 52
-<!--  <a name="tag_formal_parameter">LLVM_FORMAL_PARAMETER :  5-->
+!2 = metadata !{
+  i32 524324,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"long long unsigned int",
+  metadata !1,       ;; File
+  i32 0,             ;; Line number
+  i64 64,            ;; Size in Bits
+  i64 64,            ;; Align in Bits
+  i64 0,             ;; Offset in Bits
+  i32 0,             ;; Flags
+  i32 7              ;; Encoding
+}
 </pre>
 </div>
 
+</div>
+
+<!-- ======================================================================= -->
+<h4>
+  <a name="ccxx_basic_float">float</a>
+</h4>
 
+<div>
+
+<div class="doc_code">
+<pre>
+!2 = metadata !{
+  i32 524324,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"float",
+  metadata !1,       ;; File
+  i32 0,             ;; Line number
+  i64 32,            ;; Size in Bits
+  i64 32,            ;; Align in Bits
+  i64 0,             ;; Offset in Bits
+  i32 0,             ;; Flags
+  i32 4              ;; Encoding
+}
+</pre>
+</div>
 
-<!-- *********************************************************************** -->
-<div class="doc_section">
-  <a name="ccxx_frontend">C/C++ front-end specific debug information</a>
 </div>
-<!-- *********************************************************************** -->
 
-<div class="doc_text">
+<!-- ======================================================================= -->
+<h4>
+  <a name="ccxx_basic_double">double</a>
+</h4>
 
-<p>The C and C++ front-ends represent information about the program in a format
-that is effectively identical to <a
-href="http://www.eagercon.com/dwarf/dwarf3std.htm">Dwarf 3.0</a> in terms of
-information content.  This allows code generators to trivially support native
-debuggers by generating standard dwarf information, and contains enough
-information for non-dwarf targets to translate it as needed.</p>
-
-<p>The basic debug information required by the debugger is (intentionally)
-designed to be as minimal as possible.  This basic information is so minimal
-that it is unlikely that <b>any</b> source-language could be adequately
-described by it.  Because of this, the debugger format was designed for
-extension to support source-language-specific information.  The extended
-descriptors are read and interpreted by the <a
-href="#arch_info">language-specific</a> modules in the debugger if there is
-support available, otherwise it is ignored.</p>
-
-<p>This section describes the extensions used to represent C and C++ programs.
-Other languages could pattern themselves after this (which itself is tuned to
-representing programs in the same way that Dwarf 3 does), or they could choose
-to provide completely different extensions if they don't fit into the Dwarf
-model.  As support for debugging information gets added to the various LLVM
-source-language front-ends, the information used should be documented here.</p>
+<div>
+
+<div class="doc_code">
+<pre>
+!2 = metadata !{
+  i32 524324,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"double",;; Name
+  metadata !1,       ;; File
+  i32 0,             ;; Line number
+  i64 64,            ;; Size in Bits
+  i64 64,            ;; Align in Bits
+  i64 0,             ;; Offset in Bits
+  i32 0,             ;; Flags
+  i32 4              ;; Encoding
+}
+</pre>
+</div>
+
+</div>
 
 </div>
 
 <!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="ccxx_pse">Program Scope Entries</a>
+<h3>
+  <a name="ccxx_derived_types">C/C++ derived types</a>
+</h3>
+
+<div>
+
+<p>Given the following as an example of C/C++ derived type:</p>
+
+<div class="doc_code">
+<pre>
+typedef const int *IntPtr;
+</pre>
 </div>
 
-<div class="doc_text">
-<p>TODO</p>
+<p>a C/C++ front-end would generate the following descriptors:</p>
+
+<div class="doc_code">
+<pre>
+;;
+;; Define the typedef "IntPtr".
+;;
+!2 = metadata !{
+  i32 524310,          ;; Tag
+  metadata !1,         ;; Context
+  metadata !"IntPtr",  ;; Name
+  metadata !3,         ;; File
+  i32 0,               ;; Line number
+  i64 0,               ;; Size in bits
+  i64 0,               ;; Align in bits
+  i64 0,               ;; Offset in bits
+  i32 0,               ;; Flags
+  metadata !4          ;; Derived From type
+}
+
+;;
+;; Define the pointer type.
+;;
+!4 = metadata !{
+  i32 524303,          ;; Tag
+  metadata !1,         ;; Context
+  metadata !"",        ;; Name
+  metadata !1,         ;; File
+  i32 0,               ;; Line number
+  i64 64,              ;; Size in bits
+  i64 64,              ;; Align in bits
+  i64 0,               ;; Offset in bits
+  i32 0,               ;; Flags
+  metadata !5          ;; Derived From type
+}
+;;
+;; Define the const type.
+;;
+!5 = metadata !{
+  i32 524326,          ;; Tag
+  metadata !1,         ;; Context
+  metadata !"",        ;; Name
+  metadata !1,         ;; File
+  i32 0,               ;; Line number
+  i64 32,              ;; Size in bits
+  i64 32,              ;; Align in bits
+  i64 0,               ;; Offset in bits
+  i32 0,               ;; Flags
+  metadata !6          ;; Derived From type
+}
+;;
+;; Define the int type.
+;;
+!6 = metadata !{
+  i32 524324,          ;; Tag
+  metadata !1,         ;; Context
+  metadata !"int",     ;; Name
+  metadata !1,         ;; File
+  i32 0,               ;; Line number
+  i64 32,              ;; Size in bits
+  i64 32,              ;; Align in bits
+  i64 0,               ;; Offset in bits
+  i32 0,               ;; Flags
+  5                    ;; Encoding
+}
+</pre>
 </div>
 
-<!-- -------------------------------------------------------------------------->
-<div class="doc_subsubsection">
-  <a name="ccxx_compilation_units">Compilation unit entries</a>
 </div>
 
-<div class="doc_text">
-<p>
-Translation units do not add any information over the standard <a
-href="#format_common_source_files">source file representation</a> already
-expected by the debugger.  As such, it uses descriptors of the type specified,
-with a trailing <a href="#format_common_anchors">anchor</a>.
-</p>
+<!-- ======================================================================= -->
+<h3>
+  <a name="ccxx_composite_types">C/C++ struct/union types</a>
+</h3>
+
+<div>
+
+<p>Given the following as an example of C/C++ struct type:</p>
+
+<div class="doc_code">
+<pre>
+struct Color {
+  unsigned Red;
+  unsigned Green;
+  unsigned Blue;
+};
+</pre>
 </div>
 
-<!-- -------------------------------------------------------------------------->
-<div class="doc_subsubsection">
-  <a name="ccxx_modules">Module, namespace, and importing entries</a>
+<p>a C/C++ front-end would generate the following descriptors:</p>
+
+<div class="doc_code">
+<pre>
+;;
+;; Define basic type for unsigned int.
+;;
+!5 = metadata !{
+  i32 524324,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"unsigned int",
+  metadata !1,       ;; File
+  i32 0,             ;; Line number
+  i64 32,            ;; Size in Bits
+  i64 32,            ;; Align in Bits
+  i64 0,             ;; Offset in Bits
+  i32 0,             ;; Flags
+  i32 7              ;; Encoding
+}
+;;
+;; Define composite type for struct Color.
+;;
+!2 = metadata !{
+  i32 524307,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"Color", ;; Name
+  metadata !1,       ;; Compile unit
+  i32 1,             ;; Line number
+  i64 96,            ;; Size in bits
+  i64 32,            ;; Align in bits
+  i64 0,             ;; Offset in bits
+  i32 0,             ;; Flags
+  null,              ;; Derived From
+  metadata !3,       ;; Elements
+  i32 0              ;; Runtime Language
+}
+
+;;
+;; Define the Red field.
+;;
+!4 = metadata !{
+  i32 524301,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"Red",   ;; Name
+  metadata !1,       ;; File
+  i32 2,             ;; Line number
+  i64 32,            ;; Size in bits
+  i64 32,            ;; Align in bits
+  i64 0,             ;; Offset in bits
+  i32 0,             ;; Flags
+  metadata !5        ;; Derived From type
+}
+
+;;
+;; Define the Green field.
+;;
+!6 = metadata !{
+  i32 524301,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"Green", ;; Name
+  metadata !1,       ;; File
+  i32 3,             ;; Line number
+  i64 32,            ;; Size in bits
+  i64 32,            ;; Align in bits
+  i64 32,             ;; Offset in bits
+  i32 0,             ;; Flags
+  metadata !5        ;; Derived From type
+}
+
+;;
+;; Define the Blue field.
+;;
+!7 = metadata !{
+  i32 524301,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"Blue",  ;; Name
+  metadata !1,       ;; File
+  i32 4,             ;; Line number
+  i64 32,            ;; Size in bits
+  i64 32,            ;; Align in bits
+  i64 64,             ;; Offset in bits
+  i32 0,             ;; Flags
+  metadata !5        ;; Derived From type
+}
+
+;;
+;; Define the array of fields used by the composite type Color.
+;;
+!3 = metadata !{metadata !4, metadata !6, metadata !7}
+</pre>
 </div>
 
-<div class="doc_text">
-<p>TODO</p>
 </div>
 
 <!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="ccxx_dataobjects">Data objects (program variables)</a>
+<h3>
+  <a name="ccxx_enumeration_types">C/C++ enumeration types</a>
+</h3>
+
+<div>
+
+<p>Given the following as an example of C/C++ enumeration type:</p>
+
+<div class="doc_code">
+<pre>
+enum Trees {
+  Spruce = 100,
+  Oak = 200,
+  Maple = 300
+};
+</pre>
+</div>
+
+<p>a C/C++ front-end would generate the following descriptors:</p>
+
+<div class="doc_code">
+<pre>
+;;
+;; Define composite type for enum Trees
+;;
+!2 = metadata !{
+  i32 524292,        ;; Tag
+  metadata !1,       ;; Context
+  metadata !"Trees", ;; Name
+  metadata !1,       ;; File
+  i32 1,             ;; Line number
+  i64 32,            ;; Size in bits
+  i64 32,            ;; Align in bits
+  i64 0,             ;; Offset in bits
+  i32 0,             ;; Flags
+  null,              ;; Derived From type
+  metadata !3,       ;; Elements
+  i32 0              ;; Runtime language
+}
+
+;;
+;; Define the array of enumerators used by composite type Trees.
+;;
+!3 = metadata !{metadata !4, metadata !5, metadata !6}
+
+;;
+;; Define Spruce enumerator.
+;;
+!4 = metadata !{i32 524328, metadata !"Spruce", i64 100}
+
+;;
+;; Define Oak enumerator.
+;;
+!5 = metadata !{i32 524328, metadata !"Oak", i64 200}
+
+;;
+;; Define Maple enumerator.
+;;
+!6 = metadata !{i32 524328, metadata !"Maple", i64 300}
+
+</pre>
 </div>
 
-<div class="doc_text">
-<p>TODO</p>
 </div>
 
+</div>
 
 <!-- *********************************************************************** -->
 
 <hr>
 <address>
   <a href="http://jigsaw.w3.org/css-validator/check/referer"><img
-  src="http://jigsaw.w3.org/css-validator/images/vcss" alt="Valid CSS!"></a>
+  src="http://jigsaw.w3.org/css-validator/images/vcss-blue" alt="Valid CSS"></a>
   <a href="http://validator.w3.org/check/referer"><img
-  src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!"></a>
+  src="http://www.w3.org/Icons/valid-html401-blue" alt="Valid HTML 4.01"></a>
 
   <a href="mailto:sabre@nondot.org">Chris Lattner</a><br>
-  <a href="http://llvm.cs.uiuc.edu">LLVM Compiler Infrastructure</a><br>
+  <a href="http://llvm.org/">LLVM Compiler Infrastructure</a><br>
   Last modified: $Date$
 </address>