<div class="doc_author">
<p>Written by <a href="mailto:sabre@nondot.org">Chris Lattner</a>
- and <a href="mailto:jlaskey@apple.com">Jim Laskey</a></p>
+ and <a href="mailto:jlaskey@mac.com">Jim Laskey</a></p>
</div>
<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 of family of languages.</p>
+a specific language or family of languages.</p>
</div>
<div class="doc_text">
<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
+LLVM user a relationship between generated code and the original program source
code.</p>
<p>Currently, debug information is consumed by the DwarfWriter to produce dwarf
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>
+functions 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>
+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
numbers. We recommend using with tags in the range 0x1000 thru 0x2000 (there is
a defined enum DW_TAG_user_base = 0x1000.)</p>
-<p>The fields of debug descriptors used internally by LLVM (MachineDebugInfo)
+<p>The fields of debug descriptors used internally by LLVM (MachineModuleInfo)
are restricted to only the simple data types <tt>int</tt>, <tt>uint</tt>,
<tt>bool</tt>, <tt>float</tt>, <tt>double</tt>, <tt>sbyte*</tt> and <tt> { }*
</tt>. References to arbitrary values are handled using a <tt> { }* </tt> and a
}
</pre>
-<p>The first field of a descriptor is always an <tt>uint</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.</p>
+<p><a name="LLVMDebugVersion">The first field of a descriptor is always an
+<tt>uint</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 = 4 << 16 or 0x40000 or 262144.)</a></p>
-<p>The details of the various descriptors follow.</p>
+<p>The details of the various descriptors follow.</p>
</div>
<pre>
%<a href="#format_anchors">llvm.dbg.anchor.type</a> = type {
- uint, ;; Tag = 0
+ uint, ;; Tag = 0 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a>
uint ;; Tag of descriptors grouped by the anchor
}
</pre>
<pre>
%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a> = type {
- uint, ;; Tag = 17 (DW_TAG_compile_unit)
+ uint, ;; Tag = 17 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> (DW_TAG_compile_unit)
{ }*, ;; Compile unit anchor = cast = (%<a href="#format_anchors">llvm.dbg.anchor.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_units</a> to { }*)
- uint, ;; LLVM debug version number = 3
uint, ;; Dwarf language identifier (ex. DW_LANG_C89)
sbyte*, ;; Source file name
sbyte*, ;; Source file directory (includes trailing slash)
}
</pre>
-<p>These descriptors contain the version number for the debug info (currently
-3), 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>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> Compile unit descriptors provide the root context for objects declared in a
specific source file. Global variables and top level functions would be defined
<pre>
%<a href="#format_global_variables">llvm.dbg.global_variable.type</a> = type {
- uint, ;; Tag = 52 (DW_TAG_variable)
+ uint, ;; Tag = 52 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> (DW_TAG_variable)
{ }*, ;; Global variable anchor = cast (%<a href="#format_anchors">llvm.dbg.anchor.type</a>* %<a href="#format_global_variables">llvm.dbg.global_variables</a> to { }*),
{ }*, ;; Reference to context descriptor
sbyte*, ;; Name
+ sbyte*, ;; Display name (fully qualified C++ name)
+ sbyte*, ;; MIPS linkage name (for C++)
{ }*, ;; Reference to compile unit where defined
uint, ;; Line number where defined
{ }*, ;; Reference to type descriptor
<pre>
%<a href="#format_subprograms">llvm.dbg.subprogram.type</a> = type {
- uint, ;; Tag = 46 (DW_TAG_subprogram)
+ uint, ;; Tag = 46 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> (DW_TAG_subprogram)
{ }*, ;; Subprogram anchor = cast (%<a href="#format_anchors">llvm.dbg.anchor.type</a>* %<a href="#format_subprograms">llvm.dbg.subprograms</a> to { }*),
{ }*, ;; Reference to context descriptor
sbyte*, ;; Name
+ sbyte*, ;; Display name (fully qualified C++ name)
+ sbyte*, ;; MIPS linkage name (for C++)
{ }*, ;; Reference to compile unit where defined
uint, ;; Line number where defined
{ }*, ;; Reference to type descriptor
<pre>
%<a href="#format_blocks">llvm.dbg.block</a> = type {
- uint, ;; Tag = 13 (DW_TAG_lexical_block)
+ uint, ;; Tag = 13 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> (DW_TAG_lexical_block)
{ }* ;; Reference to context descriptor
}
</pre>
<pre>
%<a href="#format_basic_type">llvm.dbg.basictype.type</a> = type {
- uint, ;; Tag = 36 (DW_TAG_base_type)
+ uint, ;; Tag = 36 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> (DW_TAG_base_type)
{ }*, ;; Reference to context (typically a compile unit)
sbyte*, ;; Name (may be "" for anonymous types)
{ }*, ;; Reference to compile unit where defined (may be NULL)
uint, ;; Size in bits
uint, ;; Alignment in bits
uint, ;; Offset in bits
- bool, ;; Is vector flag
{ }* ;; Reference to array of member descriptors
}
</pre>
DW_TAG_enumeration_type = 4
DW_TAG_structure_type = 19
DW_TAG_union_type = 23
+ DW_TAG_vector_type = 259
+ DW_TAG_subroutine_type = 46
+ DW_TAG_inheritance = 26
</pre>
<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>) are <a
-href="#format_subrange">subrange descriptors</a>, each representing the range of
-subscripts at that level of indexing.</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
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 compile unit and line number. The size, alignment and
offset are expressed in bits and can be 64 bit values. The alignment is used to
<pre>
%<a href="#format_subrange">llvm.dbg.subrange.type</a> = type {
- uint, ;; Tag = 33 (DW_TAG_subrange_type)
+ uint, ;; Tag = 33 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> (DW_TAG_subrange_type)
uint, ;; Low value
uint ;; High value
}
<pre>
%<a href="#format_enumeration">llvm.dbg.enumerator.type</a> = type {
- uint, ;; Tag = 40 (DW_TAG_enumerator)
+ uint, ;; Tag = 40 + <a href="#LLVMDebugVersion">LLVMDebugVersion</a> (DW_TAG_enumerator)
sbyte*, ;; Name
uint ;; Value
}
<p>This intrinsic is used to provide correspondence between the source file and
the generated code. The first argument is the line number (base 1), second
-argument si the column number (0 if unknown) and the third argument the source
+argument is the column number (0 if unknown) and the third argument the source
<tt>%<a href="#format_compile_units">llvm.dbg.compile_unit</a>*</tt> cast to a
<tt>{ }*</tt>. Code following a call to this intrinsic will have been defined
in close proximity of the line, column and file. This information holds until
</pre>
<p>This intrinsic is used to link the debug information in <tt>%<a
-href="#format_subprograms">llvm.dbg.subprogram</a></tt> to the function. It also
-defines the beginning of the function's declarative region (scope.) The
-intrinsic should be called early in the function after the all the alloca
-instructions. It should be paired off with a closing <tt>%<a
+href="#format_subprograms">llvm.dbg.subprogram</a></tt> to the function. It
+defines the beginning of the function's declarative region (scope). It also
+implies a call to %<tt><a
+href="#format_common_stoppoint">llvm.dbg.stoppoint</a></tt> which defines a
+source line "stop point". The intrinsic should be called early in the function
+after the all the alloca instructions. It should be paired off with a closing
+<tt>%<a
href="#format_common_region_end">llvm.dbg.region.end</a></tt>. The function's
single argument is the <tt>%<a
href="#format_subprograms">llvm.dbg.subprogram.type</a></tt>.</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 couldchange how name lookup is
+C++ using declaration is controlled with this and could change how name lookup is
performed.</p>
</div>
;; Define the compile unit for the source file "/Users/mine/sources/MySource.cpp".
;;
%<a href="#format_compile_units">llvm.dbg.compile_unit1</a> = internal constant %<a href="#format_compile_units">llvm.dbg.compile_unit.type</a> {
- uint 17,
+ uint add(uint 17, uint 262144),
{ }* cast (%<a href="#format_anchors">llvm.dbg.anchor.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_units</a> to { }*),
uint 1,
uint 1,
;; Define the compile unit for the header file "/Users/mine/sources/MyHeader.h".
;;
%<a href="#format_compile_units">llvm.dbg.compile_unit2</a> = internal constant %<a href="#format_compile_units">llvm.dbg.compile_unit.type</a> {
- uint 17,
+ uint add(uint 17, uint 262144),
{ }* cast (%<a href="#format_anchors">llvm.dbg.anchor.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_units</a> to { }*),
uint 1,
uint 1,
;; variable anchor and the global variable itself.
;;
%<a href="#format_global_variables">llvm.dbg.global_variable</a> = internal constant %<a href="#format_global_variables">llvm.dbg.global_variable.type</a> {
- uint 52,
+ uint add(uint 52, uint 262144),
{ }* cast (%<a href="#format_anchors">llvm.dbg.anchor.type</a>* %<a href="#format_global_variables">llvm.dbg.global_variables</a> to { }*),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([9 x sbyte]* %str1, int 0, int 0),
+ sbyte* getelementptr ([1 x sbyte]* %str2, int 0, int 0),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
uint 1,
{ }* cast (%<a href="#format_basic_type">llvm.dbg.basictype.type</a>* %<a href="#format_basic_type">llvm.dbg.basictype</a> to { }*),
;; intrinsic type the source file is NULL and line 0.
;;
%<a href="#format_basic_type">llvm.dbg.basictype</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
- sbyte* getelementptr ([4 x sbyte]* %str2, int 0, int 0),
+ sbyte* getelementptr ([4 x sbyte]* %str3, int 0, int 0),
{ }* null,
int 0,
uint 32,
;; Define the names of the global variable and basic type.
;;
%str1 = internal constant [9 x sbyte] c"MyGlobal\00", section "llvm.metadata"
-%str2 = internal constant [4 x sbyte] c"int\00", section "llvm.metadata"
+%str2 = internal constant [1 x sbyte] c"\00", section "llvm.metadata"
+%str3 = internal constant [4 x sbyte] c"int\00", section "llvm.metadata"
</pre>
</div>
;; Define the descriptor for the subprogram. TODO - more details.
;;
%<a href="#format_subprograms">llvm.dbg.subprogram</a> = internal constant %<a href="#format_subprograms">llvm.dbg.subprogram.type</a> {
- uint 46,
+ uint add(uint 46, uint 262144),
{ }* cast (%<a href="#format_anchors">llvm.dbg.anchor.type</a>* %<a href="#format_subprograms">llvm.dbg.subprograms</a> to { }*),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([5 x sbyte]* %str1, int 0, int 0),
+ sbyte* getelementptr ([1 x sbyte]* %str2, int 0, int 0),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
uint 1,
{ }* null,
;; Define the name of the subprogram.
;;
%str1 = internal constant [5 x sbyte] c"main\00", section "llvm.metadata"
+%str2 = internal constant [1 x sbyte] c"\00", section "llvm.metadata"
;;
;; Define the subprogram itself.
<pre>
%<a href="#format_basic_type">llvm.dbg.basictype</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([5 x sbyte]* %str1, int 0, int 0),
{ }* null,
<pre>
%<a href="#format_basic_type">llvm.dbg.basictype</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([5 x sbyte]* %str1, int 0, int 0),
{ }* null,
<pre>
%<a href="#format_basic_type">llvm.dbg.basictype</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([14 x sbyte]* %str1, int 0, int 0),
{ }* null,
<pre>
%<a href="#format_basic_type">llvm.dbg.basictype</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([10 x sbyte]* %str1, int 0, int 0),
{ }* null,
<pre>
%<a href="#format_basic_type">llvm.dbg.basictype</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([19 x sbyte]* %str1, int 0, int 0),
{ }* null,
<pre>
%<a href="#format_basic_type">llvm.dbg.basictype</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([4 x sbyte]* %str1, int 0, int 0),
{ }* null,
<pre>
%<a href="#format_basic_type">llvm.dbg.basictype</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([13 x sbyte]* %str1, int 0, int 0),
{ }* null,
<pre>
%<a href="#format_basic_type">llvm.dbg.basictype</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([14 x sbyte]* %str1, int 0, int 0),
{ }* null,
<pre>
%<a href="#format_basic_type">llvm.dbg.basictype</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([23 x sbyte]* %str1, int 0, int 0),
{ }* null,
<pre>
%<a href="#format_basic_type">llvm.dbg.basictype</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([6 x sbyte]* %str1, int 0, int 0),
{ }* null,
<pre>
%<a href="#format_basic_type">llvm.dbg.basictype</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([7 x sbyte]* %str1, int 0, int 0),
{ }* null,
;; Define the typedef "IntPtr".
;;
%<a href="#format_derived_type">llvm.dbg.derivedtype1</a> = internal constant %<a href="#format_derived_type">llvm.dbg.derivedtype.type</a> {
- uint 22,
+ uint add(uint 22, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([7 x sbyte]* %str1, int 0, int 0),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
;; Define the pointer type.
;;
%<a href="#format_derived_type">llvm.dbg.derivedtype2</a> = internal constant %<a href="#format_derived_type">llvm.dbg.derivedtype.type</a> {
- uint 15,
+ uint add(uint 15, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* null,
{ }* null,
;; Define the const type.
;;
%<a href="#format_derived_type">llvm.dbg.derivedtype3</a> = internal constant %<a href="#format_derived_type">llvm.dbg.derivedtype.type</a> {
- uint 38,
+ uint add(uint 38, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* null,
{ }* null,
;; Define the int type.
;;
%<a href="#format_basic_type">llvm.dbg.basictype1</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([4 x sbyte]* %str2, int 0, int 0),
{ }* null,
;; Define basic type for unsigned int.
;;
%<a href="#format_basic_type">llvm.dbg.basictype</a> = internal constant %<a href="#format_basic_type">llvm.dbg.basictype.type</a> {
- uint 36,
+ uint add(uint 36, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([13 x sbyte]* %str1, int 0, int 0),
{ }* null,
;; Define composite type for struct Color.
;;
%<a href="#format_composite_type">llvm.dbg.compositetype</a> = internal constant %<a href="#format_composite_type">llvm.dbg.compositetype.type</a> {
- uint 19,
+ uint add(uint 19, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([6 x sbyte]* %str2, int 0, int 0),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
uint 32,
uint 0,
{ }* null,
- bool false,
{ }* cast ([3 x { }*]* %llvm.dbg.array to { }*) }, section "llvm.metadata"
%str2 = internal constant [6 x sbyte] c"Color\00", section "llvm.metadata"
;; Define the Red field.
;;
%<a href="#format_derived_type">llvm.dbg.derivedtype1</a> = internal constant %<a href="#format_derived_type">llvm.dbg.derivedtype.type</a> {
- uint 13,
+ uint add(uint 13, uint 262144),
{ }* null,
sbyte* getelementptr ([4 x sbyte]* %str3, int 0, int 0),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
;; Define the Green field.
;;
%<a href="#format_derived_type">llvm.dbg.derivedtype2</a> = internal constant %<a href="#format_derived_type">llvm.dbg.derivedtype.type</a> {
- uint 13,
+ uint add(uint 13, uint 262144),
{ }* null,
sbyte* getelementptr ([6 x sbyte]* %str4, int 0, int 0),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
;; Define the Blue field.
;;
%<a href="#format_derived_type">llvm.dbg.derivedtype3</a> = internal constant %<a href="#format_derived_type">llvm.dbg.derivedtype.type</a> {
- uint 13,
+ uint add(uint 13, uint 262144),
{ }* null,
sbyte* getelementptr ([5 x sbyte]* %str5, int 0, int 0),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
;; Define composite type for enum Trees
;;
%<a href="#format_composite_type">llvm.dbg.compositetype</a> = internal constant %<a href="#format_composite_type">llvm.dbg.compositetype.type</a> {
- uint 4,
+ uint add(uint 4, uint 262144),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
sbyte* getelementptr ([6 x sbyte]* %str1, int 0, int 0),
{ }* cast (%<a href="#format_compile_units">llvm.dbg.compile_unit.type</a>* %<a href="#format_compile_units">llvm.dbg.compile_unit</a> to { }*),
uint 32,
uint 0,
{ }* null,
- bool false,
{ }* cast ([3 x { }*]* %llvm.dbg.array to { }*) }, section "llvm.metadata"
%str1 = internal constant [6 x sbyte] c"Trees\00", section "llvm.metadata"
;; Define Spruce enumerator.
;;
%<a href="#format_enumeration">llvm.dbg.enumerator1</a> = internal constant %<a href="#format_enumeration">llvm.dbg.enumerator.type</a> {
- uint 40,
+ uint add(uint 40, uint 262144),
sbyte* getelementptr ([7 x sbyte]* %str2, int 0, int 0),
int 100 }, section "llvm.metadata"
%str2 = internal constant [7 x sbyte] c"Spruce\00", section "llvm.metadata"
;; Define Oak enumerator.
;;
%<a href="#format_enumeration">llvm.dbg.enumerator2</a> = internal constant %<a href="#format_enumeration">llvm.dbg.enumerator.type</a> {
- uint 40,
+ uint add(uint 40, uint 262144),
sbyte* getelementptr ([4 x sbyte]* %str3, int 0, int 0),
int 200 }, section "llvm.metadata"
%str3 = internal constant [4 x sbyte] c"Oak\00", section "llvm.metadata"
;; Define Maple enumerator.
;;
%<a href="#format_enumeration">llvm.dbg.enumerator3</a> = internal constant %<a href="#format_enumeration">llvm.dbg.enumerator.type</a> {
- uint 40,
+ uint add(uint 40, uint 262144),
sbyte* getelementptr ([6 x sbyte]* %str4, int 0, int 0),
int 300 }, section "llvm.metadata"
%str4 = internal constant [6 x sbyte] c"Maple\00", section "llvm.metadata"
projects / oota-llvm.git / blobdiff