- void %llvm.dbg.region.end( { }* )
-
-
-
This intrinsic is used to define the end of a declarative scope (ex. block)
-for local language elements. It should be paired off with an opening %llvm.dbg.region.start or %llvm.dbg.func.start. The function's
-single argument is either the %llvm.dbg.block or the %llvm.dbg.subprogram.type which is
-ending.
+define void @foo() nounwind ssp {
+entry:
+ %X = alloca i32, align 4 ; <i32*> [#uses=4]
+ %Y = alloca i32, align 4 ; <i32*> [#uses=4]
+ %Z = alloca i32, align 4 ; <i32*> [#uses=3]
+ %0 = bitcast i32* %X to {}* ; <{}*> [#uses=1]
+ call void @llvm.dbg.declare(metadata !{i32 * %X}, metadata !0), !dbg !7
+ store i32 21, i32* %X, !dbg !8
+ %1 = bitcast i32* %Y to {}* ; <{}*> [#uses=1]
+ call void @llvm.dbg.declare(metadata !{i32 * %Y}, metadata !9), !dbg !10
+ store i32 22, i32* %Y, !dbg !11
+ %2 = bitcast i32* %Z to {}* ; <{}*> [#uses=1]
+ call void @llvm.dbg.declare(metadata !{i32 * %Z}, metadata !12), !dbg !14
+ store i32 23, i32* %Z, !dbg !15
+ %tmp = load i32* %X, !dbg !16 ; <i32> [#uses=1]
+ %tmp1 = load i32* %Y, !dbg !16 ; <i32> [#uses=1]
+ %add = add nsw i32 %tmp, %tmp1, !dbg !16 ; <i32> [#uses=1]
+ store i32 %add, i32* %Z, !dbg !16
+ %tmp2 = load i32* %Y, !dbg !17 ; <i32> [#uses=1]
+ store i32 %tmp2, i32* %X, !dbg !17
+ ret void, !dbg !18
+}
+declare void @llvm.dbg.declare(metadata, metadata) nounwind readnone
+
+!0 = metadata !{i32 459008, metadata !1, metadata !"X",
+ metadata !3, i32 2, metadata !6}; [ DW_TAG_auto_variable ]
+!1 = metadata !{i32 458763, metadata !2}; [DW_TAG_lexical_block ]
+!2 = metadata !{i32 458798, i32 0, metadata !3, metadata !"foo", metadata !"foo",
+ metadata !"foo", metadata !3, i32 1, metadata !4,
+ i1 false, i1 true}; [DW_TAG_subprogram ]
+!3 = metadata !{i32 458769, i32 0, i32 12, metadata !"foo.c",
+ metadata !"/private/tmp", metadata !"clang 1.1", i1 true,
+ i1 false, metadata !"", i32 0}; [DW_TAG_compile_unit ]
+!4 = metadata !{i32 458773, metadata !3, metadata !"", null, i32 0, i64 0, i64 0,
+ i64 0, i32 0, null, metadata !5, i32 0}; [DW_TAG_subroutine_type ]
+!5 = metadata !{null}
+!6 = metadata !{i32 458788, metadata !3, metadata !"int", metadata !3, i32 0,
+ i64 32, i64 32, i64 0, i32 0, i32 5}; [DW_TAG_base_type ]
+!7 = metadata !{i32 2, i32 7, metadata !1, null}
+!8 = metadata !{i32 2, i32 3, metadata !1, null}
+!9 = metadata !{i32 459008, metadata !1, metadata !"Y", metadata !3, i32 3,
+ metadata !6}; [ DW_TAG_auto_variable ]
+!10 = metadata !{i32 3, i32 7, metadata !1, null}
+!11 = metadata !{i32 3, i32 3, metadata !1, null}
+!12 = metadata !{i32 459008, metadata !13, metadata !"Z", metadata !3, i32 5,
+ metadata !6}; [ DW_TAG_auto_variable ]
+!13 = metadata !{i32 458763, metadata !1}; [DW_TAG_lexical_block ]
+!14 = metadata !{i32 5, i32 9, metadata !13, null}
+!15 = metadata !{i32 5, i32 5, metadata !13, null}
+!16 = metadata !{i32 6, i32 5, metadata !13, null}
+!17 = metadata !{i32 8, i32 3, metadata !1, null}
+!18 = metadata !{i32 9, i32 1, metadata !2, null}
+
This example illustrates a few important details about LLVM debugging
+ information. In particular, it shows how the llvm.dbg.declare
+ intrinsic and location information, which are attached to an instruction,
+ are applied together to allow a debugger to analyze the relationship between
+ statements, variable definitions, and the code used to implement the
+ function.
+
- void %llvm.dbg.declare( { } *, { }* )
+call void @llvm.dbg.declare(metadata, metadata !0), !dbg !7
-
-
This intrinsic provides information about a local element (ex. variable.) The
-first argument is the alloca for the variable, cast to a { }*. The
-second argument is the %llvm.dbg.variable containing the description
-of the variable, also cast to a { }*.
-
-
-
-
-
-
-
-
LLVM debugger "stop points" are a key part of the debugging representation
-that allows the LLVM to maintain simple semantics for debugging optimized code. The basic idea is that the
-front-end inserts calls to the %llvm.dbg.stoppoint intrinsic
-function at every point in the program where a debugger should be able to
-inspect the program (these correspond to places a debugger stops when you
-"step" through it). The front-end can choose to place these as
-fine-grained as it would like (for example, before every subexpression
-evaluated), but it is recommended to only put them after every source statement
-that includes executable code.
-
-
Using calls to this intrinsic function to demark legal points for the
-debugger to inspect the program automatically disables any optimizations that
-could potentially confuse debugging information. To non-debug-information-aware
-transformations, these calls simply look like calls to an external function,
-which they must assume to do anything (including reading or writing to any part
-of reachable memory). On the other hand, it does not impact many optimizations,
-such as code motion of non-trapping instructions, nor does it impact
-optimization of subexpressions, code duplication transformations, or basic-block
-reordering transformations.
+
The first intrinsic
+ %llvm.dbg.declare
+ encodes debugging information for the variable X. The metadata
+ !dbg !7 attached to the intrinsic provides scope information for the
+ variable X.
+
+
+!7 = metadata !{i32 2, i32 7, metadata !1, null}
+!1 = metadata !{i32 458763, metadata !2}; [DW_TAG_lexical_block ]
+!2 = metadata !{i32 458798, i32 0, metadata !3, metadata !"foo",
+ metadata !"foo", metadata !"foo", metadata !3, i32 1,
+ metadata !4, i1 false, i1 true}; [DW_TAG_subprogram ]
+
+
Here !7 is metadata providing location information. It has four
+ fields: line number, column number, scope, and original scope. The original
+ scope represents inline location if this instruction is inlined inside a
+ caller, and is null otherwise. In this example, scope is encoded by
+ !1. !1 represents a lexical block inside the scope
+ !2, where !2 is a
+ subprogram descriptor. This way the
+ location information attached to the intrinsics indicates that the
+ variable X is declared at line number 2 at a function level scope in
+ function foo.
-
-
-
-
-
In many languages, the local variables in functions can have their lifetime
-or scope limited to a subset of a function. In the C family of languages, for
-example, variables are only live (readable and writable) within the source block
-that they are defined in. In functional languages, values are only readable
-after they have been defined. Though this is a very obvious concept, it is also
-non-trivial to model in LLVM, because it has no notion of scoping in this sense,
-and does not want to be tied to a language's scoping rules.
-
-
In order to handle this, the LLVM debug format uses the notion of "regions"
-of a function, delineated by calls to intrinsic functions. These intrinsic
-functions define new regions of the program and indicate when the region
-lifetime expires. Consider the following C fragment, for example:
+
Now lets take another example.
+
-1. void foo() {
-2. int X = ...;
-3. int Y = ...;
-4. {
-5. int Z = ...;
-6. ...
-7. }
-8. ...
-9. }
+call void @llvm.dbg.declare(metadata, metadata !12), !dbg !14
+
-
Compiled to LLVM, this function would be represented like this:
+
The second intrinsic
+ %llvm.dbg.declare
+ encodes debugging information for variable Z. The metadata
+ !dbg !14 attached to the intrinsic provides scope information for
+ the variable Z.
+
-void %foo() {
-entry:
- %X = alloca int
- %Y = alloca int
- %Z = alloca int
-
- ...
-
- call void %llvm.dbg.func.start( %llvm.dbg.subprogram.type* %llvm.dbg.subprogram )
-
- call void %llvm.dbg.stoppoint( uint 2, uint 2, %llvm.dbg.compile_unit* %llvm.dbg.compile_unit )
-
- call void %llvm.dbg.declare({}* %X, ...)
- call void %llvm.dbg.declare({}* %Y, ...)
-
- ;; Evaluate expression on line 2, assigning to X.
-
- call void %llvm.dbg.stoppoint( uint 3, uint 2, %llvm.dbg.compile_unit* %llvm.dbg.compile_unit )
-
- ;; Evaluate expression on line 3, assigning to Y.
-
- call void %llvm.region.start()
- call void %llvm.dbg.stoppoint( uint 5, uint 4, %llvm.dbg.compile_unit* %llvm.dbg.compile_unit )
- call void %llvm.dbg.declare({}* %X, ...)
-
- ;; Evaluate expression on line 5, assigning to Z.
-
- call void %llvm.dbg.stoppoint( uint 7, uint 2, %llvm.dbg.compile_unit* %llvm.dbg.compile_unit )
- call void %llvm.region.end()
-
- call void %llvm.dbg.stoppoint( uint 9, uint 2, %llvm.dbg.compile_unit* %llvm.dbg.compile_unit )
-
- call void %llvm.region.end()
-
- ret void
-}
+!13 = metadata !{i32 458763, metadata !1}; [DW_TAG_lexical_block ]
+!14 = metadata !{i32 5, i32 9, metadata !13, null}
+
-
This example illustrates a few important details about the LLVM debugging
-information. In particular, it shows how the various intrinsics are applied
-together to allow a debugger to analyze the relationship between statements,
-variable definitions, and the code used to implement the function.
-
-
The first intrinsic %llvm.dbg.func.start provides
-a link with the subprogram descriptor
-containing the details of this function. This call also defines the beginning
-of the function region, bounded by the %llvm.region.end at the end of
-the function. This region is used to bracket the lifetime of variables declared
-within. For a function, this outer region defines a new stack frame whose
-lifetime ends when the region is ended.
-
-
It is possible to define inner regions for short term variables by using the
-%llvm.region.start and %llvm.region.end to bound a
-region. The inner region in this example would be for the block containing the
-declaration of Z.
-
-
Using regions to represent the boundaries of source-level functions allow
-LLVM interprocedural optimizations to arbitrarily modify LLVM functions without
-having to worry about breaking mapping information between the LLVM code and the
-and source-level program. In particular, the inliner requires no modification
-to support inlining with debugging information: there is no explicit correlation
-drawn between LLVM functions and their source-level counterparts (note however,
-that if the inliner inlines all instances of a non-strong-linkage function into
-its caller that it will not be possible for the user to manually invoke the
-inlined function from a debugger).
-
-
Once the function has been defined, the stopping point corresponding to
-line #2 (column #2) of the function is encountered. At this point in the
-function, no local variables are live. As lines 2 and 3 of the example
-are executed, their variable definitions are introduced into the program using
-%llvm.dbg.declare, without the
-need to specify a new region. These variables do not require new regions to be
-introduced because they go out of scope at the same point in the program: line
-9.
-
-
In contrast, the Z variable goes out of scope at a different time,
-on line 7. For this reason, it is defined within the inner region, which kills
-the availability of Z before the code for line 8 is executed. In this
-way, regions can support arbitrary source-language scoping rules, as long as
-they can only be nested (ie, one scope cannot partially overlap with a part of
-another scope).
-
-
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
-performed.
+
Here !14 indicates that Z is declared at line number 5 and
+ column number 9 inside of lexical scope !13. The lexical scope
+ itself resides inside of lexical scope !1 described above.
-
+
The scope information attached with each instruction provides a
+ straightforward way to find instructions covered by a scope.
+
+
+
The C and C++ front-ends represent information about the program in a format
-that is effectively identical to Dwarf 3.0 in terms of
-information content. This allows code generators to trivially support native
-debuggers by generating standard dwarf information, and contains enough
-information for non-dwarf targets to translate it as needed.
+ that is effectively identical
+ to
DWARF 3.0 in
+ terms of information content. This allows code generators to trivially
+ support native debuggers by generating standard dwarf information, and
+ contains enough information for non-dwarf targets to translate it as
+ needed.
This section describes the forms used to represent C and C++ programs. Other
-languages could pattern themselves after this (which itself is tuned to
-representing programs in the same way that Dwarf 3 does), or they could choose
-to provide completely different forms if they don't fit into the Dwarf model.
-As support for debugging information gets added to the various LLVM
-source-language front-ends, the information used should be documented here.
+ languages could pattern themselves after this (which itself is tuned to
+ representing programs in the same way that DWARF 3 does), or they could
+ choose to provide completely different forms if they don't fit into the DWARF
+ model. As support for debugging information gets added to the various LLVM
+ source-language front-ends, the information used should be documented
+ here.
The following sections provide examples of various C/C++ constructs and the
-debug information that would best describe those constructs.
-
-
+ debug information that would best describe those constructs.
-
+
-
+
-
Given the source files "MySource.cpp" and "MyHeader.h" located in the
-directory "/Users/mine/sources", the following code;
+
Given the source files MySource.cpp and MyHeader.h located
+ in the directory /Users/mine/sources, the following code:
+
#include "MyHeader.h"
@@ -1021,552 +1054,584 @@ int main(int argc, char *argv[]) {
return 0;
}
+
-
a C/C++ front-end would generate the following descriptors;
+
a C/C++ front-end would generate the following descriptors:
+
...
;;
-;; Define types used. In this case we need one for compile unit anchors and one
-;; for compile units.
-;;
-%llvm.dbg.anchor.type = type { uint, uint }
-%llvm.dbg.compile_unit.type = type { uint, { }*, uint, uint, sbyte*, sbyte*, sbyte* }
-...
-;;
-;; Define the anchor for compile units. Note that the second field of the
-;; anchor is 17, which is the same as the tag for compile units
-;; (17 = DW_TAG_compile_unit.)
+;; Define the compile unit for the main source file "/Users/mine/sources/MySource.cpp".
;;
-%llvm.dbg.compile_units = linkonce constant %llvm.dbg.anchor.type { uint 0, uint 17 }, section "llvm.metadata"
+!2 = metadata !{
+ i32 524305, ;; Tag
+ i32 0, ;; Unused
+ i32 4, ;; Language Id
+ metadata !"MySource.cpp",
+ metadata !"/Users/mine/sources",
+ metadata !"4.2.1 (Based on Apple Inc. build 5649) (LLVM build 00)",
+ i1 true, ;; Main Compile Unit
+ i1 false, ;; Optimized compile unit
+ metadata !"", ;; Compiler flags
+ i32 0} ;; Runtime version
;;
-;; Define the compile unit for the source file "/Users/mine/sources/MySource.cpp".
+;; Define the file for the file "/Users/mine/sources/MySource.cpp".
;;
-%llvm.dbg.compile_unit1 = internal constant %llvm.dbg.compile_unit.type {
- uint add(uint 17, uint 262144),
- { }* cast (%llvm.dbg.anchor.type* %llvm.dbg.compile_units to { }*),
- uint 1,
- uint 1,
- sbyte* getelementptr ([13 x sbyte]* %str1, int 0, int 0),
- sbyte* getelementptr ([21 x sbyte]* %str2, int 0, int 0),
- sbyte* getelementptr ([33 x sbyte]* %str3, int 0, int 0) }, section "llvm.metadata"
-
-;;
-;; Define the compile unit for the header file "/Users/mine/sources/MyHeader.h".
-;;
-%llvm.dbg.compile_unit2 = internal constant %llvm.dbg.compile_unit.type {
- uint add(uint 17, uint 262144),
- { }* cast (%llvm.dbg.anchor.type* %llvm.dbg.compile_units to { }*),
- uint 1,
- uint 1,
- sbyte* getelementptr ([11 x sbyte]* %str4, int 0, int 0),
- sbyte* getelementptr ([21 x sbyte]* %str2, int 0, int 0),
- sbyte* getelementptr ([33 x sbyte]* %str3, int 0, int 0) }, section "llvm.metadata"
+!1 = metadata !{
+ i32 524329, ;; Tag
+ metadata !"MySource.cpp",
+ metadata !"/Users/mine/sources",
+ metadata !2 ;; Compile unit
+}
;;
-;; Define each of the strings used in the compile units.
+;; Define the file for the file "/Users/mine/sources/Myheader.h"
;;
-%str1 = internal constant [13 x sbyte] c"MySource.cpp\00", section "llvm.metadata";
-%str2 = internal constant [21 x sbyte] c"/Users/mine/sources/\00", section "llvm.metadata";
-%str3 = internal constant [33 x sbyte] c"4.0.1 LLVM (LLVM research group)\00", section "llvm.metadata";
-%str4 = internal constant [11 x sbyte] c"MyHeader.h\00", section "llvm.metadata";
+!3 = metadata !{
+ i32 524329, ;; Tag
+ metadata !"Myheader.h"
+ metadata !"/Users/mine/sources",
+ metadata !2 ;; Compile unit
+}
+
...
+
+
llvm::Instruction provides easy access to metadata attached with an
+instruction. One can extract line number information encoded in LLVM IR
+using Instruction::getMetadata() and
+DILocation::getLineNumber().
+
+ if (MDNode *N = I->getMetadata("dbg")) { // Here I is an LLVM instruction
+ DILocation Loc(N); // DILocation is in DebugInfo.h
+ unsigned Line = Loc.getLineNumber();
+ StringRef File = Loc.getFilename();
+ StringRef Dir = Loc.getDirectory();
+ }
+
-
+
-
+
-
Given an integer global variable declared as follows;
+
Given an integer global variable declared as follows:
+
-
a C/C++ front-end would generate the following descriptors;
+
a C/C++ front-end would generate the following descriptors:
+
;;
-;; Define types used. One for global variable anchors, one for the global
-;; variable descriptor, one for the global's basic type and one for the global's
-;; compile unit.
-;;
-%llvm.dbg.anchor.type = type { uint, uint }
-%llvm.dbg.global_variable.type = type { uint, { }*, { }*, sbyte*, { }*, uint, { }*, bool, bool, { }*, uint }
-%llvm.dbg.basictype.type = type { uint, { }*, sbyte*, { }*, int, uint, uint, uint, uint }
-%llvm.dbg.compile_unit.type = ...
-...
-;;
;; Define the global itself.
;;
%MyGlobal = global int 100
...
;;
-;; Define the anchor for global variables. Note that the second field of the
-;; anchor is 52, which is the same as the tag for global variables
-;; (52 = DW_TAG_variable.)
+;; List of debug info of globals
;;
-%llvm.dbg.global_variables = linkonce constant %llvm.dbg.anchor.type { uint 0, uint 52 }, section "llvm.metadata"
+!llvm.dbg.gv = !{!0}
;;
;; Define the global variable descriptor. Note the reference to the global
;; variable anchor and the global variable itself.
;;
-%llvm.dbg.global_variable = internal constant %llvm.dbg.global_variable.type {
- uint add(uint 52, uint 262144),
- { }* cast (%llvm.dbg.anchor.type* %llvm.dbg.global_variables to { }*),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([9 x sbyte]* %str1, int 0, int 0),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- uint 1,
- { }* cast (%llvm.dbg.basictype.type* %llvm.dbg.basictype to { }*),
- bool false,
- bool true,
- { }* cast (int* %MyGlobal to { }*) }, section "llvm.metadata"
-
+!0 = metadata !{
+ i32 524340, ;; Tag
+ i32 0, ;; Unused
+ metadata !1, ;; Context
+ metadata !"MyGlobal", ;; Name
+ metadata !"MyGlobal", ;; Display Name
+ metadata !"MyGlobal", ;; Linkage Name
+ metadata !3, ;; Compile Unit
+ i32 1, ;; Line Number
+ metadata !4, ;; Type
+ i1 false, ;; Is a local variable
+ i1 true, ;; Is this a definition
+ i32* @MyGlobal ;; The global variable
+}
+
;;
;; Define the basic type of 32 bit signed integer. Note that since int is an
;; intrinsic type the source file is NULL and line 0.
;;
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([4 x sbyte]* %str2, int 0, int 0),
- { }* null,
- int 0,
- uint 32,
- uint 32,
- uint 0,
- uint 5 }, section "llvm.metadata"
+!4 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"int", ;; Name
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 32, ;; Size in Bits
+ i64 32, ;; Align in Bits
+ i64 0, ;; Offset in Bits
+ i32 0, ;; Flags
+ i32 5 ;; Encoding
+}
-;;
-;; 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"
+
-
+
-
+
-
Given a function declared as follows;
+
Given a function declared as follows:
+
int main(int argc, char *argv[]) {
return 0;
}
+
-
a C/C++ front-end would generate the following descriptors;
+
a C/C++ front-end would generate the following descriptors:
+
-;;
-;; Define types used. One for subprogram anchors, one for the subprogram
-;; descriptor, one for the global's basic type and one for the subprogram's
-;; compile unit.
-;;
-%llvm.dbg.subprogram.type = type { uint, { }*, { }*, sbyte*, { }*, bool, bool }
-%llvm.dbg.anchor.type = type { uint, uint }
-%llvm.dbg.compile_unit.type = ...
-
;;
;; Define the anchor for subprograms. Note that the second field of the
;; anchor is 46, which is the same as the tag for subprograms
;; (46 = DW_TAG_subprogram.)
;;
-%llvm.dbg.subprograms = linkonce constant %llvm.dbg.anchor.type { uint 0, uint 46 }, section "llvm.metadata"
-
-;;
-;; Define the descriptor for the subprogram. TODO - more details.
-;;
-%llvm.dbg.subprogram = internal constant %llvm.dbg.subprogram.type {
- uint add(uint 46, uint 262144),
- { }* cast (%llvm.dbg.anchor.type* %llvm.dbg.subprograms to { }*),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([5 x sbyte]* %str1, int 0, int 0),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- uint 1,
- { }* null,
- bool false,
- bool true }, section "llvm.metadata"
-
-;;
-;; Define the name of the subprogram.
-;;
-%str1 = internal constant [5 x sbyte] c"main\00", section "llvm.metadata"
-
+!6 = metadata !{
+ i32 524334, ;; Tag
+ i32 0, ;; Unused
+ metadata !1, ;; Context
+ metadata !"main", ;; Name
+ metadata !"main", ;; Display name
+ metadata !"main", ;; Linkage name
+ metadata !1, ;; File
+ i32 1, ;; Line number
+ metadata !4, ;; Type
+ i1 false, ;; Is local
+ i1 true, ;; Is definition
+ i32 0, ;; Virtuality attribute, e.g. pure virtual function
+ i32 0, ;; Index into virtual table for C++ methods
+ i32 0, ;; Type that holds virtual table.
+ i32 0, ;; Flags
+ i1 false, ;; True if this function is optimized
+ Function *, ;; Pointer to llvm::Function
+ null ;; Function template parameters
+}
;;
;; Define the subprogram itself.
;;
-int %main(int %argc, sbyte** %argv) {
+define i32 @main(i32 %argc, i8** %argv) {
...
}
+
-
+
-
+
-
The following are the basic type descriptors for C/C++ core types;
-
-
+
The following are the basic type descriptors for C/C++ core types:
-
+
-
+
+
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([5 x sbyte]* %str1, int 0, int 0),
- { }* null,
- int 0,
- uint 32,
- uint 32,
- uint 0,
- uint 2 }, section "llvm.metadata"
-%str1 = internal constant [5 x sbyte] c"bool\00", section "llvm.metadata"
+!2 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"bool", ;; Name
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 8, ;; Size in Bits
+ i64 8, ;; Align in Bits
+ i64 0, ;; Offset in Bits
+ i32 0, ;; Flags
+ i32 2 ;; Encoding
+}
+
-
+
-
+
+
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([5 x sbyte]* %str1, int 0, int 0),
- { }* null,
- int 0,
- uint 8,
- uint 8,
- uint 0,
- uint 6 }, section "llvm.metadata"
-%str1 = internal constant [5 x sbyte] c"char\00", section "llvm.metadata"
+!2 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"char", ;; Name
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 8, ;; Size in Bits
+ i64 8, ;; Align in Bits
+ i64 0, ;; Offset in Bits
+ i32 0, ;; Flags
+ i32 6 ;; Encoding
+}
+
-
+
-
+
+
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([14 x sbyte]* %str1, int 0, int 0),
- { }* null,
- int 0,
- uint 8,
- uint 8,
- uint 0,
- uint 8 }, section "llvm.metadata"
-%str1 = internal constant [14 x sbyte] c"unsigned char\00", section "llvm.metadata"
+!2 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"unsigned char",
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 8, ;; Size in Bits
+ i64 8, ;; Align in Bits
+ i64 0, ;; Offset in Bits
+ i32 0, ;; Flags
+ i32 8 ;; Encoding
+}
+
-
+
-
+
+
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([10 x sbyte]* %str1, int 0, int 0),
- { }* null,
- int 0,
- uint 16,
- uint 16,
- uint 0,
- uint 5 }, section "llvm.metadata"
-%str1 = internal constant [10 x sbyte] c"short int\00", section "llvm.metadata"
+!2 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"short int",
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 16, ;; Size in Bits
+ i64 16, ;; Align in Bits
+ i64 0, ;; Offset in Bits
+ i32 0, ;; Flags
+ i32 5 ;; Encoding
+}
+
-
+
-
+
+
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([19 x sbyte]* %str1, int 0, int 0),
- { }* null,
- int 0,
- uint 16,
- uint 16,
- uint 0,
- uint 7 }, section "llvm.metadata"
-%str1 = internal constant [19 x sbyte] c"short unsigned int\00", section "llvm.metadata"
+!2 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"short unsigned int",
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 16, ;; Size in Bits
+ i64 16, ;; Align in Bits
+ i64 0, ;; Offset in Bits
+ i32 0, ;; Flags
+ i32 7 ;; Encoding
+}
+
-
+
-
+
+
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([4 x sbyte]* %str1, int 0, int 0),
- { }* null,
- int 0,
- uint 32,
- uint 32,
- uint 0,
- uint 5 }, section "llvm.metadata"
-%str1 = internal constant [4 x sbyte] c"int\00", section "llvm.metadata"
-
+!2 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"int", ;; Name
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 32, ;; Size in Bits
+ i64 32, ;; Align in Bits
+ i64 0, ;; Offset in Bits
+ i32 0, ;; Flags
+ i32 5 ;; Encoding
+}
+
-
+
-
+
+
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([13 x sbyte]* %str1, int 0, int 0),
- { }* null,
- int 0,
- uint 32,
- uint 32,
- uint 0,
- uint 7 }, section "llvm.metadata"
-%str1 = internal constant [13 x sbyte] c"unsigned int\00", section "llvm.metadata"
+!2 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"unsigned int",
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 32, ;; Size in Bits
+ i64 32, ;; Align in Bits
+ i64 0, ;; Offset in Bits
+ i32 0, ;; Flags
+ i32 7 ;; Encoding
+}
+
-
+
-
+
+
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([14 x sbyte]* %str1, int 0, int 0),
- { }* null,
- int 0,
- uint 64,
- uint 64,
- uint 0,
- uint 5 }, section "llvm.metadata"
-%str1 = internal constant [14 x sbyte] c"long long int\00", section "llvm.metadata"
+!2 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"long long int",
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 64, ;; Size in Bits
+ i64 64, ;; Align in Bits
+ i64 0, ;; Offset in Bits
+ i32 0, ;; Flags
+ i32 5 ;; Encoding
+}
+
-
+
-
+
+
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([23 x sbyte]* %str1, int 0, int 0),
- { }* null,
- int 0,
- uint 64,
- uint 64,
- uint 0,
- uint 7 }, section "llvm.metadata"
-%str1 = internal constant [23 x sbyte] c"long long unsigned int\00", section "llvm.metadata"
+!2 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"long long unsigned int",
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 64, ;; Size in Bits
+ i64 64, ;; Align in Bits
+ i64 0, ;; Offset in Bits
+ i32 0, ;; Flags
+ i32 7 ;; Encoding
+}
+
-
+
-
+
+
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([6 x sbyte]* %str1, int 0, int 0),
- { }* null,
- int 0,
- uint 32,
- uint 32,
- uint 0,
- uint 4 }, section "llvm.metadata"
-%str1 = internal constant [6 x sbyte] c"float\00", section "llvm.metadata"
+!2 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"float",
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 32, ;; Size in Bits
+ i64 32, ;; Align in Bits
+ i64 0, ;; Offset in Bits
+ i32 0, ;; Flags
+ i32 4 ;; Encoding
+}
+
-
+
-
+
+
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([7 x sbyte]* %str1, int 0, int 0),
- { }* null,
- int 0,
- uint 64,
- uint 64,
- uint 0,
- uint 4 }, section "llvm.metadata"
-%str1 = internal constant [7 x sbyte] c"double\00", section "llvm.metadata"
+!2 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"double",;; Name
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 64, ;; Size in Bits
+ i64 64, ;; Align in Bits
+ i64 0, ;; Offset in Bits
+ i32 0, ;; Flags
+ i32 4 ;; Encoding
+}
+
+
+
-
+
-
+
-
Given the following as an example of C/C++ derived type;
+
Given the following as an example of C/C++ derived type:
+
typedef const int *IntPtr;
+
-
a C/C++ front-end would generate the following descriptors;
+
a C/C++ front-end would generate the following descriptors:
+
;;
;; Define the typedef "IntPtr".
;;
-%llvm.dbg.derivedtype1 = internal constant %llvm.dbg.derivedtype.type {
- uint add(uint 22, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([7 x sbyte]* %str1, int 0, int 0),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- int 1,
- uint 0,
- uint 0,
- uint 0,
- { }* cast (%llvm.dbg.derivedtype.type* %llvm.dbg.derivedtype2 to { }*) }, section "llvm.metadata"
-%str1 = internal constant [7 x sbyte] c"IntPtr\00", section "llvm.metadata"
+!2 = metadata !{
+ i32 524310, ;; Tag
+ metadata !1, ;; Context
+ metadata !"IntPtr", ;; Name
+ metadata !3, ;; File
+ i32 0, ;; Line number
+ i64 0, ;; Size in bits
+ i64 0, ;; Align in bits
+ i64 0, ;; Offset in bits
+ i32 0, ;; Flags
+ metadata !4 ;; Derived From type
+}
;;
;; Define the pointer type.
;;
-%llvm.dbg.derivedtype2 = internal constant %llvm.dbg.derivedtype.type {
- uint add(uint 15, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* null,
- { }* null,
- int 0,
- uint 32,
- uint 32,
- uint 0,
- { }* cast (%llvm.dbg.derivedtype.type* %llvm.dbg.derivedtype3 to { }*) }, section "llvm.metadata"
-
+!4 = metadata !{
+ i32 524303, ;; Tag
+ metadata !1, ;; Context
+ metadata !"", ;; Name
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 64, ;; Size in bits
+ i64 64, ;; Align in bits
+ i64 0, ;; Offset in bits
+ i32 0, ;; Flags
+ metadata !5 ;; Derived From type
+}
;;
;; Define the const type.
;;
-%llvm.dbg.derivedtype3 = internal constant %llvm.dbg.derivedtype.type {
- uint add(uint 38, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* null,
- { }* null,
- int 0,
- uint 0,
- uint 0,
- uint 0,
- { }* cast (%llvm.dbg.basictype.type* %llvm.dbg.basictype1 to { }*) }, section "llvm.metadata"
-
+!5 = metadata !{
+ i32 524326, ;; Tag
+ metadata !1, ;; Context
+ metadata !"", ;; Name
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 32, ;; Size in bits
+ i64 32, ;; Align in bits
+ i64 0, ;; Offset in bits
+ i32 0, ;; Flags
+ metadata !6 ;; Derived From type
+}
;;
;; Define the int type.
;;
-%llvm.dbg.basictype1 = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([4 x sbyte]* %str2, int 0, int 0),
- { }* null,
- int 0,
- uint 32,
- uint 32,
- uint 0,
- uint 5 }, section "llvm.metadata"
-%str2 = internal constant [4 x sbyte] c"int\00", section "llvm.metadata"
+!6 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"int", ;; Name
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 32, ;; Size in bits
+ i64 32, ;; Align in bits
+ i64 0, ;; Offset in bits
+ i32 0, ;; Flags
+ 5 ;; Encoding
+}
+
-
+
-
+
-
Given the following as an example of C/C++ struct type;
+
Given the following as an example of C/C++ struct type:
+
struct Color {
unsigned Red;
@@ -1574,106 +1639,112 @@ struct Color {
unsigned Blue;
};
+
-
a C/C++ front-end would generate the following descriptors;
+
a C/C++ front-end would generate the following descriptors:
+
;;
;; Define basic type for unsigned int.
;;
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
- uint add(uint 36, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([13 x sbyte]* %str1, int 0, int 0),
- { }* null,
- int 0,
- uint 32,
- uint 32,
- uint 0,
- uint 7 }, section "llvm.metadata"
-%str1 = internal constant [13 x sbyte] c"unsigned int\00", section "llvm.metadata"
-
+!5 = metadata !{
+ i32 524324, ;; Tag
+ metadata !1, ;; Context
+ metadata !"unsigned int",
+ metadata !1, ;; File
+ i32 0, ;; Line number
+ i64 32, ;; Size in Bits
+ i64 32, ;; Align in Bits
+ i64 0, ;; Offset in Bits
+ i32 0, ;; Flags
+ i32 7 ;; Encoding
+}
;;
;; Define composite type for struct Color.
;;
-%llvm.dbg.compositetype = internal constant %llvm.dbg.compositetype.type {
- uint add(uint 19, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([6 x sbyte]* %str2, int 0, int 0),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- int 1,
- uint 96,
- uint 32,
- uint 0,
- { }* null,
- { }* cast ([3 x { }*]* %llvm.dbg.array to { }*) }, section "llvm.metadata"
-%str2 = internal constant [6 x sbyte] c"Color\00", section "llvm.metadata"
+!2 = metadata !{
+ i32 524307, ;; Tag
+ metadata !1, ;; Context
+ metadata !"Color", ;; Name
+ metadata !1, ;; Compile unit
+ i32 1, ;; Line number
+ i64 96, ;; Size in bits
+ i64 32, ;; Align in bits
+ i64 0, ;; Offset in bits
+ i32 0, ;; Flags
+ null, ;; Derived From
+ metadata !3, ;; Elements
+ i32 0 ;; Runtime Language
+}
;;
;; Define the Red field.
;;
-%llvm.dbg.derivedtype1 = internal constant %llvm.dbg.derivedtype.type {
- uint add(uint 13, uint 262144),
- { }* null,
- sbyte* getelementptr ([4 x sbyte]* %str3, int 0, int 0),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- int 2,
- uint 32,
- uint 32,
- uint 0,
- { }* cast (%llvm.dbg.basictype.type* %llvm.dbg.basictype to { }*) }, section "llvm.metadata"
-%str3 = internal constant [4 x sbyte] c"Red\00", section "llvm.metadata"
+!4 = metadata !{
+ i32 524301, ;; Tag
+ metadata !1, ;; Context
+ metadata !"Red", ;; Name
+ metadata !1, ;; File
+ i32 2, ;; Line number
+ i64 32, ;; Size in bits
+ i64 32, ;; Align in bits
+ i64 0, ;; Offset in bits
+ i32 0, ;; Flags
+ metadata !5 ;; Derived From type
+}
;;
;; Define the Green field.
;;
-%llvm.dbg.derivedtype2 = internal constant %llvm.dbg.derivedtype.type {
- uint add(uint 13, uint 262144),
- { }* null,
- sbyte* getelementptr ([6 x sbyte]* %str4, int 0, int 0),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- int 3,
- uint 32,
- uint 32,
- uint 32,
- { }* cast (%llvm.dbg.basictype.type* %llvm.dbg.basictype to { }*) }, section "llvm.metadata"
-%str4 = internal constant [6 x sbyte] c"Green\00", section "llvm.metadata"
+!6 = metadata !{
+ i32 524301, ;; Tag
+ metadata !1, ;; Context
+ metadata !"Green", ;; Name
+ metadata !1, ;; File
+ i32 3, ;; Line number
+ i64 32, ;; Size in bits
+ i64 32, ;; Align in bits
+ i64 32, ;; Offset in bits
+ i32 0, ;; Flags
+ metadata !5 ;; Derived From type
+}
;;
;; Define the Blue field.
;;
-%llvm.dbg.derivedtype3 = internal constant %llvm.dbg.derivedtype.type {
- uint add(uint 13, uint 262144),
- { }* null,
- sbyte* getelementptr ([5 x sbyte]* %str5, int 0, int 0),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- int 4,
- uint 32,
- uint 32,
- uint 64,
- { }* cast (%llvm.dbg.basictype.type* %llvm.dbg.basictype to { }*) }, section "llvm.metadata"
-%str5 = internal constant [5 x sbyte] c"Blue\00", section "llvm.metadata"
+!7 = metadata !{
+ i32 524301, ;; Tag
+ metadata !1, ;; Context
+ metadata !"Blue", ;; Name
+ metadata !1, ;; File
+ i32 4, ;; Line number
+ i64 32, ;; Size in bits
+ i64 32, ;; Align in bits
+ i64 64, ;; Offset in bits
+ i32 0, ;; Flags
+ metadata !5 ;; Derived From type
+}
;;
;; Define the array of fields used by the composite type Color.
;;
-%llvm.dbg.array = internal constant [3 x { }*] [
- { }* cast (%llvm.dbg.derivedtype.type* %llvm.dbg.derivedtype1 to { }*),
- { }* cast (%llvm.dbg.derivedtype.type* %llvm.dbg.derivedtype2 to { }*),
- { }* cast (%llvm.dbg.derivedtype.type* %llvm.dbg.derivedtype3 to { }*) ], section "llvm.metadata"
+!3 = metadata !{metadata !4, metadata !6, metadata !7}
+
-
+
-
+
-
Given the following as an example of C/C++ enumeration type;
+
Given the following as an example of C/C++ enumeration type:
+
enum Trees {
Spruce = 100,
@@ -1681,61 +1752,54 @@ enum Trees {
Maple = 300
};
+
-
a C/C++ front-end would generate the following descriptors;
+
a C/C++ front-end would generate the following descriptors:
+
;;
;; Define composite type for enum Trees
;;
-%llvm.dbg.compositetype = internal constant %llvm.dbg.compositetype.type {
- uint add(uint 4, uint 262144),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- sbyte* getelementptr ([6 x sbyte]* %str1, int 0, int 0),
- { }* cast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to { }*),
- int 1,
- uint 32,
- uint 32,
- uint 0,
- { }* null,
- { }* cast ([3 x { }*]* %llvm.dbg.array to { }*) }, section "llvm.metadata"
-%str1 = internal constant [6 x sbyte] c"Trees\00", section "llvm.metadata"
+!2 = metadata !{
+ i32 524292, ;; Tag
+ metadata !1, ;; Context
+ metadata !"Trees", ;; Name
+ metadata !1, ;; File
+ i32 1, ;; Line number
+ i64 32, ;; Size in bits
+ i64 32, ;; Align in bits
+ i64 0, ;; Offset in bits
+ i32 0, ;; Flags
+ null, ;; Derived From type
+ metadata !3, ;; Elements
+ i32 0 ;; Runtime language
+}
+
+;;
+;; Define the array of enumerators used by composite type Trees.
+;;
+!3 = metadata !{metadata !4, metadata !5, metadata !6}
;;
;; Define Spruce enumerator.
;;
-%llvm.dbg.enumerator1 = internal constant %llvm.dbg.enumerator.type {
- 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"
+!4 = metadata !{i32 524328, metadata !"Spruce", i64 100}
;;
;; Define Oak enumerator.
;;
-%llvm.dbg.enumerator2 = internal constant %llvm.dbg.enumerator.type {
- 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"
+!5 = metadata !{i32 524328, metadata !"Oak", i64 200}
;;
;; Define Maple enumerator.
;;
-%llvm.dbg.enumerator3 = internal constant %llvm.dbg.enumerator.type {
- 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"
+!6 = metadata !{i32 524328, metadata !"Maple", i64 300}
-;;
-;; Define the array of enumerators used by composite type Trees.
-;;
-%llvm.dbg.array = internal constant [3 x { }*] [
- { }* cast (%llvm.dbg.enumerator.type* %llvm.dbg.enumerator1 to { }*),
- { }* cast (%llvm.dbg.enumerator.type* %llvm.dbg.enumerator2 to { }*),
- { }* cast (%llvm.dbg.enumerator.type* %llvm.dbg.enumerator3 to { }*) ], section "llvm.metadata"
+
+
+
@@ -1744,12 +1808,12 @@ enum Trees {
+ src="http://jigsaw.w3.org/css-validator/images/vcss-blue" alt="Valid CSS">
+ src="http://www.w3.org/Icons/valid-html401-blue" alt="Valid HTML 4.01">
Chris Lattner
- LLVM Compiler Infrastructure
+ LLVM Compiler Infrastructure
Last modified: $Date$