Add DIBuilder binding

llvmpy/src/DIBuilder.py

@@ -0,0 +1,357 @@
+from binding import *
+from .namespace import llvm
+
+DIBuilder = llvm.Class()
+
+from .Module import Module
+from .Value import Value, MDNode, Function, BasicBlock
+from .Instruction import Instruction
+from .DebugInfo import DIFile, DIEnumerator, DIType, DIBasicType, DIDerivedType
+from .DebugInfo import DIDescriptor, DIArray, DISubrange, DIGlobalVariable
+from .DebugInfo import DIVariable, DISubprogram, DINameSpace, DILexicalBlockFile
+from .DebugInfo import DILexicalBlock
+from .ADT.SmallVector import SmallVector_Value
+from .ADT.StringRef import StringRef
+
+unsigned_arg = cast(int, Unsigned)
+stringref_arg = cast(str, StringRef)
+bool_arg = cast(bool, Bool)
+uint64_arg = cast(int, Uint64)
+int64_arg = cast(int, Int64)
+
+@DIBuilder
+class DIBuilder:
+    _include_ = 'llvm/DIBuilder.h'
+    new = Constructor(ref(Module))
+    delete = Destructor()
+
+    getCU = Method(const(ptr(MDNode)))
+    finalize = Method()
+
+    createCompileUnit = Method(Void,
+                               unsigned_arg,  # Lang
+                               stringref_arg, # File
+                               stringref_arg, # Dir
+                               stringref_arg, # Producer
+                               bool_arg,      # isOptimized
+                               stringref_arg, # Flags,
+                               unsigned_arg,  # RV
+                               # stringref_arg, # SplitName LLVM3.3
+                               )  #.require_only(7)
+
+    createFile = Method(DIFile,
+                        stringref_arg,  # Filename
+                        stringref_arg,  # Directory
+                        )
+
+    createEnumerator = Method(DIEnumerator,
+                              stringref_arg,    # Name
+                              uint64_arg,       # Val
+                              )
+
+    createNullPtrType = Method(DIType,
+                               stringref_arg,   # Name
+                               )
+
+    createBasicType = Method(DIType,
+                             stringref_arg,     # Name
+                             uint64_arg,        # SizeIntBits,
+                             uint64_arg,        # AlignInBits,
+                             unsigned_arg,      # Encoding
+                             )
+
+    createQualifiedType = Method(DIType,
+                                 unsigned_arg,  # Tag
+                                 ref(DIType),   # FromTy
+                                 )
+
+    createPointerType = Method(DIType,
+                               ref(DIType),  # PointeeTy
+                               uint64_arg,   # SizeInBits
+                               uint64_arg,   # AlignInBits
+                               stringref_arg, # Name
+                               ).require_only(2)
+
+    createReferenceType = Method(DIType,
+                                 unsigned_arg,  # Tag
+                                 ref(DIType),   # RTy
+                                 )
+
+    createTypedef = Method(DIType,
+                           ref(DIType),        # Ty
+                           stringref_arg,     # Name
+                           ref(DIFile),       # File
+                           unsigned_arg,      # LineNo
+                           ref(DIDescriptor), # Context
+                           )
+
+    createFriend = Method(DIType,
+                          ref(DIType),   # Ty
+                          ref(DIType), # FriendTy
+                          )
+
+    createInheritance = Method(DIType,
+                               ref(DIType),       # Ty
+                               ref(DIType),       # BaseTy
+                               uint64_arg,        # BaseOffset
+                               unsigned_arg,      # Flags
+                               )
+
+    createMemberType = Method(DIType,
+                              ref(DIDescriptor),   # Scope
+                              stringref_arg,        # Name
+                              ref(DIFile),          # File
+                              unsigned_arg,         # LineNo
+                              uint64_arg,           # SizeInBits
+                              uint64_arg,           # AlignInBits
+                              uint64_arg,           # OffsetInBits
+                              unsigned_arg,         # Flags
+                              ref(DIType),          # Ty
+                              )
+
+    createClassType = Method(DIType,
+                             ref(DIDescriptor),     # Scope
+                             stringref_arg,         # Name
+                             ref(DIFile),           # File
+                             unsigned_arg,          # LineNum
+                             uint64_arg,            # SizeInBits
+                             uint64_arg,            # AlignInBits
+                             uint64_arg,            # OffsetInBits,
+                             unsigned_arg,          # Flags
+                             ref(DIType),           # DerivedFrom
+                             ref(DIArray),          # Elements
+                             ptr(MDNode),           # VTableHolder = 0
+                             ptr(MDNode),           # TemplateParms = 0
+                             ).require_only(10)
+
+    createStructType = Method(DIType,
+                              ref(DIDescriptor),   # Scope
+                              stringref_arg,        # Name
+                              ref(DIFile),          # File
+                              unsigned_arg,         # LineNumber
+                              uint64_arg,           # SizeInBits
+                              uint64_arg,           # AlignInBits
+                              unsigned_arg,         # Flags
+                              ref(DIArray),         # Elements
+                              unsigned_arg,         # RunTimeLang = 0
+                              ).require_only(8)
+
+    createUnionType = Method(DIType,
+                             ref(DIDescriptor),     # Scope
+                             stringref_arg,         # Name
+                             ref(DIFile),           # File
+                             unsigned_arg,          # LineNum
+                             uint64_arg,            # SizeInBits
+                             uint64_arg,            # AlignInBits
+                             unsigned_arg,          # Flags
+                             ref(DIArray),          # Elements
+                             unsigned_arg,          # RunTimeLang = 0
+                             ).require_only(8)
+
+    createArrayType = Method(DIType,
+                             uint64_arg,  # Size
+                             uint64_arg,  # AlignInBits
+                             ref(DIType),  # Ty
+                             ref(DIArray),  # Subscripts
+                             )
+
+    createVectorType = Method(DIType,
+                             uint64_arg,  # Size
+                             uint64_arg,  # AlignInBits
+                             ref(DIType),  # Ty
+                             ref(DIArray),  # Subscripts
+                             )
+
+    createEnumerationType = Method(DIType,
+                                   ref(DIDescriptor),   # Scope
+                                   stringref_arg,       # Name
+                                   ref(DIFile),         # File
+                                   unsigned_arg,        # LineNumber
+                                   uint64_arg,          # SizeInBits
+                                   uint64_arg,          # AlignInBits
+                                   ref(DIArray),        # Elements
+                                   ref(DIType),         # ClassType
+                                   )
+
+    createSubroutineType = Method(DIType,
+                                  ref(DIFile),      # File
+                                  ref(DIArray),     # ParameterTypes
+                                  )
+
+    createArtificialType = Method(DIType,
+                                ref(DIType),      # Ty
+                                )
+
+    createObjectPointerType = Method(DIType,
+                                ref(DIType),      # Ty
+                                )
+    
+    createTemporaryType = Method(DIType, ref(DIFile)).require_only(0)
+
+    createForwardDecl = Method(DIType,
+                               unsigned_arg,         # Tag
+                               stringref_arg,        # Name
+                               ref(DIDescriptor),    # scope
+                               ref(DIFile),          # F
+                               unsigned_arg,         # Line
+                               unsigned_arg,         # RuntimeLang=0
+                               uint64_arg,           # SizeInBits=0
+                               uint64_arg,           # AlignInBits=0
+                               ).require_only(5)
+
+    retainType = Method(Void, ref(DIType))
+
+    createUnspecifiedParameter = Method(DIDescriptor)
+
+    getOrCreateArray = Method(DIArray,
+                              ref(SmallVector_Value),   # Elements
+                              )
+
+    getOrCreateSubrange = Method(DISubrange,
+                                 int64_arg,     # Lo
+                                 int64_arg,     # Hi
+                                 )
+
+    createGlobalVariable = Method(DIGlobalVariable,
+                                  stringref_arg,    # Name
+                                  ref(DIFile),      # File
+                                  unsigned_arg,     # LineNo
+                                  ref(DIType),      # Ty
+                                  bool_arg,         # isLocalToUnit
+                                  ptr(Value),       # Val
+                                  )
+
+    createStaticVariable = Method(DIGlobalVariable,
+                                  ref(DIDescriptor), # Context
+                                  stringref_arg,     # Name
+                                  stringref_arg,     # LinkageName
+                                  ref(DIFile),       # File
+                                  unsigned_arg,      # LineNo
+                                  ref(DIType),       # Ty
+                                  bool_arg,          # isLocalToUnit
+                                  ptr(Value),        # Val
+                                  )
+ 
+    createLocalVariable = Method(DIVariable,
+                                 unsigned_arg,      # Tag,
+                                 ref(DIDescriptor), # Scope,
+                                 stringref_arg,     # Name,
+                                 ref(DIFile),       # File,
+                                 unsigned_arg,      # LineNo,
+                                 ref(DIType),       # Ty,
+                                 bool_arg,          # AlwaysPreserve=false,
+                                 unsigned_arg,      # Flags=0,
+                                 unsigned_arg,      # ArgNo=0
+                                 ).require_only(6)
+
+    createComplexVariable = Method(DIVariable,
+                                   unsigned_arg,        # Tag,
+                                   ref(DIDescriptor),   # Scope,
+                                   stringref_arg,       # Name,
+                                   ref(DIFile),         # F,
+                                   unsigned_arg,        # LineNo,
+                                   ref(DIType),         # Ty,
+                                   ref(SmallVector_Value),   # Addr,
+                                   unsigned_arg,        # ArgNo=0,
+                                   ).require_only(7)
+ 
+    createFunction = Method(DISubprogram,
+                            ref(DIDescriptor),  # Scope
+                            stringref_arg,      # Name
+                            stringref_arg,      # LinkageName
+                            ref(DIFile),        # File
+                            unsigned_arg,       # LineNo
+                            ref(DIType),        # Ty
+                            bool_arg,           # isLocalToUnit
+                            bool_arg,           # isDefinition
+                            unsigned_arg,       # ScopeLine
+                            unsigned_arg,       # Flags=0
+                            bool_arg,           # isOptimized=false
+                            ptr(Function),      # *Fn=0
+                            ptr(MDNode),        # *TParam=0,
+                            ptr(MDNode),        # *Decl=0
+                            ).require_only(9)
+
+
+    createMethod = Method(DISubprogram,
+                          ref(DIDescriptor),        # Scope
+                          stringref_arg,            # Name
+                          stringref_arg,            # LinkageName
+                          ref(DIFile),              # File
+                          unsigned_arg,             # LineNo
+                          ref(DIType),              # Ty
+                          bool_arg,                 # isLocalToUnit
+                          bool_arg,                 # isDefinition
+                          unsigned_arg,             # Virtuality=0
+                          unsigned_arg,             # VTableIndex=0
+                          ptr(MDNode),              # *VTableHolder=0
+                          unsigned_arg,             # Flags=0
+                          bool_arg,                 # isOptimized=false
+                          ptr(Function),            # *Fn=0
+                          ptr(MDNode),              # *TParam=0
+                          ).require_only(8)
+
+
+    createNameSpace = Method(DINameSpace,
+                             ref(DIDescriptor),     # Scope,
+                             stringref_arg,         # Name,
+                             ref(DIFile),           # File,
+                             unsigned_arg,          # LineNo
+                             )
+
+    createLexicalBlockFile = Method(DILexicalBlockFile, 
+                                    ref(DIDescriptor),  # Scope,
+                                    ref(DIFile),        # File
+                                    )
+
+    createLexicalBlock = Method(DILexicalBlock,
+                                ref(DIDescriptor),  # Scope,
+                                ref(DIFile),        # File,
+                                unsigned_arg,       # Line,
+                                unsigned_arg,       # Col
+                                )
+ 
+    _insertDeclare_1 = Method(ptr(Instruction),
+                           ptr(Value),          # Storage,
+                           ref(DIVariable),     # VarInfo
+                           ptr(BasicBlock),     # *InsertAtEnd
+                           )
+    _insertDeclare_1.realname = 'insertDeclare'
+
+    _insertDeclare_2 = Method(ptr(Instruction),
+                           ptr(Value),          # Storage,
+                           ref(DIVariable),     # VarInfo
+                           ptr(Instruction),     # *InsertBefore
+                           )
+    _insertDeclare_2.realname = 'insertDeclare'
+
+    @CustomPythonMethod
+    def insertDeclare(self, storage, varinfo, insertpt):
+        if isinstance(insertbefore, _api.llvm.Instruction):
+            return self._insertDeclare_2(storage, varinfo, insertpt)
+        else:
+            return self._insertDeclare_1(storage, varinfo, insertpt)
+
+    _insertDbgValueIntrinsic_1 = Method(ptr(Instruction),
+                                        ptr(Value),        # *Val
+                                        uint64_arg,        # Offset
+                                        ref(DIVariable),   # VarInfo
+                                        ptr(BasicBlock),   # *InsertAtEnd
+                                        )
+    _insertDbgValueIntrinsic_1.realname = 'insertDbgValueIntrinsic'
+
+    _insertDbgValueIntrinsic_2 = Method(ptr(Instruction),
+                                        ptr(Value),        # *Val
+                                        uint64_arg,        # Offset
+                                        ref(DIVariable),   # VarInfo
+                                        ptr(Instruction),   # *InsertAtEnd
+                                        )
+    _insertDbgValueIntrinsic_2.realname = 'insertDbgValueIntrinsic'
+
+
+    @CustomPythonMethod
+    def insertDbgValueIntrinsic(self, storage, varinfo, insertpt):
+        if isinstance(insertbefore, _api.llvm.Instruction):
+            return self._insertDbgValueIntrinsic_2(storage, varinfo, insertpt)
+        else:
+            return self._insertDbgValueIntrinsic_1(storage, varinfo, insertpt)

llvmpy/src/DebugInfo.py

@@ -0,0 +1,98 @@
+from binding import *
+from .namespace import llvm
+
+from .ADT.StringRef import StringRef
+from .Value import MDNode
+
+DIDescriptor = llvm.Class(MDNode)
+DIEnumerator = llvm.Class(DIDescriptor)
+DIScope = llvm.Class(DIDescriptor)
+DIType = llvm.Class(DIScope)
+DIBasicType = llvm.Class(DIType)
+DIDerivedType = llvm.Class(DIType)
+DICompositeType = llvm.Class(DIDerivedType)
+DIFile = llvm.Class(DIScope)
+DIArray = llvm.Class(DIDescriptor)
+DISubrange = llvm.Class(DIDescriptor)
+DIGlobalVariable = llvm.Class(DIDescriptor)
+DIVariable = llvm.Class(DIDescriptor)
+DISubprogram = llvm.Class(DIScope)
+DINameSpace = llvm.Class(DIScope)
+DILexicalBlockFile = llvm.Class(DIScope)
+DILexicalBlock = llvm.Class(DIScope)
+
+llvm.includes.add('llvm/DebugInfo.h')
+
+return_bool = cast(Bool, bool)
+return_stringref = cast(StringRef, str)
+return_unsigned = cast(Unsigned, int)
+
+@DIDescriptor
+class DIDescriptor:
+    pass
+
+@DIScope
+class DIScope:
+    pass
+
+@DIFile
+class DIFile:
+    # getFileNode = Method(ptr(MDNode)) # not in LLVM 3.2?
+    Verify = Method(return_bool)
+
+@DIEnumerator
+class DIEnumerator:
+    getName = Method(return_stringref)
+    getEnumValue = Method(cast(Uint64, int))
+    Verify = Method(return_bool)
+
+@DIType
+class DIType:
+    getName = Method(return_stringref)
+    getLineNumber = Method(return_unsigned)
+    Verify = Method(return_bool)
+
+@DIBasicType
+class DIBasicType:
+    pass
+
+@DIDerivedType
+class DIDerivedType:
+    pass
+
+@DICompositeType
+class DICompositeType:
+    pass
+
+@DIArray
+class DIArray:
+    Verify = Method(return_bool)
+
+@DISubrange
+class DISubrange:
+    Verify = Method(return_bool)
+
+@DIGlobalVariable
+class DIGlobalVariable:
+    Verify = Method(return_bool)
+
+@DIVariable
+class DIVariable:
+    Verify = Method(return_bool)
+
+@DISubprogram
+class DISubprogram:
+    Verify = Method(return_bool)
+
+@DINameSpace
+class DINameSpace:
+    Verify = Method(return_bool)
+
+@DILexicalBlockFile
+class DILexicalBlockFile:
+    Verify = Method(return_bool)
+
+@DILexicalBlock
+class DILexicalBlock:
+    Verify = Method(return_bool)
+

llvmpy/src/Support/Dwarf.py

@@ -0,0 +1,563 @@
+from binding import *
+from ..namespace import llvm
+
+dwarf = llvm.Namespace('dwarf')
+
+dwarf.includes.add('llvm/Support/Dwarf.h')
+
+dwarf_constants = dwarf.Enum('dwarf_constants',
+'''
+DWARF_VERSION 	
+DW_TAG_array_type 	
+DW_TAG_class_type 	
+DW_TAG_entry_point 	
+DW_TAG_enumeration_type 	
+DW_TAG_formal_parameter 	
+DW_TAG_imported_declaration 	
+DW_TAG_label 	
+DW_TAG_lexical_block 	
+DW_TAG_member 	
+DW_TAG_pointer_type
+DW_TAG_reference_type 	
+DW_TAG_compile_unit 	
+DW_TAG_string_type 	
+DW_TAG_structure_type 	
+DW_TAG_subroutine_type 	
+DW_TAG_typedef 	
+DW_TAG_union_type 	
+DW_TAG_unspecified_parameters 	
+DW_TAG_variant 	
+DW_TAG_common_block 	
+DW_TAG_common_inclusion 	
+DW_TAG_inheritance 	
+DW_TAG_inlined_subroutine 	
+DW_TAG_module 	
+DW_TAG_ptr_to_member_type 	
+DW_TAG_set_type 	
+DW_TAG_subrange_type 	
+DW_TAG_with_stmt 	
+DW_TAG_access_declaration 	
+DW_TAG_base_type 	
+DW_TAG_catch_block 	
+DW_TAG_const_type 	
+DW_TAG_constant 	
+DW_TAG_enumerator 	
+DW_TAG_file_type 	
+DW_TAG_friend 	
+DW_TAG_namelist 	
+DW_TAG_namelist_item 	
+DW_TAG_packed_type 	
+DW_TAG_subprogram 	
+DW_TAG_template_type_parameter 	
+DW_TAG_template_value_parameter 	
+DW_TAG_thrown_type 	
+DW_TAG_try_block 	
+DW_TAG_variant_part 	
+DW_TAG_variable 	
+DW_TAG_volatile_type 	
+DW_TAG_dwarf_procedure 	
+DW_TAG_restrict_type 	
+DW_TAG_interface_type 	
+DW_TAG_namespace 	
+DW_TAG_imported_module 	
+DW_TAG_unspecified_type 	
+DW_TAG_partial_unit 	
+DW_TAG_imported_unit 	
+DW_TAG_condition 	
+DW_TAG_shared_type 	
+DW_TAG_type_unit 	
+DW_TAG_rvalue_reference_type 	
+DW_TAG_template_alias 	
+DW_TAG_MIPS_loop 	
+DW_TAG_format_label 	
+DW_TAG_function_template 	
+DW_TAG_class_template 	
+DW_TAG_GNU_template_template_param 	
+DW_TAG_GNU_template_parameter_pack 	
+DW_TAG_GNU_formal_parameter_pack 	
+DW_TAG_lo_user 	
+DW_TAG_APPLE_property 	
+DW_TAG_hi_user 	
+DW_CHILDREN_no 	
+DW_CHILDREN_yes 	
+DW_AT_sibling 	
+DW_AT_location 	
+DW_AT_name 	
+DW_AT_ordering 	
+DW_AT_byte_size 	
+DW_AT_bit_offset 	
+DW_AT_bit_size 	
+DW_AT_stmt_list 	
+DW_AT_low_pc 	
+DW_AT_high_pc 	
+DW_AT_language 	
+DW_AT_discr
+DW_AT_discr_value 	
+DW_AT_visibility 	
+DW_AT_import 	
+DW_AT_string_length 	
+DW_AT_common_reference 	
+DW_AT_comp_dir 	
+DW_AT_const_value 	
+DW_AT_containing_type 	
+DW_AT_default_value 	
+DW_AT_inline 	
+DW_AT_is_optional 	
+DW_AT_lower_bound 	
+DW_AT_producer 	
+DW_AT_prototyped 	
+DW_AT_return_addr 	
+DW_AT_start_scope 	
+DW_AT_bit_stride 	
+DW_AT_upper_bound 	
+DW_AT_abstract_origin 	
+DW_AT_accessibility 	
+DW_AT_address_class 	
+DW_AT_artificial 	
+DW_AT_base_types 	
+DW_AT_calling_convention 	
+DW_AT_count 	
+DW_AT_data_member_location 	
+DW_AT_decl_column 	
+DW_AT_decl_file 	
+DW_AT_decl_line 	
+DW_AT_declaration 	
+DW_AT_discr_list 	
+DW_AT_encoding 	
+DW_AT_external 	
+DW_AT_frame_base 	
+DW_AT_friend 	
+DW_AT_identifier_case 	
+DW_AT_macro_info 	
+DW_AT_namelist_item 	
+DW_AT_priority 	
+DW_AT_segment 	
+DW_AT_specification 	
+DW_AT_static_link 	
+DW_AT_type 	
+DW_AT_use_location 	
+DW_AT_variable_parameter 	
+DW_AT_virtuality 	
+DW_AT_vtable_elem_location 	
+DW_AT_allocated 	
+DW_AT_associated 	
+DW_AT_data_location 	
+DW_AT_byte_stride 	
+DW_AT_entry_pc 	
+DW_AT_use_UTF8 	
+DW_AT_extension 	
+DW_AT_ranges 	
+DW_AT_trampoline 	
+DW_AT_call_column 	
+DW_AT_call_file 	
+DW_AT_call_line 	
+DW_AT_description 	
+DW_AT_binary_scale 	
+DW_AT_decimal_scale 	
+DW_AT_small 	
+DW_AT_decimal_sign 	
+DW_AT_digit_count 	
+DW_AT_picture_string 	
+DW_AT_mutable 	
+DW_AT_threads_scaled 	
+DW_AT_explicit 	
+DW_AT_object_pointer 	
+DW_AT_endianity 	
+DW_AT_elemental 	
+DW_AT_pure 	
+DW_AT_recursive 	
+DW_AT_signature 	
+DW_AT_main_subprogram 	
+DW_AT_data_bit_offset 	
+DW_AT_const_expr 	
+DW_AT_enum_class 	
+DW_AT_linkage_name 	
+DW_AT_lo_user 	
+DW_AT_hi_user 	
+DW_AT_MIPS_loop_begin 	
+DW_AT_MIPS_tail_loop_begin 	
+DW_AT_MIPS_epilog_begin 	
+DW_AT_MIPS_loop_unroll_factor 	
+DW_AT_MIPS_software_pipeline_depth 	
+DW_AT_MIPS_linkage_name 	
+DW_AT_MIPS_stride 	
+DW_AT_MIPS_abstract_name 	
+DW_AT_MIPS_clone_origin 	
+DW_AT_MIPS_has_inlines 	
+DW_AT_MIPS_stride_byte 	
+DW_AT_MIPS_stride_elem 	
+DW_AT_MIPS_ptr_dopetype 	
+DW_AT_MIPS_allocatable_dopetype 	
+DW_AT_MIPS_assumed_shape_dopetype 	
+DW_AT_MIPS_assumed_size 	
+DW_AT_sf_names 	
+DW_AT_src_info 	
+DW_AT_mac_info 	
+DW_AT_src_coords 	
+DW_AT_body_begin 	
+DW_AT_body_end 	
+DW_AT_APPLE_optimized
+DW_AT_APPLE_flags 	
+DW_AT_APPLE_isa 	
+DW_AT_APPLE_block 	
+DW_AT_APPLE_major_runtime_vers 	
+DW_AT_APPLE_runtime_class 	
+DW_AT_APPLE_omit_frame_ptr 	
+DW_AT_APPLE_property_name 	
+DW_AT_APPLE_property_getter 	
+DW_AT_APPLE_property_setter 	
+DW_AT_APPLE_property_attribute 	
+DW_AT_APPLE_objc_complete_type 	
+DW_AT_APPLE_property 	
+DW_FORM_addr 	
+DW_FORM_block2 	
+DW_FORM_block4 	
+DW_FORM_data2 	
+DW_FORM_data4 	
+DW_FORM_data8 	
+DW_FORM_string 	
+DW_FORM_block 	
+DW_FORM_block1 	
+DW_FORM_data1 	
+DW_FORM_flag 	
+DW_FORM_sdata 	
+DW_FORM_strp 	
+DW_FORM_udata 	
+DW_FORM_ref_addr 	
+DW_FORM_ref1 	
+DW_FORM_ref2 	
+DW_FORM_ref4 	
+DW_FORM_ref8 	
+DW_FORM_ref_udata 	
+DW_FORM_indirect 	
+DW_FORM_sec_offset 	
+DW_FORM_exprloc 	
+DW_FORM_flag_present 	
+DW_FORM_ref_sig8
+DW_OP_addr 	
+DW_OP_deref 	
+DW_OP_const1u 	
+DW_OP_const1s 	
+DW_OP_const2u 	
+DW_OP_const2s 	
+DW_OP_const4u 	
+DW_OP_const4s 	
+DW_OP_const8u 	
+DW_OP_const8s 	
+DW_OP_constu 	
+DW_OP_consts 	
+DW_OP_dup 	
+DW_OP_drop 	
+DW_OP_over 	
+DW_OP_pick 	
+DW_OP_swap 	
+DW_OP_rot 	
+DW_OP_xderef 	
+DW_OP_abs 	
+DW_OP_and 	
+DW_OP_div 	
+DW_OP_minus 	
+DW_OP_mod 	
+DW_OP_mul 	
+DW_OP_neg 	
+DW_OP_not 	
+DW_OP_or 	
+DW_OP_plus 	
+DW_OP_plus_uconst 	
+DW_OP_shl 	
+DW_OP_shr 	
+DW_OP_shra 	
+DW_OP_xor 	
+DW_OP_skip 	
+DW_OP_bra 	
+DW_OP_eq 	
+DW_OP_ge 	
+DW_OP_gt 	
+DW_OP_le 	
+DW_OP_lt 	
+DW_OP_ne 	
+DW_OP_lit0 	
+DW_OP_lit1 	
+DW_OP_lit2 	
+DW_OP_lit3 	
+DW_OP_lit4 	
+DW_OP_lit5 	
+DW_OP_lit6 	
+DW_OP_lit7 	
+DW_OP_lit8 	
+DW_OP_lit9 	
+DW_OP_lit10 	
+DW_OP_lit11 	
+DW_OP_lit12 	
+DW_OP_lit13 	
+DW_OP_lit14 	
+DW_OP_lit15 	
+DW_OP_lit16 	
+DW_OP_lit17 	
+DW_OP_lit18 	
+DW_OP_lit19 	
+DW_OP_lit20 	
+DW_OP_lit21 	
+DW_OP_lit22 	
+DW_OP_lit23 	
+DW_OP_lit24 	
+DW_OP_lit25 	
+DW_OP_lit26 	
+DW_OP_lit27 	
+DW_OP_lit28 	
+DW_OP_lit29 	
+DW_OP_lit30 	
+DW_OP_lit31 	
+DW_OP_reg0 	
+DW_OP_reg1 	
+DW_OP_reg2 	
+DW_OP_reg3 	
+DW_OP_reg4 	
+DW_OP_reg5 	
+DW_OP_reg6 	
+DW_OP_reg7 	
+DW_OP_reg8 	
+DW_OP_reg9 	
+DW_OP_reg10 	
+DW_OP_reg11 	
+DW_OP_reg12 	
+DW_OP_reg13 	
+DW_OP_reg14 	
+DW_OP_reg15 	
+DW_OP_reg16 	
+DW_OP_reg17 	
+DW_OP_reg18 	
+DW_OP_reg19 	
+DW_OP_reg20 	
+DW_OP_reg21 	
+DW_OP_reg22 	
+DW_OP_reg23 	
+DW_OP_reg24 	
+DW_OP_reg25 	
+DW_OP_reg26 	
+DW_OP_reg27 	
+DW_OP_reg28 	
+DW_OP_reg29 	
+DW_OP_reg30 	
+DW_OP_reg31 	
+DW_OP_breg0 	
+DW_OP_breg1 	
+DW_OP_breg2 	
+DW_OP_breg3 	
+DW_OP_breg4 	
+DW_OP_breg5 	
+DW_OP_breg6 	
+DW_OP_breg7 	
+DW_OP_breg8 	
+DW_OP_breg9 	
+DW_OP_breg10 	
+DW_OP_breg11 	
+DW_OP_breg12 	
+DW_OP_breg13 	
+DW_OP_breg14 	
+DW_OP_breg15 	
+DW_OP_breg16 	
+DW_OP_breg17 	
+DW_OP_breg18 	
+DW_OP_breg19 	
+DW_OP_breg20 	
+DW_OP_breg21 	
+DW_OP_breg22 	
+DW_OP_breg23 	
+DW_OP_breg24 	
+DW_OP_breg25 	
+DW_OP_breg26 	
+DW_OP_breg27 	
+DW_OP_breg28 	
+DW_OP_breg29 	
+DW_OP_breg30 	
+DW_OP_breg31 	
+DW_OP_regx 	
+DW_OP_fbreg 	
+DW_OP_bregx 	
+DW_OP_piece 	
+DW_OP_deref_size 	
+DW_OP_xderef_size 	
+DW_OP_nop 	
+DW_OP_push_object_address 	
+DW_OP_call2 	
+DW_OP_call4 	
+DW_OP_call_ref 	
+DW_OP_form_tls_address 	
+DW_OP_call_frame_cfa 	
+DW_OP_bit_piece 	
+DW_OP_implicit_value 	
+DW_OP_stack_value 	
+DW_OP_lo_user 	
+DW_OP_hi_user
+DW_ATE_address 	
+DW_ATE_boolean 	
+DW_ATE_complex_float 	
+DW_ATE_float 	
+DW_ATE_signed 	
+DW_ATE_signed_char 	
+DW_ATE_unsigned 	
+DW_ATE_unsigned_char 	
+DW_ATE_imaginary_float 	
+DW_ATE_packed_decimal 	
+DW_ATE_numeric_string 	
+DW_ATE_edited 	
+DW_ATE_signed_fixed 	
+DW_ATE_unsigned_fixed 	
+DW_ATE_decimal_float 	
+DW_ATE_UTF 	
+DW_ATE_lo_user 	
+DW_ATE_hi_user 	
+DW_DS_unsigned 	
+DW_DS_leading_overpunch 	
+DW_DS_trailing_overpunch 	
+DW_DS_leading_separate 	
+DW_DS_trailing_separate 	
+DW_END_default 	
+DW_END_big 	
+DW_END_little 	
+DW_END_lo_user 	
+DW_END_hi_user 	
+DW_ACCESS_public 	
+DW_ACCESS_protected 	
+DW_ACCESS_private 	
+DW_VIS_local 	
+DW_VIS_exported 	
+DW_VIS_qualified 	
+DW_VIRTUALITY_none 	
+DW_VIRTUALITY_virtual 	
+DW_VIRTUALITY_pure_virtual 	
+DW_LANG_C89 	
+DW_LANG_C 	
+DW_LANG_Ada83 	
+DW_LANG_C_plus_plus 	
+DW_LANG_Cobol74 	
+DW_LANG_Cobol85 	
+DW_LANG_Fortran77 	
+DW_LANG_Fortran90 	
+DW_LANG_Pascal83 	
+DW_LANG_Modula2 	
+DW_LANG_Java 	
+DW_LANG_C99 	
+DW_LANG_Ada95 	
+DW_LANG_Fortran95 	
+DW_LANG_PLI 	
+DW_LANG_ObjC 	
+DW_LANG_ObjC_plus_plus 	
+DW_LANG_UPC 	
+DW_LANG_D 	
+DW_LANG_Python 	
+DW_LANG_lo_user 	
+DW_LANG_Mips_Assembler 	
+DW_LANG_hi_user 	
+DW_ID_case_sensitive 	
+DW_ID_up_case 	
+DW_ID_down_case 	
+DW_ID_case_insensitive 	
+DW_CC_normal 	
+DW_CC_program 	
+DW_CC_nocall 	
+DW_CC_lo_user 	
+DW_CC_hi_user 	
+DW_INL_not_inlined 	
+DW_INL_inlined 	
+DW_INL_declared_not_inlined 	
+DW_INL_declared_inlined 	
+DW_ORD_row_major 	
+DW_ORD_col_major 	
+DW_DSC_label 	
+DW_DSC_range 	
+DW_LNS_extended_op 	
+DW_LNS_copy 	
+DW_LNS_advance_pc 	
+DW_LNS_advance_line 	
+DW_LNS_set_file 	
+DW_LNS_set_column 	
+DW_LNS_negate_stmt 	
+DW_LNS_set_basic_block 	
+DW_LNS_const_add_pc 	
+DW_LNS_fixed_advance_pc 	
+DW_LNS_set_prologue_end 	
+DW_LNS_set_epilogue_begin 	
+DW_LNS_set_isa 	
+DW_LNE_end_sequence 	
+DW_LNE_set_address 	
+DW_LNE_define_file 	
+DW_LNE_set_discriminator 	
+DW_LNE_lo_user 	
+DW_LNE_hi_user 	
+DW_MACINFO_define 	
+DW_MACINFO_undef 	
+DW_MACINFO_start_file 	
+DW_MACINFO_end_file 	
+DW_MACINFO_vendor_ext 	
+DW_CFA_extended 	
+DW_CFA_nop 	
+DW_CFA_advance_loc 	
+DW_CFA_offset 	
+DW_CFA_restore 	
+DW_CFA_set_loc 	
+DW_CFA_advance_loc1 	
+DW_CFA_advance_loc2 	
+DW_CFA_advance_loc4 	
+DW_CFA_offset_extended 	
+DW_CFA_restore_extended 	
+DW_CFA_undefined 	
+DW_CFA_same_value 	
+DW_CFA_register 	
+DW_CFA_remember_state 	
+DW_CFA_restore_state 	
+DW_CFA_def_cfa 	
+DW_CFA_def_cfa_register 	
+DW_CFA_def_cfa_offset 	
+DW_CFA_def_cfa_expression 	
+DW_CFA_expression 	
+DW_CFA_offset_extended_sf 	
+DW_CFA_def_cfa_sf 	
+DW_CFA_def_cfa_offset_sf 	
+DW_CFA_val_offset 	
+DW_CFA_val_offset_sf 	
+DW_CFA_val_expression 	
+DW_CFA_MIPS_advance_loc8 	
+DW_CFA_GNU_window_save 	
+DW_CFA_GNU_args_size 	
+DW_CFA_lo_user 	
+DW_CFA_hi_user 	
+DW_EH_PE_absptr 	
+DW_EH_PE_omit 	
+DW_EH_PE_uleb128
+DW_EH_PE_udata2 	
+DW_EH_PE_udata4 	
+DW_EH_PE_udata8 	
+DW_EH_PE_sleb128 	
+DW_EH_PE_sdata2 	
+DW_EH_PE_sdata4 	
+DW_EH_PE_sdata8 	
+DW_EH_PE_signed 	
+DW_EH_PE_pcrel 	
+DW_EH_PE_textrel 	
+DW_EH_PE_datarel 	
+DW_EH_PE_funcrel 	
+DW_EH_PE_aligned 	
+DW_EH_PE_indirect 	
+DW_APPLE_PROPERTY_readonly 	
+DW_APPLE_PROPERTY_readwrite 	
+DW_APPLE_PROPERTY_assign 	
+DW_APPLE_PROPERTY_retain 	
+DW_APPLE_PROPERTY_copy 	
+DW_APPLE_PROPERTY_nonatomic 	
+''')
+
+### The following enums are not available in LLVM 3.2
+#    DW_AT_GNU_dwo_name
+#    DW_AT_GNU_vector 	
+#    DW_AT_GNU_template_name
+#    DW_AT_GNU_dwo_id
+#    DW_AT_GNU_ranges_base 	
+#    DW_AT_GNU_addr_base 	
+#    DW_AT_GNU_pubnames 	
+#    DW_AT_GNU_pubtypes 	
+#    DW_FORM_GNU_addr_index 	
+#    DW_FORM_GNU_str_index
+#    DW_OP_GNU_addr_index 	
+#    DW_OP_GNU_const_index