docs/SourceLevelDebugging.html

   1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
   2                       "http://www.w3.org/TR/html4/strict.dtd">
   3 <html>
   4 <head>
   5   <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
   6   <title>Source Level Debugging with LLVM</title>
   7   <link rel="stylesheet" href="llvm.css" type="text/css">
   8 </head>
   9 <body>
  10
  11 <h1>Source Level Debugging with LLVM</h1>
  12
  13 <table class="layout" style="width:100%">
  14   <tr class="layout">
  15     <td class="left">
  16 <ul>
  17   <li><a href="#introduction">Introduction</a>
  18   <ol>
  19     <li><a href="#phil">Philosophy behind LLVM debugging information</a></li>
  20     <li><a href="#consumers">Debug information consumers</a></li>
  21     <li><a href="#debugopt">Debugging optimized code</a></li>
  22   </ol></li>
  23   <li><a href="#format">Debugging information format</a>
  24   <ol>
  25     <li><a href="#debug_info_descriptors">Debug information descriptors</a>
  26     <ul>
  27       <li><a href="#format_compile_units">Compile unit descriptors</a></li>
  28       <li><a href="#format_files">File descriptors</a></li>
  29       <li><a href="#format_global_variables">Global variable descriptors</a></li>
  30       <li><a href="#format_subprograms">Subprogram descriptors</a></li>
  31       <li><a href="#format_blocks">Block descriptors</a></li>
  32       <li><a href="#format_basic_type">Basic type descriptors</a></li>
  33       <li><a href="#format_derived_type">Derived type descriptors</a></li>
  34       <li><a href="#format_composite_type">Composite type descriptors</a></li>
  35       <li><a href="#format_subrange">Subrange descriptors</a></li>
  36       <li><a href="#format_enumeration">Enumerator descriptors</a></li>
  37       <li><a href="#format_variables">Local variables</a></li>
  38     </ul></li>
  39     <li><a href="#format_common_intrinsics">Debugger intrinsic functions</a>
  40       <ul>
  41       <li><a href="#format_common_declare">llvm.dbg.declare</a></li>
  42       <li><a href="#format_common_value">llvm.dbg.value</a></li>
  43     </ul></li>
  44   </ol></li>
  45   <li><a href="#format_common_lifetime">Object lifetimes and scoping</a></li>
  46   <li><a href="#ccxx_frontend">C/C++ front-end specific debug information</a>
  47   <ol>
  48     <li><a href="#ccxx_compile_units">C/C++ source file information</a></li>
  49     <li><a href="#ccxx_global_variable">C/C++ global variable information</a></li>
  50     <li><a href="#ccxx_subprogram">C/C++ function information</a></li>
  51     <li><a href="#ccxx_basic_types">C/C++ basic types</a></li>
  52     <li><a href="#ccxx_derived_types">C/C++ derived types</a></li>
  53     <li><a href="#ccxx_composite_types">C/C++ struct/union types</a></li>
  54     <li><a href="#ccxx_enumeration_types">C/C++ enumeration types</a></li>
  55   </ol></li>
  56   <li><a href="#llvmdwarfextension">LLVM Dwarf Extensions</a>
  57     <ol>
  58       <li><a href="#objcproperty">Debugging Information Extension
  59           for Objective C Properties</a></li>
  60       <ul>
  61         <li><a href="#objcpropertyintroduction">Introduction</a></li>
  62         <li><a href="#objcpropertyproposal">Proposal</a></li>
  63         <li><a href="#objcpropertynewattributes">New DWARF Attributes</a></li>
  64         <li><a href="#objcpropertynewconstants">New DWARF Constants</a></li>
  65       </ul>
  66
  67     </ol>
  68   </li>
  69 </ul>
  70 </td>
  71 <td class="right">
  72 <img src="img/venusflytrap.jpg" alt="A leafy and green bug eater" width="247"
  73 height="369">
  74 </td>
  75 </tr></table>
  76
  77 <div class="doc_author">
  78   <p>Written by <a href="mailto:sabre@nondot.org">Chris Lattner</a>
  79             and <a href="mailto:jlaskey@mac.com">Jim Laskey</a></p>
  80 </div>
  81
  82
  83 <!-- *********************************************************************** -->
  84 <h2><a name="introduction">Introduction</a></h2>
  85 <!-- *********************************************************************** -->
  86
  87 <div>
  88
  89 <p>This document is the central repository for all information pertaining to
  90    debug information in LLVM.  It describes the <a href="#format">actual format
  91    that the LLVM debug information</a> takes, which is useful for those
  92    interested in creating front-ends or dealing directly with the information.
  93    Further, this document provides specific examples of what debug information
  94    for C/C++ looks like.</p>
  95
  96 <!-- ======================================================================= -->
  97 <h3>
  98   <a name="phil">Philosophy behind LLVM debugging information</a>
  99 </h3>
 100
 101 <div>
 102
 103 <p>The idea of the LLVM debugging information is to capture how the important
 104    pieces of the source-language's Abstract Syntax Tree map onto LLVM code.
 105    Several design aspects have shaped the solution that appears here.  The
 106    important ones are:</p>
 107
 108 <ul>
 109   <li>Debugging information should have very little impact on the rest of the
 110       compiler.  No transformations, analyses, or code generators should need to
 111       be modified because of debugging information.</li>
 112
 113   <li>LLVM optimizations should interact in <a href="#debugopt">well-defined and
 114       easily described ways</a> with the debugging information.</li>
 115
 116   <li>Because LLVM is designed to support arbitrary programming languages,
 117       LLVM-to-LLVM tools should not need to know anything about the semantics of
 118       the source-level-language.</li>
 119
 120   <li>Source-level languages are often <b>widely</b> different from one another.
 121       LLVM should not put any restrictions of the flavor of the source-language,
 122       and the debugging information should work with any language.</li>
 123
 124   <li>With code generator support, it should be possible to use an LLVM compiler
 125       to compile a program to native machine code and standard debugging
 126       formats.  This allows compatibility with traditional machine-code level
 127       debuggers, like GDB or DBX.</li>
 128 </ul>
 129
 130 <p>The approach used by the LLVM implementation is to use a small set
 131    of <a href="#format_common_intrinsics">intrinsic functions</a> to define a
 132    mapping between LLVM program objects and the source-level objects.  The
 133    description of the source-level program is maintained in LLVM metadata
 134    in an <a href="#ccxx_frontend">implementation-defined format</a>
 135    (the C/C++ front-end currently uses working draft 7 of
 136    the <a href="http://www.eagercon.com/dwarf/dwarf3std.htm">DWARF 3
 137    standard</a>).</p>
 138
 139 <p>When a program is being debugged, a debugger interacts with the user and
 140    turns the stored debug information into source-language specific information.
 141    As such, a debugger must be aware of the source-language, and is thus tied to
 142    a specific language or family of languages.</p>
 143
 144 </div>
 145
 146 <!-- ======================================================================= -->
 147 <h3>
 148   <a name="consumers">Debug information consumers</a>
 149 </h3>
 150
 151 <div>
 152
 153 <p>The role of debug information is to provide meta information normally
 154    stripped away during the compilation process.  This meta information provides
 155    an LLVM user a relationship between generated code and the original program
 156    source code.</p>
 157
 158 <p>Currently, debug information is consumed by DwarfDebug to produce dwarf
 159    information used by the gdb debugger.  Other targets could use the same
 160    information to produce stabs or other debug forms.</p>
 161
 162 <p>It would also be reasonable to use debug information to feed profiling tools
 163    for analysis of generated code, or, tools for reconstructing the original
 164    source from generated code.</p>
 165
 166 <p>TODO - expound a bit more.</p>
 167
 168 </div>
 169
 170 <!-- ======================================================================= -->
 171 <h3>
 172   <a name="debugopt">Debugging optimized code</a>
 173 </h3>
 174
 175 <div>
 176
 177 <p>An extremely high priority of LLVM debugging information is to make it
 178    interact well with optimizations and analysis.  In particular, the LLVM debug
 179    information provides the following guarantees:</p>
 180
 181 <ul>
 182   <li>LLVM debug information <b>always provides information to accurately read
 183       the source-level state of the program</b>, regardless of which LLVM
 184       optimizations have been run, and without any modification to the
 185       optimizations themselves.  However, some optimizations may impact the
 186       ability to modify the current state of the program with a debugger, such
 187       as setting program variables, or calling functions that have been
 188       deleted.</li>
 189
 190   <li>As desired, LLVM optimizations can be upgraded to be aware of the LLVM
 191       debugging information, allowing them to update the debugging information
 192       as they perform aggressive optimizations.  This means that, with effort,
 193       the LLVM optimizers could optimize debug code just as well as non-debug
 194       code.</li>
 195
 196   <li>LLVM debug information does not prevent optimizations from
 197       happening (for example inlining, basic block reordering/merging/cleanup,
 198       tail duplication, etc).</li>
 199
 200   <li>LLVM debug information is automatically optimized along with the rest of
 201       the program, using existing facilities.  For example, duplicate
 202       information is automatically merged by the linker, and unused information
 203       is automatically removed.</li>
 204 </ul>
 205
 206 <p>Basically, the debug information allows you to compile a program with
 207    "<tt>-O0 -g</tt>" and get full debug information, allowing you to arbitrarily
 208    modify the program as it executes from a debugger.  Compiling a program with
 209    "<tt>-O3 -g</tt>" gives you full debug information that is always available
 210    and accurate for reading (e.g., you get accurate stack traces despite tail
 211    call elimination and inlining), but you might lose the ability to modify the
 212    program and call functions where were optimized out of the program, or
 213    inlined away completely.</p>
 214
 215 <p><a href="TestingGuide.html#quicktestsuite">LLVM test suite</a> provides a
 216    framework to test optimizer's handling of debugging information. It can be
 217    run like this:</p>
 218
 219 <div class="doc_code">
 220 <pre>
 221 % cd llvm/projects/test-suite/MultiSource/Benchmarks  # or some other level
 222 % make TEST=dbgopt
 223 </pre>
 224 </div>
 225
 226 <p>This will test impact of debugging information on optimization passes. If
 227    debugging information influences optimization passes then it will be reported
 228    as a failure. See <a href="TestingGuide.html">TestingGuide</a> for more
 229    information on LLVM test infrastructure and how to run various tests.</p>
 230
 231 </div>
 232
 233 </div>
 234
 235 <!-- *********************************************************************** -->
 236 <h2>
 237   <a name="format">Debugging information format</a>
 238 </h2>
 239 <!-- *********************************************************************** -->
 240
 241 <div>
 242
 243 <p>LLVM debugging information has been carefully designed to make it possible
 244    for the optimizer to optimize the program and debugging information without
 245    necessarily having to know anything about debugging information.  In
 246    particular, the use of metadata avoids duplicated debugging information from
 247    the beginning, and the global dead code elimination pass automatically
 248    deletes debugging information for a function if it decides to delete the
 249    function. </p>
 250
 251 <p>To do this, most of the debugging information (descriptors for types,
 252    variables, functions, source files, etc) is inserted by the language
 253    front-end in the form of LLVM metadata. </p>
 254
 255 <p>Debug information is designed to be agnostic about the target debugger and
 256    debugging information representation (e.g. DWARF/Stabs/etc).  It uses a
 257    generic pass to decode the information that represents variables, types,
 258    functions, namespaces, etc: this allows for arbitrary source-language
 259    semantics and type-systems to be used, as long as there is a module
 260    written for the target debugger to interpret the information. </p>
 261
 262 <p>To provide basic functionality, the LLVM debugger does have to make some
 263    assumptions about the source-level language being debugged, though it keeps
 264    these to a minimum.  The only common features that the LLVM debugger assumes
 265    exist are <a href="#format_files">source files</a>,
 266    and <a href="#format_global_variables">program objects</a>.  These abstract
 267    objects are used by a debugger to form stack traces, show information about
 268    local variables, etc.</p>
 269
 270 <p>This section of the documentation first describes the representation aspects
 271    common to any source-language.  The <a href="#ccxx_frontend">next section</a>
 272    describes the data layout conventions used by the C and C++ front-ends.</p>
 273
 274 <!-- ======================================================================= -->
 275 <h3>
 276   <a name="debug_info_descriptors">Debug information descriptors</a>
 277 </h3>
 278
 279 <div>
 280
 281 <p>In consideration of the complexity and volume of debug information, LLVM
 282    provides a specification for well formed debug descriptors. </p>
 283
 284 <p>Consumers of LLVM debug information expect the descriptors for program
 285    objects to start in a canonical format, but the descriptors can include
 286    additional information appended at the end that is source-language
 287    specific. All LLVM debugging information is versioned, allowing backwards
 288    compatibility in the case that the core structures need to change in some
 289    way.  Also, all debugging information objects start with a tag to indicate
 290    what type of object it is.  The source-language is allowed to define its own
 291    objects, by using unreserved tag numbers.  We recommend using with tags in
 292    the range 0x1000 through 0x2000 (there is a defined enum DW_TAG_user_base =
 293    0x1000.)</p>
 294
 295 <p>The fields of debug descriptors used internally by LLVM
 296    are restricted to only the simple data types <tt>i32</tt>, <tt>i1</tt>,
 297    <tt>float</tt>, <tt>double</tt>, <tt>mdstring</tt> and <tt>mdnode</tt>. </p>
 298
 299 <div class="doc_code">
 300 <pre>
 301 !1 = metadata !{
 302   i32,   ;; A tag
 303   ...
 304 }
 305 </pre>
 306 </div>
 307
 308 <p><a name="LLVMDebugVersion">The first field of a descriptor is always an
 309    <tt>i32</tt> containing a tag value identifying the content of the
 310    descriptor.  The remaining fields are specific to the descriptor.  The values
 311    of tags are loosely bound to the tag values of DWARF information entries.
 312    However, that does not restrict the use of the information supplied to DWARF
 313    targets.  To facilitate versioning of debug information, the tag is augmented
 314    with the current debug version (LLVMDebugVersion = 8 &lt;&lt; 16 or
 315    0x80000 or 524288.)</a></p>
 316
 317 <p>The details of the various descriptors follow.</p>
 318
 319 <!-- ======================================================================= -->
 320 <h4>
 321   <a name="format_compile_units">Compile unit descriptors</a>
 322 </h4>
 323
 324 <div>
 325
 326 <div class="doc_code">
 327 <pre>
 328 !0 = metadata !{
 329   i32,       ;; Tag = 17 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a>
 330              ;; (DW_TAG_compile_unit)
 331   i32,       ;; Unused field.
 332   i32,       ;; DWARF language identifier (ex. DW_LANG_C89)
 333   metadata,  ;; Source file name
 334   metadata,  ;; Source file directory (includes trailing slash)
 335   metadata   ;; Producer (ex. "4.0.1 LLVM (LLVM research group)")
 336   i1,        ;; True if this is a main compile unit.
 337   i1,        ;; True if this is optimized.
 338   metadata,  ;; Flags
 339   i32        ;; Runtime version
 340   metadata   ;; List of enums types
 341   metadata   ;; List of retained types
 342   metadata   ;; List of subprograms
 343   metadata   ;; List of global variables
 344 }
 345 </pre>
 346 </div>
 347
 348 <p>These descriptors contain a source language ID for the file (we use the DWARF
 349    3.0 ID numbers, such as <tt>DW_LANG_C89</tt>, <tt>DW_LANG_C_plus_plus</tt>,
 350    <tt>DW_LANG_Cobol74</tt>, etc), three strings describing the filename,
 351    working directory of the compiler, and an identifier string for the compiler
 352    that produced it.</p>
 353
 354 <p>Compile unit descriptors provide the root context for objects declared in a
 355    specific compilation unit. File descriptors are defined using this context.
 356    These descriptors are collected by a named metadata
 357    <tt>!llvm.dbg.cu</tt>. Compile unit descriptor keeps track of subprograms,
 358    global variables and type information.
 359
 360 </div>
 361
 362 <!-- ======================================================================= -->
 363 <h4>
 364   <a name="format_files">File descriptors</a>
 365 </h4>
 366
 367 <div>
 368
 369 <div class="doc_code">
 370 <pre>
 371 !0 = metadata !{
 372   i32,       ;; Tag = 41 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a>
 373              ;; (DW_TAG_file_type)
 374   metadata,  ;; Source file name
 375   metadata,  ;; Source file directory (includes trailing slash)
 376   metadata   ;; Unused
 377 }
 378 </pre>
 379 </div>
 380
 381 <p>These descriptors contain information for a file. Global variables and top
 382    level functions would be defined using this context.k File descriptors also
 383    provide context for source line correspondence. </p>
 384
 385 <p>Each input file is encoded as a separate file descriptor in LLVM debugging
 386    information output. </p>
 387
 388 </div>
 389
 390 <!-- ======================================================================= -->
 391 <h4>
 392   <a name="format_global_variables">Global variable descriptors</a>
 393 </h4>
 394
 395 <div>
 396
 397 <div class="doc_code">
 398 <pre>
 399 !1 = metadata !{
 400   i32,      ;; Tag = 52 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a>
 401             ;; (DW_TAG_variable)
 402   i32,      ;; Unused field.
 403   metadata, ;; Reference to context descriptor
 404   metadata, ;; Name
 405   metadata, ;; Display name (fully qualified C++ name)
 406   metadata, ;; MIPS linkage name (for C++)
 407   metadata, ;; Reference to file where defined
 408   i32,      ;; Line number where defined
 409   metadata, ;; Reference to type descriptor
 410   i1,       ;; True if the global is local to compile unit (static)
 411   i1,       ;; True if the global is defined in the compile unit (not extern)
 412   {}*       ;; Reference to the global variable
 413 }
 414 </pre>
 415 </div>
 416
 417 <p>These descriptors provide debug information about globals variables.  The
 418 provide details such as name, type and where the variable is defined. All
 419 global variables are collected by named metadata <tt>!llvm.dbg.gv</tt>.</p>
 420
 421 </div>
 422
 423 <!-- ======================================================================= -->
 424 <h4>
 425   <a name="format_subprograms">Subprogram descriptors</a>
 426 </h4>
 427
 428 <div>
 429
 430 <div class="doc_code">
 431 <pre>
 432 !2 = metadata !{
 433   i32,      ;; Tag = 46 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a>
 434             ;; (DW_TAG_subprogram)
 435   i32,      ;; Unused field.
 436   metadata, ;; Reference to context descriptor
 437   metadata, ;; Name
 438   metadata, ;; Display name (fully qualified C++ name)
 439   metadata, ;; MIPS linkage name (for C++)
 440   metadata, ;; Reference to file where defined
 441   i32,      ;; Line number where defined
 442   metadata, ;; Reference to type descriptor
 443   i1,       ;; True if the global is local to compile unit (static)
 444   i1,       ;; True if the global is defined in the compile unit (not extern)
 445   i32,      ;; Virtuality, e.g. dwarf::DW_VIRTUALITY__virtual
 446   i32,      ;; Index into a virtual function
 447   metadata, ;; indicates which base type contains the vtable pointer for the
 448             ;; derived class
 449   i32,      ;; Flags - Artifical, Private, Protected, Explicit, Prototyped.
 450   i1,       ;; isOptimized
 451   Function *,;; Pointer to LLVM function
 452   metadata, ;; Lists function template parameters
 453   metadata  ;; Function declaration descriptor
 454   metadata  ;; List of function variables
 455 }
 456 </pre>
 457 </div>
 458
 459 <p>These descriptors provide debug information about functions, methods and
 460    subprograms.  They provide details such as name, return types and the source
 461    location where the subprogram is defined.
 462    All subprogram descriptors are collected by a named metadata
 463    <tt>!llvm.dbg.sp</tt>.
 464 </p>
 465
 466 </div>
 467
 468 <!-- ======================================================================= -->
 469 <h4>
 470   <a name="format_blocks">Block descriptors</a>
 471 </h4>
 472
 473 <div>
 474
 475 <div class="doc_code">
 476 <pre>
 477 !3 = metadata !{
 478   i32,     ;; Tag = 11 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> (DW_TAG_lexical_block)
 479   metadata,;; Reference to context descriptor
 480   i32,     ;; Line number
 481   i32,     ;; Column number
 482   metadata,;; Reference to source file
 483   i32      ;; Unique ID to identify blocks from a template function
 484 }
 485 </pre>
 486 </div>
 487
 488 <p>This descriptor provides debug information about nested blocks within a
 489    subprogram. The line number and column numbers are used to dinstinguish
 490    two lexical blocks at same depth. </p>
 491
 492 <div class="doc_code">
 493 <pre>
 494 !3 = metadata !{
 495   i32,     ;; Tag = 11 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> (DW_TAG_lexical_block)
 496   metadata ;; Reference to the scope we're annotating with a file change
 497   metadata,;; Reference to the file the scope is enclosed in.
 498 }
 499 </pre>
 500 </div>
 501
 502 <p>This descriptor provides a wrapper around a lexical scope to handle file
 503    changes in the middle of a lexical block.</p>
 504
 505 </div>
 506
 507 <!-- ======================================================================= -->
 508 <h4>
 509   <a name="format_basic_type">Basic type descriptors</a>
 510 </h4>
 511
 512 <div>
 513
 514 <div class="doc_code">
 515 <pre>
 516 !4 = metadata !{
 517   i32,      ;; Tag = 36 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a>
 518             ;; (DW_TAG_base_type)
 519   metadata, ;; Reference to context
 520   metadata, ;; Name (may be "" for anonymous types)
 521   metadata, ;; Reference to file where defined (may be NULL)
 522   i32,      ;; Line number where defined (may be 0)
 523   i64,      ;; Size in bits
 524   i64,      ;; Alignment in bits
 525   i64,      ;; Offset in bits
 526   i32,      ;; Flags
 527   i32       ;; DWARF type encoding
 528 }
 529 </pre>
 530 </div>
 531
 532 <p>These descriptors define primitive types used in the code. Example int, bool
 533    and float.  The context provides the scope of the type, which is usually the
 534    top level.  Since basic types are not usually user defined the context
 535    and line number can be left as NULL and 0.  The size, alignment and offset
 536    are expressed in bits and can be 64 bit values.  The alignment is used to
 537    round the offset when embedded in a
 538    <a href="#format_composite_type">composite type</a> (example to keep float
 539    doubles on 64 bit boundaries.) The offset is the bit offset if embedded in
 540    a <a href="#format_composite_type">composite type</a>.</p>
 541
 542 <p>The type encoding provides the details of the type.  The values are typically
 543    one of the following:</p>
 544
 545 <div class="doc_code">
 546 <pre>
 547 DW_ATE_address       = 1
 548 DW_ATE_boolean       = 2
 549 DW_ATE_float         = 4
 550 DW_ATE_signed        = 5
 551 DW_ATE_signed_char   = 6
 552 DW_ATE_unsigned      = 7
 553 DW_ATE_unsigned_char = 8
 554 </pre>
 555 </div>
 556
 557 </div>
 558
 559 <!-- ======================================================================= -->
 560 <h4>
 561   <a name="format_derived_type">Derived type descriptors</a>
 562 </h4>
 563
 564 <div>
 565
 566 <div class="doc_code">
 567 <pre>
 568 !5 = metadata !{
 569   i32,      ;; Tag (see below)
 570   metadata, ;; Reference to context
 571   metadata, ;; Name (may be "" for anonymous types)
 572   metadata, ;; Reference to file where defined (may be NULL)
 573   i32,      ;; Line number where defined (may be 0)
 574   i64,      ;; Size in bits
 575   i64,      ;; Alignment in bits
 576   i64,      ;; Offset in bits
 577   i32,      ;; Flags to encode attributes, e.g. private
 578   metadata, ;; Reference to type derived from
 579   metadata, ;; (optional) Name of the Objective C property associated with
 580             ;; Objective-C an ivar
 581   metadata, ;; (optional) Name of the Objective C property getter selector.
 582   metadata, ;; (optional) Name of the Objective C property setter selector.
 583   i32       ;; (optional) Objective C property attributes.
 584 }
 585 </pre>
 586 </div>
 587
 588 <p>These descriptors are used to define types derived from other types.  The
 589 value of the tag varies depending on the meaning.  The following are possible
 590 tag values:</p>
 591
 592 <div class="doc_code">
 593 <pre>
 594 DW_TAG_formal_parameter = 5
 595 DW_TAG_member           = 13
 596 DW_TAG_pointer_type     = 15
 597 DW_TAG_reference_type   = 16
 598 DW_TAG_typedef          = 22
 599 DW_TAG_const_type       = 38
 600 DW_TAG_volatile_type    = 53
 601 DW_TAG_restrict_type    = 55
 602 </pre>
 603 </div>
 604
 605 <p><tt>DW_TAG_member</tt> is used to define a member of
 606    a <a href="#format_composite_type">composite type</a>
 607    or <a href="#format_subprograms">subprogram</a>.  The type of the member is
 608    the <a href="#format_derived_type">derived
 609    type</a>. <tt>DW_TAG_formal_parameter</tt> is used to define a member which
 610    is a formal argument of a subprogram.</p>
 611
 612 <p><tt>DW_TAG_typedef</tt> is used to provide a name for the derived type.</p>
 613
 614 <p><tt>DW_TAG_pointer_type</tt>, <tt>DW_TAG_reference_type</tt>,
 615    <tt>DW_TAG_const_type</tt>, <tt>DW_TAG_volatile_type</tt> and
 616    <tt>DW_TAG_restrict_type</tt> are used to qualify
 617    the <a href="#format_derived_type">derived type</a>. </p>
 618
 619 <p><a href="#format_derived_type">Derived type</a> location can be determined
 620    from the context and line number.  The size, alignment and offset are
 621    expressed in bits and can be 64 bit values.  The alignment is used to round
 622    the offset when embedded in a <a href="#format_composite_type">composite
 623    type</a> (example to keep float doubles on 64 bit boundaries.) The offset is
 624    the bit offset if embedded in a <a href="#format_composite_type">composite
 625    type</a>.</p>
 626
 627 <p>Note that the <tt>void *</tt> type is expressed as a type derived from NULL.
 628 </p>
 629
 630 </div>
 631
 632 <!-- ======================================================================= -->
 633 <h4>
 634   <a name="format_composite_type">Composite type descriptors</a>
 635 </h4>
 636
 637 <div>
 638
 639 <div class="doc_code">
 640 <pre>
 641 !6 = metadata !{
 642   i32,      ;; Tag (see below)
 643   metadata, ;; Reference to context
 644   metadata, ;; Name (may be "" for anonymous types)
 645   metadata, ;; Reference to file where defined (may be NULL)
 646   i32,      ;; Line number where defined (may be 0)
 647   i64,      ;; Size in bits
 648   i64,      ;; Alignment in bits
 649   i64,      ;; Offset in bits
 650   i32,      ;; Flags
 651   metadata, ;; Reference to type derived from
 652   metadata, ;; Reference to array of member descriptors
 653   i32       ;; Runtime languages
 654 }
 655 </pre>
 656 </div>
 657
 658 <p>These descriptors are used to define types that are composed of 0 or more
 659 elements.  The value of the tag varies depending on the meaning.  The following
 660 are possible tag values:</p>
 661
 662 <div class="doc_code">
 663 <pre>
 664 DW_TAG_array_type       = 1
 665 DW_TAG_enumeration_type = 4
 666 DW_TAG_structure_type   = 19
 667 DW_TAG_union_type       = 23
 668 DW_TAG_vector_type      = 259
 669 DW_TAG_subroutine_type  = 21
 670 DW_TAG_inheritance      = 28
 671 </pre>
 672 </div>
 673
 674 <p>The vector flag indicates that an array type is a native packed vector.</p>
 675
 676 <p>The members of array types (tag = <tt>DW_TAG_array_type</tt>) or vector types
 677    (tag = <tt>DW_TAG_vector_type</tt>) are <a href="#format_subrange">subrange
 678    descriptors</a>, each representing the range of subscripts at that level of
 679    indexing.</p>
 680
 681 <p>The members of enumeration types (tag = <tt>DW_TAG_enumeration_type</tt>) are
 682    <a href="#format_enumeration">enumerator descriptors</a>, each representing
 683    the definition of enumeration value for the set. All enumeration type
 684    descriptors are collected by named metadata <tt>!llvm.dbg.enum</tt>.</p>
 685
 686 <p>The members of structure (tag = <tt>DW_TAG_structure_type</tt>) or union (tag
 687    = <tt>DW_TAG_union_type</tt>) types are any one of
 688    the <a href="#format_basic_type">basic</a>,
 689    <a href="#format_derived_type">derived</a>
 690    or <a href="#format_composite_type">composite</a> type descriptors, each
 691    representing a field member of the structure or union.</p>
 692
 693 <p>For C++ classes (tag = <tt>DW_TAG_structure_type</tt>), member descriptors
 694    provide information about base classes, static members and member
 695    functions. If a member is a <a href="#format_derived_type">derived type
 696    descriptor</a> and has a tag of <tt>DW_TAG_inheritance</tt>, then the type
 697    represents a base class. If the member of is
 698    a <a href="#format_global_variables">global variable descriptor</a> then it
 699    represents a static member.  And, if the member is
 700    a <a href="#format_subprograms">subprogram descriptor</a> then it represents
 701    a member function.  For static members and member
 702    functions, <tt>getName()</tt> returns the members link or the C++ mangled
 703    name.  <tt>getDisplayName()</tt> the simplied version of the name.</p>
 704
 705 <p>The first member of subroutine (tag = <tt>DW_TAG_subroutine_type</tt>) type
 706    elements is the return type for the subroutine.  The remaining elements are
 707    the formal arguments to the subroutine.</p>
 708
 709 <p><a href="#format_composite_type">Composite type</a> location can be
 710    determined from the context and line number.  The size, alignment and
 711    offset are expressed in bits and can be 64 bit values.  The alignment is used
 712    to round the offset when embedded in
 713    a <a href="#format_composite_type">composite type</a> (as an example, to keep
 714    float doubles on 64 bit boundaries.) The offset is the bit offset if embedded
 715    in a <a href="#format_composite_type">composite type</a>.</p>
 716
 717 </div>
 718
 719 <!-- ======================================================================= -->
 720 <h4>
 721   <a name="format_subrange">Subrange descriptors</a>
 722 </h4>
 723
 724 <div>
 725
 726 <div class="doc_code">
 727 <pre>
 728 !42 = metadata !{
 729   i32,    ;; Tag = 33 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> (DW_TAG_subrange_type)
 730   i64,    ;; Low value
 731   i64     ;; High value
 732 }
 733 </pre>
 734 </div>
 735
 736 <p>These descriptors are used to define ranges of array subscripts for an array
 737    <a href="#format_composite_type">composite type</a>.  The low value defines
 738    the lower bounds typically zero for C/C++.  The high value is the upper
 739    bounds.  Values are 64 bit.  High - low + 1 is the size of the array.  If low
 740    > high the array bounds are not included in generated debugging information.
 741 </p>
 742
 743 </div>
 744
 745 <!-- ======================================================================= -->
 746 <h4>
 747   <a name="format_enumeration">Enumerator descriptors</a>
 748 </h4>
 749
 750 <div>
 751
 752 <div class="doc_code">
 753 <pre>
 754 !6 = metadata !{
 755   i32,      ;; Tag = 40 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a>
 756             ;; (DW_TAG_enumerator)
 757   metadata, ;; Name
 758   i64       ;; Value
 759 }
 760 </pre>
 761 </div>
 762
 763 <p>These descriptors are used to define members of an
 764    enumeration <a href="#format_composite_type">composite type</a>, it
 765    associates the name to the value.</p>
 766
 767 </div>
 768
 769 <!-- ======================================================================= -->
 770 <h4>
 771   <a name="format_variables">Local variables</a>
 772 </h4>
 773
 774 <div>
 775
 776 <div class="doc_code">
 777 <pre>
 778 !7 = metadata !{
 779   i32,      ;; Tag (see below)
 780   metadata, ;; Context
 781   metadata, ;; Name
 782   metadata, ;; Reference to file where defined
 783   i32,      ;; 24 bit - Line number where defined
 784             ;; 8 bit - Argument number. 1 indicates 1st argument.
 785   metadata, ;; Type descriptor
 786   i32,      ;; flags
 787   metadata  ;; (optional) Reference to inline location
 788 }
 789 </pre>
 790 </div>
 791
 792 <p>These descriptors are used to define variables local to a sub program.  The
 793    value of the tag depends on the usage of the variable:</p>
 794
 795 <div class="doc_code">
 796 <pre>
 797 DW_TAG_auto_variable   = 256
 798 DW_TAG_arg_variable    = 257
 799 DW_TAG_return_variable = 258
 800 </pre>
 801 </div>
 802
 803 <p>An auto variable is any variable declared in the body of the function.  An
 804    argument variable is any variable that appears as a formal argument to the
 805    function.  A return variable is used to track the result of a function and
 806    has no source correspondent.</p>
 807
 808 <p>The context is either the subprogram or block where the variable is defined.
 809    Name the source variable name.  Context and line indicate where the
 810    variable was defined. Type descriptor defines the declared type of the
 811    variable.</p>
 812
 813 </div>
 814
 815 </div>
 816
 817 <!-- ======================================================================= -->
 818 <h3>
 819   <a name="format_common_intrinsics">Debugger intrinsic functions</a>
 820 </h3>
 821
 822 <div>
 823
 824 <p>LLVM uses several intrinsic functions (name prefixed with "llvm.dbg") to
 825    provide debug information at various points in generated code.</p>
 826
 827 <!-- ======================================================================= -->
 828 <h4>
 829   <a name="format_common_declare">llvm.dbg.declare</a>
 830 </h4>
 831
 832 <div>
 833 <pre>
 834   void %<a href="#format_common_declare">llvm.dbg.declare</a>(metadata, metadata)
 835 </pre>
 836
 837 <p>This intrinsic provides information about a local element (ex. variable.) The
 838    first argument is metadata holding alloca for the variable. The
 839    second argument is metadata containing description of the variable. </p>
 840 </div>
 841
 842 <!-- ======================================================================= -->
 843 <h4>
 844   <a name="format_common_value">llvm.dbg.value</a>
 845 </h4>
 846
 847 <div>
 848 <pre>
 849   void %<a href="#format_common_value">llvm.dbg.value</a>(metadata, i64, metadata)
 850 </pre>
 851
 852 <p>This intrinsic provides information when a user source variable is set to a
 853    new value.  The first argument is the new value (wrapped as metadata).  The
 854    second argument is the offset in the user source variable where the new value
 855    is written.  The third argument is metadata containing description of the
 856    user source variable. </p>
 857 </div>
 858
 859 </div>
 860
 861 <!-- ======================================================================= -->
 862 <h3>
 863   <a name="format_common_lifetime">Object lifetimes and scoping</a>
 864 </h3>
 865
 866 <div>
 867 <p>In many languages, the local variables in functions can have their lifetimes
 868    or scopes limited to a subset of a function.  In the C family of languages,
 869    for example, variables are only live (readable and writable) within the
 870    source block that they are defined in.  In functional languages, values are
 871    only readable after they have been defined.  Though this is a very obvious
 872    concept, it is non-trivial to model in LLVM, because it has no notion of
 873    scoping in this sense, and does not want to be tied to a language's scoping
 874    rules.</p>
 875
 876 <p>In order to handle this, the LLVM debug format uses the metadata attached to
 877    llvm instructions to encode line number and scoping information. Consider
 878    the following C fragment, for example:</p>
 879
 880 <div class="doc_code">
 881 <pre>
 882 1.  void foo() {
 883 2.    int X = 21;
 884 3.    int Y = 22;
 885 4.    {
 886 5.      int Z = 23;
 887 6.      Z = X;
 888 7.    }
 889 8.    X = Y;
 890 9.  }
 891 </pre>
 892 </div>
 893
 894 <p>Compiled to LLVM, this function would be represented like this:</p>
 895
 896 <div class="doc_code">
 897 <pre>
 898 define void @foo() nounwind ssp {
 899 entry:
 900   %X = alloca i32, align 4                        ; &lt;i32*&gt; [#uses=4]
 901   %Y = alloca i32, align 4                        ; &lt;i32*&gt; [#uses=4]
 902   %Z = alloca i32, align 4                        ; &lt;i32*&gt; [#uses=3]
 903   %0 = bitcast i32* %X to {}*                     ; &lt;{}*&gt; [#uses=1]
 904   call void @llvm.dbg.declare(metadata !{i32 * %X}, metadata !0), !dbg !7
 905   store i32 21, i32* %X, !dbg !8
 906   %1 = bitcast i32* %Y to {}*                     ; &lt;{}*&gt; [#uses=1]
 907   call void @llvm.dbg.declare(metadata !{i32 * %Y}, metadata !9), !dbg !10
 908   store i32 22, i32* %Y, !dbg !11
 909   %2 = bitcast i32* %Z to {}*                     ; &lt;{}*&gt; [#uses=1]
 910   call void @llvm.dbg.declare(metadata !{i32 * %Z}, metadata !12), !dbg !14
 911   store i32 23, i32* %Z, !dbg !15
 912   %tmp = load i32* %X, !dbg !16                   ; &lt;i32&gt; [#uses=1]
 913   %tmp1 = load i32* %Y, !dbg !16                  ; &lt;i32&gt; [#uses=1]
 914   %add = add nsw i32 %tmp, %tmp1, !dbg !16        ; &lt;i32&gt; [#uses=1]
 915   store i32 %add, i32* %Z, !dbg !16
 916   %tmp2 = load i32* %Y, !dbg !17                  ; &lt;i32&gt; [#uses=1]
 917   store i32 %tmp2, i32* %X, !dbg !17
 918   ret void, !dbg !18
 919 }
 920
 921 declare void @llvm.dbg.declare(metadata, metadata) nounwind readnone
 922
 923 !0 = metadata !{i32 459008, metadata !1, metadata !"X",
 924                 metadata !3, i32 2, metadata !6}; [ DW_TAG_auto_variable ]
 925 !1 = metadata !{i32 458763, metadata !2}; [DW_TAG_lexical_block ]
 926 !2 = metadata !{i32 458798, i32 0, metadata !3, metadata !"foo", metadata !"foo",
 927                metadata !"foo", metadata !3, i32 1, metadata !4,
 928                i1 false, i1 true}; [DW_TAG_subprogram ]
 929 !3 = metadata !{i32 458769, i32 0, i32 12, metadata !"foo.c",
 930                 metadata !"/private/tmp", metadata !"clang 1.1", i1 true,
 931                 i1 false, metadata !"", i32 0}; [DW_TAG_compile_unit ]
 932 !4 = metadata !{i32 458773, metadata !3, metadata !"", null, i32 0, i64 0, i64 0,
 933                 i64 0, i32 0, null, metadata !5, i32 0}; [DW_TAG_subroutine_type ]
 934 !5 = metadata !{null}
 935 !6 = metadata !{i32 458788, metadata !3, metadata !"int", metadata !3, i32 0,
 936                 i64 32, i64 32, i64 0, i32 0, i32 5}; [DW_TAG_base_type ]
 937 !7 = metadata !{i32 2, i32 7, metadata !1, null}
 938 !8 = metadata !{i32 2, i32 3, metadata !1, null}
 939 !9 = metadata !{i32 459008, metadata !1, metadata !"Y", metadata !3, i32 3,
 940                 metadata !6}; [ DW_TAG_auto_variable ]
 941 !10 = metadata !{i32 3, i32 7, metadata !1, null}
 942 !11 = metadata !{i32 3, i32 3, metadata !1, null}
 943 !12 = metadata !{i32 459008, metadata !13, metadata !"Z", metadata !3, i32 5,
 944                  metadata !6}; [ DW_TAG_auto_variable ]
 945 !13 = metadata !{i32 458763, metadata !1}; [DW_TAG_lexical_block ]
 946 !14 = metadata !{i32 5, i32 9, metadata !13, null}
 947 !15 = metadata !{i32 5, i32 5, metadata !13, null}
 948 !16 = metadata !{i32 6, i32 5, metadata !13, null}
 949 !17 = metadata !{i32 8, i32 3, metadata !1, null}
 950 !18 = metadata !{i32 9, i32 1, metadata !2, null}
 951 </pre>
 952 </div>
 953
 954 <p>This example illustrates a few important details about LLVM debugging
 955    information. In particular, it shows how the <tt>llvm.dbg.declare</tt>
 956    intrinsic and location information, which are attached to an instruction,
 957    are applied together to allow a debugger to analyze the relationship between
 958    statements, variable definitions, and the code used to implement the
 959    function.</p>
 960
 961 <div class="doc_code">
 962 <pre>
 963 call void @llvm.dbg.declare(metadata, metadata !0), !dbg !7
 964 </pre>
 965 </div>
 966
 967 <p>The first intrinsic
 968    <tt>%<a href="#format_common_declare">llvm.dbg.declare</a></tt>
 969    encodes debugging information for the variable <tt>X</tt>. The metadata
 970    <tt>!dbg !7</tt> attached to the intrinsic provides scope information for the
 971    variable <tt>X</tt>.</p>
 972
 973 <div class="doc_code">
 974 <pre>
 975 !7 = metadata !{i32 2, i32 7, metadata !1, null}
 976 !1 = metadata !{i32 458763, metadata !2}; [DW_TAG_lexical_block ]
 977 !2 = metadata !{i32 458798, i32 0, metadata !3, metadata !"foo",
 978                 metadata !"foo", metadata !"foo", metadata !3, i32 1,
 979                 metadata !4, i1 false, i1 true}; [DW_TAG_subprogram ]
 980 </pre>
 981 </div>
 982
 983 <p>Here <tt>!7</tt> is metadata providing location information. It has four
 984    fields: line number, column number, scope, and original scope. The original
 985    scope represents inline location if this instruction is inlined inside a
 986    caller, and is null otherwise. In this example, scope is encoded by
 987    <tt>!1</tt>. <tt>!1</tt> represents a lexical block inside the scope
 988    <tt>!2</tt>, where <tt>!2</tt> is a
 989    <a href="#format_subprograms">subprogram descriptor</a>. This way the
 990    location information attached to the intrinsics indicates that the
 991    variable <tt>X</tt> is declared at line number 2 at a function level scope in
 992    function <tt>foo</tt>.</p>
 993
 994 <p>Now lets take another example.</p>
 995
 996 <div class="doc_code">
 997 <pre>
 998 call void @llvm.dbg.declare(metadata, metadata !12), !dbg !14
 999 </pre>
1000 </div>
1001
1002 <p>The second intrinsic
1003    <tt>%<a href="#format_common_declare">llvm.dbg.declare</a></tt>
1004    encodes debugging information for variable <tt>Z</tt>. The metadata
1005    <tt>!dbg !14</tt> attached to the intrinsic provides scope information for
1006    the variable <tt>Z</tt>.</p>
1007
1008 <div class="doc_code">
1009 <pre>
1010 !13 = metadata !{i32 458763, metadata !1}; [DW_TAG_lexical_block ]
1011 !14 = metadata !{i32 5, i32 9, metadata !13, null}
1012 </pre>
1013 </div>
1014
1015 <p>Here <tt>!14</tt> indicates that <tt>Z</tt> is declared at line number 5 and
1016    column number 9 inside of lexical scope <tt>!13</tt>. The lexical scope
1017    itself resides inside of lexical scope <tt>!1</tt> described above.</p>
1018
1019 <p>The scope information attached with each instruction provides a
1020    straightforward way to find instructions covered by a scope.</p>
1021
1022 </div>
1023
1024 </div>
1025
1026 <!-- *********************************************************************** -->
1027 <h2>
1028   <a name="ccxx_frontend">C/C++ front-end specific debug information</a>
1029 </h2>
1030 <!-- *********************************************************************** -->
1031
1032 <div>
1033
1034 <p>The C and C++ front-ends represent information about the program in a format
1035    that is effectively identical
1036    to <a href="http://www.eagercon.com/dwarf/dwarf3std.htm">DWARF 3.0</a> in
1037    terms of information content.  This allows code generators to trivially
1038    support native debuggers by generating standard dwarf information, and
1039    contains enough information for non-dwarf targets to translate it as
1040    needed.</p>
1041
1042 <p>This section describes the forms used to represent C and C++ programs. Other
1043    languages could pattern themselves after this (which itself is tuned to
1044    representing programs in the same way that DWARF 3 does), or they could
1045    choose to provide completely different forms if they don't fit into the DWARF
1046    model.  As support for debugging information gets added to the various LLVM
1047    source-language front-ends, the information used should be documented
1048    here.</p>
1049
1050 <p>The following sections provide examples of various C/C++ constructs and the
1051    debug information that would best describe those constructs.</p>
1052
1053 <!-- ======================================================================= -->
1054 <h3>
1055   <a name="ccxx_compile_units">C/C++ source file information</a>
1056 </h3>
1057
1058 <div>
1059
1060 <p>Given the source files <tt>MySource.cpp</tt> and <tt>MyHeader.h</tt> located
1061    in the directory <tt>/Users/mine/sources</tt>, the following code:</p>
1062
1063 <div class="doc_code">
1064 <pre>
1065 #include "MyHeader.h"
1066
1067 int main(int argc, char *argv[]) {
1068   return 0;
1069 }
1070 </pre>
1071 </div>
1072
1073 <p>a C/C++ front-end would generate the following descriptors:</p>
1074
1075 <div class="doc_code">
1076 <pre>
1077 ...
1078 ;;
1079 ;; Define the compile unit for the main source file "/Users/mine/sources/MySource.cpp".
1080 ;;
1081 !2 = metadata !{
1082   i32 524305,    ;; Tag
1083   i32 0,         ;; Unused
1084   i32 4,         ;; Language Id
1085   metadata !"MySource.cpp",
1086   metadata !"/Users/mine/sources",
1087   metadata !"4.2.1 (Based on Apple Inc. build 5649) (LLVM build 00)",
1088   i1 true,       ;; Main Compile Unit
1089   i1 false,      ;; Optimized compile unit
1090   metadata !"",  ;; Compiler flags
1091   i32 0}         ;; Runtime version
1092
1093 ;;
1094 ;; Define the file for the file "/Users/mine/sources/MySource.cpp".
1095 ;;
1096 !1 = metadata !{
1097   i32 524329,    ;; Tag
1098   metadata !"MySource.cpp",
1099   metadata !"/Users/mine/sources",
1100   metadata !2    ;; Compile unit
1101 }
1102
1103 ;;
1104 ;; Define the file for the file "/Users/mine/sources/Myheader.h"
1105 ;;
1106 !3 = metadata !{
1107   i32 524329,    ;; Tag
1108   metadata !"Myheader.h"
1109   metadata !"/Users/mine/sources",
1110   metadata !2    ;; Compile unit
1111 }
1112
1113 ...
1114 </pre>
1115 </div>
1116
1117 <p>llvm::Instruction provides easy access to metadata attached with an
1118 instruction. One can extract line number information encoded in LLVM IR
1119 using <tt>Instruction::getMetadata()</tt> and
1120 <tt>DILocation::getLineNumber()</tt>.
1121 <pre>
1122  if (MDNode *N = I->getMetadata("dbg")) {  // Here I is an LLVM instruction
1123    DILocation Loc(N);                      // DILocation is in DebugInfo.h
1124    unsigned Line = Loc.getLineNumber();
1125    StringRef File = Loc.getFilename();
1126    StringRef Dir = Loc.getDirectory();
1127  }
1128 </pre>
1129 </div>
1130
1131 <!-- ======================================================================= -->
1132 <h3>
1133   <a name="ccxx_global_variable">C/C++ global variable information</a>
1134 </h3>
1135
1136 <div>
1137
1138 <p>Given an integer global variable declared as follows:</p>
1139
1140 <div class="doc_code">
1141 <pre>
1142 int MyGlobal = 100;
1143 </pre>
1144 </div>
1145
1146 <p>a C/C++ front-end would generate the following descriptors:</p>
1147
1148 <div class="doc_code">
1149 <pre>
1150 ;;
1151 ;; Define the global itself.
1152 ;;
1153 %MyGlobal = global int 100
1154 ...
1155 ;;
1156 ;; List of debug info of globals
1157 ;;
1158 !llvm.dbg.gv = !{!0}
1159
1160 ;;
1161 ;; Define the global variable descriptor.  Note the reference to the global
1162 ;; variable anchor and the global variable itself.
1163 ;;
1164 !0 = metadata !{
1165   i32 524340,              ;; Tag
1166   i32 0,                   ;; Unused
1167   metadata !1,             ;; Context
1168   metadata !"MyGlobal",    ;; Name
1169   metadata !"MyGlobal",    ;; Display Name
1170   metadata !"MyGlobal",    ;; Linkage Name
1171   metadata !3,             ;; Compile Unit
1172   i32 1,                   ;; Line Number
1173   metadata !4,             ;; Type
1174   i1 false,                ;; Is a local variable
1175   i1 true,                 ;; Is this a definition
1176   i32* @MyGlobal           ;; The global variable
1177 }
1178
1179 ;;
1180 ;; Define the basic type of 32 bit signed integer.  Note that since int is an
1181 ;; intrinsic type the source file is NULL and line 0.
1182 ;;
1183 !4 = metadata !{
1184   i32 524324,              ;; Tag
1185   metadata !1,             ;; Context
1186   metadata !"int",         ;; Name
1187   metadata !1,             ;; File
1188   i32 0,                   ;; Line number
1189   i64 32,                  ;; Size in Bits
1190   i64 32,                  ;; Align in Bits
1191   i64 0,                   ;; Offset in Bits
1192   i32 0,                   ;; Flags
1193   i32 5                    ;; Encoding
1194 }
1195
1196 </pre>
1197 </div>
1198
1199 </div>
1200
1201 <!-- ======================================================================= -->
1202 <h3>
1203   <a name="ccxx_subprogram">C/C++ function information</a>
1204 </h3>
1205
1206 <div>
1207
1208 <p>Given a function declared as follows:</p>
1209
1210 <div class="doc_code">
1211 <pre>
1212 int main(int argc, char *argv[]) {
1213   return 0;
1214 }
1215 </pre>
1216 </div>
1217
1218 <p>a C/C++ front-end would generate the following descriptors:</p>
1219
1220 <div class="doc_code">
1221 <pre>
1222 ;;
1223 ;; Define the anchor for subprograms.  Note that the second field of the
1224 ;; anchor is 46, which is the same as the tag for subprograms
1225 ;; (46 = DW_TAG_subprogram.)
1226 ;;
1227 !6 = metadata !{
1228   i32 524334,        ;; Tag
1229   i32 0,             ;; Unused
1230   metadata !1,       ;; Context
1231   metadata !"main",  ;; Name
1232   metadata !"main",  ;; Display name
1233   metadata !"main",  ;; Linkage name
1234   metadata !1,       ;; File
1235   i32 1,             ;; Line number
1236   metadata !4,       ;; Type
1237   i1 false,          ;; Is local
1238   i1 true,           ;; Is definition
1239   i32 0,             ;; Virtuality attribute, e.g. pure virtual function
1240   i32 0,             ;; Index into virtual table for C++ methods
1241   i32 0,             ;; Type that holds virtual table.
1242   i32 0,             ;; Flags
1243   i1 false,          ;; True if this function is optimized
1244   Function *,        ;; Pointer to llvm::Function
1245   null               ;; Function template parameters
1246 }
1247 ;;
1248 ;; Define the subprogram itself.
1249 ;;
1250 define i32 @main(i32 %argc, i8** %argv) {
1251 ...
1252 }
1253 </pre>
1254 </div>
1255
1256 </div>
1257
1258 <!-- ======================================================================= -->
1259 <h3>
1260   <a name="ccxx_basic_types">C/C++ basic types</a>
1261 </h3>
1262
1263 <div>
1264
1265 <p>The following are the basic type descriptors for C/C++ core types:</p>
1266
1267 <!-- ======================================================================= -->
1268 <h4>
1269   <a name="ccxx_basic_type_bool">bool</a>
1270 </h4>
1271
1272 <div>
1273
1274 <div class="doc_code">
1275 <pre>
1276 !2 = metadata !{
1277   i32 524324,        ;; Tag
1278   metadata !1,       ;; Context
1279   metadata !"bool",  ;; Name
1280   metadata !1,       ;; File
1281   i32 0,             ;; Line number
1282   i64 8,             ;; Size in Bits
1283   i64 8,             ;; Align in Bits
1284   i64 0,             ;; Offset in Bits
1285   i32 0,             ;; Flags
1286   i32 2              ;; Encoding
1287 }
1288 </pre>
1289 </div>
1290
1291 </div>
1292
1293 <!-- ======================================================================= -->
1294 <h4>
1295   <a name="ccxx_basic_char">char</a>
1296 </h4>
1297
1298 <div>
1299
1300 <div class="doc_code">
1301 <pre>
1302 !2 = metadata !{
1303   i32 524324,        ;; Tag
1304   metadata !1,       ;; Context
1305   metadata !"char",  ;; Name
1306   metadata !1,       ;; File
1307   i32 0,             ;; Line number
1308   i64 8,             ;; Size in Bits
1309   i64 8,             ;; Align in Bits
1310   i64 0,             ;; Offset in Bits
1311   i32 0,             ;; Flags
1312   i32 6              ;; Encoding
1313 }
1314 </pre>
1315 </div>
1316
1317 </div>
1318
1319 <!-- ======================================================================= -->
1320 <h4>
1321   <a name="ccxx_basic_unsigned_char">unsigned char</a>
1322 </h4>
1323
1324 <div>
1325
1326 <div class="doc_code">
1327 <pre>
1328 !2 = metadata !{
1329   i32 524324,        ;; Tag
1330   metadata !1,       ;; Context
1331   metadata !"unsigned char",
1332   metadata !1,       ;; File
1333   i32 0,             ;; Line number
1334   i64 8,             ;; Size in Bits
1335   i64 8,             ;; Align in Bits
1336   i64 0,             ;; Offset in Bits
1337   i32 0,             ;; Flags
1338   i32 8              ;; Encoding
1339 }
1340 </pre>
1341 </div>
1342
1343 </div>
1344
1345 <!-- ======================================================================= -->
1346 <h4>
1347   <a name="ccxx_basic_short">short</a>
1348 </h4>
1349
1350 <div>
1351
1352 <div class="doc_code">
1353 <pre>
1354 !2 = metadata !{
1355   i32 524324,        ;; Tag
1356   metadata !1,       ;; Context
1357   metadata !"short int",
1358   metadata !1,       ;; File
1359   i32 0,             ;; Line number
1360   i64 16,            ;; Size in Bits
1361   i64 16,            ;; Align in Bits
1362   i64 0,             ;; Offset in Bits
1363   i32 0,             ;; Flags
1364   i32 5              ;; Encoding
1365 }
1366 </pre>
1367 </div>
1368
1369 </div>
1370
1371 <!-- ======================================================================= -->
1372 <h4>
1373   <a name="ccxx_basic_unsigned_short">unsigned short</a>
1374 </h4>
1375
1376 <div>
1377
1378 <div class="doc_code">
1379 <pre>
1380 !2 = metadata !{
1381   i32 524324,        ;; Tag
1382   metadata !1,       ;; Context
1383   metadata !"short unsigned int",
1384   metadata !1,       ;; File
1385   i32 0,             ;; Line number
1386   i64 16,            ;; Size in Bits
1387   i64 16,            ;; Align in Bits
1388   i64 0,             ;; Offset in Bits
1389   i32 0,             ;; Flags
1390   i32 7              ;; Encoding
1391 }
1392 </pre>
1393 </div>
1394
1395 </div>
1396
1397 <!-- ======================================================================= -->
1398 <h4>
1399   <a name="ccxx_basic_int">int</a>
1400 </h4>
1401
1402 <div>
1403
1404 <div class="doc_code">
1405 <pre>
1406 !2 = metadata !{
1407   i32 524324,        ;; Tag
1408   metadata !1,       ;; Context
1409   metadata !"int",   ;; Name
1410   metadata !1,       ;; File
1411   i32 0,             ;; Line number
1412   i64 32,            ;; Size in Bits
1413   i64 32,            ;; Align in Bits
1414   i64 0,             ;; Offset in Bits
1415   i32 0,             ;; Flags
1416   i32 5              ;; Encoding
1417 }
1418 </pre></div>
1419
1420 </div>
1421
1422 <!-- ======================================================================= -->
1423 <h4>
1424   <a name="ccxx_basic_unsigned_int">unsigned int</a>
1425 </h4>
1426
1427 <div>
1428
1429 <div class="doc_code">
1430 <pre>
1431 !2 = metadata !{
1432   i32 524324,        ;; Tag
1433   metadata !1,       ;; Context
1434   metadata !"unsigned int",
1435   metadata !1,       ;; File
1436   i32 0,             ;; Line number
1437   i64 32,            ;; Size in Bits
1438   i64 32,            ;; Align in Bits
1439   i64 0,             ;; Offset in Bits
1440   i32 0,             ;; Flags
1441   i32 7              ;; Encoding
1442 }
1443 </pre>
1444 </div>
1445
1446 </div>
1447
1448 <!-- ======================================================================= -->
1449 <h4>
1450   <a name="ccxx_basic_long_long">long long</a>
1451 </h4>
1452
1453 <div>
1454
1455 <div class="doc_code">
1456 <pre>
1457 !2 = metadata !{
1458   i32 524324,        ;; Tag
1459   metadata !1,       ;; Context
1460   metadata !"long long int",
1461   metadata !1,       ;; File
1462   i32 0,             ;; Line number
1463   i64 64,            ;; Size in Bits
1464   i64 64,            ;; Align in Bits
1465   i64 0,             ;; Offset in Bits
1466   i32 0,             ;; Flags
1467   i32 5              ;; Encoding
1468 }
1469 </pre>
1470 </div>
1471
1472 </div>
1473
1474 <!-- ======================================================================= -->
1475 <h4>
1476   <a name="ccxx_basic_unsigned_long_long">unsigned long long</a>
1477 </h4>
1478
1479 <div>
1480
1481 <div class="doc_code">
1482 <pre>
1483 !2 = metadata !{
1484   i32 524324,        ;; Tag
1485   metadata !1,       ;; Context
1486   metadata !"long long unsigned int",
1487   metadata !1,       ;; File
1488   i32 0,             ;; Line number
1489   i64 64,            ;; Size in Bits
1490   i64 64,            ;; Align in Bits
1491   i64 0,             ;; Offset in Bits
1492   i32 0,             ;; Flags
1493   i32 7              ;; Encoding
1494 }
1495 </pre>
1496 </div>
1497
1498 </div>
1499
1500 <!-- ======================================================================= -->
1501 <h4>
1502   <a name="ccxx_basic_float">float</a>
1503 </h4>
1504
1505 <div>
1506
1507 <div class="doc_code">
1508 <pre>
1509 !2 = metadata !{
1510   i32 524324,        ;; Tag
1511   metadata !1,       ;; Context
1512   metadata !"float",
1513   metadata !1,       ;; File
1514   i32 0,             ;; Line number
1515   i64 32,            ;; Size in Bits
1516   i64 32,            ;; Align in Bits
1517   i64 0,             ;; Offset in Bits
1518   i32 0,             ;; Flags
1519   i32 4              ;; Encoding
1520 }
1521 </pre>
1522 </div>
1523
1524 </div>
1525
1526 <!-- ======================================================================= -->
1527 <h4>
1528   <a name="ccxx_basic_double">double</a>
1529 </h4>
1530
1531 <div>
1532
1533 <div class="doc_code">
1534 <pre>
1535 !2 = metadata !{
1536   i32 524324,        ;; Tag
1537   metadata !1,       ;; Context
1538   metadata !"double",;; Name
1539   metadata !1,       ;; File
1540   i32 0,             ;; Line number
1541   i64 64,            ;; Size in Bits
1542   i64 64,            ;; Align in Bits
1543   i64 0,             ;; Offset in Bits
1544   i32 0,             ;; Flags
1545   i32 4              ;; Encoding
1546 }
1547 </pre>
1548 </div>
1549
1550 </div>
1551
1552 </div>
1553
1554 <!-- ======================================================================= -->
1555 <h3>
1556   <a name="ccxx_derived_types">C/C++ derived types</a>
1557 </h3>
1558
1559 <div>
1560
1561 <p>Given the following as an example of C/C++ derived type:</p>
1562
1563 <div class="doc_code">
1564 <pre>
1565 typedef const int *IntPtr;
1566 </pre>
1567 </div>
1568
1569 <p>a C/C++ front-end would generate the following descriptors:</p>
1570
1571 <div class="doc_code">
1572 <pre>
1573 ;;
1574 ;; Define the typedef "IntPtr".
1575 ;;
1576 !2 = metadata !{
1577   i32 524310,          ;; Tag
1578   metadata !1,         ;; Context
1579   metadata !"IntPtr",  ;; Name
1580   metadata !3,         ;; File
1581   i32 0,               ;; Line number
1582   i64 0,               ;; Size in bits
1583   i64 0,               ;; Align in bits
1584   i64 0,               ;; Offset in bits
1585   i32 0,               ;; Flags
1586   metadata !4          ;; Derived From type
1587 }
1588
1589 ;;
1590 ;; Define the pointer type.
1591 ;;
1592 !4 = metadata !{
1593   i32 524303,          ;; Tag
1594   metadata !1,         ;; Context
1595   metadata !"",        ;; Name
1596   metadata !1,         ;; File
1597   i32 0,               ;; Line number
1598   i64 64,              ;; Size in bits
1599   i64 64,              ;; Align in bits
1600   i64 0,               ;; Offset in bits
1601   i32 0,               ;; Flags
1602   metadata !5          ;; Derived From type
1603 }
1604 ;;
1605 ;; Define the const type.
1606 ;;
1607 !5 = metadata !{
1608   i32 524326,          ;; Tag
1609   metadata !1,         ;; Context
1610   metadata !"",        ;; Name
1611   metadata !1,         ;; File
1612   i32 0,               ;; Line number
1613   i64 32,              ;; Size in bits
1614   i64 32,              ;; Align in bits
1615   i64 0,               ;; Offset in bits
1616   i32 0,               ;; Flags
1617   metadata !6          ;; Derived From type
1618 }
1619 ;;
1620 ;; Define the int type.
1621 ;;
1622 !6 = metadata !{
1623   i32 524324,          ;; Tag
1624   metadata !1,         ;; Context
1625   metadata !"int",     ;; Name
1626   metadata !1,         ;; File
1627   i32 0,               ;; Line number
1628   i64 32,              ;; Size in bits
1629   i64 32,              ;; Align in bits
1630   i64 0,               ;; Offset in bits
1631   i32 0,               ;; Flags
1632   5                    ;; Encoding
1633 }
1634 </pre>
1635 </div>
1636
1637 </div>
1638
1639 <!-- ======================================================================= -->
1640 <h3>
1641   <a name="ccxx_composite_types">C/C++ struct/union types</a>
1642 </h3>
1643
1644 <div>
1645
1646 <p>Given the following as an example of C/C++ struct type:</p>
1647
1648 <div class="doc_code">
1649 <pre>
1650 struct Color {
1651   unsigned Red;
1652   unsigned Green;
1653   unsigned Blue;
1654 };
1655 </pre>
1656 </div>
1657
1658 <p>a C/C++ front-end would generate the following descriptors:</p>
1659
1660 <div class="doc_code">
1661 <pre>
1662 ;;
1663 ;; Define basic type for unsigned int.
1664 ;;
1665 !5 = metadata !{
1666   i32 524324,        ;; Tag
1667   metadata !1,       ;; Context
1668   metadata !"unsigned int",
1669   metadata !1,       ;; File
1670   i32 0,             ;; Line number
1671   i64 32,            ;; Size in Bits
1672   i64 32,            ;; Align in Bits
1673   i64 0,             ;; Offset in Bits
1674   i32 0,             ;; Flags
1675   i32 7              ;; Encoding
1676 }
1677 ;;
1678 ;; Define composite type for struct Color.
1679 ;;
1680 !2 = metadata !{
1681   i32 524307,        ;; Tag
1682   metadata !1,       ;; Context
1683   metadata !"Color", ;; Name
1684   metadata !1,       ;; Compile unit
1685   i32 1,             ;; Line number
1686   i64 96,            ;; Size in bits
1687   i64 32,            ;; Align in bits
1688   i64 0,             ;; Offset in bits
1689   i32 0,             ;; Flags
1690   null,              ;; Derived From
1691   metadata !3,       ;; Elements
1692   i32 0              ;; Runtime Language
1693 }
1694
1695 ;;
1696 ;; Define the Red field.
1697 ;;
1698 !4 = metadata !{
1699   i32 524301,        ;; Tag
1700   metadata !1,       ;; Context
1701   metadata !"Red",   ;; Name
1702   metadata !1,       ;; File
1703   i32 2,             ;; Line number
1704   i64 32,            ;; Size in bits
1705   i64 32,            ;; Align in bits
1706   i64 0,             ;; Offset in bits
1707   i32 0,             ;; Flags
1708   metadata !5        ;; Derived From type
1709 }
1710
1711 ;;
1712 ;; Define the Green field.
1713 ;;
1714 !6 = metadata !{
1715   i32 524301,        ;; Tag
1716   metadata !1,       ;; Context
1717   metadata !"Green", ;; Name
1718   metadata !1,       ;; File
1719   i32 3,             ;; Line number
1720   i64 32,            ;; Size in bits
1721   i64 32,            ;; Align in bits
1722   i64 32,             ;; Offset in bits
1723   i32 0,             ;; Flags
1724   metadata !5        ;; Derived From type
1725 }
1726
1727 ;;
1728 ;; Define the Blue field.
1729 ;;
1730 !7 = metadata !{
1731   i32 524301,        ;; Tag
1732   metadata !1,       ;; Context
1733   metadata !"Blue",  ;; Name
1734   metadata !1,       ;; File
1735   i32 4,             ;; Line number
1736   i64 32,            ;; Size in bits
1737   i64 32,            ;; Align in bits
1738   i64 64,             ;; Offset in bits
1739   i32 0,             ;; Flags
1740   metadata !5        ;; Derived From type
1741 }
1742
1743 ;;
1744 ;; Define the array of fields used by the composite type Color.
1745 ;;
1746 !3 = metadata !{metadata !4, metadata !6, metadata !7}
1747 </pre>
1748 </div>
1749
1750 </div>
1751
1752 <!-- ======================================================================= -->
1753 <h3>
1754   <a name="ccxx_enumeration_types">C/C++ enumeration types</a>
1755 </h3>
1756
1757 <div>
1758
1759 <p>Given the following as an example of C/C++ enumeration type:</p>
1760
1761 <div class="doc_code">
1762 <pre>
1763 enum Trees {
1764   Spruce = 100,
1765   Oak = 200,
1766   Maple = 300
1767 };
1768 </pre>
1769 </div>
1770
1771 <p>a C/C++ front-end would generate the following descriptors:</p>
1772
1773 <div class="doc_code">
1774 <pre>
1775 ;;
1776 ;; Define composite type for enum Trees
1777 ;;
1778 !2 = metadata !{
1779   i32 524292,        ;; Tag
1780   metadata !1,       ;; Context
1781   metadata !"Trees", ;; Name
1782   metadata !1,       ;; File
1783   i32 1,             ;; Line number
1784   i64 32,            ;; Size in bits
1785   i64 32,            ;; Align in bits
1786   i64 0,             ;; Offset in bits
1787   i32 0,             ;; Flags
1788   null,              ;; Derived From type
1789   metadata !3,       ;; Elements
1790   i32 0              ;; Runtime language
1791 }
1792
1793 ;;
1794 ;; Define the array of enumerators used by composite type Trees.
1795 ;;
1796 !3 = metadata !{metadata !4, metadata !5, metadata !6}
1797
1798 ;;
1799 ;; Define Spruce enumerator.
1800 ;;
1801 !4 = metadata !{i32 524328, metadata !"Spruce", i64 100}
1802
1803 ;;
1804 ;; Define Oak enumerator.
1805 ;;
1806 !5 = metadata !{i32 524328, metadata !"Oak", i64 200}
1807
1808 ;;
1809 ;; Define Maple enumerator.
1810 ;;
1811 !6 = metadata !{i32 524328, metadata !"Maple", i64 300}
1812
1813 </pre>
1814 </div>
1815
1816 </div>
1817
1818 </div>
1819
1820
1821 <!-- *********************************************************************** -->
1822 <h2>
1823   <a name="llvmdwarfextension">Debugging information format</a>
1824 </h2>
1825 <!-- *********************************************************************** -->
1826 <div>
1827 <!-- ======================================================================= -->
1828 <h3>
1829   <a name="objcproperty">Debugging Information Extension for Objective C
1830 Properties</a></li>
1831 </h3>
1832 <div>
1833 <!-- *********************************************************************** -->
1834 <h4>
1835   <a name="objcpropertyintroduction">Introduction</a>
1836 </h4>
1837 <!-- *********************************************************************** -->
1838
1839 <div>
1840 <p>Objective C provides a simpler way to declare and define accessor methods
1841 using declared properties. The language provides features to declare a
1842 property and to let compiler synthesize accessor methods.
1843 </p>
1844
1845 <p>The debugger lets developer inspect Objective C interfaces and their
1846 instance variables and class variables. However, the debugger does not know
1847 anything about the properties defined in Objective C interfaces. The debugger
1848 consumes information generated by compiler in DWARF format. The format does
1849 not support encoding of Objective C properties. This proposal describes DWARF
1850 extensions to encode Objective C properties, which the debugger can use to let
1851 developers inspect Objective C properties.
1852 </p>
1853
1854 </div>
1855
1856
1857 <!-- *********************************************************************** -->
1858 <h4>
1859   <a name="objcpropertyproposal">Proposal</a>
1860 </h4>
1861 <!-- *********************************************************************** -->
1862
1863 <div>
1864 <p>Objective C properties are always backed by an instance variable. The
1865 instance variables backing properties are identified using
1866 DW_AT_APPLE_property_name attribute. The instance variables with this
1867 attribute may not have data location attributes. The location of instance
1868 variables is determined by debugger only after consulting Objective C runtime.
1869 </p>
1870
1871 <div class="doc_code">
1872 <pre>
1873 @interface I1 {
1874   int n2;
1875 }
1876
1877 @property p1;
1878 @property p2;
1879 @end
1880
1881 @implementation I1
1882 @synthesize p1;
1883 @synthesize p2 = n2;
1884 @end
1885
1886
1887 TAG_structure_type [7] *
1888   AT_APPLE_runtime_class( 0x10 )
1889   AT_name( "I1" )
1890   AT_decl_file( "Objc_Property.m" )
1891   AT_decl_line( 3 )
1892
1893   TAG_member [8]
1894     AT_name( "p1" )
1895     AT_APPLE_property_name(“p1”)
1896     AT_type( {0x00000147} ( int ) )
1897
1898   TAG_member [8]
1899     AT_name( "n2" )
1900     AT_APPLE_property_name(“p2”)
1901     AT_type( {0x00000147} ( int ) )
1902 </pre>
1903 </div>
1904
1905 <p> Developers can decorate a property with attributes which are encoded using
1906 DW_AT_APPLE_property_attribute.
1907 </p>
1908
1909 <div class="doc_code">
1910 <pre>
1911 @property (readonly, nonatomic) int pr;
1912
1913
1914 TAG_member [8]
1915   AT_name(“pr”)
1916   AT_APPLE_property_name(“pr”)
1917   AT_type ( {0x00000147} (int) )
1918   AT_APPLE_property_attribute (DW_APPLE_PROPERTY_readonly, DW_APPLE_PROPERTY_nonatomic)
1919 </pre>
1920 </div>
1921
1922 <p> The setter and getter method names are attached to the property using
1923 DW_AT_APPLE_property_setter and DW_AT_APPLE_property_getter attributes.
1924 </p>
1925 <div class="doc_code">
1926 <pre>
1927 @interface I1
1928 @property (setter=myOwnP3Setter:) int p3;
1929 -(void)myOwnP3Setter:(int)a;
1930 @end
1931
1932 @implementation I1
1933 @synthesize p3;
1934 -(void)myOwnP3Setter:(int)a{ }
1935 @end
1936
1937 0x000003bd: TAG_structure_type [7] *
1938               AT_APPLE_runtime_class( 0x10 )
1939               AT_name( "I1" )
1940               AT_decl_file( "Objc_Property.m" )
1941               AT_decl_line( 3 )
1942 0x000003f3: TAG_member [8]
1943               AT_name( "p3" )
1944               AT_APPLE_property_name(“p3”)
1945               AT_APPLE_property_setter(“myOwnP3Setter:”)
1946               AT_type( {0x00000147} ( int ) )
1947 </pre>
1948 </div>
1949
1950 </div>
1951
1952 <!-- *********************************************************************** -->
1953 <h4>
1954   <a name="objcpropertynewattributes">New DWARF Attributes</a>
1955 </h4>
1956 <!-- *********************************************************************** -->
1957
1958 <div>
1959 <table border="1" cellspacing="0">
1960   <tr>
1961     <th width=200 >Attribute</th>
1962     <th width=200 >Value</th>
1963     <th width=200 >Classes</th>
1964   </tr>
1965   <tr>
1966     <td width=200 >DW_AT_APPLE_property_name</td>
1967     <td width=200 >0x3fe8</td>
1968     <td width=200 >String</td>
1969   </tr>
1970   <tr>
1971     <td width=200 >DW_AT_APPLE_property_getter</td>
1972     <td width=200 >0x3fe9</td>
1973     <td width=200 >String</td>
1974   </tr>
1975   <tr>
1976     <td width=200 >DW_AT_APPLE_property_setter</td>
1977     <td width=200 >0x3fea</td>
1978     <td width=200 >String</td>
1979   </tr>
1980   <tr>
1981     <td width=200 >DW_AT_APPLE_property_attribute</td>
1982     <td width=200 >0x3feb</td>
1983     <td width=200 >Constant</td>
1984   </tr>
1985 </table>
1986
1987 </div>
1988
1989 <!-- *********************************************************************** -->
1990 <h4>
1991   <a name="objcpropertynewconstants">New DWARF Constants</a>
1992 </h4>
1993 <!-- *********************************************************************** -->
1994
1995 <div>
1996 <table border="1" cellspacing="0">
1997   <tr>
1998     <th width=200 >Name</th>
1999     <th width=200 >Value</th>
2000   </tr>
2001   <tr>
2002     <td width=200 >DW_AT_APPLE_PROPERTY_readonly</td>
2003     <td width=200 >0x1</td>
2004   </tr>
2005   <tr>
2006     <td width=200 >DW_AT_APPLE_PROPERTY_readwrite</td>
2007     <td width=200 >0x2</td>
2008   </tr>
2009   <tr>
2010     <td width=200 >DW_AT_APPLE_PROPERTY_assign</td>
2011     <td width=200 >0x4</td>
2012   </tr>
2013   <tr>
2014     <td width=200 >DW_AT_APPLE_PROPERTY_retain</td>
2015     <td width=200 >0x8</td>
2016   </tr>
2017   <tr>
2018     <td width=200 >DW_AT_APPLE_PROPERTY_copy</td>
2019     <td width=200 >0x10</td>
2020   </tr>
2021   <tr>
2022     <td width=200 >DW_AT_APPLE_PROPERTY_nonatomic</td>
2023     <td width=200 >0x20</td>
2024   </tr>
2025 </table>
2026
2027 </div>
2028 </div>
2029 </div>
2030
2031 <!-- *********************************************************************** -->
2032
2033 <hr>
2034 <address>
2035   <a href="http://jigsaw.w3.org/css-validator/check/referer"><img
2036   src="http://jigsaw.w3.org/css-validator/images/vcss-blue" alt="Valid CSS"></a>
2037   <a href="http://validator.w3.org/check/referer"><img
2038   src="http://www.w3.org/Icons/valid-html401-blue" alt="Valid HTML 4.01"></a>
2039
2040   <a href="mailto:sabre@nondot.org">Chris Lattner</a><br>
2041   <a href="http://llvm.org/">LLVM Compiler Infrastructure</a><br>
2042   Last modified: $Date$
2043 </address>
2044
2045 </body>
2046 </html>