IR: Give 'DI' prefix to debug info metadata
authorDuncan P. N. Exon Smith <dexonsmith@apple.com>
Wed, 29 Apr 2015 16:38:44 +0000 (16:38 +0000)
committerDuncan P. N. Exon Smith <dexonsmith@apple.com>
Wed, 29 Apr 2015 16:38:44 +0000 (16:38 +0000)
Finish off PR23080 by renaming the debug info IR constructs from `MD*`
to `DI*`.  The last of the `DIDescriptor` classes were deleted in
r235356, and the last of the related typedefs removed in r235413, so
this has all baked for about a week.

Note: If you have out-of-tree code (like a frontend), I recommend that
you get everything compiling and tests passing with the *previous*
commit before updating to this one.  It'll be easier to keep track of
what code is using the `DIDescriptor` hierarchy and what you've already
updated, and I think you're extremely unlikely to insert bugs.  YMMV of
course.

Back to *this* commit: I did this using the rename-md-di-nodes.sh
upgrade script I've attached to PR23080 (both code and testcases) and
filtered through clang-format-diff.py.  I edited the tests for
test/Assembler/invalid-generic-debug-node-*.ll by hand since the columns
were off-by-three.  It should work on your out-of-tree testcases (and
code, if you've followed the advice in the previous paragraph).

Some of the tests are in badly named files now (e.g.,
test/Assembler/invalid-mdcompositetype-missing-tag.ll should be
'dicompositetype'); I'll come back and move the files in a follow-up
commit.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@236120 91177308-0d34-0410-b5e6-96231b3b80d8

548 files changed:
bindings/go/llvm/DIBuilderBindings.cpp
docs/CommandGuide/FileCheck.rst
docs/LangRef.rst
docs/SourceLevelDebugging.rst
docs/tutorial/LangImpl8.rst
examples/Kaleidoscope/Chapter8/toy.cpp
include/llvm/CodeGen/LexicalScopes.h
include/llvm/CodeGen/MachineInstr.h
include/llvm/CodeGen/MachineInstrBuilder.h
include/llvm/CodeGen/MachineModuleInfo.h
include/llvm/IR/DIBuilder.h
include/llvm/IR/DebugInfo.h
include/llvm/IR/DebugInfoMetadata.h
include/llvm/IR/DebugLoc.h
include/llvm/IR/IntrinsicInst.h
include/llvm/IR/Metadata.def
include/llvm/IR/Metadata.h
lib/Analysis/ModuleDebugInfoPrinter.cpp
lib/AsmParser/LLParser.cpp
lib/Bitcode/Reader/BitcodeReader.cpp
lib/Bitcode/Writer/BitcodeWriter.cpp
lib/Bitcode/Writer/ValueEnumerator.cpp
lib/Bitcode/Writer/ValueEnumerator.h
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
lib/CodeGen/AsmPrinter/DbgValueHistoryCalculator.cpp
lib/CodeGen/AsmPrinter/DbgValueHistoryCalculator.h
lib/CodeGen/AsmPrinter/DebugLocEntry.h
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
lib/CodeGen/AsmPrinter/DwarfDebug.cpp
lib/CodeGen/AsmPrinter/DwarfDebug.h
lib/CodeGen/AsmPrinter/DwarfExpression.cpp
lib/CodeGen/AsmPrinter/DwarfExpression.h
lib/CodeGen/AsmPrinter/DwarfFile.cpp
lib/CodeGen/AsmPrinter/DwarfFile.h
lib/CodeGen/AsmPrinter/DwarfUnit.cpp
lib/CodeGen/AsmPrinter/DwarfUnit.h
lib/CodeGen/AsmPrinter/WinCodeViewLineTables.cpp
lib/CodeGen/InlineSpiller.cpp
lib/CodeGen/LexicalScopes.cpp
lib/CodeGen/LiveDebugVariables.cpp
lib/CodeGen/LiveDebugVariables.h
lib/CodeGen/MachineInstr.cpp
lib/CodeGen/RegAllocFast.cpp
lib/CodeGen/SelectionDAG/InstrEmitter.cpp
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h
lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
lib/CodeGen/StackColoring.cpp
lib/IR/AsmWriter.cpp
lib/IR/DIBuilder.cpp
lib/IR/DebugInfo.cpp
lib/IR/DebugInfoMetadata.cpp
lib/IR/DebugLoc.cpp
lib/IR/DiagnosticInfo.cpp
lib/IR/LLVMContextImpl.h
lib/IR/Verifier.cpp
lib/Linker/LinkModules.cpp
lib/Target/AArch64/AArch64AsmPrinter.cpp
lib/Target/NVPTX/NVPTXAsmPrinter.cpp
lib/Transforms/IPO/ArgumentPromotion.cpp
lib/Transforms/IPO/DeadArgumentElimination.cpp
lib/Transforms/IPO/StripSymbols.cpp
lib/Transforms/Instrumentation/AddressSanitizer.cpp
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp
lib/Transforms/Instrumentation/GCOVProfiling.cpp
lib/Transforms/Scalar/SROA.cpp
lib/Transforms/Scalar/SampleProfile.cpp
lib/Transforms/Scalar/ScalarReplAggregates.cpp
lib/Transforms/Utils/AddDiscriminators.cpp
lib/Transforms/Utils/CloneFunction.cpp
lib/Transforms/Utils/InlineFunction.cpp
lib/Transforms/Utils/Local.cpp
test/Assembler/2010-02-05-FunctionLocalMetadataBecomesNull.ll
test/Assembler/debug-info.ll
test/Assembler/drop-debug-info.ll
test/Assembler/generic-debug-node.ll
test/Assembler/invalid-generic-debug-node-tag-bad.ll
test/Assembler/invalid-generic-debug-node-tag-missing.ll
test/Assembler/invalid-generic-debug-node-tag-overflow.ll
test/Assembler/invalid-generic-debug-node-tag-wrong-type.ll
test/Assembler/invalid-mdcompileunit-language-bad.ll
test/Assembler/invalid-mdcompileunit-language-overflow.ll
test/Assembler/invalid-mdcompileunit-missing-language.ll
test/Assembler/invalid-mdcompileunit-null-file.ll
test/Assembler/invalid-mdcompositetype-missing-tag.ll
test/Assembler/invalid-mdderivedtype-missing-basetype.ll
test/Assembler/invalid-mdderivedtype-missing-tag.ll
test/Assembler/invalid-mdenumerator-missing-name.ll
test/Assembler/invalid-mdenumerator-missing-value.ll
test/Assembler/invalid-mdexpression-large.ll
test/Assembler/invalid-mdexpression-verify.ll
test/Assembler/invalid-mdfile-missing-directory.ll
test/Assembler/invalid-mdfile-missing-filename.ll
test/Assembler/invalid-mdglobalvariable-empty-name.ll
test/Assembler/invalid-mdglobalvariable-missing-name.ll
test/Assembler/invalid-mdimportedentity-missing-scope.ll
test/Assembler/invalid-mdimportedentity-missing-tag.ll
test/Assembler/invalid-mdlexicalblock-missing-scope.ll
test/Assembler/invalid-mdlexicalblock-null-scope.ll
test/Assembler/invalid-mdlexicalblockfile-missing-discriminator.ll
test/Assembler/invalid-mdlexicalblockfile-missing-scope.ll
test/Assembler/invalid-mdlexicalblockfile-null-scope.ll
test/Assembler/invalid-mdlocalvariable-missing-scope.ll
test/Assembler/invalid-mdlocalvariable-missing-tag.ll
test/Assembler/invalid-mdlocalvariable-null-scope.ll
test/Assembler/invalid-mdlocation-field-bad.ll
test/Assembler/invalid-mdlocation-field-twice.ll
test/Assembler/invalid-mdlocation-missing-scope-2.ll
test/Assembler/invalid-mdlocation-missing-scope.ll
test/Assembler/invalid-mdlocation-null-scope.ll
test/Assembler/invalid-mdlocation-overflow-column.ll
test/Assembler/invalid-mdlocation-overflow-line.ll
test/Assembler/invalid-mdnamespace-missing-namespace.ll
test/Assembler/invalid-mdsubrange-count-large.ll
test/Assembler/invalid-mdsubrange-count-missing.ll
test/Assembler/invalid-mdsubrange-count-negative.ll
test/Assembler/invalid-mdsubrange-lowerBound-max.ll
test/Assembler/invalid-mdsubrange-lowerBound-min.ll
test/Assembler/invalid-mdsubroutinetype-missing-types.ll
test/Assembler/invalid-mdtemplatetypeparameter-missing-type.ll
test/Assembler/invalid-mdtemplatevalueparameter-missing-value.ll
test/Assembler/mdcompileunit.ll
test/Assembler/mdexpression.ll
test/Assembler/mdfile-escaped-chars.ll
test/Assembler/mdglobalvariable.ll
test/Assembler/mdimportedentity.ll
test/Assembler/mdlexicalblock.ll
test/Assembler/mdlocalvariable.ll
test/Assembler/mdlocation.ll
test/Assembler/mdnamespace.ll
test/Assembler/mdobjcproperty.ll
test/Assembler/mdsubprogram.ll
test/Assembler/mdsubrange-empty-array.ll
test/Assembler/mdsubroutinetype.ll
test/Assembler/mdtemplateparameter.ll
test/Assembler/mdtype-large-values.ll
test/Assembler/metadata-null-operands.ll
test/Assembler/metadata.ll
test/Bindings/OCaml/core.ml
test/BugPoint/metadata.ll
test/CodeGen/AArch64/aarch64-2014-08-11-MachineCombinerCrash.ll
test/CodeGen/AArch64/arm64-2011-03-17-AsmPrinterCrash.ll
test/CodeGen/ARM/2009-10-16-Scope.ll
test/CodeGen/ARM/2010-04-15-ScavengerDebugValue.ll
test/CodeGen/ARM/2010-06-25-Thumb2ITInvalidIterator.ll
test/CodeGen/ARM/2010-08-04-StackVariable.ll
test/CodeGen/ARM/2011-01-19-MergedGlobalDbg.ll
test/CodeGen/ARM/2011-08-02-MergedGlobalDbg.ll
test/CodeGen/ARM/coalesce-dbgvalue.ll
test/CodeGen/ARM/debug-frame-vararg.ll
test/CodeGen/ARM/debug-frame.ll
test/CodeGen/ARM/debug-info-arg.ll
test/CodeGen/ARM/debug-info-blocks.ll
test/CodeGen/ARM/debug-info-branch-folding.ll
test/CodeGen/ARM/debug-info-d16-reg.ll
test/CodeGen/ARM/debug-info-no-frame.ll
test/CodeGen/ARM/debug-info-qreg.ll
test/CodeGen/ARM/debug-info-s16-reg.ll
test/CodeGen/ARM/debug-info-sreg2.ll
test/CodeGen/ARM/debug-segmented-stacks.ll
test/CodeGen/ARM/vfp-regs-dwarf.ll
test/CodeGen/Generic/dbg_value.ll
test/CodeGen/Hexagon/hwloop-dbg.ll
test/CodeGen/Inputs/DbgValueOtherTargets.ll
test/CodeGen/PowerPC/dbg.ll
test/CodeGen/PowerPC/pr17168.ll
test/CodeGen/PowerPC/unwind-dw2-g.ll
test/CodeGen/Thumb/2010-07-15-debugOrdering.ll
test/CodeGen/X86/2009-02-12-DebugInfoVLA.ll
test/CodeGen/X86/2009-10-16-Scope.ll
test/CodeGen/X86/2010-01-18-DbgValue.ll
test/CodeGen/X86/2010-02-01-DbgValueCrash.ll
test/CodeGen/X86/2010-05-25-DotDebugLoc.ll
test/CodeGen/X86/2010-05-26-DotDebugLoc.ll
test/CodeGen/X86/2010-05-28-Crash.ll
test/CodeGen/X86/2010-06-01-DeadArg-DbgInfo.ll
test/CodeGen/X86/2010-07-06-DbgCrash.ll
test/CodeGen/X86/2010-08-04-StackVariable.ll
test/CodeGen/X86/2010-09-16-EmptyFilename.ll
test/CodeGen/X86/2010-11-02-DbgParameter.ll
test/CodeGen/X86/2011-01-24-DbgValue-Before-Use.ll
test/CodeGen/X86/2012-11-30-handlemove-dbg.ll
test/CodeGen/X86/2012-11-30-misched-dbg.ll
test/CodeGen/X86/2012-11-30-regpres-dbg.ll
test/CodeGen/X86/MachineSink-DbgValue.ll
test/CodeGen/X86/StackColoring-dbg.ll
test/CodeGen/X86/dbg-changes-codegen-branch-folding.ll
test/CodeGen/X86/dbg-changes-codegen.ll
test/CodeGen/X86/dbg-combine.ll
test/CodeGen/X86/dwarf-comp-dir.ll
test/CodeGen/X86/fpstack-debuginstr-kill.ll
test/CodeGen/X86/misched-code-difference-with-debug.ll
test/CodeGen/X86/null-streamer.ll
test/CodeGen/X86/stack-protector-dbginfo.ll
test/CodeGen/X86/unknown-location.ll
test/CodeGen/XCore/dwarf_debug.ll
test/DebugInfo/2009-11-03-InsertExtractValue.ll
test/DebugInfo/2009-11-05-DeadGlobalVariable.ll
test/DebugInfo/2009-11-06-NamelessGlobalVariable.ll
test/DebugInfo/2009-11-10-CurrentFn.ll
test/DebugInfo/2010-01-05-DbgScope.ll
test/DebugInfo/2010-03-12-llc-crash.ll
test/DebugInfo/2010-03-19-DbgDeclare.ll
test/DebugInfo/2010-03-24-MemberFn.ll
test/DebugInfo/2010-04-06-NestedFnDbgInfo.ll
test/DebugInfo/2010-04-19-FramePtr.ll
test/DebugInfo/2010-05-03-DisableFramePtr.ll
test/DebugInfo/2010-05-03-OriginDIE.ll
test/DebugInfo/2010-05-10-MultipleCU.ll
test/DebugInfo/2010-06-29-InlinedFnLocalVar.ll
test/DebugInfo/2010-07-19-Crash.ll
test/DebugInfo/2010-10-01-crash.ll
test/DebugInfo/AArch64/big-endian.ll
test/DebugInfo/AArch64/cfi-eof-prologue.ll
test/DebugInfo/AArch64/coalescing.ll
test/DebugInfo/AArch64/constant-dbgloc.ll
test/DebugInfo/AArch64/dwarfdump.ll
test/DebugInfo/AArch64/frameindices.ll
test/DebugInfo/AArch64/struct_by_value.ll
test/DebugInfo/ARM/PR16736.ll
test/DebugInfo/ARM/cfi-eof-prologue.ll
test/DebugInfo/ARM/constant-dbgloc.ll
test/DebugInfo/ARM/header.ll
test/DebugInfo/ARM/lowerbdgdeclare_vla.ll
test/DebugInfo/ARM/s-super-register.ll
test/DebugInfo/ARM/selectiondag-deadcode.ll
test/DebugInfo/ARM/tls.ll
test/DebugInfo/COFF/asan-module-ctor.ll
test/DebugInfo/COFF/asan-module-without-functions.ll
test/DebugInfo/COFF/asm.ll
test/DebugInfo/COFF/cpp-mangling.ll
test/DebugInfo/COFF/multifile.ll
test/DebugInfo/COFF/multifunction.ll
test/DebugInfo/COFF/simple.ll
test/DebugInfo/COFF/tail-call-without-lexical-scopes.ll
test/DebugInfo/Inputs/gmlt.ll
test/DebugInfo/Inputs/line.ll
test/DebugInfo/Mips/InlinedFnLocalVar.ll
test/DebugInfo/Mips/delay-slot.ll
test/DebugInfo/Mips/fn-call-line.ll
test/DebugInfo/PR20038.ll
test/DebugInfo/PowerPC/tls-fission.ll
test/DebugInfo/PowerPC/tls.ll
test/DebugInfo/Sparc/gnu-window-save.ll
test/DebugInfo/SystemZ/variable-loc.ll
test/DebugInfo/X86/2010-04-13-PubType.ll
test/DebugInfo/X86/2011-09-26-GlobalVarContext.ll
test/DebugInfo/X86/2011-12-16-BadStructRef.ll
test/DebugInfo/X86/DW_AT_byte_size.ll
test/DebugInfo/X86/DW_AT_linkage_name.ll
test/DebugInfo/X86/DW_AT_location-reference.ll
test/DebugInfo/X86/DW_AT_object_pointer.ll
test/DebugInfo/X86/DW_AT_specification.ll
test/DebugInfo/X86/DW_AT_stmt_list_sec_offset.ll
test/DebugInfo/X86/DW_TAG_friend.ll
test/DebugInfo/X86/InlinedFnLocalVar.ll
test/DebugInfo/X86/aligned_stack_var.ll
test/DebugInfo/X86/arange-and-stub.ll
test/DebugInfo/X86/arange.ll
test/DebugInfo/X86/arguments.ll
test/DebugInfo/X86/array.ll
test/DebugInfo/X86/array2.ll
test/DebugInfo/X86/block-capture.ll
test/DebugInfo/X86/byvalstruct.ll
test/DebugInfo/X86/c-type-units.ll
test/DebugInfo/X86/coff_debug_info_type.ll
test/DebugInfo/X86/coff_relative_names.ll
test/DebugInfo/X86/concrete_out_of_line.ll
test/DebugInfo/X86/constant-aggregate.ll
test/DebugInfo/X86/cu-ranges-odr.ll
test/DebugInfo/X86/cu-ranges.ll
test/DebugInfo/X86/data_member_location.ll
test/DebugInfo/X86/dbg-at-specficiation.ll
test/DebugInfo/X86/dbg-byval-parameter.ll
test/DebugInfo/X86/dbg-const-int.ll
test/DebugInfo/X86/dbg-const.ll
test/DebugInfo/X86/dbg-declare-arg.ll
test/DebugInfo/X86/dbg-declare.ll
test/DebugInfo/X86/dbg-file-name.ll
test/DebugInfo/X86/dbg-i128-const.ll
test/DebugInfo/X86/dbg-merge-loc-entry.ll
test/DebugInfo/X86/dbg-prolog-end.ll
test/DebugInfo/X86/dbg-subrange.ll
test/DebugInfo/X86/dbg-value-const-byref.ll
test/DebugInfo/X86/dbg-value-dag-combine.ll
test/DebugInfo/X86/dbg-value-inlined-parameter.ll
test/DebugInfo/X86/dbg-value-isel.ll
test/DebugInfo/X86/dbg-value-location.ll
test/DebugInfo/X86/dbg-value-range.ll
test/DebugInfo/X86/dbg-value-terminator.ll
test/DebugInfo/X86/dbg_value_direct.ll
test/DebugInfo/X86/debug-dead-local-var.ll
test/DebugInfo/X86/debug-info-access.ll
test/DebugInfo/X86/debug-info-block-captured-self.ll
test/DebugInfo/X86/debug-info-blocks.ll
test/DebugInfo/X86/debug-info-static-member.ll
test/DebugInfo/X86/debug-loc-asan.ll
test/DebugInfo/X86/debug-loc-offset.ll
test/DebugInfo/X86/debug-ranges-offset.ll
test/DebugInfo/X86/debug_frame.ll
test/DebugInfo/X86/decl-derived-member.ll
test/DebugInfo/X86/deleted-bit-piece.ll
test/DebugInfo/X86/discriminator.ll
test/DebugInfo/X86/dwarf-aranges-no-dwarf-labels.ll
test/DebugInfo/X86/dwarf-aranges.ll
test/DebugInfo/X86/dwarf-public-names.ll
test/DebugInfo/X86/dwarf-pubnames-split.ll
test/DebugInfo/X86/earlydup-crash.ll
test/DebugInfo/X86/elf-names.ll
test/DebugInfo/X86/empty-and-one-elem-array.ll
test/DebugInfo/X86/empty-array.ll
test/DebugInfo/X86/empty.ll
test/DebugInfo/X86/ending-run.ll
test/DebugInfo/X86/enum-class.ll
test/DebugInfo/X86/enum-fwd-decl.ll
test/DebugInfo/X86/fission-cu.ll
test/DebugInfo/X86/fission-hash.ll
test/DebugInfo/X86/fission-inline.ll
test/DebugInfo/X86/fission-ranges.ll
test/DebugInfo/X86/float_const.ll
test/DebugInfo/X86/formal_parameter.ll
test/DebugInfo/X86/frame-register.ll
test/DebugInfo/X86/generate-odr-hash.ll
test/DebugInfo/X86/ghost-sdnode-dbgvalues.ll
test/DebugInfo/X86/gnu-public-names-empty.ll
test/DebugInfo/X86/gnu-public-names.ll
test/DebugInfo/X86/header.ll
test/DebugInfo/X86/inline-member-function.ll
test/DebugInfo/X86/inline-seldag-test.ll
test/DebugInfo/X86/inlined-formal-parameter.ll
test/DebugInfo/X86/instcombine-instrinsics.ll
test/DebugInfo/X86/lexical_block.ll
test/DebugInfo/X86/line-info.ll
test/DebugInfo/X86/linkage-name.ll
test/DebugInfo/X86/low-pc-cu.ll
test/DebugInfo/X86/memberfnptr.ll
test/DebugInfo/X86/mi-print.ll
test/DebugInfo/X86/misched-dbg-value.ll
test/DebugInfo/X86/missing-file-line.ll
test/DebugInfo/X86/multiple-aranges.ll
test/DebugInfo/X86/multiple-at-const-val.ll
test/DebugInfo/X86/nodebug_with_debug_loc.ll
test/DebugInfo/X86/nondefault-subrange-array.ll
test/DebugInfo/X86/nophysreg.ll
test/DebugInfo/X86/objc-fwd-decl.ll
test/DebugInfo/X86/objc-property-void.ll
test/DebugInfo/X86/op_deref.ll
test/DebugInfo/X86/parameters.ll
test/DebugInfo/X86/pieces-1.ll
test/DebugInfo/X86/pieces-2.ll
test/DebugInfo/X86/pieces-3.ll
test/DebugInfo/X86/pointer-type-size.ll
test/DebugInfo/X86/pr11300.ll
test/DebugInfo/X86/pr12831.ll
test/DebugInfo/X86/pr13303.ll
test/DebugInfo/X86/pr19307.ll
test/DebugInfo/X86/processes-relocations.ll
test/DebugInfo/X86/prologue-stack.ll
test/DebugInfo/X86/recursive_inlining.ll
test/DebugInfo/X86/ref_addr_relocation.ll
test/DebugInfo/X86/reference-argument.ll
test/DebugInfo/X86/rvalue-ref.ll
test/DebugInfo/X86/sret.ll
test/DebugInfo/X86/sroasplit-1.ll
test/DebugInfo/X86/sroasplit-2.ll
test/DebugInfo/X86/sroasplit-3.ll
test/DebugInfo/X86/sroasplit-4.ll
test/DebugInfo/X86/sroasplit-5.ll
test/DebugInfo/X86/stmt-list-multiple-compile-units.ll
test/DebugInfo/X86/stmt-list.ll
test/DebugInfo/X86/stringpool.ll
test/DebugInfo/X86/struct-loc.ll
test/DebugInfo/X86/subrange-type.ll
test/DebugInfo/X86/subreg.ll
test/DebugInfo/X86/subregisters.ll
test/DebugInfo/X86/template.ll
test/DebugInfo/X86/tls.ll
test/DebugInfo/X86/type_units_with_addresses.ll
test/DebugInfo/X86/union-const.ll
test/DebugInfo/X86/union-template.ll
test/DebugInfo/X86/vector.ll
test/DebugInfo/X86/vla.ll
test/DebugInfo/accel-table-hash-collisions.ll
test/DebugInfo/array.ll
test/DebugInfo/block-asan.ll
test/DebugInfo/bug_null_debuginfo.ll
test/DebugInfo/constant-pointers.ll
test/DebugInfo/constant-sdnodes-have-dbg-location.ll
test/DebugInfo/cross-cu-inlining.ll
test/DebugInfo/cross-cu-linkonce-distinct.ll
test/DebugInfo/cross-cu-linkonce.ll
test/DebugInfo/cu-range-hole.ll
test/DebugInfo/cu-ranges.ll
test/DebugInfo/dead-argument-order.ll
test/DebugInfo/debug-info-always-inline.ll
test/DebugInfo/debug-info-qualifiers.ll
test/DebugInfo/debuginfofinder-forward-declaration.ll
test/DebugInfo/debuginfofinder-multiple-cu.ll
test/DebugInfo/dwarf-public-names.ll
test/DebugInfo/empty.ll
test/DebugInfo/enum-types.ll
test/DebugInfo/enum.ll
test/DebugInfo/global.ll
test/DebugInfo/incorrect-variable-debugloc.ll
test/DebugInfo/incorrect-variable-debugloc1.ll
test/DebugInfo/inheritance.ll
test/DebugInfo/inline-debug-info-multiret.ll
test/DebugInfo/inline-debug-info.ll
test/DebugInfo/inline-no-debug-info.ll
test/DebugInfo/inline-scopes.ll
test/DebugInfo/inlined-arguments.ll
test/DebugInfo/inlined-vars.ll
test/DebugInfo/location-verifier.ll
test/DebugInfo/lto-comp-dir.ll
test/DebugInfo/member-order.ll
test/DebugInfo/member-pointers.ll
test/DebugInfo/missing-abstract-variable.ll
test/DebugInfo/multiline.ll
test/DebugInfo/namespace.ll
test/DebugInfo/namespace_function_definition.ll
test/DebugInfo/namespace_inline_function_definition.ll
test/DebugInfo/nodebug.ll
test/DebugInfo/piece-verifier.ll
test/DebugInfo/restrict.ll
test/DebugInfo/sugared-constants.ll
test/DebugInfo/template-recursive-void.ll
test/DebugInfo/tu-composite.ll
test/DebugInfo/tu-member-pointer.ll
test/DebugInfo/two-cus-from-same-file.ll
test/DebugInfo/typedef.ll
test/DebugInfo/unconditional-branch.ll
test/DebugInfo/varargs.ll
test/DebugInfo/version.ll
test/Instrumentation/AddressSanitizer/debug_info.ll
test/Instrumentation/DataFlowSanitizer/debug.ll
test/Instrumentation/MemorySanitizer/store-origin.ll
test/Instrumentation/SanitizerCoverage/coverage-dbg.ll
test/Instrumentation/SanitizerCoverage/coverage2-dbg.ll
test/JitListener/multiple.ll
test/JitListener/simple.ll
test/Linker/2009-09-03-mdnode.ll
test/Linker/2009-09-03-mdnode2.ll
test/Linker/2011-08-04-DebugLoc.ll
test/Linker/2011-08-04-DebugLoc2.ll
test/Linker/2011-08-04-Metadata.ll
test/Linker/2011-08-04-Metadata2.ll
test/Linker/2011-08-18-unique-class-type.ll
test/Linker/2011-08-18-unique-class-type2.ll
test/Linker/2011-08-18-unique-debug-type.ll
test/Linker/2011-08-18-unique-debug-type2.ll
test/Linker/DbgDeclare.ll
test/Linker/DbgDeclare2.ll
test/Linker/Inputs/mdlocation.ll
test/Linker/Inputs/replaced-function-matches-first-subprogram.ll
test/Linker/Inputs/subprogram-linkonce-weak-odr.ll
test/Linker/Inputs/subprogram-linkonce-weak.ll
test/Linker/Inputs/type-unique-inheritance-a.ll
test/Linker/Inputs/type-unique-inheritance-b.ll
test/Linker/Inputs/type-unique-simple2-a.ll
test/Linker/Inputs/type-unique-simple2-b.ll
test/Linker/debug-info-version-a.ll
test/Linker/debug-info-version-b.ll
test/Linker/mdlocation.ll
test/Linker/replaced-function-matches-first-subprogram.ll
test/Linker/subprogram-linkonce-weak-odr.ll
test/Linker/subprogram-linkonce-weak.ll
test/Linker/type-unique-odr-a.ll
test/Linker/type-unique-odr-b.ll
test/Linker/type-unique-simple-a.ll
test/Linker/type-unique-simple-b.ll
test/Linker/type-unique-simple2-a.ll
test/Linker/type-unique-simple2-b.ll
test/Linker/type-unique-type-array-a.ll
test/Linker/type-unique-type-array-b.ll
test/MC/ARM/coff-debugging-secrel.ll
test/MC/ELF/cfi-version.ll
test/MC/X86/i386-darwin-frame-register.ll
test/Transforms/AddDiscriminators/basic.ll
test/Transforms/AddDiscriminators/first-only.ll
test/Transforms/AddDiscriminators/multiple.ll
test/Transforms/AddDiscriminators/no-discriminators.ll
test/Transforms/ArgumentPromotion/dbg.ll
test/Transforms/DeadArgElim/2010-04-30-DbgInfo.ll
test/Transforms/DeadArgElim/dbginfo.ll
test/Transforms/DeadStoreElimination/inst-limits.ll
test/Transforms/GCOVProfiling/function-numbering.ll
test/Transforms/GCOVProfiling/global-ctor.ll
test/Transforms/GCOVProfiling/linezero.ll
test/Transforms/GCOVProfiling/linkagename.ll
test/Transforms/GCOVProfiling/return-block.ll
test/Transforms/GCOVProfiling/version.ll
test/Transforms/GlobalOpt/2009-03-05-dbg.ll
test/Transforms/Inline/alloca-dbgdeclare.ll
test/Transforms/Inline/debug-info-duplicate-calls.ll
test/Transforms/Inline/debug-invoke.ll
test/Transforms/Inline/ignore-debug-info.ll
test/Transforms/Inline/inline_dbg_declare.ll
test/Transforms/InstCombine/debug-line.ll
test/Transforms/InstCombine/debuginfo.ll
test/Transforms/LICM/debug-value.ll
test/Transforms/LoopIdiom/debug-line.ll
test/Transforms/LoopRotate/dbgvalue.ll
test/Transforms/LoopStrengthReduce/pr12018.ll
test/Transforms/LoopVectorize/X86/vectorization-remarks-missed.ll
test/Transforms/LoopVectorize/X86/vectorization-remarks.ll
test/Transforms/LoopVectorize/conditional-assignment.ll
test/Transforms/LoopVectorize/control-flow.ll
test/Transforms/LoopVectorize/dbg.value.ll
test/Transforms/LoopVectorize/debugloc.ll
test/Transforms/LoopVectorize/no_array_bounds.ll
test/Transforms/LoopVectorize/no_switch.ll
test/Transforms/Mem2Reg/ConvertDebugInfo.ll
test/Transforms/Mem2Reg/ConvertDebugInfo2.ll
test/Transforms/ObjCARC/basic.ll
test/Transforms/ObjCARC/ensure-that-exception-unwind-path-is-visited.ll
test/Transforms/SLPVectorizer/X86/debug_info.ll
test/Transforms/SampleProfile/branch.ll
test/Transforms/SampleProfile/calls.ll
test/Transforms/SampleProfile/discriminator.ll
test/Transforms/SampleProfile/fnptr.ll
test/Transforms/SampleProfile/propagate.ll
test/Transforms/ScalarRepl/debuginfo-preserved.ll
test/Transforms/Scalarizer/dbginfo.ll
test/Transforms/SimplifyCFG/branch-fold-dbg.ll
test/Transforms/SimplifyCFG/hoist-dbgvalue.ll
test/Transforms/SimplifyCFG/trap-debugloc.ll
test/Transforms/StripSymbols/2010-06-30-StripDebug.ll
test/Transforms/StripSymbols/2010-08-25-crash.ll
test/Transforms/StripSymbols/strip-dead-debug-info.ll
test/Verifier/dbg-typerefs.ll
test/Verifier/dbg.ll
test/Verifier/llvm.dbg.declare-address.ll
test/Verifier/llvm.dbg.declare-expression.ll
test/Verifier/llvm.dbg.declare-variable.ll
test/Verifier/llvm.dbg.intrinsic-dbg-attachment.ll
test/Verifier/llvm.dbg.value-expression.ll
test/Verifier/llvm.dbg.value-value.ll
test/Verifier/llvm.dbg.value-variable.ll
test/Verifier/mdcompositetype-templateparams-tuple.ll
test/Verifier/mdcompositetype-templateparams.ll
tools/llvm-dis/llvm-dis.cpp
tools/opt/BreakpointPrinter.cpp
unittests/IR/DebugInfoTest.cpp
unittests/IR/MetadataTest.cpp
unittests/Transforms/Utils/Cloning.cpp

index 48f58b8..df5885d 100644 (file)
@@ -56,8 +56,8 @@ LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef Dref,
                                                 unsigned Line,
                                                 unsigned Column) {
   DIBuilder *D = unwrap(Dref);
-  auto *LB = D->createLexicalBlock(unwrap<MDLocalScope>(Scope),
-                                   unwrap<MDFile>(File), Line, Column);
+  auto *LB = D->createLexicalBlock(unwrap<DILocalScope>(Scope),
+                                   unwrap<DIFile>(File), Line, Column);
   return wrap(LB);
 }
 
@@ -66,8 +66,8 @@ LLVMMetadataRef LLVMDIBuilderCreateLexicalBlockFile(LLVMDIBuilderRef Dref,
                                                     LLVMMetadataRef File,
                                                     unsigned Discriminator) {
   DIBuilder *D = unwrap(Dref);
-  return wrap(D->createLexicalBlockFile(unwrap<MDLocalScope>(Scope),
-                                        unwrap<MDFile>(File), Discriminator));
+  return wrap(D->createLexicalBlockFile(unwrap<DILocalScope>(Scope),
+                                        unwrap<DIFile>(File), Discriminator));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateFunction(
@@ -76,9 +76,9 @@ LLVMMetadataRef LLVMDIBuilderCreateFunction(
     LLVMMetadataRef CompositeType, int IsLocalToUnit, int IsDefinition,
     unsigned ScopeLine, unsigned Flags, int IsOptimized, LLVMValueRef Func) {
   DIBuilder *D = unwrap(Dref);
-  return wrap(D->createFunction(unwrap<MDScope>(Scope), Name, LinkageName,
-                                File ? unwrap<MDFile>(File) : nullptr, Line,
-                                unwrap<MDSubroutineType>(CompositeType),
+  return wrap(D->createFunction(unwrap<DIScope>(Scope), Name, LinkageName,
+                                File ? unwrap<DIFile>(File) : nullptr, Line,
+                                unwrap<DISubroutineType>(CompositeType),
                                 IsLocalToUnit, IsDefinition, ScopeLine, Flags,
                                 IsOptimized, unwrap<Function>(Func)));
 }
@@ -89,8 +89,8 @@ LLVMMetadataRef LLVMDIBuilderCreateLocalVariable(
     int AlwaysPreserve, unsigned Flags, unsigned ArgNo) {
   DIBuilder *D = unwrap(Dref);
   return wrap(D->createLocalVariable(
-      Tag, unwrap<MDScope>(Scope), Name, unwrap<MDFile>(File), Line,
-      unwrap<MDType>(Ty), AlwaysPreserve, Flags, ArgNo));
+      Tag, unwrap<DIScope>(Scope), Name, unwrap<DIFile>(File), Line,
+      unwrap<DIType>(Ty), AlwaysPreserve, Flags, ArgNo));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Dref,
@@ -108,7 +108,7 @@ LLVMMetadataRef LLVMDIBuilderCreatePointerType(LLVMDIBuilderRef Dref,
                                                uint64_t AlignInBits,
                                                const char *Name) {
   DIBuilder *D = unwrap(Dref);
-  return wrap(D->createPointerType(unwrap<MDType>(PointeeType), SizeInBits,
+  return wrap(D->createPointerType(unwrap<DIType>(PointeeType), SizeInBits,
                                    AlignInBits, Name));
 }
 
@@ -117,8 +117,8 @@ LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Dref, LLVMMetadataRef File,
                                   LLVMMetadataRef ParameterTypes) {
   DIBuilder *D = unwrap(Dref);
   return wrap(
-      D->createSubroutineType(File ? unwrap<MDFile>(File) : nullptr,
-                              MDTypeRefArray(unwrap<MDTuple>(ParameterTypes))));
+      D->createSubroutineType(File ? unwrap<DIFile>(File) : nullptr,
+                              DITypeRefArray(unwrap<MDTuple>(ParameterTypes))));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateStructType(
@@ -128,10 +128,10 @@ LLVMMetadataRef LLVMDIBuilderCreateStructType(
     LLVMMetadataRef ElementTypes) {
   DIBuilder *D = unwrap(Dref);
   return wrap(D->createStructType(
-      unwrap<MDScope>(Scope), Name, File ? unwrap<MDFile>(File) : nullptr, Line,
+      unwrap<DIScope>(Scope), Name, File ? unwrap<DIFile>(File) : nullptr, Line,
       SizeInBits, AlignInBits, Flags,
-      DerivedFrom ? unwrap<MDType>(DerivedFrom) : nullptr,
-      ElementTypes ? DebugNodeArray(unwrap<MDTuple>(ElementTypes)) : nullptr));
+      DerivedFrom ? unwrap<DIType>(DerivedFrom) : nullptr,
+      ElementTypes ? DINodeArray(unwrap<MDTuple>(ElementTypes)) : nullptr));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateReplaceableCompositeType(
@@ -141,7 +141,7 @@ LLVMMetadataRef LLVMDIBuilderCreateReplaceableCompositeType(
     unsigned Flags) {
   DIBuilder *D = unwrap(Dref);
   return wrap(D->createReplaceableCompositeType(
-      Tag, Name, unwrap<MDScope>(Scope), File ? unwrap<MDFile>(File) : nullptr,
+      Tag, Name, unwrap<DIScope>(Scope), File ? unwrap<DIFile>(File) : nullptr,
       Line, RuntimeLang, SizeInBits, AlignInBits, Flags));
 }
 
@@ -153,8 +153,8 @@ LLVMDIBuilderCreateMemberType(LLVMDIBuilderRef Dref, LLVMMetadataRef Scope,
                               unsigned Flags, LLVMMetadataRef Ty) {
   DIBuilder *D = unwrap(Dref);
   return wrap(D->createMemberType(
-      unwrap<MDScope>(Scope), Name, File ? unwrap<MDFile>(File) : nullptr, Line,
-      SizeInBits, AlignInBits, OffsetInBits, Flags, unwrap<MDType>(Ty)));
+      unwrap<DIScope>(Scope), Name, File ? unwrap<DIFile>(File) : nullptr, Line,
+      SizeInBits, AlignInBits, OffsetInBits, Flags, unwrap<DIType>(Ty)));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Dref,
@@ -164,8 +164,8 @@ LLVMMetadataRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Dref,
                                              LLVMMetadataRef Subscripts) {
   DIBuilder *D = unwrap(Dref);
   return wrap(D->createArrayType(SizeInBits, AlignInBits,
-                                 unwrap<MDType>(ElementType),
-                                 DebugNodeArray(unwrap<MDTuple>(Subscripts))));
+                                 unwrap<DIType>(ElementType),
+                                 DINodeArray(unwrap<MDTuple>(Subscripts))));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Dref,
@@ -173,9 +173,9 @@ LLVMMetadataRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef Dref,
                                            LLVMMetadataRef File, unsigned Line,
                                            LLVMMetadataRef Context) {
   DIBuilder *D = unwrap(Dref);
-  return wrap(D->createTypedef(unwrap<MDType>(Ty), Name,
-                               File ? unwrap<MDFile>(File) : nullptr, Line,
-                               Context ? unwrap<MDScope>(Context) : nullptr));
+  return wrap(D->createTypedef(unwrap<DIType>(Ty), Name,
+                               File ? unwrap<DIFile>(File) : nullptr, Line,
+                               Context ? unwrap<DIScope>(Context) : nullptr));
 }
 
 LLVMMetadataRef LLVMDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Dref,
@@ -190,7 +190,7 @@ LLVMMetadataRef LLVMDIBuilderGetOrCreateArray(LLVMDIBuilderRef Dref,
   DIBuilder *D = unwrap(Dref);
   Metadata **DataValue = unwrap(Data);
   ArrayRef<Metadata *> Elements(DataValue, Length);
-  DebugNodeArray A = D->getOrCreateArray(Elements);
+  DINodeArray A = D->getOrCreateArray(Elements);
   return wrap(A.get());
 }
 
@@ -200,7 +200,7 @@ LLVMMetadataRef LLVMDIBuilderGetOrCreateTypeArray(LLVMDIBuilderRef Dref,
   DIBuilder *D = unwrap(Dref);
   Metadata **DataValue = unwrap(Data);
   ArrayRef<Metadata *> Elements(DataValue, Length);
-  MDTypeRefArray A = D->getOrCreateTypeArray(Elements);
+  DITypeRefArray A = D->getOrCreateTypeArray(Elements);
   return wrap(A.get());
 }
 
@@ -221,8 +221,8 @@ LLVMValueRef LLVMDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef Dref,
 
   DIBuilder *D = unwrap(Dref);
   Instruction *Instr = D->insertDeclare(
-      unwrap(Storage), unwrap<MDLocalVariable>(VarInfo),
-      unwrap<MDExpression>(Expr), /* DebugLoc */ nullptr, unwrap(Block));
+      unwrap(Storage), unwrap<DILocalVariable>(VarInfo),
+      unwrap<DIExpression>(Expr), /* DebugLoc */ nullptr, unwrap(Block));
   return wrap(Instr);
 }
 
@@ -237,7 +237,7 @@ LLVMValueRef LLVMDIBuilderInsertValueAtEnd(LLVMDIBuilderRef Dref,
 
   DIBuilder *D = unwrap(Dref);
   Instruction *Instr = D->insertDbgValueIntrinsic(
-      unwrap(Val), Offset, unwrap<MDLocalVariable>(VarInfo),
-      unwrap<MDExpression>(Expr), /* DebugLoc */ nullptr, unwrap(Block));
+      unwrap(Val), Offset, unwrap<DILocalVariable>(VarInfo),
+      unwrap<DIExpression>(Expr), /* DebugLoc */ nullptr, unwrap(Block));
   return wrap(Instr);
 }
index f48bf47..03c8829 100644 (file)
@@ -200,9 +200,9 @@ For example, the following works like you'd expect:
 
 .. code-block:: llvm
 
-   !0 = !MDLocation(line: 5, scope: !1, inlinedAt: !2)
+   !0 = !DILocation(line: 5, scope: !1, inlinedAt: !2)
 
-   ; CHECK:       !MDLocation(line: 5,
+   ; CHECK:       !DILocation(line: 5,
    ; CHECK-NOT:               column:
    ; CHECK-SAME:              scope: ![[SCOPE:[0-9]+]]
 
index 767d97a..b33266a 100644 (file)
@@ -2922,12 +2922,12 @@ order.
 These aren't inherently debug info centric, but currently all the specialized
 metadata nodes are related to debug info.
 
-.. _MDCompileUnit:
+.. _DICompileUnit:
 
-MDCompileUnit
+DICompileUnit
 """""""""""""
 
-``MDCompileUnit`` nodes represent a compile unit.  The ``enums:``,
+``DICompileUnit`` nodes represent a compile unit.  The ``enums:``,
 ``retainedTypes:``, ``subprograms:``, ``globals:`` and ``imports:`` fields are
 tuples containing the debug info to be emitted along with the compile unit,
 regardless of code optimizations (some nodes are only emitted if there are
@@ -2935,7 +2935,7 @@ references to them from instructions).
 
 .. code-block:: llvm
 
-    !0 = !MDCompileUnit(language: DW_LANG_C99, file: !1, producer: "clang",
+    !0 = !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang",
                         isOptimized: true, flags: "-O2", runtimeVersion: 2,
                         splitDebugFilename: "abc.debug", emissionKind: 1,
                         enums: !2, retainedTypes: !3, subprograms: !4,
@@ -2947,33 +2947,33 @@ These descriptors are collected by a named metadata ``!llvm.dbg.cu``.  They
 keep track of subprograms, global variables, type information, and imported
 entities (declarations and namespaces).
 
-.. _MDFile:
+.. _DIFile:
 
-MDFile
+DIFile
 """"""
 
-``MDFile`` nodes represent files.  The ``filename:`` can include slashes.
+``DIFile`` nodes represent files.  The ``filename:`` can include slashes.
 
 .. code-block:: llvm
 
-    !0 = !MDFile(filename: "path/to/file", directory: "/path/to/dir")
+    !0 = !DIFile(filename: "path/to/file", directory: "/path/to/dir")
 
 Files are sometimes used in ``scope:`` fields, and are the only valid target
 for ``file:`` fields.
 
-.. _MDLocation:
+.. _DILocation:
 
-MDBasicType
+DIBasicType
 """""""""""
 
-``MDBasicType`` nodes represent primitive types, such as ``int``, ``bool`` and
+``DIBasicType`` nodes represent primitive types, such as ``int``, ``bool`` and
 ``float``.  ``tag:`` defaults to ``DW_TAG_base_type``.
 
 .. code-block:: llvm
 
-    !0 = !MDBasicType(name: "unsigned char", size: 8, align: 8,
+    !0 = !DIBasicType(name: "unsigned char", size: 8, align: 8,
                       encoding: DW_ATE_unsigned_char)
-    !1 = !MDBasicType(tag: DW_TAG_unspecified_type, name: "decltype(nullptr)")
+    !1 = !DIBasicType(tag: DW_TAG_unspecified_type, name: "decltype(nullptr)")
 
 The ``encoding:`` describes the details of the type.  Usually it's one of the
 following:
@@ -2988,12 +2988,12 @@ following:
   DW_ATE_unsigned      = 7
   DW_ATE_unsigned_char = 8
 
-.. _MDSubroutineType:
+.. _DISubroutineType:
 
-MDSubroutineType
+DISubroutineType
 """"""""""""""""
 
-``MDSubroutineType`` nodes represent subroutine types.  Their ``types:`` field
+``DISubroutineType`` nodes represent subroutine types.  Their ``types:`` field
 refers to a tuple; the first operand is the return type, while the rest are the
 types of the formal arguments in order.  If the first operand is ``null``, that
 represents a function with no return value (such as ``void foo() {}`` in C++).
@@ -3002,21 +3002,21 @@ represents a function with no return value (such as ``void foo() {}`` in C++).
 
     !0 = !BasicType(name: "int", size: 32, align: 32, DW_ATE_signed)
     !1 = !BasicType(name: "char", size: 8, align: 8, DW_ATE_signed_char)
-    !2 = !MDSubroutineType(types: !{null, !0, !1}) ; void (int, char)
+    !2 = !DISubroutineType(types: !{null, !0, !1}) ; void (int, char)
 
-.. _MDDerivedType:
+.. _DIDerivedType:
 
-MDDerivedType
+DIDerivedType
 """""""""""""
 
-``MDDerivedType`` nodes represent types derived from other types, such as
+``DIDerivedType`` nodes represent types derived from other types, such as
 qualified types.
 
 .. code-block:: llvm
 
-    !0 = !MDBasicType(name: "unsigned char", size: 8, align: 8,
+    !0 = !DIBasicType(name: "unsigned char", size: 8, align: 8,
                       encoding: DW_ATE_unsigned_char)
-    !1 = !MDDerivedType(tag: DW_TAG_pointer_type, baseType: !0, size: 32,
+    !1 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !0, size: 32,
                         align: 32)
 
 The following ``tag:`` values are valid:
@@ -3034,7 +3034,7 @@ The following ``tag:`` values are valid:
   DW_TAG_restrict_type      = 55
 
 ``DW_TAG_member`` is used to define a member of a :ref:`composite type
-<MDCompositeType>` or :ref:`subprogram <MDSubprogram>`.  The type of the member
+<DICompositeType>` or :ref:`subprogram <DISubprogram>`.  The type of the member
 is the ``baseType:``.  The ``offset:`` is the member's bit offset.
 ``DW_TAG_formal_parameter`` is used to define a member which is a formal
 argument of a subprogram.
@@ -3047,12 +3047,12 @@ argument of a subprogram.
 
 Note that the ``void *`` type is expressed as a type derived from NULL.
 
-.. _MDCompositeType:
+.. _DICompositeType:
 
-MDCompositeType
+DICompositeType
 """""""""""""""
 
-``MDCompositeType`` nodes represent types composed of other types, like
+``DICompositeType`` nodes represent types composed of other types, like
 structures and unions.  ``elements:`` points to a tuple of the composed types.
 
 If the source language supports ODR, the ``identifier:`` field gives the unique
@@ -3062,10 +3062,10 @@ can refer to composite types indirectly via a :ref:`metadata string
 
 .. code-block:: llvm
 
-    !0 = !MDEnumerator(name: "SixKind", value: 7)
-    !1 = !MDEnumerator(name: "SevenKind", value: 7)
-    !2 = !MDEnumerator(name: "NegEightKind", value: -8)
-    !3 = !MDCompositeType(tag: DW_TAG_enumeration_type, name: "Enum", file: !12,
+    !0 = !DIEnumerator(name: "SixKind", value: 7)
+    !1 = !DIEnumerator(name: "SevenKind", value: 7)
+    !2 = !DIEnumerator(name: "NegEightKind", value: -8)
+    !3 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "Enum", file: !12,
                           line: 2, size: 32, align: 32, identifier: "_M4Enum",
                           elements: !{!0, !1, !2})
 
@@ -3083,108 +3083,108 @@ The following ``tag:`` values are valid:
 
 
 For ``DW_TAG_array_type``, the ``elements:`` should be :ref:`subrange
-descriptors <MDSubrange>`, each representing the range of subscripts at that
+descriptors <DISubrange>`, each representing the range of subscripts at that
 level of indexing.  The ``DIFlagVector`` flag to ``flags:`` indicates that an
 array type is a native packed vector.
 
 For ``DW_TAG_enumeration_type``, the ``elements:`` should be :ref:`enumerator
-descriptors <MDEnumerator>`, each representing the definition of an enumeration
+descriptors <DIEnumerator>`, each representing the definition of an enumeration
 value for the set.  All enumeration type descriptors are collected in the
-``enums:`` field of the :ref:`compile unit <MDCompileUnit>`.
+``enums:`` field of the :ref:`compile unit <DICompileUnit>`.
 
 For ``DW_TAG_structure_type``, ``DW_TAG_class_type``, and
 ``DW_TAG_union_type``, the ``elements:`` should be :ref:`derived types
-<MDDerivedType>` with ``tag: DW_TAG_member`` or ``tag: DW_TAG_inheritance``.
+<DIDerivedType>` with ``tag: DW_TAG_member`` or ``tag: DW_TAG_inheritance``.
 
-.. _MDSubrange:
+.. _DISubrange:
 
-MDSubrange
+DISubrange
 """"""""""
 
-``MDSubrange`` nodes are the elements for ``DW_TAG_array_type`` variants of
-:ref:`MDCompositeType`.  ``count: -1`` indicates an empty array.
+``DISubrange`` nodes are the elements for ``DW_TAG_array_type`` variants of
+:ref:`DICompositeType`.  ``count: -1`` indicates an empty array.
 
 .. code-block:: llvm
 
-    !0 = !MDSubrange(count: 5, lowerBound: 0) ; array counting from 0
-    !1 = !MDSubrange(count: 5, lowerBound: 1) ; array counting from 1
-    !2 = !MDSubrange(count: -1) ; empty array.
+    !0 = !DISubrange(count: 5, lowerBound: 0) ; array counting from 0
+    !1 = !DISubrange(count: 5, lowerBound: 1) ; array counting from 1
+    !2 = !DISubrange(count: -1) ; empty array.
 
-.. _MDEnumerator:
+.. _DIEnumerator:
 
-MDEnumerator
+DIEnumerator
 """"""""""""
 
-``MDEnumerator`` nodes are the elements for ``DW_TAG_enumeration_type``
-variants of :ref:`MDCompositeType`.
+``DIEnumerator`` nodes are the elements for ``DW_TAG_enumeration_type``
+variants of :ref:`DICompositeType`.
 
 .. code-block:: llvm
 
-    !0 = !MDEnumerator(name: "SixKind", value: 7)
-    !1 = !MDEnumerator(name: "SevenKind", value: 7)
-    !2 = !MDEnumerator(name: "NegEightKind", value: -8)
+    !0 = !DIEnumerator(name: "SixKind", value: 7)
+    !1 = !DIEnumerator(name: "SevenKind", value: 7)
+    !2 = !DIEnumerator(name: "NegEightKind", value: -8)
 
-MDTemplateTypeParameter
+DITemplateTypeParameter
 """""""""""""""""""""""
 
-``MDTemplateTypeParameter`` nodes represent type parameters to generic source
-language constructs.  They are used (optionally) in :ref:`MDCompositeType` and
-:ref:`MDSubprogram` ``templateParams:`` fields.
+``DITemplateTypeParameter`` nodes represent type parameters to generic source
+language constructs.  They are used (optionally) in :ref:`DICompositeType` and
+:ref:`DISubprogram` ``templateParams:`` fields.
 
 .. code-block:: llvm
 
-    !0 = !MDTemplateTypeParameter(name: "Ty", type: !1)
+    !0 = !DITemplateTypeParameter(name: "Ty", type: !1)
 
-MDTemplateValueParameter
+DITemplateValueParameter
 """"""""""""""""""""""""
 
-``MDTemplateValueParameter`` nodes represent value parameters to generic source
+``DITemplateValueParameter`` nodes represent value parameters to generic source
 language constructs.  ``tag:`` defaults to ``DW_TAG_template_value_parameter``,
 but if specified can also be set to ``DW_TAG_GNU_template_template_param`` or
 ``DW_TAG_GNU_template_param_pack``.  They are used (optionally) in
-:ref:`MDCompositeType` and :ref:`MDSubprogram` ``templateParams:`` fields.
+:ref:`DICompositeType` and :ref:`DISubprogram` ``templateParams:`` fields.
 
 .. code-block:: llvm
 
-    !0 = !MDTemplateValueParameter(name: "Ty", type: !1, value: i32 7)
+    !0 = !DITemplateValueParameter(name: "Ty", type: !1, value: i32 7)
 
-MDNamespace
+DINamespace
 """""""""""
 
-``MDNamespace`` nodes represent namespaces in the source language.
+``DINamespace`` nodes represent namespaces in the source language.
 
 .. code-block:: llvm
 
-    !0 = !MDNamespace(name: "myawesomeproject", scope: !1, file: !2, line: 7)
+    !0 = !DINamespace(name: "myawesomeproject", scope: !1, file: !2, line: 7)
 
-MDGlobalVariable
+DIGlobalVariable
 """"""""""""""""
 
-``MDGlobalVariable`` nodes represent global variables in the source language.
+``DIGlobalVariable`` nodes represent global variables in the source language.
 
 .. code-block:: llvm
 
-    !0 = !MDGlobalVariable(name: "foo", linkageName: "foo", scope: !1,
+    !0 = !DIGlobalVariable(name: "foo", linkageName: "foo", scope: !1,
                            file: !2, line: 7, type: !3, isLocal: true,
                            isDefinition: false, variable: i32* @foo,
                            declaration: !4)
 
 All global variables should be referenced by the `globals:` field of a
-:ref:`compile unit <MDCompileUnit>`.
+:ref:`compile unit <DICompileUnit>`.
 
-.. _MDSubprogram:
+.. _DISubprogram:
 
-MDSubprogram
+DISubprogram
 """"""""""""
 
-``MDSubprogram`` nodes represent functions from the source language.  The
-``variables:`` field points at :ref:`variables <MDLocalVariable>` that must be
+``DISubprogram`` nodes represent functions from the source language.  The
+``variables:`` field points at :ref:`variables <DILocalVariable>` that must be
 retained, even if their IR counterparts are optimized out of the IR.  The
-``type:`` field must point at an :ref:`MDSubroutineType`.
+``type:`` field must point at an :ref:`DISubroutineType`.
 
 .. code-block:: llvm
 
-    !0 = !MDSubprogram(name: "foo", linkageName: "_Zfoov", scope: !1,
+    !0 = !DISubprogram(name: "foo", linkageName: "_Zfoov", scope: !1,
                        file: !2, line: 7, type: !3, isLocal: true,
                        isDefinition: false, scopeLine: 8, containingType: !4,
                        virtuality: DW_VIRTUALITY_pure_virtual, virtualIndex: 10,
@@ -3192,76 +3192,76 @@ retained, even if their IR counterparts are optimized out of the IR.  The
                        function: void ()* @_Z3foov,
                        templateParams: !5, declaration: !6, variables: !7)
 
-.. _MDLexicalBlock:
+.. _DILexicalBlock:
 
-MDLexicalBlock
+DILexicalBlock
 """"""""""""""
 
-``MDLexicalBlock`` nodes describe nested blocks within a :ref:`subprogram
-<MDSubprogram>`.  The line number and column numbers are used to dinstinguish
+``DILexicalBlock`` nodes describe nested blocks within a :ref:`subprogram
+<DISubprogram>`.  The line number and column numbers are used to dinstinguish
 two lexical blocks at same depth.  They are valid targets for ``scope:``
 fields.
 
 .. code-block:: llvm
 
-    !0 = distinct !MDLexicalBlock(scope: !1, file: !2, line: 7, column: 35)
+    !0 = distinct !DILexicalBlock(scope: !1, file: !2, line: 7, column: 35)
 
 Usually lexical blocks are ``distinct`` to prevent node merging based on
 operands.
 
-.. _MDLexicalBlockFile:
+.. _DILexicalBlockFile:
 
-MDLexicalBlockFile
+DILexicalBlockFile
 """"""""""""""""""
 
-``MDLexicalBlockFile`` nodes are used to discriminate between sections of a
-:ref:`lexical block <MDLexicalBlock>`.  The ``file:`` field can be changed to
+``DILexicalBlockFile`` nodes are used to discriminate between sections of a
+:ref:`lexical block <DILexicalBlock>`.  The ``file:`` field can be changed to
 indicate textual inclusion, or the ``discriminator:`` field can be used to
 discriminate between control flow within a single block in the source language.
 
 .. code-block:: llvm
 
-    !0 = !MDLexicalBlock(scope: !3, file: !4, line: 7, column: 35)
-    !1 = !MDLexicalBlockFile(scope: !0, file: !4, discriminator: 0)
-    !2 = !MDLexicalBlockFile(scope: !0, file: !4, discriminator: 1)
+    !0 = !DILexicalBlock(scope: !3, file: !4, line: 7, column: 35)
+    !1 = !DILexicalBlockFile(scope: !0, file: !4, discriminator: 0)
+    !2 = !DILexicalBlockFile(scope: !0, file: !4, discriminator: 1)
 
-MDLocation
+DILocation
 """"""""""
 
-``MDLocation`` nodes represent source debug locations.  The ``scope:`` field is
-mandatory, and points at an :ref:`MDLexicalBlockFile`, an
-:ref:`MDLexicalBlock`, or an :ref:`MDSubprogram`.
+``DILocation`` nodes represent source debug locations.  The ``scope:`` field is
+mandatory, and points at an :ref:`DILexicalBlockFile`, an
+:ref:`DILexicalBlock`, or an :ref:`DISubprogram`.
 
 .. code-block:: llvm
 
-    !0 = !MDLocation(line: 2900, column: 42, scope: !1, inlinedAt: !2)
+    !0 = !DILocation(line: 2900, column: 42, scope: !1, inlinedAt: !2)
 
-.. _MDLocalVariable:
+.. _DILocalVariable:
 
-MDLocalVariable
+DILocalVariable
 """""""""""""""
 
-``MDLocalVariable`` nodes represent local variables in the source language.
+``DILocalVariable`` nodes represent local variables in the source language.
 Instead of ``DW_TAG_variable``, they use LLVM-specific fake tags to
 discriminate between local variables (``DW_TAG_auto_variable``) and subprogram
 arguments (``DW_TAG_arg_variable``).  In the latter case, the ``arg:`` field
 specifies the argument position, and this variable will be included in the
-``variables:`` field of its :ref:`MDSubprogram`.
+``variables:`` field of its :ref:`DISubprogram`.
 
 .. code-block:: llvm
 
-    !0 = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "this", arg: 0,
+    !0 = !DILocalVariable(tag: DW_TAG_arg_variable, name: "this", arg: 0,
                           scope: !3, file: !2, line: 7, type: !3,
                           flags: DIFlagArtificial)
-    !1 = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "x", arg: 1,
+    !1 = !DILocalVariable(tag: DW_TAG_arg_variable, name: "x", arg: 1,
                           scope: !4, file: !2, line: 7, type: !3)
-    !1 = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "y",
+    !1 = !DILocalVariable(tag: DW_TAG_auto_variable, name: "y",
                           scope: !5, file: !2, line: 7, type: !3)
 
-MDExpression
+DIExpression
 """"""""""""
 
-``MDExpression`` nodes represent DWARF expression sequences.  They are used in
+``DIExpression`` nodes represent DWARF expression sequences.  They are used in
 :ref:`debug intrinsics<dbg_intrinsics>` (such as ``llvm.dbg.declare``) to
 describe how the referenced LLVM variable relates to the source language
 variable.
@@ -3275,30 +3275,30 @@ The current supported vocabulary is limited:
 
 .. code-block:: llvm
 
-    !0 = !MDExpression(DW_OP_deref)
-    !1 = !MDExpression(DW_OP_plus, 3)
-    !2 = !MDExpression(DW_OP_bit_piece, 3, 7)
-    !3 = !MDExpression(DW_OP_deref, DW_OP_plus, 3, DW_OP_bit_piece, 3, 7)
+    !0 = !DIExpression(DW_OP_deref)
+    !1 = !DIExpression(DW_OP_plus, 3)
+    !2 = !DIExpression(DW_OP_bit_piece, 3, 7)
+    !3 = !DIExpression(DW_OP_deref, DW_OP_plus, 3, DW_OP_bit_piece, 3, 7)
 
-MDObjCProperty
+DIObjCProperty
 """"""""""""""
 
-``MDObjCProperty`` nodes represent Objective-C property nodes.
+``DIObjCProperty`` nodes represent Objective-C property nodes.
 
 .. code-block:: llvm
 
-    !3 = !MDObjCProperty(name: "foo", file: !1, line: 7, setter: "setFoo",
+    !3 = !DIObjCProperty(name: "foo", file: !1, line: 7, setter: "setFoo",
                          getter: "getFoo", attributes: 7, type: !2)
 
-MDImportedEntity
+DIImportedEntity
 """"""""""""""""
 
-``MDImportedEntity`` nodes represent entities (such as modules) imported into a
+``DIImportedEntity`` nodes represent entities (such as modules) imported into a
 compile unit.
 
 .. code-block:: llvm
 
-   !2 = !MDImportedEntity(tag: DW_TAG_imported_module, name: "foo", scope: !0,
+   !2 = !DIImportedEntity(tag: DW_TAG_imported_module, name: "foo", scope: !0,
                           entity: !1, line: 7)
 
 '``tbaa``' Metadata
index 55e12d3..95f5d07 100644 (file)
@@ -153,8 +153,8 @@ debugger to interpret the information.
 To provide basic functionality, the LLVM debugger does have to make some
 assumptions about the source-level language being debugged, though it keeps
 these to a minimum.  The only common features that the LLVM debugger assumes
-exist are `source files <LangRef.html#MDFile>`_, and `program objects
-<LangRef.html#MDGlobalVariable>`_.  These abstract objects are used by a
+exist are `source files <LangRef.html#DIFile>`_, and `program objects
+<LangRef.html#DIGlobalVariable>`_.  These abstract objects are used by a
 debugger to form stack traces, show information about local variables, etc.
 
 This section of the documentation first describes the representation aspects
@@ -181,9 +181,9 @@ provide debug information at various points in generated code.
 
 This intrinsic provides information about a local element (e.g., variable).
 The first argument is metadata holding the alloca for the variable.  The second
-argument is a `local variable <LangRef.html#MDLocalVariable>`_ containing a
+argument is a `local variable <LangRef.html#DILocalVariable>`_ containing a
 description of the variable.  The third argument is a `complex expression
-<LangRef.html#MDExpression>`_.
+<LangRef.html#DIExpression>`_.
 
 ``llvm.dbg.value``
 ^^^^^^^^^^^^^^^^^^
@@ -196,8 +196,8 @@ This intrinsic provides information when a user source variable is set to a new
 value.  The first argument is the new value (wrapped as metadata).  The second
 argument is the offset in the user source variable where the new value is
 written.  The third argument is a `local variable
-<LangRef.html#MDLocalVariable>`_ containing a description of the variable.  The
-third argument is a `complex expression <LangRef.html#MDExpression>`_.
+<LangRef.html#DILocalVariable>`_ containing a description of the variable.  The
+third argument is a `complex expression <LangRef.html#DIExpression>`_.
 
 Object lifetimes and scoping
 ============================
@@ -259,31 +259,31 @@ Compiled to LLVM, this function would be represented like this:
   !llvm.module.flags = !{!7, !8, !9}
   !llvm.ident = !{!10}
 
-  !0 = !MDCompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.7.0 (trunk 231150) (llvm/trunk 231154)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !2, subprograms: !3, globals: !2, imports: !2)
-  !1 = !MDFile(filename: "/dev/stdin", directory: "/Users/dexonsmith/data/llvm/debug-info")
+  !0 = !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.7.0 (trunk 231150) (llvm/trunk 231154)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !2, subprograms: !3, globals: !2, imports: !2)
+  !1 = !DIFile(filename: "/dev/stdin", directory: "/Users/dexonsmith/data/llvm/debug-info")
   !2 = !{}
   !3 = !{!4}
-  !4 = !MDSubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, scopeLine: 1, isOptimized: false, function: void ()* @foo, variables: !2)
-  !5 = !MDSubroutineType(types: !6)
+  !4 = !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, scopeLine: 1, isOptimized: false, function: void ()* @foo, variables: !2)
+  !5 = !DISubroutineType(types: !6)
   !6 = !{null}
   !7 = !{i32 2, !"Dwarf Version", i32 2}
   !8 = !{i32 2, !"Debug Info Version", i32 3}
   !9 = !{i32 1, !"PIC Level", i32 2}
   !10 = !{!"clang version 3.7.0 (trunk 231150) (llvm/trunk 231154)"}
-  !11 = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "X", scope: !4, file: !1, line: 2, type: !12)
-  !12 = !MDBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
-  !13 = !MDExpression()
-  !14 = !MDLocation(line: 2, column: 9, scope: !4)
-  !15 = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "Y", scope: !4, file: !1, line: 3, type: !12)
-  !16 = !MDLocation(line: 3, column: 9, scope: !4)
-  !17 = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "Z", scope: !18, file: !1, line: 5, type: !12)
-  !18 = distinct !MDLexicalBlock(scope: !4, file: !1, line: 4, column: 5)
-  !19 = !MDLocation(line: 5, column: 11, scope: !18)
-  !20 = !MDLocation(line: 6, column: 11, scope: !18)
-  !21 = !MDLocation(line: 6, column: 9, scope: !18)
-  !22 = !MDLocation(line: 8, column: 9, scope: !4)
-  !23 = !MDLocation(line: 8, column: 7, scope: !4)
-  !24 = !MDLocation(line: 9, column: 3, scope: !4)
+  !11 = !DILocalVariable(tag: DW_TAG_auto_variable, name: "X", scope: !4, file: !1, line: 2, type: !12)
+  !12 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+  !13 = !DIExpression()
+  !14 = !DILocation(line: 2, column: 9, scope: !4)
+  !15 = !DILocalVariable(tag: DW_TAG_auto_variable, name: "Y", scope: !4, file: !1, line: 3, type: !12)
+  !16 = !DILocation(line: 3, column: 9, scope: !4)
+  !17 = !DILocalVariable(tag: DW_TAG_auto_variable, name: "Z", scope: !18, file: !1, line: 5, type: !12)
+  !18 = distinct !DILexicalBlock(scope: !4, file: !1, line: 4, column: 5)
+  !19 = !DILocation(line: 5, column: 11, scope: !18)
+  !20 = !DILocation(line: 6, column: 11, scope: !18)
+  !21 = !DILocation(line: 6, column: 9, scope: !18)
+  !22 = !DILocation(line: 8, column: 9, scope: !4)
+  !23 = !DILocation(line: 8, column: 7, scope: !4)
+  !24 = !DILocation(line: 9, column: 3, scope: !4)
 
 
 This example illustrates a few important details about LLVM debugging
@@ -303,15 +303,15 @@ scope information for the variable ``X``.
 
 .. code-block:: llvm
 
-  !14 = !MDLocation(line: 2, column: 9, scope: !4)
-  !4 = !MDSubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !5,
+  !14 = !DILocation(line: 2, column: 9, scope: !4)
+  !4 = !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !5,
                      isLocal: false, isDefinition: true, scopeLine: 1,
                      isOptimized: false, function: void ()* @foo,
                      variables: !2)
 
 Here ``!14`` is metadata providing `location information
-<LangRef.html#MDLocation>`_.  In this example, scope is encoded by ``!4``, a
-`subprogram descriptor <LangRef.html#MDSubprogram>`_.  This way the location
+<LangRef.html#DILocation>`_.  In this example, scope is encoded by ``!4``, a
+`subprogram descriptor <LangRef.html#DISubprogram>`_.  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``.
 
@@ -328,8 +328,8 @@ scope information for the variable ``Z``.
 
 .. code-block:: llvm
 
-  !18 = distinct !MDLexicalBlock(scope: !4, file: !1, line: 4, column: 5)
-  !19 = !MDLocation(line: 5, column: 11, scope: !18)
+  !18 = distinct !DILexicalBlock(scope: !4, file: !1, line: 4, column: 5)
+  !19 = !DILocation(line: 5, column: 11, scope: !18)
 
 Here ``!19`` indicates that ``Z`` is declared at line number 5 and column
 number 0 inside of lexical scope ``!18``.  The lexical scope itself resides
@@ -406,7 +406,7 @@ a C/C++ front-end would generate the following descriptors:
   !llvm.module.flags = !{!6, !7}
 
   ;; Define the compile unit.
-  !0 = !MDCompileUnit(language: DW_LANG_C99, file: !1,
+  !0 = !DICompileUnit(language: DW_LANG_C99, file: !1,
                       producer:
                       "clang version 3.7.0 (trunk 231150) (llvm/trunk 231154)",
                       isOptimized: false, runtimeVersion: 0, emissionKind: 1,
@@ -416,7 +416,7 @@ a C/C++ front-end would generate the following descriptors:
   ;;
   ;; Define the file
   ;;
-  !1 = !MDFile(filename: "/dev/stdin",
+  !1 = !DIFile(filename: "/dev/stdin",
                directory: "/Users/dexonsmith/data/llvm/debug-info")
 
   ;; An empty array.
@@ -428,14 +428,14 @@ a C/C++ front-end would generate the following descriptors:
   ;;
   ;; Define the global variable itself.
   ;;
-  !4 = !MDGlobalVariable(name: "MyGlobal", scope: !0, file: !1, line: 1,
+  !4 = !DIGlobalVariable(name: "MyGlobal", scope: !0, file: !1, line: 1,
                          type: !5, isLocal: false, isDefinition: true,
                          variable: i32* @MyGlobal)
 
   ;;
   ;; Define the type
   ;;
-  !5 = !MDBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+  !5 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 
   ;; Dwarf version to output.
   !6 = !{i32 2, !"Dwarf Version", i32 2}
@@ -461,7 +461,7 @@ a C/C++ front-end would generate the following descriptors:
   ;;
   ;; Define the anchor for subprograms.
   ;;
-  !4 = !MDSubprogram(name: "main", scope: !1, file: !1, line: 1, type: !5,
+  !4 = !DISubprogram(name: "main", scope: !1, file: !1, line: 1, type: !5,
                      isLocal: false, isDefinition: true, scopeLine: 1,
                      flags: DIFlagPrototyped, isOptimized: false,
                      function: i32 (i32, i8**)* @main, variables: !2)
index 90c3b83..0b9b39c 100644 (file)
@@ -187,13 +187,13 @@ expressions:
   static DIBuilder *DBuilder;
 
   struct DebugInfo {
-    MDCompileUnit *TheCU;
-    MDType *DblTy;
+    DICompileUnit *TheCU;
+    DIType *DblTy;
 
-    MDType *getDoubleTy();
+    DIType *getDoubleTy();
   } KSDbgInfo;
 
-  MDType *DebugInfo::getDoubleTy() {
+  DIType *DebugInfo::getDoubleTy() {
     if (DblTy.isValid())
       return DblTy;
 
@@ -245,25 +245,25 @@ So the context:
 
 .. code-block:: c++
 
-  MDFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU.getFilename(),
+  DIFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU.getFilename(),
                                       KSDbgInfo.TheCU.getDirectory());
 
-giving us an MDFile and asking the ``Compile Unit`` we created above for the
+giving us an DIFile and asking the ``Compile Unit`` we created above for the
 directory and filename where we are currently. Then, for now, we use some
 source locations of 0 (since our AST doesn't currently have source location
 information) and construct our function definition:
 
 .. code-block:: c++
 
-  MDScope *FContext = Unit;
+  DIScope *FContext = Unit;
   unsigned LineNo = 0;
   unsigned ScopeLine = 0;
-  MDSubprogram *SP = DBuilder->createFunction(
+  DISubprogram *SP = DBuilder->createFunction(
       FContext, Name, StringRef(), Unit, LineNo,
       CreateFunctionType(Args.size(), Unit), false /* internal linkage */,
-      true /* definition */, ScopeLine, DebugNode::FlagPrototyped, false, F);
+      true /* definition */, ScopeLine, DINode::FlagPrototyped, false, F);
 
-and we now have an MDSubprogram that contains a reference to all of our
+and we now have an DISubprogram that contains a reference to all of our
 metadata for the function.
 
 Source Locations
@@ -330,7 +330,7 @@ by constructing another small function:
 .. code-block:: c++
 
   void DebugInfo::emitLocation(ExprAST *AST) {
-    MDScope *Scope;
+    DIScope *Scope;
     if (LexicalBlocks.empty())
       Scope = TheCU;
     else
@@ -347,11 +347,11 @@ of scopes:
 
 .. code-block:: c++
 
-   std::vector<MDScope *> LexicalBlocks;
-   std::map<const PrototypeAST *, MDScope *> FnScopeMap;
+   std::vector<DIScope *> LexicalBlocks;
+   std::map<const PrototypeAST *, DIScope *> FnScopeMap;
 
 and keep a map of each function to the scope that it represents (an
-MDSubprogram is also an MDScope).
+DISubprogram is also an DIScope).
 
 Then we make sure to:
 
@@ -392,10 +392,10 @@ argument allocas in ``PrototypeAST::CreateArgumentAllocas``.
 
 .. code-block:: c++
 
-  MDScope *Scope = KSDbgInfo.LexicalBlocks.back();
-  MDFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU.getFilename(),
+  DIScope *Scope = KSDbgInfo.LexicalBlocks.back();
+  DIFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU.getFilename(),
                                       KSDbgInfo.TheCU.getDirectory());
-  MDLocalVariable D = DBuilder->createLocalVariable(
+  DILocalVariable D = DBuilder->createLocalVariable(
       dwarf::DW_TAG_arg_variable, Scope, Args[Idx], Unit, Line,
       KSDbgInfo.getDoubleTy(), Idx);
 
index a565e52..71bc2f6 100644 (file)
@@ -93,13 +93,13 @@ class ExprAST;
 }
 static IRBuilder<> Builder(getGlobalContext());
 struct DebugInfo {
-  MDCompileUnit *TheCU;
-  MDType *DblTy;
-  std::vector<MDScope *> LexicalBlocks;
-  std::map<const PrototypeAST *, MDScope *> FnScopeMap;
+  DICompileUnit *TheCU;
+  DIType *DblTy;
+  std::vector<DIScope *> LexicalBlocks;
+  std::map<const PrototypeAST *, DIScope *> FnScopeMap;
 
   void emitLocation(ExprAST *AST);
-  MDType *getDoubleTy();
+  DIType *getDoubleTy();
 } KSDbgInfo;
 
 static std::string IdentifierStr; // Filled in if tok_identifier
@@ -816,7 +816,7 @@ static PrototypeAST *ParseExtern() {
 
 static DIBuilder *DBuilder;
 
-MDType *DebugInfo::getDoubleTy() {
+DIType *DebugInfo::getDoubleTy() {
   if (DblTy)
     return DblTy;
 
@@ -827,7 +827,7 @@ MDType *DebugInfo::getDoubleTy() {
 void DebugInfo::emitLocation(ExprAST *AST) {
   if (!AST)
     return Builder.SetCurrentDebugLocation(DebugLoc());
-  MDScope *Scope;
+  DIScope *Scope;
   if (LexicalBlocks.empty())
     Scope = TheCU;
   else
@@ -836,9 +836,9 @@ void DebugInfo::emitLocation(ExprAST *AST) {
       DebugLoc::get(AST->getLine(), AST->getCol(), Scope));
 }
 
-static MDSubroutineType *CreateFunctionType(unsigned NumArgs, MDFile *Unit) {
+static DISubroutineType *CreateFunctionType(unsigned NumArgs, DIFile *Unit) {
   SmallVector<Metadata *, 8> EltTys;
-  MDType *DblTy = KSDbgInfo.getDoubleTy();
+  DIType *DblTy = KSDbgInfo.getDoubleTy();
 
   // Add the result type.
   EltTys.push_back(DblTy);
@@ -1227,15 +1227,15 @@ Function *PrototypeAST::Codegen() {
     AI->setName(Args[Idx]);
 
   // Create a subprogram DIE for this function.
-  MDFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU->getFilename(),
+  DIFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU->getFilename(),
                                       KSDbgInfo.TheCU->getDirectory());
-  MDScope *FContext = Unit;
+  DIScope *FContext = Unit;
   unsigned LineNo = Line;
   unsigned ScopeLine = Line;
-  MDSubprogram *SP = DBuilder->createFunction(
+  DISubprogram *SP = DBuilder->createFunction(
       FContext, Name, StringRef(), Unit, LineNo,
       CreateFunctionType(Args.size(), Unit), false /* internal linkage */,
-      true /* definition */, ScopeLine, DebugNode::FlagPrototyped, false, F);
+      true /* definition */, ScopeLine, DINode::FlagPrototyped, false, F);
 
   KSDbgInfo.FnScopeMap[this] = SP;
   return F;
@@ -1250,10 +1250,10 @@ void PrototypeAST::CreateArgumentAllocas(Function *F) {
     AllocaInst *Alloca = CreateEntryBlockAlloca(F, Args[Idx]);
 
     // Create a debug descriptor for the variable.
-    MDScope *Scope = KSDbgInfo.LexicalBlocks.back();
-    MDFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU->getFilename(),
+    DIScope *Scope = KSDbgInfo.LexicalBlocks.back();
+    DIFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU->getFilename(),
                                         KSDbgInfo.TheCU->getDirectory());
-    MDLocalVariable *D = DBuilder->createLocalVariable(
+    DILocalVariable *D = DBuilder->createLocalVariable(
         dwarf::DW_TAG_arg_variable, Scope, Args[Idx], Unit, Line,
         KSDbgInfo.getDoubleTy(), Idx);
 
index aa217d5..7d7e48a 100644 (file)
@@ -45,7 +45,7 @@ typedef std::pair<const MachineInstr *, const MachineInstr *> InsnRange;
 class LexicalScope {
 
 public:
-  LexicalScope(LexicalScope *P, const MDLocalScope *D, const MDLocation *I,
+  LexicalScope(LexicalScope *P, const DILocalScope *D, const DILocation *I,
                bool A)
       : Parent(P), Desc(D), InlinedAtLocation(I), AbstractScope(A),
         LastInsn(nullptr), FirstInsn(nullptr), DFSIn(0), DFSOut(0) {
@@ -58,8 +58,8 @@ public:
   // Accessors.
   LexicalScope *getParent() const { return Parent; }
   const MDNode *getDesc() const { return Desc; }
-  const MDLocation *getInlinedAt() const { return InlinedAtLocation; }
-  const MDLocalScope *getScopeNode() const { return Desc; }
+  const DILocation *getInlinedAt() const { return InlinedAtLocation; }
+  const DILocalScope *getScopeNode() const { return Desc; }
   bool isAbstractScope() const { return AbstractScope; }
   SmallVectorImpl<LexicalScope *> &getChildren() { return Children; }
   SmallVectorImpl<InsnRange> &getRanges() { return Ranges; }
@@ -119,8 +119,8 @@ public:
 
 private:
   LexicalScope *Parent;                        // Parent to this scope.
-  const MDLocalScope *Desc;                    // Debug info descriptor.
-  const MDLocation *InlinedAtLocation;         // Location at which this
+  const DILocalScope *Desc;                    // Debug info descriptor.
+  const DILocation *InlinedAtLocation;         // Location at which this
                                                // scope is inlined.
   bool AbstractScope;                          // Abstract Scope
   SmallVector<LexicalScope *, 4> Children;     // Scopes defined in scope.
@@ -159,16 +159,16 @@ public:
   /// getMachineBasicBlocks - Populate given set using machine basic blocks
   /// which have machine instructions that belong to lexical scope identified by
   /// DebugLoc.
-  void getMachineBasicBlocks(const MDLocation *DL,
+  void getMachineBasicBlocks(const DILocation *DL,
                              SmallPtrSetImpl<const MachineBasicBlock *> &MBBs);
 
   /// dominates - Return true if DebugLoc's lexical scope dominates at least one
   /// machine instruction's lexical scope in a given machine basic block.
-  bool dominates(const MDLocation *DL, MachineBasicBlock *MBB);
+  bool dominates(const DILocation *DL, MachineBasicBlock *MBB);
 
   /// findLexicalScope - Find lexical scope, either regular or inlined, for the
   /// given DebugLoc. Return NULL if not found.
-  LexicalScope *findLexicalScope(const MDLocation *DL);
+  LexicalScope *findLexicalScope(const DILocation *DL);
 
   /// getAbstractScopesList - Return a reference to list of abstract scopes.
   ArrayRef<LexicalScope *> getAbstractScopesList() const {
@@ -176,19 +176,19 @@ public:
   }
 
   /// findAbstractScope - Find an abstract scope or return null.
-  LexicalScope *findAbstractScope(const MDLocalScope *N) {
+  LexicalScope *findAbstractScope(const DILocalScope *N) {
     auto I = AbstractScopeMap.find(N);
     return I != AbstractScopeMap.end() ? &I->second : nullptr;
   }
 
   /// findInlinedScope - Find an inlined scope for the given scope/inlined-at.
-  LexicalScope *findInlinedScope(const MDLocalScope *N, const MDLocation *IA) {
+  LexicalScope *findInlinedScope(const DILocalScope *N, const DILocation *IA) {
     auto I = InlinedLexicalScopeMap.find(std::make_pair(N, IA));
     return I != InlinedLexicalScopeMap.end() ? &I->second : nullptr;
   }
 
   /// findLexicalScope - Find regular lexical scope or return null.
-  LexicalScope *findLexicalScope(const MDLocalScope *N) {
+  LexicalScope *findLexicalScope(const DILocalScope *N) {
     auto I = LexicalScopeMap.find(N);
     return I != LexicalScopeMap.end() ? &I->second : nullptr;
   }
@@ -197,24 +197,24 @@ public:
   void dump();
 
   /// getOrCreateAbstractScope - Find or create an abstract lexical scope.
-  LexicalScope *getOrCreateAbstractScope(const MDLocalScope *Scope);
+  LexicalScope *getOrCreateAbstractScope(const DILocalScope *Scope);
 
 private:
   /// getOrCreateLexicalScope - Find lexical scope for the given Scope/IA. If
   /// not available then create new lexical scope.
-  LexicalScope *getOrCreateLexicalScope(const MDLocalScope *Scope,
-                                        const MDLocation *IA = nullptr);
-  LexicalScope *getOrCreateLexicalScope(const MDLocation *DL) {
+  LexicalScope *getOrCreateLexicalScope(const DILocalScope *Scope,
+                                        const DILocation *IA = nullptr);
+  LexicalScope *getOrCreateLexicalScope(const DILocation *DL) {
     return DL ? getOrCreateLexicalScope(DL->getScope(), DL->getInlinedAt())
               : nullptr;
   }
 
   /// getOrCreateRegularScope - Find or create a regular lexical scope.
-  LexicalScope *getOrCreateRegularScope(const MDLocalScope *Scope);
+  LexicalScope *getOrCreateRegularScope(const DILocalScope *Scope);
 
   /// getOrCreateInlinedScope - Find or create an inlined lexical scope.
-  LexicalScope *getOrCreateInlinedScope(const MDLocalScope *Scope,
-                                        const MDLocation *InlinedAt);
+  LexicalScope *getOrCreateInlinedScope(const DILocalScope *Scope,
+                                        const DILocation *InlinedAt);
 
   /// extractLexicalScopes - Extract instruction ranges for each lexical scopes
   /// for the given machine function.
@@ -230,18 +230,18 @@ private:
 
   /// LexicalScopeMap - Tracks the scopes in the current function.
   // Use an unordered_map to ensure value pointer validity over insertion.
-  std::unordered_map<const MDLocalScope *, LexicalScope> LexicalScopeMap;
+  std::unordered_map<const DILocalScope *, LexicalScope> LexicalScopeMap;
 
   /// InlinedLexicalScopeMap - Tracks inlined function scopes in current
   /// function.
-  std::unordered_map<std::pair<const MDLocalScope *, const MDLocation *>,
+  std::unordered_map<std::pair<const DILocalScope *, const DILocation *>,
                      LexicalScope,
-                     pair_hash<const MDLocalScope *, const MDLocation *>>
+                     pair_hash<const DILocalScope *, const DILocation *>>
       InlinedLexicalScopeMap;
 
   /// AbstractScopeMap - These scopes are  not included LexicalScopeMap.
   // Use an unordered_map to ensure value pointer validity over insertion.
-  std::unordered_map<const MDLocalScope *, LexicalScope> AbstractScopeMap;
+  std::unordered_map<const DILocalScope *, LexicalScope> AbstractScopeMap;
 
   /// AbstractScopesList - Tracks abstract scopes constructed while processing
   /// a function.
index 5a28c1b..586ac04 100644 (file)
@@ -246,16 +246,16 @@ public:
 
   /// \brief Return the debug variable referenced by
   /// this DBG_VALUE instruction.
-  const MDLocalVariable *getDebugVariable() const {
+  const DILocalVariable *getDebugVariable() const {
     assert(isDebugValue() && "not a DBG_VALUE");
-    return cast<MDLocalVariable>(getOperand(2).getMetadata());
+    return cast<DILocalVariable>(getOperand(2).getMetadata());
   }
 
   /// \brief Return the complex address expression referenced by
   /// this DBG_VALUE instruction.
-  const MDExpression *getDebugExpression() const {
+  const DIExpression *getDebugExpression() const {
     assert(isDebugValue() && "not a DBG_VALUE");
-    return cast<MDExpression>(getOperand(3).getMetadata());
+    return cast<DIExpression>(getOperand(3).getMetadata());
   }
 
   /// emitError - Emit an error referring to the source location of this
index 8825452..47397c6 100644 (file)
@@ -356,9 +356,9 @@ inline MachineInstrBuilder BuildMI(MachineFunction &MF, DebugLoc DL,
                                    const MCInstrDesc &MCID, bool IsIndirect,
                                    unsigned Reg, unsigned Offset,
                                    const MDNode *Variable, const MDNode *Expr) {
-  assert(isa<MDLocalVariable>(Variable) && "not a variable");
-  assert(cast<MDExpression>(Expr)->isValid() && "not an expression");
-  assert(cast<MDLocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
+  assert(isa<DILocalVariable>(Variable) && "not a variable");
+  assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
+  assert(cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
   if (IsIndirect)
     return BuildMI(MF, DL, MCID)
@@ -385,8 +385,8 @@ inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB,
                                    const MCInstrDesc &MCID, bool IsIndirect,
                                    unsigned Reg, unsigned Offset,
                                    const MDNode *Variable, const MDNode *Expr) {
-  assert(isa<MDLocalVariable>(Variable) && "not a variable");
-  assert(cast<MDExpression>(Expr)->isValid() && "not an expression");
+  assert(isa<DILocalVariable>(Variable) && "not a variable");
+  assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
   MachineFunction &MF = *BB.getParent();
   MachineInstr *MI =
       BuildMI(MF, DL, MCID, IsIndirect, Reg, Offset, Variable, Expr);
index d53fdd4..ce45c16 100644 (file)
@@ -193,13 +193,13 @@ public:
   static char ID; // Pass identification, replacement for typeid
 
   struct VariableDbgInfo {
-    const MDLocalVariable *Var;
-    const MDExpression *Expr;
+    const DILocalVariable *Var;
+    const DIExpression *Expr;
     unsigned Slot;
-    const MDLocation *Loc;
+    const DILocation *Loc;
 
-    VariableDbgInfo(const MDLocalVariable *Var, const MDExpression *Expr,
-                    unsigned Slot, const MDLocation *Loc)
+    VariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr,
+                    unsigned Slot, const DILocation *Loc)
         : Var(Var), Expr(Expr), Slot(Slot), Loc(Loc) {}
   };
   typedef SmallVector<VariableDbgInfo, 4> VariableDbgInfoMapTy;
@@ -448,8 +448,8 @@ public:
 
   /// setVariableDbgInfo - Collect information used to emit debugging
   /// information of a variable.
-  void setVariableDbgInfo(const MDLocalVariable *Var, const MDExpression *Expr,
-                          unsigned Slot, const MDLocation *Loc) {
+  void setVariableDbgInfo(const DILocalVariable *Var, const DIExpression *Expr,
+                          unsigned Slot, const DILocation *Loc) {
     VariableDbgInfos.emplace_back(Var, Expr, Slot, Loc);
   }
 
index 0ed97b6..68fb59b 100644 (file)
@@ -104,7 +104,7 @@ namespace llvm {
     ///                        source location information in the back end
     ///                        without actually changing the output (e.g.,
     ///                        when using optimization remarks).
-    MDCompileUnit *createCompileUnit(unsigned Lang, StringRef File,
+    DICompileUnit *createCompileUnit(unsigned Lang, StringRef File,
                                      StringRef Dir, StringRef Producer,
                                      bool isOptimized, StringRef Flags,
                                      unsigned RV, StringRef SplitName = "",
@@ -113,16 +113,16 @@ namespace llvm {
 
     /// createFile - Create a file descriptor to hold debugging information
     /// for a file.
-    MDFile *createFile(StringRef Filename, StringRef Directory);
+    DIFile *createFile(StringRef Filename, StringRef Directory);
 
     /// createEnumerator - Create a single enumerator value.
-    MDEnumerator *createEnumerator(StringRef Name, int64_t Val);
+    DIEnumerator *createEnumerator(StringRef Name, int64_t Val);
 
     /// \brief Create a DWARF unspecified type.
-    MDBasicType *createUnspecifiedType(StringRef Name);
+    DIBasicType *createUnspecifiedType(StringRef Name);
 
     /// \brief Create C++11 nullptr type.
-    MDBasicType *createNullPtrType();
+    DIBasicType *createNullPtrType();
 
     /// createBasicType - Create debugging information entry for a basic
     /// type.
@@ -130,21 +130,21 @@ namespace llvm {
     /// @param SizeInBits  Size of the type.
     /// @param AlignInBits Type alignment.
     /// @param Encoding    DWARF encoding code, e.g. dwarf::DW_ATE_float.
-    MDBasicType *createBasicType(StringRef Name, uint64_t SizeInBits,
+    DIBasicType *createBasicType(StringRef Name, uint64_t SizeInBits,
                                  uint64_t AlignInBits, unsigned Encoding);
 
     /// createQualifiedType - Create debugging information entry for a qualified
     /// type, e.g. 'const int'.
     /// @param Tag         Tag identifing type, e.g. dwarf::TAG_volatile_type
     /// @param FromTy      Base Type.
-    MDDerivedType *createQualifiedType(unsigned Tag, MDType *FromTy);
+    DIDerivedType *createQualifiedType(unsigned Tag, DIType *FromTy);
 
     /// createPointerType - Create debugging information entry for a pointer.
     /// @param PointeeTy   Type pointed by this pointer.
     /// @param SizeInBits  Size.
     /// @param AlignInBits Alignment. (optional)
     /// @param Name        Pointer type name. (optional)
-    MDDerivedType *createPointerType(MDType *PointeeTy, uint64_t SizeInBits,
+    DIDerivedType *createPointerType(DIType *PointeeTy, uint64_t SizeInBits,
                                      uint64_t AlignInBits = 0,
                                      StringRef Name = "");
 
@@ -153,13 +153,13 @@ namespace llvm {
     /// @param SizeInBits  Size.
     /// @param AlignInBits Alignment. (optional)
     /// @param Class Type for which this pointer points to members of.
-    MDDerivedType *createMemberPointerType(MDType *PointeeTy, MDType *Class,
+    DIDerivedType *createMemberPointerType(DIType *PointeeTy, DIType *Class,
                                            uint64_t SizeInBits,
                                            uint64_t AlignInBits = 0);
 
     /// createReferenceType - Create debugging information entry for a c++
     /// style reference or rvalue reference type.
-    MDDerivedType *createReferenceType(unsigned Tag, MDType *RTy);
+    DIDerivedType *createReferenceType(unsigned Tag, DIType *RTy);
 
     /// createTypedef - Create debugging information entry for a typedef.
     /// @param Ty          Original type.
@@ -167,11 +167,11 @@ namespace llvm {
     /// @param File        File where this type is defined.
     /// @param LineNo      Line number.
     /// @param Context     The surrounding context for the typedef.
-    MDDerivedType *createTypedef(MDType *Ty, StringRef Name, MDFile *File,
-                                 unsigned LineNo, MDScope *Context);
+    DIDerivedType *createTypedef(DIType *Ty, StringRef Name, DIFile *File,
+                                 unsigned LineNo, DIScope *Context);
 
     /// createFriend - Create debugging information entry for a 'friend'.
-    MDDerivedType *createFriend(MDType *Ty, MDType *FriendTy);
+    DIDerivedType *createFriend(DIType *Ty, DIType *FriendTy);
 
     /// createInheritance - Create debugging information entry to establish
     /// inheritance relationship between two types.
@@ -180,7 +180,7 @@ namespace llvm {
     /// @param BaseOffset   Base offset.
     /// @param Flags        Flags to describe inheritance attribute,
     ///                     e.g. private
-    MDDerivedType *createInheritance(MDType *Ty, MDType *BaseTy,
+    DIDerivedType *createInheritance(DIType *Ty, DIType *BaseTy,
                                      uint64_t BaseOffset, unsigned Flags);
 
     /// createMemberType - Create debugging information entry for a member.
@@ -193,11 +193,11 @@ namespace llvm {
     /// @param OffsetInBits Member offset.
     /// @param Flags        Flags to encode member attribute, e.g. private
     /// @param Ty           Parent type.
-    MDDerivedType *createMemberType(MDScope *Scope, StringRef Name,
-                                    MDFile *File, unsigned LineNo,
+    DIDerivedType *createMemberType(DIScope *Scope, StringRef Name,
+                                    DIFile *File, unsigned LineNo,
                                     uint64_t SizeInBits, uint64_t AlignInBits,
                                     uint64_t OffsetInBits, unsigned Flags,
-                                    MDType *Ty);
+                                    DIType *Ty);
 
     /// createStaticMemberType - Create debugging information entry for a
     /// C++ static data member.
@@ -208,9 +208,9 @@ namespace llvm {
     /// @param Ty         Type of the static member.
     /// @param Flags      Flags to encode member attribute, e.g. private.
     /// @param Val        Const initializer of the member.
-    MDDerivedType *createStaticMemberType(MDScope *Scope, StringRef Name,
-                                          MDFile *File, unsigned LineNo,
-                                          MDType *Ty, unsigned Flags,
+    DIDerivedType *createStaticMemberType(DIScope *Scope, StringRef Name,
+                                          DIFile *File, unsigned LineNo,
+                                          DIType *Ty, unsigned Flags,
                                           llvm::Constant *Val);
 
     /// createObjCIVar - Create debugging information entry for Objective-C
@@ -224,10 +224,10 @@ namespace llvm {
     /// @param Flags        Flags to encode member attribute, e.g. private
     /// @param Ty           Parent type.
     /// @param PropertyNode Property associated with this ivar.
-    MDDerivedType *createObjCIVar(StringRef Name, MDFile *File, unsigned LineNo,
+    DIDerivedType *createObjCIVar(StringRef Name, DIFile *File, unsigned LineNo,
                                   uint64_t SizeInBits, uint64_t AlignInBits,
                                   uint64_t OffsetInBits, unsigned Flags,
-                                  MDType *Ty, MDNode *PropertyNode);
+                                  DIType *Ty, MDNode *PropertyNode);
 
     /// createObjCProperty - Create debugging information entry for Objective-C
     /// property.
@@ -238,11 +238,11 @@ namespace llvm {
     /// @param SetterName   Name of the Objective C property setter selector.
     /// @param PropertyAttributes Objective C property attributes.
     /// @param Ty           Type.
-    MDObjCProperty *createObjCProperty(StringRef Name, MDFile *File,
+    DIObjCProperty *createObjCProperty(StringRef Name, DIFile *File,
                                        unsigned LineNumber,
                                        StringRef GetterName,
                                        StringRef SetterName,
-                                       unsigned PropertyAttributes, MDType *Ty);
+                                       unsigned PropertyAttributes, DIType *Ty);
 
     /// createClassType - Create debugging information entry for a class.
     /// @param Scope        Scope in which this class is defined.
@@ -260,12 +260,14 @@ namespace llvm {
     ///                     for more info.
     /// @param TemplateParms Template type parameters.
     /// @param UniqueIdentifier A unique identifier for the class.
-    MDCompositeType *createClassType(
-        MDScope *Scope, StringRef Name, MDFile *File, unsigned LineNumber,
-        uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
-        unsigned Flags, MDType *DerivedFrom, DebugNodeArray Elements,
-        MDType *VTableHolder = nullptr, MDNode *TemplateParms = nullptr,
-        StringRef UniqueIdentifier = "");
+    DICompositeType *createClassType(DIScope *Scope, StringRef Name,
+                                     DIFile *File, unsigned LineNumber,
+                                     uint64_t SizeInBits, uint64_t AlignInBits,
+                                     uint64_t OffsetInBits, unsigned Flags,
+                                     DIType *DerivedFrom, DINodeArray Elements,
+                                     DIType *VTableHolder = nullptr,
+                                     MDNode *TemplateParms = nullptr,
+                                     StringRef UniqueIdentifier = "");
 
     /// createStructType - Create debugging information entry for a struct.
     /// @param Scope        Scope in which this struct is defined.
@@ -278,11 +280,11 @@ namespace llvm {
     /// @param Elements     Struct elements.
     /// @param RunTimeLang  Optional parameter, Objective-C runtime version.
     /// @param UniqueIdentifier A unique identifier for the struct.
-    MDCompositeType *createStructType(
-        MDScope *Scope, StringRef Name, MDFile *File, unsigned LineNumber,
+    DICompositeType *createStructType(
+        DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
         uint64_t SizeInBits, uint64_t AlignInBits, unsigned Flags,
-        MDType *DerivedFrom, DebugNodeArray Elements, unsigned RunTimeLang = 0,
-        MDType *VTableHolder = nullptr, StringRef UniqueIdentifier = "");
+        DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang = 0,
+        DIType *VTableHolder = nullptr, StringRef UniqueIdentifier = "");
 
     /// createUnionType - Create debugging information entry for an union.
     /// @param Scope        Scope in which this union is defined.
@@ -295,10 +297,10 @@ namespace llvm {
     /// @param Elements     Union elements.
     /// @param RunTimeLang  Optional parameter, Objective-C runtime version.
     /// @param UniqueIdentifier A unique identifier for the union.
-    MDCompositeType *createUnionType(MDScope *Scope, StringRef Name,
-                                     MDFile *File, unsigned LineNumber,
+    DICompositeType *createUnionType(DIScope *Scope, StringRef Name,
+                                     DIFile *File, unsigned LineNumber,
                                      uint64_t SizeInBits, uint64_t AlignInBits,
-                                     unsigned Flags, DebugNodeArray Elements,
+                                     unsigned Flags, DINodeArray Elements,
                                      unsigned RunTimeLang = 0,
                                      StringRef UniqueIdentifier = "");
 
@@ -307,8 +309,8 @@ namespace llvm {
     /// @param Scope        Scope in which this type is defined.
     /// @param Name         Type parameter name.
     /// @param Ty           Parameter type.
-    MDTemplateTypeParameter *
-    createTemplateTypeParameter(MDScope *Scope, StringRef Name, MDType *Ty);
+    DITemplateTypeParameter *
+    createTemplateTypeParameter(DIScope *Scope, StringRef Name, DIType *Ty);
 
     /// createTemplateValueParameter - Create debugging information for template
     /// value parameter.
@@ -316,9 +318,9 @@ namespace llvm {
     /// @param Name         Value parameter name.
     /// @param Ty           Parameter type.
     /// @param Val          Constant parameter value.
-    MDTemplateValueParameter *createTemplateValueParameter(MDScope *Scope,
+    DITemplateValueParameter *createTemplateValueParameter(DIScope *Scope,
                                                            StringRef Name,
-                                                           MDType *Ty,
+                                                           DIType *Ty,
                                                            Constant *Val);
 
     /// \brief Create debugging information for a template template parameter.
@@ -326,9 +328,9 @@ namespace llvm {
     /// @param Name         Value parameter name.
     /// @param Ty           Parameter type.
     /// @param Val          The fully qualified name of the template.
-    MDTemplateValueParameter *createTemplateTemplateParameter(MDScope *Scope,
+    DITemplateValueParameter *createTemplateTemplateParameter(DIScope *Scope,
                                                               StringRef Name,
-                                                              MDType *Ty,
+                                                              DIType *Ty,
                                                               StringRef Val);
 
     /// \brief Create debugging information for a template parameter pack.
@@ -336,26 +338,26 @@ namespace llvm {
     /// @param Name         Value parameter name.
     /// @param Ty           Parameter type.
     /// @param Val          An array of types in the pack.
-    MDTemplateValueParameter *createTemplateParameterPack(MDScope *Scope,
+    DITemplateValueParameter *createTemplateParameterPack(DIScope *Scope,
                                                           StringRef Name,
-                                                          MDType *Ty,
-                                                          DebugNodeArray Val);
+                                                          DIType *Ty,
+                                                          DINodeArray Val);
 
     /// createArrayType - Create debugging information entry for an array.
     /// @param Size         Array size.
     /// @param AlignInBits  Alignment.
     /// @param Ty           Element type.
     /// @param Subscripts   Subscripts.
-    MDCompositeType *createArrayType(uint64_t Size, uint64_t AlignInBits,
-                                     MDType *Ty, DebugNodeArray Subscripts);
+    DICompositeType *createArrayType(uint64_t Size, uint64_t AlignInBits,
+                                     DIType *Ty, DINodeArray Subscripts);
 
     /// createVectorType - Create debugging information entry for a vector type.
     /// @param Size         Array size.
     /// @param AlignInBits  Alignment.
     /// @param Ty           Element type.
     /// @param Subscripts   Subscripts.
-    MDCompositeType *createVectorType(uint64_t Size, uint64_t AlignInBits,
-                                      MDType *Ty, DebugNodeArray Subscripts);
+    DICompositeType *createVectorType(uint64_t Size, uint64_t AlignInBits,
+                                      DIType *Ty, DINodeArray Subscripts);
 
     /// createEnumerationType - Create debugging information entry for an
     /// enumeration.
@@ -368,10 +370,10 @@ namespace llvm {
     /// @param Elements       Enumeration elements.
     /// @param UnderlyingType Underlying type of a C++11/ObjC fixed enum.
     /// @param UniqueIdentifier A unique identifier for the enum.
-    MDCompositeType *createEnumerationType(
-        MDScope *Scope, StringRef Name, MDFile *File, unsigned LineNumber,
-        uint64_t SizeInBits, uint64_t AlignInBits, DebugNodeArray Elements,
-        MDType *UnderlyingType, StringRef UniqueIdentifier = "");
+    DICompositeType *createEnumerationType(
+        DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
+        uint64_t SizeInBits, uint64_t AlignInBits, DINodeArray Elements,
+        DIType *UnderlyingType, StringRef UniqueIdentifier = "");
 
     /// createSubroutineType - Create subroutine type.
     /// @param File            File in which this subroutine is defined.
@@ -379,49 +381,49 @@ namespace llvm {
     ///                        includes return type at 0th index.
     /// @param Flags           E.g.: LValueReference.
     ///                        These flags are used to emit dwarf attributes.
-    MDSubroutineType *createSubroutineType(MDFile *File,
-                                           MDTypeRefArray ParameterTypes,
+    DISubroutineType *createSubroutineType(DIFile *File,
+                                           DITypeRefArray ParameterTypes,
                                            unsigned Flags = 0);
 
-    /// createArtificialType - Create a new MDType* with "artificial" flag set.
-    MDType *createArtificialType(MDType *Ty);
+    /// createArtificialType - Create a new DIType* with "artificial" flag set.
+    DIType *createArtificialType(DIType *Ty);
 
-    /// createObjectPointerType - Create a new MDType* with the "object pointer"
+    /// createObjectPointerType - Create a new DIType* with the "object pointer"
     /// flag set.
-    MDType *createObjectPointerType(MDType *Ty);
+    DIType *createObjectPointerType(DIType *Ty);
 
     /// \brief Create a permanent forward-declared type.
-    MDCompositeType *createForwardDecl(unsigned Tag, StringRef Name,
-                                       MDScope *Scope, MDFile *F, unsigned Line,
+    DICompositeType *createForwardDecl(unsigned Tag, StringRef Name,
+                                       DIScope *Scope, DIFile *F, unsigned Line,
                                        unsigned RuntimeLang = 0,
                                        uint64_t SizeInBits = 0,
                                        uint64_t AlignInBits = 0,
                                        StringRef UniqueIdentifier = "");
 
     /// \brief Create a temporary forward-declared type.
-    MDCompositeType *createReplaceableCompositeType(
-        unsigned Tag, StringRef Name, MDScope *Scope, MDFile *F, unsigned Line,
+    DICompositeType *createReplaceableCompositeType(
+        unsigned Tag, StringRef Name, DIScope *Scope, DIFile *F, unsigned Line,
         unsigned RuntimeLang = 0, uint64_t SizeInBits = 0,
-        uint64_t AlignInBits = 0, unsigned Flags = DebugNode::FlagFwdDecl,
+        uint64_t AlignInBits = 0, unsigned Flags = DINode::FlagFwdDecl,
         StringRef UniqueIdentifier = "");
 
-    /// retainType - Retain MDType* in a module even if it is not referenced
+    /// retainType - Retain DIType* in a module even if it is not referenced
     /// through debug info anchors.
-    void retainType(MDType *T);
+    void retainType(DIType *T);
 
     /// createUnspecifiedParameter - Create unspecified parameter type
     /// for a subroutine type.
-    MDBasicType *createUnspecifiedParameter();
+    DIBasicType *createUnspecifiedParameter();
 
-    /// getOrCreateArray - Get a DebugNodeArray, create one if required.
-    DebugNodeArray getOrCreateArray(ArrayRef<Metadata *> Elements);
+    /// getOrCreateArray - Get a DINodeArray, create one if required.
+    DINodeArray getOrCreateArray(ArrayRef<Metadata *> Elements);
 
-    /// getOrCreateTypeArray - Get a MDTypeRefArray, create one if required.
-    MDTypeRefArray getOrCreateTypeArray(ArrayRef<Metadata *> Elements);
+    /// getOrCreateTypeArray - Get a DITypeRefArray, create one if required.
+    DITypeRefArray getOrCreateTypeArray(ArrayRef<Metadata *> Elements);
 
     /// getOrCreateSubrange - Create a descriptor for a value range.  This
     /// implicitly uniques the values returned.
-    MDSubrange *getOrCreateSubrange(int64_t Lo, int64_t Count);
+    DISubrange *getOrCreateSubrange(int64_t Lo, int64_t Count);
 
     /// createGlobalVariable - Create a new descriptor for the specified
     /// variable.
@@ -435,18 +437,18 @@ namespace llvm {
     ///                      externally visible or not.
     /// @param Val         llvm::Value of the variable.
     /// @param Decl        Reference to the corresponding declaration.
-    MDGlobalVariable *createGlobalVariable(MDScope *Context, StringRef Name,
-                                           StringRef LinkageName, MDFile *File,
-                                           unsigned LineNo, MDType *Ty,
+    DIGlobalVariable *createGlobalVariable(DIScope *Context, StringRef Name,
+                                           StringRef LinkageName, DIFile *File,
+                                           unsigned LineNo, DIType *Ty,
                                            bool isLocalToUnit,
                                            llvm::Constant *Val,
                                            MDNode *Decl = nullptr);
 
     /// createTempGlobalVariableFwdDecl - Identical to createGlobalVariable
     /// except that the resulting DbgNode is temporary and meant to be RAUWed.
-    MDGlobalVariable *createTempGlobalVariableFwdDecl(
-        MDScope *Context, StringRef Name, StringRef LinkageName, MDFile *File,
-        unsigned LineNo, MDType *Ty, bool isLocalToUnit, llvm::Constant *Val,
+    DIGlobalVariable *createTempGlobalVariableFwdDecl(
+        DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
+        unsigned LineNo, DIType *Ty, bool isLocalToUnit, llvm::Constant *Val,
         MDNode *Decl = nullptr);
 
     /// createLocalVariable - Create a new descriptor for the specified
@@ -463,9 +465,9 @@ namespace llvm {
     /// @param Flags       Flags, e.g. artificial variable.
     /// @param ArgNo       If this variable is an argument then this argument's
     ///                    number. 1 indicates 1st argument.
-    MDLocalVariable *createLocalVariable(unsigned Tag, MDScope *Scope,
-                                         StringRef Name, MDFile *File,
-                                         unsigned LineNo, MDType *Ty,
+    DILocalVariable *createLocalVariable(unsigned Tag, DIScope *Scope,
+                                         StringRef Name, DIFile *File,
+                                         unsigned LineNo, DIType *Ty,
                                          bool AlwaysPreserve = false,
                                          unsigned Flags = 0,
                                          unsigned ArgNo = 0);
@@ -473,19 +475,19 @@ namespace llvm {
     /// createExpression - Create a new descriptor for the specified
     /// variable which has a complex address expression for its address.
     /// @param Addr        An array of complex address operations.
-    MDExpression *createExpression(ArrayRef<uint64_t> Addr = None);
-    MDExpression *createExpression(ArrayRef<int64_t> Addr);
+    DIExpression *createExpression(ArrayRef<uint64_t> Addr = None);
+    DIExpression *createExpression(ArrayRef<int64_t> Addr);
 
     /// createBitPieceExpression - Create a descriptor to describe one part
     /// of aggregate variable that is fragmented across multiple Values.
     ///
     /// @param OffsetInBits Offset of the piece in bits.
     /// @param SizeInBits   Size of the piece in bits.
-    MDExpression *createBitPieceExpression(unsigned OffsetInBits,
+    DIExpression *createBitPieceExpression(unsigned OffsetInBits,
                                            unsigned SizeInBits);
 
     /// createFunction - Create a new descriptor for the specified subprogram.
-    /// See comments in MDSubprogram* for descriptions of these fields.
+    /// See comments in DISubprogram* for descriptions of these fields.
     /// @param Scope         Function scope.
     /// @param Name          Function name.
     /// @param LinkageName   Mangled function name.
@@ -500,9 +502,9 @@ namespace llvm {
     /// @param isOptimized   True if optimization is ON.
     /// @param Fn            llvm::Function pointer.
     /// @param TParam        Function template parameters.
-    MDSubprogram *
-    createFunction(MDScope *Scope, StringRef Name, StringRef LinkageName,
-                   MDFile *File, unsigned LineNo, MDSubroutineType *Ty,
+    DISubprogram *
+    createFunction(DIScope *Scope, StringRef Name, StringRef LinkageName,
+                   DIFile *File, unsigned LineNo, DISubroutineType *Ty,
                    bool isLocalToUnit, bool isDefinition, unsigned ScopeLine,
                    unsigned Flags = 0, bool isOptimized = false,
                    Function *Fn = nullptr, MDNode *TParam = nullptr,
@@ -510,25 +512,25 @@ namespace llvm {
 
     /// createTempFunctionFwdDecl - Identical to createFunction,
     /// except that the resulting DbgNode is meant to be RAUWed.
-    MDSubprogram *createTempFunctionFwdDecl(
-        MDScope *Scope, StringRef Name, StringRef LinkageName, MDFile *File,
-        unsigned LineNo, MDSubroutineType *Ty, bool isLocalToUnit,
+    DISubprogram *createTempFunctionFwdDecl(
+        DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File,
+        unsigned LineNo, DISubroutineType *Ty, bool isLocalToUnit,
         bool isDefinition, unsigned ScopeLine, unsigned Flags = 0,
         bool isOptimized = false, Function *Fn = nullptr,
         MDNode *TParam = nullptr, MDNode *Decl = nullptr);
 
     /// FIXME: this is added for dragonegg. Once we update dragonegg
     /// to call resolve function, this will be removed.
-    MDSubprogram *
-    createFunction(MDScopeRef Scope, StringRef Name, StringRef LinkageName,
-                   MDFile *File, unsigned LineNo, MDSubroutineType *Ty,
+    DISubprogram *
+    createFunction(DIScopeRef Scope, StringRef Name, StringRef LinkageName,
+                   DIFile *File, unsigned LineNo, DISubroutineType *Ty,
                    bool isLocalToUnit, bool isDefinition, unsigned ScopeLine,
                    unsigned Flags = 0, bool isOptimized = false,
                    Function *Fn = nullptr, MDNode *TParam = nullptr,
                    MDNode *Decl = nullptr);
 
     /// createMethod - Create a new descriptor for the specified C++ method.
-    /// See comments in MDSubprogram* for descriptions of these fields.
+    /// See comments in DISubprogram* for descriptions of these fields.
     /// @param Scope         Function scope.
     /// @param Name          Function name.
     /// @param LinkageName   Mangled function name.
@@ -546,11 +548,11 @@ namespace llvm {
     /// @param isOptimized   True if optimization is ON.
     /// @param Fn            llvm::Function pointer.
     /// @param TParam        Function template parameters.
-    MDSubprogram *
-    createMethod(MDScope *Scope, StringRef Name, StringRef LinkageName,
-                 MDFile *File, unsigned LineNo, MDSubroutineType *Ty,
+    DISubprogram *
+    createMethod(DIScope *Scope, StringRef Name, StringRef LinkageName,
+                 DIFile *File, unsigned LineNo, DISubroutineType *Ty,
                  bool isLocalToUnit, bool isDefinition, unsigned Virtuality = 0,
-                 unsigned VTableIndex = 0, MDType *VTableHolder = nullptr,
+                 unsigned VTableIndex = 0, DIType *VTableHolder = nullptr,
                  unsigned Flags = 0, bool isOptimized = false,
                  Function *Fn = nullptr, MDNode *TParam = nullptr);
 
@@ -560,7 +562,7 @@ namespace llvm {
     /// @param Name        Name of this namespace
     /// @param File        Source file
     /// @param LineNo      Line number
-    MDNamespace *createNameSpace(MDScope *Scope, StringRef Name, MDFile *File,
+    DINamespace *createNameSpace(DIScope *Scope, StringRef Name, DIFile *File,
                                  unsigned LineNo);
 
     /// createLexicalBlockFile - This creates a descriptor for a lexical
@@ -569,7 +571,7 @@ namespace llvm {
     /// @param Scope       Lexical block.
     /// @param File        Source file.
     /// @param Discriminator DWARF path discriminator value.
-    MDLexicalBlockFile *createLexicalBlockFile(MDScope *Scope, MDFile *File,
+    DILexicalBlockFile *createLexicalBlockFile(DIScope *Scope, DIFile *File,
                                                unsigned Discriminator = 0);
 
     /// createLexicalBlock - This creates a descriptor for a lexical block
@@ -578,30 +580,30 @@ namespace llvm {
     /// @param File          Source file.
     /// @param Line          Line number.
     /// @param Col           Column number.
-    MDLexicalBlock *createLexicalBlock(MDScope *Scope, MDFile *File,
+    DILexicalBlock *createLexicalBlock(DIScope *Scope, DIFile *File,
                                        unsigned Line, unsigned Col);
 
     /// \brief Create a descriptor for an imported module.
     /// @param Context The scope this module is imported into
     /// @param NS The namespace being imported here
     /// @param Line Line number
-    MDImportedEntity *createImportedModule(MDScope *Context, MDNamespace *NS,
+    DIImportedEntity *createImportedModule(DIScope *Context, DINamespace *NS,
                                            unsigned Line);
 
     /// \brief Create a descriptor for an imported module.
     /// @param Context The scope this module is imported into
     /// @param NS An aliased namespace
     /// @param Line Line number
-    MDImportedEntity *createImportedModule(MDScope *Context,
-                                           MDImportedEntity *NS, unsigned Line);
+    DIImportedEntity *createImportedModule(DIScope *Context,
+                                           DIImportedEntity *NS, unsigned Line);
 
     /// \brief Create a descriptor for an imported function.
     /// @param Context The scope this module is imported into
     /// @param Decl The declaration (or definition) of a function, type, or
     ///             variable
     /// @param Line Line number
-    MDImportedEntity *createImportedDeclaration(MDScope *Context,
-                                                DebugNode *Decl, unsigned Line,
+    DIImportedEntity *createImportedDeclaration(DIScope *Context, DINode *Decl,
+                                                unsigned Line,
                                                 StringRef Name = "");
 
     /// insertDeclare - Insert a new llvm.dbg.declare intrinsic call.
@@ -610,8 +612,8 @@ namespace llvm {
     /// @param Expr         A complex location expression.
     /// @param DL           Debug info location.
     /// @param InsertAtEnd Location for the new intrinsic.
-    Instruction *insertDeclare(llvm::Value *Storage, MDLocalVariable *VarInfo,
-                               MDExpression *Expr, const MDLocation *DL,
+    Instruction *insertDeclare(llvm::Value *Storage, DILocalVariable *VarInfo,
+                               DIExpression *Expr, const DILocation *DL,
                                BasicBlock *InsertAtEnd);
 
     /// insertDeclare - Insert a new llvm.dbg.declare intrinsic call.
@@ -620,8 +622,8 @@ namespace llvm {
     /// @param Expr         A complex location expression.
     /// @param DL           Debug info location.
     /// @param InsertBefore Location for the new intrinsic.
-    Instruction *insertDeclare(llvm::Value *Storage, MDLocalVariable *VarInfo,
-                               MDExpression *Expr, const MDLocation *DL,
+    Instruction *insertDeclare(llvm::Value *Storage, DILocalVariable *VarInfo,
+                               DIExpression *Expr, const DILocation *DL,
                                Instruction *InsertBefore);
 
     /// insertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
@@ -632,9 +634,9 @@ namespace llvm {
     /// @param DL           Debug info location.
     /// @param InsertAtEnd Location for the new intrinsic.
     Instruction *insertDbgValueIntrinsic(llvm::Value *Val, uint64_t Offset,
-                                         MDLocalVariable *VarInfo,
-                                         MDExpression *Expr,
-                                         const MDLocation *DL,
+                                         DILocalVariable *VarInfo,
+                                         DIExpression *Expr,
+                                         const DILocation *DL,
                                          BasicBlock *InsertAtEnd);
 
     /// insertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
@@ -645,25 +647,25 @@ namespace llvm {
     /// @param DL           Debug info location.
     /// @param InsertBefore Location for the new intrinsic.
     Instruction *insertDbgValueIntrinsic(llvm::Value *Val, uint64_t Offset,
-                                         MDLocalVariable *VarInfo,
-                                         MDExpression *Expr,
-                                         const MDLocation *DL,
+                                         DILocalVariable *VarInfo,
+                                         DIExpression *Expr,
+                                         const DILocation *DL,
                                          Instruction *InsertBefore);
 
     /// \brief Replace the vtable holder in the given composite type.
     ///
     /// If this creates a self reference, it may orphan some unresolved cycles
     /// in the operands of \c T, so \a DIBuilder needs to track that.
-    void replaceVTableHolder(MDCompositeType *&T,
-                             MDCompositeType *VTableHolder);
+    void replaceVTableHolder(DICompositeType *&T,
+                             DICompositeType *VTableHolder);
 
     /// \brief Replace arrays on a composite type.
     ///
     /// If \c T is resolved, but the arrays aren't -- which can happen if \c T
     /// has a self-reference -- \a DIBuilder needs to track the array to
     /// resolve cycles.
-    void replaceArrays(MDCompositeType *&T, DebugNodeArray Elements,
-                       DebugNodeArray TParems = DebugNodeArray());
+    void replaceArrays(DICompositeType *&T, DINodeArray Elements,
+                       DINodeArray TParems = DINodeArray());
 
     /// \brief Replace a temporary node.
     ///
index b32bdb6..5429648 100644 (file)
@@ -34,18 +34,18 @@ class DbgDeclareInst;
 class DbgValueInst;
 
 /// \brief Maps from type identifier to the actual MDNode.
-typedef DenseMap<const MDString *, MDType *> DITypeIdentifierMap;
+typedef DenseMap<const MDString *, DIType *> DITypeIdentifierMap;
 
 /// \brief Find subprogram that is enclosing this scope.
-MDSubprogram *getDISubprogram(const MDNode *Scope);
+DISubprogram *getDISubprogram(const MDNode *Scope);
 
 /// \brief Find debug info for a given function.
 ///
 /// \returns a valid subprogram, if found. Otherwise, return \c nullptr.
-MDSubprogram *getDISubprogram(const Function *F);
+DISubprogram *getDISubprogram(const Function *F);
 
 /// \brief Find underlying composite type.
-MDCompositeTypeBase *getDICompositeType(MDType *T);
+DICompositeTypeBase *getDICompositeType(DIType *T);
 
 /// \brief Generate map by visiting all retained types.
 DITypeIdentifierMap generateDITypeIdentifierMap(const NamedMDNode *CU_Nodes);
@@ -81,7 +81,7 @@ public:
   /// \brief Process DbgValueInst.
   void processValue(const Module &M, const DbgValueInst *DVI);
   /// \brief Process debug info location.
-  void processLocation(const Module &M, const MDLocation *Loc);
+  void processLocation(const Module &M, const DILocation *Loc);
 
   /// \brief Clear all lists.
   void reset();
@@ -89,23 +89,23 @@ public:
 private:
   void InitializeTypeMap(const Module &M);
 
-  void processType(MDType *DT);
-  void processSubprogram(MDSubprogram *SP);
-  void processScope(MDScope *Scope);
-  bool addCompileUnit(MDCompileUnit *CU);
-  bool addGlobalVariable(MDGlobalVariable *DIG);
-  bool addSubprogram(MDSubprogram *SP);
-  bool addType(MDType *DT);
-  bool addScope(MDScope *Scope);
+  void processType(DIType *DT);
+  void processSubprogram(DISubprogram *SP);
+  void processScope(DIScope *Scope);
+  bool addCompileUnit(DICompileUnit *CU);
+  bool addGlobalVariable(DIGlobalVariable *DIG);
+  bool addSubprogram(DISubprogram *SP);
+  bool addType(DIType *DT);
+  bool addScope(DIScope *Scope);
 
 public:
-  typedef SmallVectorImpl<MDCompileUnit *>::const_iterator
+  typedef SmallVectorImpl<DICompileUnit *>::const_iterator
       compile_unit_iterator;
-  typedef SmallVectorImpl<MDSubprogram *>::const_iterator subprogram_iterator;
-  typedef SmallVectorImpl<MDGlobalVariable *>::const_iterator
+  typedef SmallVectorImpl<DISubprogram *>::const_iterator subprogram_iterator;
+  typedef SmallVectorImpl<DIGlobalVariable *>::const_iterator
       global_variable_iterator;
-  typedef SmallVectorImpl<MDType *>::const_iterator type_iterator;
-  typedef SmallVectorImpl<MDScope *>::const_iterator scope_iterator;
+  typedef SmallVectorImpl<DIType *>::const_iterator type_iterator;
+  typedef SmallVectorImpl<DIScope *>::const_iterator scope_iterator;
 
   iterator_range<compile_unit_iterator> compile_units() const {
     return iterator_range<compile_unit_iterator>(CUs.begin(), CUs.end());
@@ -134,11 +134,11 @@ public:
   unsigned scope_count() const { return Scopes.size(); }
 
 private:
-  SmallVector<MDCompileUnit *, 8> CUs;
-  SmallVector<MDSubprogram *, 8> SPs;
-  SmallVector<MDGlobalVariable *, 8> GVs;
-  SmallVector<MDType *, 8> TYs;
-  SmallVector<MDScope *, 8> Scopes;
+  SmallVector<DICompileUnit *, 8> CUs;
+  SmallVector<DISubprogram *, 8> SPs;
+  SmallVector<DIGlobalVariable *, 8> GVs;
+  SmallVector<DIType *, 8> TYs;
+  SmallVector<DIScope *, 8> Scopes;
   SmallPtrSet<const MDNode *, 64> NodesSeen;
   DITypeIdentifierMap TypeIdentifierMap;
 
@@ -146,7 +146,7 @@ private:
   bool TypeMapInitialized;
 };
 
-DenseMap<const Function *, MDSubprogram *> makeSubprogramMap(const Module &M);
+DenseMap<const Function *, DISubprogram *> makeSubprogramMap(const Module &M);
 
 } // end namespace llvm
 
index 6fef189..2be5e93 100644 (file)
 
 namespace llvm {
 
-/// \brief Pointer union between a subclass of DebugNode and MDString.
+/// \brief Pointer union between a subclass of DINode and MDString.
 ///
-/// \a MDCompositeType can be referenced via an \a MDString unique identifier.
+/// \a DICompositeType can be referenced via an \a MDString unique identifier.
 /// This class allows some type safety in the face of that, requiring either a
 /// node of a particular type or an \a MDString.
-template <class T> class TypedDebugNodeRef {
+template <class T> class TypedDINodeRef {
   const Metadata *MD = nullptr;
 
 public:
-  TypedDebugNodeRef() = default;
-  TypedDebugNodeRef(std::nullptr_t) {}
+  TypedDINodeRef() = default;
+  TypedDINodeRef(std::nullptr_t) {}
 
   /// \brief Construct from a raw pointer.
-  explicit TypedDebugNodeRef(const Metadata *MD) : MD(MD) {
+  explicit TypedDINodeRef(const Metadata *MD) : MD(MD) {
     assert((!MD || isa<MDString>(MD) || isa<T>(MD)) && "Expected valid ref");
   }
 
   template <class U>
-  TypedDebugNodeRef(
-      const TypedDebugNodeRef<U> &X,
+  TypedDINodeRef(
+      const TypedDINodeRef<U> &X,
       typename std::enable_if<std::is_convertible<U *, T *>::value>::type * =
           nullptr)
       : MD(X) {}
 
   operator Metadata *() const { return const_cast<Metadata *>(MD); }
 
-  bool operator==(const TypedDebugNodeRef<T> &X) const { return MD == X.MD; };
-  bool operator!=(const TypedDebugNodeRef<T> &X) const { return MD != X.MD; };
+  bool operator==(const TypedDINodeRef<T> &X) const { return MD == X.MD; };
+  bool operator!=(const TypedDINodeRef<T> &X) const { return MD != X.MD; };
 
   /// \brief Create a reference.
   ///
   /// Get a reference to \c N, using an \a MDString reference if available.
-  static TypedDebugNodeRef get(const T *N);
+  static TypedDINodeRef get(const T *N);
 
   template <class MapTy> T *resolve(const MapTy &Map) const {
     if (!MD)
@@ -89,15 +89,15 @@ public:
   }
 };
 
-typedef TypedDebugNodeRef<DebugNode> DebugNodeRef;
-typedef TypedDebugNodeRef<MDScope> MDScopeRef;
-typedef TypedDebugNodeRef<MDType> MDTypeRef;
+typedef TypedDINodeRef<DINode> DINodeRef;
+typedef TypedDINodeRef<DIScope> DIScopeRef;
+typedef TypedDINodeRef<DIType> DITypeRef;
 
-class MDTypeRefArray {
+class DITypeRefArray {
   const MDTuple *N = nullptr;
 
 public:
-  MDTypeRefArray(const MDTuple *N) : N(N) {}
+  DITypeRefArray(const MDTuple *N) : N(N) {}
 
   explicit operator bool() const { return get(); }
   explicit operator MDTuple *() const { return get(); }
@@ -108,16 +108,16 @@ public:
 
   // FIXME: Fix callers and remove condition on N.
   unsigned size() const { return N ? N->getNumOperands() : 0u; }
-  MDTypeRef operator[](unsigned I) const { return MDTypeRef(N->getOperand(I)); }
+  DITypeRef operator[](unsigned I) const { return DITypeRef(N->getOperand(I)); }
 
-  class iterator : std::iterator<std::input_iterator_tag, MDTypeRef,
-                                 std::ptrdiff_t, void, MDTypeRef> {
+  class iterator : std::iterator<std::input_iterator_tag, DITypeRef,
+                                 std::ptrdiff_t, void, DITypeRef> {
     MDNode::op_iterator I = nullptr;
 
   public:
     iterator() = default;
     explicit iterator(MDNode::op_iterator I) : I(I) {}
-    MDTypeRef operator*() const { return MDTypeRef(*I); }
+    DITypeRef operator*() const { return DITypeRef(*I); }
     iterator &operator++() {
       ++I;
       return *this;
@@ -139,20 +139,20 @@ public:
 /// \brief Tagged DWARF-like metadata node.
 ///
 /// A metadata node with a DWARF tag (i.e., a constant named \c DW_TAG_*,
-/// defined in llvm/Support/Dwarf.h).  Called \a DebugNode because it's
+/// defined in llvm/Support/Dwarf.h).  Called \a DINode because it's
 /// potentially used for non-DWARF output.
-class DebugNode : public MDNode {
+class DINode : public MDNode {
   friend class LLVMContextImpl;
   friend class MDNode;
 
 protected:
-  DebugNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
-            ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
+  DINode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
+         ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
       : MDNode(C, ID, Storage, Ops1, Ops2) {
     assert(Tag < 1u << 16);
     SubclassData16 = Tag;
   }
-  ~DebugNode() = default;
+  ~DINode() = default;
 
   template <class Ty> Ty *getOperandAs(unsigned I) const {
     return cast_or_null<Ty>(getOperand(I));
@@ -193,47 +193,46 @@ public:
   static unsigned splitFlags(unsigned Flags,
                              SmallVectorImpl<unsigned> &SplitFlags);
 
-  DebugNodeRef getRef() const { return DebugNodeRef::get(this); }
+  DINodeRef getRef() const { return DINodeRef::get(this); }
 
   static bool classof(const Metadata *MD) {
     switch (MD->getMetadataID()) {
     default:
       return false;
-    case GenericDebugNodeKind:
-    case MDSubrangeKind:
-    case MDEnumeratorKind:
-    case MDBasicTypeKind:
-    case MDDerivedTypeKind:
-    case MDCompositeTypeKind:
-    case MDSubroutineTypeKind:
-    case MDFileKind:
-    case MDCompileUnitKind:
-    case MDSubprogramKind:
-    case MDLexicalBlockKind:
-    case MDLexicalBlockFileKind:
-    case MDNamespaceKind:
-    case MDTemplateTypeParameterKind:
-    case MDTemplateValueParameterKind:
-    case MDGlobalVariableKind:
-    case MDLocalVariableKind:
-    case MDObjCPropertyKind:
-    case MDImportedEntityKind:
+    case GenericDINodeKind:
+    case DISubrangeKind:
+    case DIEnumeratorKind:
+    case DIBasicTypeKind:
+    case DIDerivedTypeKind:
+    case DICompositeTypeKind:
+    case DISubroutineTypeKind:
+    case DIFileKind:
+    case DICompileUnitKind:
+    case DISubprogramKind:
+    case DILexicalBlockKind:
+    case DILexicalBlockFileKind:
+    case DINamespaceKind:
+    case DITemplateTypeParameterKind:
+    case DITemplateValueParameterKind:
+    case DIGlobalVariableKind:
+    case DILocalVariableKind:
+    case DIObjCPropertyKind:
+    case DIImportedEntityKind:
       return true;
     }
   }
 };
 
-template <class T>
-struct simplify_type<const TypedDebugNodeRef<T>> {
+template <class T> struct simplify_type<const TypedDINodeRef<T>> {
   typedef Metadata *SimpleType;
-  static SimpleType getSimplifiedValue(const TypedDebugNodeRef<T> &MD) {
+  static SimpleType getSimplifiedValue(const TypedDINodeRef<T> &MD) {
     return MD;
   }
 };
 
 template <class T>
-struct simplify_type<TypedDebugNodeRef<T>>
-    : simplify_type<const TypedDebugNodeRef<T>> {};
+struct simplify_type<TypedDINodeRef<T>>
+    : simplify_type<const TypedDINodeRef<T>> {};
 
 /// \brief Generic tagged DWARF-like metadata node.
 ///
@@ -241,37 +240,33 @@ struct simplify_type<TypedDebugNodeRef<T>>
 /// (possibly empty) null-separated \a MDString header that contains arbitrary
 /// fields.  The remaining operands are \a dwarf_operands(), and are pointers
 /// to other metadata.
-class GenericDebugNode : public DebugNode {
+class GenericDINode : public DINode {
   friend class LLVMContextImpl;
   friend class MDNode;
 
-  GenericDebugNode(LLVMContext &C, StorageType Storage, unsigned Hash,
-                   unsigned Tag, ArrayRef<Metadata *> Ops1,
-                   ArrayRef<Metadata *> Ops2)
-      : DebugNode(C, GenericDebugNodeKind, Storage, Tag, Ops1, Ops2) {
+  GenericDINode(LLVMContext &C, StorageType Storage, unsigned Hash,
+                unsigned Tag, ArrayRef<Metadata *> Ops1,
+                ArrayRef<Metadata *> Ops2)
+      : DINode(C, GenericDINodeKind, Storage, Tag, Ops1, Ops2) {
     setHash(Hash);
   }
-  ~GenericDebugNode() { dropAllReferences(); }
+  ~GenericDINode() { dropAllReferences(); }
 
   void setHash(unsigned Hash) { SubclassData32 = Hash; }
   void recalculateHash();
 
-  static GenericDebugNode *getImpl(LLVMContext &Context, unsigned Tag,
-                                   StringRef Header,
-                                   ArrayRef<Metadata *> DwarfOps,
-                                   StorageType Storage,
-                                   bool ShouldCreate = true) {
+  static GenericDINode *getImpl(LLVMContext &Context, unsigned Tag,
+                                StringRef Header, ArrayRef<Metadata *> DwarfOps,
+                                StorageType Storage, bool ShouldCreate = true) {
     return getImpl(Context, Tag, getCanonicalMDString(Context, Header),
                    DwarfOps, Storage, ShouldCreate);
   }
 
-  static GenericDebugNode *getImpl(LLVMContext &Context, unsigned Tag,
-                                   MDString *Header,
-                                   ArrayRef<Metadata *> DwarfOps,
-                                   StorageType Storage,
-                                   bool ShouldCreate = true);
+  static GenericDINode *getImpl(LLVMContext &Context, unsigned Tag,
+                                MDString *Header, ArrayRef<Metadata *> DwarfOps,
+                                StorageType Storage, bool ShouldCreate = true);
 
-  TempGenericDebugNode cloneImpl() const {
+  TempGenericDINode cloneImpl() const {
     return getTemporary(
         getContext(), getTag(), getHeader(),
         SmallVector<Metadata *, 4>(dwarf_op_begin(), dwarf_op_end()));
@@ -280,15 +275,15 @@ class GenericDebugNode : public DebugNode {
 public:
   unsigned getHash() const { return SubclassData32; }
 
-  DEFINE_MDNODE_GET(GenericDebugNode, (unsigned Tag, StringRef Header,
-                                       ArrayRef<Metadata *> DwarfOps),
+  DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, StringRef Header,
+                                    ArrayRef<Metadata *> DwarfOps),
                     (Tag, Header, DwarfOps))
-  DEFINE_MDNODE_GET(GenericDebugNode, (unsigned Tag, MDString *Header,
-                                       ArrayRef<Metadata *> DwarfOps),
+  DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, MDString *Header,
+                                    ArrayRef<Metadata *> DwarfOps),
                     (Tag, Header, DwarfOps))
 
   /// \brief Return a (temporary) clone of this.
-  TempGenericDebugNode clone() const { return cloneImpl(); }
+  TempGenericDINode clone() const { return cloneImpl(); }
 
   unsigned getTag() const { return SubclassData16; }
   StringRef getHeader() const { return getStringOperand(0); }
@@ -308,7 +303,7 @@ public:
   }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == GenericDebugNodeKind;
+    return MD->getMetadataID() == GenericDINodeKind;
   }
 };
 
@@ -316,39 +311,38 @@ public:
 ///
 /// TODO: Merge into node for DW_TAG_array_type, which should have a custom
 /// type.
-class MDSubrange : public DebugNode {
+class DISubrange : public DINode {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   int64_t Count;
   int64_t LowerBound;
 
-  MDSubrange(LLVMContext &C, StorageType Storage, int64_t Count,
+  DISubrange(LLVMContext &C, StorageType Storage, int64_t Count,
              int64_t LowerBound)
-      : DebugNode(C, MDSubrangeKind, Storage, dwarf::DW_TAG_subrange_type,
-                  None),
+      : DINode(C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, None),
         Count(Count), LowerBound(LowerBound) {}
-  ~MDSubrange() = default;
+  ~DISubrange() = default;
 
-  static MDSubrange *getImpl(LLVMContext &Context, int64_t Count,
+  static DISubrange *getImpl(LLVMContext &Context, int64_t Count,
                              int64_t LowerBound, StorageType Storage,
                              bool ShouldCreate = true);
 
-  TempMDSubrange cloneImpl() const {
+  TempDISubrange cloneImpl() const {
     return getTemporary(getContext(), getCount(), getLowerBound());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDSubrange, (int64_t Count, int64_t LowerBound = 0),
+  DEFINE_MDNODE_GET(DISubrange, (int64_t Count, int64_t LowerBound = 0),
                     (Count, LowerBound))
 
-  TempMDSubrange clone() const { return cloneImpl(); }
+  TempDISubrange clone() const { return cloneImpl(); }
 
   int64_t getLowerBound() const { return LowerBound; }
   int64_t getCount() const { return Count; }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDSubrangeKind;
+    return MD->getMetadataID() == DISubrangeKind;
   }
 };
 
@@ -356,39 +350,39 @@ public:
 ///
 /// TODO: Add a pointer to the context (DW_TAG_enumeration_type) once that no
 /// longer creates a type cycle.
-class MDEnumerator : public DebugNode {
+class DIEnumerator : public DINode {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   int64_t Value;
 
-  MDEnumerator(LLVMContext &C, StorageType Storage, int64_t Value,
+  DIEnumerator(LLVMContext &C, StorageType Storage, int64_t Value,
                ArrayRef<Metadata *> Ops)
-      : DebugNode(C, MDEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
+      : DINode(C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
         Value(Value) {}
-  ~MDEnumerator() = default;
+  ~DIEnumerator() = default;
 
-  static MDEnumerator *getImpl(LLVMContext &Context, int64_t Value,
+  static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
                                StringRef Name, StorageType Storage,
                                bool ShouldCreate = true) {
     return getImpl(Context, Value, getCanonicalMDString(Context, Name), Storage,
                    ShouldCreate);
   }
-  static MDEnumerator *getImpl(LLVMContext &Context, int64_t Value,
+  static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value,
                                MDString *Name, StorageType Storage,
                                bool ShouldCreate = true);
 
-  TempMDEnumerator cloneImpl() const {
+  TempDIEnumerator cloneImpl() const {
     return getTemporary(getContext(), getValue(), getName());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDEnumerator, (int64_t Value, StringRef Name),
+  DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, StringRef Name),
                     (Value, Name))
-  DEFINE_MDNODE_GET(MDEnumerator, (int64_t Value, MDString *Name),
+  DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, MDString *Name),
                     (Value, Name))
 
-  TempMDEnumerator clone() const { return cloneImpl(); }
+  TempDIEnumerator clone() const { return cloneImpl(); }
 
   int64_t getValue() const { return Value; }
   StringRef getName() const { return getStringOperand(0); }
@@ -396,7 +390,7 @@ public:
   MDString *getRawName() const { return getOperandAs<MDString>(0); }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDEnumeratorKind;
+    return MD->getMetadataID() == DIEnumeratorKind;
   }
 };
 
@@ -406,49 +400,49 @@ public:
 /// contexts).
 ///
 /// TODO: Separate the concepts of declaration contexts and lexical scopes.
-class MDScope : public DebugNode {
+class DIScope : public DINode {
 protected:
-  MDScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
+  DIScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
           ArrayRef<Metadata *> Ops)
-      : DebugNode(C, ID, Storage, Tag, Ops) {}
-  ~MDScope() = default;
+      : DINode(C, ID, Storage, Tag, Ops) {}
+  ~DIScope() = default;
 
 public:
-  MDFile *getFile() const { return cast_or_null<MDFile>(getRawFile()); }
+  DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
 
   inline StringRef getFilename() const;
   inline StringRef getDirectory() const;
 
   StringRef getName() const;
-  MDScopeRef getScope() const;
+  DIScopeRef getScope() const;
 
   /// \brief Return the raw underlying file.
   ///
-  /// An \a MDFile is an \a MDScope, but it doesn't point at a separate file
-  /// (it\em is the file).  If \c this is an \a MDFile, we need to return \c
+  /// An \a DIFile is an \a DIScope, but it doesn't point at a separate file
+  /// (it\em is the file).  If \c this is an \a DIFile, we need to return \c
   /// this.  Otherwise, return the first operand, which is where all other
   /// subclasses store their file pointer.
   Metadata *getRawFile() const {
-    return isa<MDFile>(this) ? const_cast<MDScope *>(this)
+    return isa<DIFile>(this) ? const_cast<DIScope *>(this)
                              : static_cast<Metadata *>(getOperand(0));
   }
 
-  MDScopeRef getRef() const { return MDScopeRef::get(this); }
+  DIScopeRef getRef() const { return DIScopeRef::get(this); }
 
   static bool classof(const Metadata *MD) {
     switch (MD->getMetadataID()) {
     default:
       return false;
-    case MDBasicTypeKind:
-    case MDDerivedTypeKind:
-    case MDCompositeTypeKind:
-    case MDSubroutineTypeKind:
-    case MDFileKind:
-    case MDCompileUnitKind:
-    case MDSubprogramKind:
-    case MDLexicalBlockKind:
-    case MDLexicalBlockFileKind:
-    case MDNamespaceKind:
+    case DIBasicTypeKind:
+    case DIDerivedTypeKind:
+    case DICompositeTypeKind:
+    case DISubroutineTypeKind:
+    case DIFileKind:
+    case DICompileUnitKind:
+    case DISubprogramKind:
+    case DILexicalBlockKind:
+    case DILexicalBlockFileKind:
+    case DINamespaceKind:
       return true;
     }
   }
@@ -458,36 +452,36 @@ public:
 ///
 /// TODO: Merge with directory/file node (including users).
 /// TODO: Canonicalize paths on creation.
-class MDFile : public MDScope {
+class DIFile : public DIScope {
   friend class LLVMContextImpl;
   friend class MDNode;
 
-  MDFile(LLVMContext &C, StorageType Storage, ArrayRef<Metadata *> Ops)
-      : MDScope(C, MDFileKind, Storage, dwarf::DW_TAG_file_type, Ops) {}
-  ~MDFile() = default;
+  DIFile(LLVMContext &C, StorageType Storage, ArrayRef<Metadata *> Ops)
+      : DIScope(C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops) {}
+  ~DIFile() = default;
 
-  static MDFile *getImpl(LLVMContext &Context, StringRef Filename,
+  static DIFile *getImpl(LLVMContext &Context, StringRef Filename,
                          StringRef Directory, StorageType Storage,
                          bool ShouldCreate = true) {
     return getImpl(Context, getCanonicalMDString(Context, Filename),
                    getCanonicalMDString(Context, Directory), Storage,
                    ShouldCreate);
   }
-  static MDFile *getImpl(LLVMContext &Context, MDString *Filename,
+  static DIFile *getImpl(LLVMContext &Context, MDString *Filename,
                          MDString *Directory, StorageType Storage,
                          bool ShouldCreate = true);
 
-  TempMDFile cloneImpl() const {
+  TempDIFile cloneImpl() const {
     return getTemporary(getContext(), getFilename(), getDirectory());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDFile, (StringRef Filename, StringRef Directory),
+  DEFINE_MDNODE_GET(DIFile, (StringRef Filename, StringRef Directory),
                     (Filename, Directory))
-  DEFINE_MDNODE_GET(MDFile, (MDString * Filename, MDString *Directory),
+  DEFINE_MDNODE_GET(DIFile, (MDString * Filename, MDString *Directory),
                     (Filename, Directory))
 
-  TempMDFile clone() const { return cloneImpl(); }
+  TempDIFile clone() const { return cloneImpl(); }
 
   StringRef getFilename() const { return getStringOperand(0); }
   StringRef getDirectory() const { return getStringOperand(1); }
@@ -496,17 +490,17 @@ public:
   MDString *getRawDirectory() const { return getOperandAs<MDString>(1); }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDFileKind;
+    return MD->getMetadataID() == DIFileKind;
   }
 };
 
-StringRef MDScope::getFilename() const {
+StringRef DIScope::getFilename() const {
   if (auto *F = getFile())
     return F->getFilename();
   return "";
 }
 
-StringRef MDScope::getDirectory() const {
+StringRef DIScope::getDirectory() const {
   if (auto *F = getFile())
     return F->getDirectory();
   return "";
@@ -517,7 +511,7 @@ StringRef MDScope::getDirectory() const {
 /// TODO: Remove the hardcoded name and context, since many types don't use
 /// them.
 /// TODO: Split up flags.
-class MDType : public MDScope {
+class DIType : public DIScope {
   unsigned Line;
   unsigned Flags;
   uint64_t SizeInBits;
@@ -525,17 +519,17 @@ class MDType : public MDScope {
   uint64_t OffsetInBits;
 
 protected:
-  MDType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
+  DIType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
          unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
          uint64_t OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops)
-      : MDScope(C, ID, Storage, Tag, Ops), Line(Line), Flags(Flags),
+      : DIScope(C, ID, Storage, Tag, Ops), Line(Line), Flags(Flags),
         SizeInBits(SizeInBits), AlignInBits(AlignInBits),
         OffsetInBits(OffsetInBits) {}
-  ~MDType() = default;
+  ~DIType() = default;
 
 public:
-  TempMDType clone() const {
-    return TempMDType(cast<MDType>(MDNode::clone().release()));
+  TempDIType clone() const {
+    return TempDIType(cast<DIType>(MDNode::clone().release()));
   }
 
   unsigned getLine() const { return Line; }
@@ -544,7 +538,7 @@ public:
   uint64_t getOffsetInBits() const { return OffsetInBits; }
   unsigned getFlags() const { return Flags; }
 
-  MDScopeRef getScope() const { return MDScopeRef(getRawScope()); }
+  DIScopeRef getScope() const { return DIScopeRef(getRawScope()); }
   StringRef getName() const { return getStringOperand(2); }
 
 
@@ -579,16 +573,16 @@ public:
   bool isLValueReference() const { return getFlags() & FlagLValueReference; }
   bool isRValueReference() const { return getFlags() & FlagRValueReference; }
 
-  MDTypeRef getRef() const { return MDTypeRef::get(this); }
+  DITypeRef getRef() const { return DITypeRef::get(this); }
 
   static bool classof(const Metadata *MD) {
     switch (MD->getMetadataID()) {
     default:
       return false;
-    case MDBasicTypeKind:
-    case MDDerivedTypeKind:
-    case MDCompositeTypeKind:
-    case MDSubroutineTypeKind:
+    case DIBasicTypeKind:
+    case DIDerivedTypeKind:
+    case DICompositeTypeKind:
+    case DISubroutineTypeKind:
       return true;
     }
   }
@@ -598,79 +592,79 @@ public:
 ///
 /// TODO: Split out DW_TAG_unspecified_type.
 /// TODO: Drop unused accessors.
-class MDBasicType : public MDType {
+class DIBasicType : public DIType {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned Encoding;
 
-  MDBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
+  DIBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
               uint64_t SizeInBits, uint64_t AlignInBits, unsigned Encoding,
               ArrayRef<Metadata *> Ops)
-      : MDType(C, MDBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
+      : DIType(C, DIBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
                0, Ops),
         Encoding(Encoding) {}
-  ~MDBasicType() = default;
+  ~DIBasicType() = default;
 
-  static MDBasicType *getImpl(LLVMContext &Context, unsigned Tag,
+  static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
                               StringRef Name, uint64_t SizeInBits,
                               uint64_t AlignInBits, unsigned Encoding,
                               StorageType Storage, bool ShouldCreate = true) {
     return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
                    SizeInBits, AlignInBits, Encoding, Storage, ShouldCreate);
   }
-  static MDBasicType *getImpl(LLVMContext &Context, unsigned Tag,
+  static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
                               MDString *Name, uint64_t SizeInBits,
                               uint64_t AlignInBits, unsigned Encoding,
                               StorageType Storage, bool ShouldCreate = true);
 
-  TempMDBasicType cloneImpl() const {
+  TempDIBasicType cloneImpl() const {
     return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
                         getAlignInBits(), getEncoding());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDBasicType, (unsigned Tag, StringRef Name),
+  DEFINE_MDNODE_GET(DIBasicType, (unsigned Tag, StringRef Name),
                     (Tag, Name, 0, 0, 0))
-  DEFINE_MDNODE_GET(MDBasicType,
+  DEFINE_MDNODE_GET(DIBasicType,
                     (unsigned Tag, StringRef Name, uint64_t SizeInBits,
                      uint64_t AlignInBits, unsigned Encoding),
                     (Tag, Name, SizeInBits, AlignInBits, Encoding))
-  DEFINE_MDNODE_GET(MDBasicType,
+  DEFINE_MDNODE_GET(DIBasicType,
                     (unsigned Tag, MDString *Name, uint64_t SizeInBits,
                      uint64_t AlignInBits, unsigned Encoding),
                     (Tag, Name, SizeInBits, AlignInBits, Encoding))
 
-  TempMDBasicType clone() const { return cloneImpl(); }
+  TempDIBasicType clone() const { return cloneImpl(); }
 
   unsigned getEncoding() const { return Encoding; }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDBasicTypeKind;
+    return MD->getMetadataID() == DIBasicTypeKind;
   }
 };
 
-/// \brief Base class for MDDerivedType and MDCompositeType.
+/// \brief Base class for DIDerivedType and DICompositeType.
 ///
 /// TODO: Delete; they're not really related.
-class MDDerivedTypeBase : public MDType {
+class DIDerivedTypeBase : public DIType {
 protected:
-  MDDerivedTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
+  DIDerivedTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
                     unsigned Tag, unsigned Line, uint64_t SizeInBits,
                     uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
                     ArrayRef<Metadata *> Ops)
-      : MDType(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits,
+      : DIType(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits,
                Flags, Ops) {}
-  ~MDDerivedTypeBase() = default;
+  ~DIDerivedTypeBase() = default;
 
 public:
-  MDTypeRef getBaseType() const { return MDTypeRef(getRawBaseType()); }
+  DITypeRef getBaseType() const { return DITypeRef(getRawBaseType()); }
   Metadata *getRawBaseType() const { return getOperand(3); }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDDerivedTypeKind ||
-           MD->getMetadataID() == MDCompositeTypeKind ||
-           MD->getMetadataID() == MDSubroutineTypeKind;
+    return MD->getMetadataID() == DIDerivedTypeKind ||
+           MD->getMetadataID() == DICompositeTypeKind ||
+           MD->getMetadataID() == DISubroutineTypeKind;
   }
 };
 
@@ -680,20 +674,20 @@ public:
 /// class members.
 ///
 /// TODO: Split out members (inheritance, fields, methods, etc.).
-class MDDerivedType : public MDDerivedTypeBase {
+class DIDerivedType : public DIDerivedTypeBase {
   friend class LLVMContextImpl;
   friend class MDNode;
 
-  MDDerivedType(LLVMContext &C, StorageType Storage, unsigned Tag,
+  DIDerivedType(LLVMContext &C, StorageType Storage, unsigned Tag,
                 unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
                 uint64_t OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops)
-      : MDDerivedTypeBase(C, MDDerivedTypeKind, Storage, Tag, Line, SizeInBits,
+      : DIDerivedTypeBase(C, DIDerivedTypeKind, Storage, Tag, Line, SizeInBits,
                           AlignInBits, OffsetInBits, Flags, Ops) {}
-  ~MDDerivedType() = default;
+  ~DIDerivedType() = default;
 
-  static MDDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
-                                StringRef Name, MDFile *File, unsigned Line,
-                                MDScopeRef Scope, MDTypeRef BaseType,
+  static DIDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
+                                StringRef Name, DIFile *File, unsigned Line,
+                                DIScopeRef Scope, DITypeRef BaseType,
                                 uint64_t SizeInBits, uint64_t AlignInBits,
                                 uint64_t OffsetInBits, unsigned Flags,
                                 Metadata *ExtraData, StorageType Storage,
@@ -702,7 +696,7 @@ class MDDerivedType : public MDDerivedTypeBase {
                    Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
                    Flags, ExtraData, Storage, ShouldCreate);
   }
-  static MDDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
+  static DIDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
                                 MDString *Name, Metadata *File, unsigned Line,
                                 Metadata *Scope, Metadata *BaseType,
                                 uint64_t SizeInBits, uint64_t AlignInBits,
@@ -710,7 +704,7 @@ class MDDerivedType : public MDDerivedTypeBase {
                                 Metadata *ExtraData, StorageType Storage,
                                 bool ShouldCreate = true);
 
-  TempMDDerivedType cloneImpl() const {
+  TempDIDerivedType cloneImpl() const {
     return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
                         getScope(), getBaseType(), getSizeInBits(),
                         getAlignInBits(), getOffsetInBits(), getFlags(),
@@ -718,7 +712,7 @@ class MDDerivedType : public MDDerivedTypeBase {
   }
 
 public:
-  DEFINE_MDNODE_GET(MDDerivedType,
+  DEFINE_MDNODE_GET(DIDerivedType,
                     (unsigned Tag, MDString *Name, Metadata *File,
                      unsigned Line, Metadata *Scope, Metadata *BaseType,
                      uint64_t SizeInBits, uint64_t AlignInBits,
@@ -726,15 +720,15 @@ public:
                      Metadata *ExtraData = nullptr),
                     (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
                      AlignInBits, OffsetInBits, Flags, ExtraData))
-  DEFINE_MDNODE_GET(MDDerivedType,
-                    (unsigned Tag, StringRef Name, MDFile *File, unsigned Line,
-                     MDScopeRef Scope, MDTypeRef BaseType, uint64_t SizeInBits,
+  DEFINE_MDNODE_GET(DIDerivedType,
+                    (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
+                     DIScopeRef Scope, DITypeRef BaseType, uint64_t SizeInBits,
                      uint64_t AlignInBits, uint64_t OffsetInBits,
                      unsigned Flags, Metadata *ExtraData = nullptr),
                     (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
                      AlignInBits, OffsetInBits, Flags, ExtraData))
 
-  TempMDDerivedType clone() const { return cloneImpl(); }
+  TempDIDerivedType clone() const { return cloneImpl(); }
 
   /// \brief Get extra data associated with this derived type.
   ///
@@ -748,12 +742,12 @@ public:
 
   /// \brief Get casted version of extra data.
   /// @{
-  MDTypeRef getClassType() const {
+  DITypeRef getClassType() const {
     assert(getTag() == dwarf::DW_TAG_ptr_to_member_type);
-    return MDTypeRef(getExtraData());
+    return DITypeRef(getExtraData());
   }
-  MDObjCProperty *getObjCProperty() const {
-    return dyn_cast_or_null<MDObjCProperty>(getExtraData());
+  DIObjCProperty *getObjCProperty() const {
+    return dyn_cast_or_null<DIObjCProperty>(getExtraData());
   }
   Constant *getConstant() const {
     assert(getTag() == dwarf::DW_TAG_member && isStaticMember());
@@ -764,39 +758,39 @@ public:
   /// @}
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDDerivedTypeKind;
+    return MD->getMetadataID() == DIDerivedTypeKind;
   }
 };
 
-/// \brief Base class for MDCompositeType and MDSubroutineType.
+/// \brief Base class for DICompositeType and DISubroutineType.
 ///
 /// TODO: Delete; they're not really related.
-class MDCompositeTypeBase : public MDDerivedTypeBase {
+class DICompositeTypeBase : public DIDerivedTypeBase {
   unsigned RuntimeLang;
 
 protected:
-  MDCompositeTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
+  DICompositeTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
                       unsigned Tag, unsigned Line, unsigned RuntimeLang,
                       uint64_t SizeInBits, uint64_t AlignInBits,
                       uint64_t OffsetInBits, unsigned Flags,
                       ArrayRef<Metadata *> Ops)
-      : MDDerivedTypeBase(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits,
+      : DIDerivedTypeBase(C, ID, Storage, Tag, Line, SizeInBits, AlignInBits,
                           OffsetInBits, Flags, Ops),
         RuntimeLang(RuntimeLang) {}
-  ~MDCompositeTypeBase() = default;
+  ~DICompositeTypeBase() = default;
 
 public:
   /// \brief Get the elements of the composite type.
   ///
-  /// \note Calling this is only valid for \a MDCompositeType.  This assertion
-  /// can be removed once \a MDSubroutineType has been separated from
+  /// \note Calling this is only valid for \a DICompositeType.  This assertion
+  /// can be removed once \a DISubroutineType has been separated from
   /// "composite types".
-  DebugNodeArray getElements() const {
-    assert(!isa<MDSubroutineType>(this) && "no elements for DISubroutineType");
+  DINodeArray getElements() const {
+    assert(!isa<DISubroutineType>(this) && "no elements for DISubroutineType");
     return cast_or_null<MDTuple>(getRawElements());
   }
-  MDTypeRef getVTableHolder() const { return MDTypeRef(getRawVTableHolder()); }
-  MDTemplateParameterArray getTemplateParams() const {
+  DITypeRef getVTableHolder() const { return DITypeRef(getRawVTableHolder()); }
+  DITemplateParameterArray getTemplateParams() const {
     return cast_or_null<MDTuple>(getRawTemplateParams());
   }
   StringRef getIdentifier() const { return getStringOperand(7); }
@@ -813,25 +807,25 @@ public:
   /// this will be RAUW'ed and deleted.  Use a \a TrackingMDRef to keep track
   /// of its movement if necessary.
   /// @{
-  void replaceElements(DebugNodeArray Elements) {
+  void replaceElements(DINodeArray Elements) {
 #ifndef NDEBUG
-    for (DebugNode *Op : getElements())
+    for (DINode *Op : getElements())
       assert(std::find(Elements->op_begin(), Elements->op_end(), Op) &&
              "Lost a member during member list replacement");
 #endif
     replaceOperandWith(4, Elements.get());
   }
-  void replaceVTableHolder(MDTypeRef VTableHolder) {
+  void replaceVTableHolder(DITypeRef VTableHolder) {
     replaceOperandWith(5, VTableHolder);
   }
-  void replaceTemplateParams(MDTemplateParameterArray TemplateParams) {
+  void replaceTemplateParams(DITemplateParameterArray TemplateParams) {
     replaceOperandWith(6, TemplateParams.get());
   }
   /// @}
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDCompositeTypeKind ||
-           MD->getMetadataID() == MDSubroutineTypeKind;
+    return MD->getMetadataID() == DICompositeTypeKind ||
+           MD->getMetadataID() == DISubroutineTypeKind;
   }
 };
 
@@ -839,25 +833,25 @@ public:
 ///
 /// TODO: Detach from DerivedTypeBase (split out MDEnumType?).
 /// TODO: Create a custom, unrelated node for DW_TAG_array_type.
-class MDCompositeType : public MDCompositeTypeBase {
+class DICompositeType : public DICompositeTypeBase {
   friend class LLVMContextImpl;
   friend class MDNode;
 
-  MDCompositeType(LLVMContext &C, StorageType Storage, unsigned Tag,
+  DICompositeType(LLVMContext &C, StorageType Storage, unsigned Tag,
                   unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits,
                   uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
                   ArrayRef<Metadata *> Ops)
-      : MDCompositeTypeBase(C, MDCompositeTypeKind, Storage, Tag, Line,
+      : DICompositeTypeBase(C, DICompositeTypeKind, Storage, Tag, Line,
                             RuntimeLang, SizeInBits, AlignInBits, OffsetInBits,
                             Flags, Ops) {}
-  ~MDCompositeType() = default;
+  ~DICompositeType() = default;
 
-  static MDCompositeType *
+  static DICompositeType *
   getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, Metadata *File,
-          unsigned Line, MDScopeRef Scope, MDTypeRef BaseType,
+          unsigned Line, DIScopeRef Scope, DITypeRef BaseType,
           uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
-          uint64_t Flags, DebugNodeArray Elements, unsigned RuntimeLang,
-          MDTypeRef VTableHolder, MDTemplateParameterArray TemplateParams,
+          uint64_t Flags, DINodeArray Elements, unsigned RuntimeLang,
+          DITypeRef VTableHolder, DITemplateParameterArray TemplateParams,
           StringRef Identifier, StorageType Storage, bool ShouldCreate = true) {
     return getImpl(
         Context, Tag, getCanonicalMDString(Context, Name), File, Line, Scope,
@@ -865,7 +859,7 @@ class MDCompositeType : public MDCompositeTypeBase {
         RuntimeLang, VTableHolder, TemplateParams.get(),
         getCanonicalMDString(Context, Identifier), Storage, ShouldCreate);
   }
-  static MDCompositeType *
+  static DICompositeType *
   getImpl(LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
           unsigned Line, Metadata *Scope, Metadata *BaseType,
           uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
@@ -873,7 +867,7 @@ class MDCompositeType : public MDCompositeTypeBase {
           Metadata *VTableHolder, Metadata *TemplateParams,
           MDString *Identifier, StorageType Storage, bool ShouldCreate = true);
 
-  TempMDCompositeType cloneImpl() const {
+  TempDICompositeType cloneImpl() const {
     return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
                         getScope(), getBaseType(), getSizeInBits(),
                         getAlignInBits(), getOffsetInBits(), getFlags(),
@@ -882,18 +876,18 @@ class MDCompositeType : public MDCompositeTypeBase {
   }
 
 public:
-  DEFINE_MDNODE_GET(MDCompositeType,
-                    (unsigned Tag, StringRef Name, MDFile *File, unsigned Line,
-                     MDScopeRef Scope, MDTypeRef BaseType, uint64_t SizeInBits,
+  DEFINE_MDNODE_GET(DICompositeType,
+                    (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
+                     DIScopeRef Scope, DITypeRef BaseType, uint64_t SizeInBits,
                      uint64_t AlignInBits, uint64_t OffsetInBits,
-                     unsigned Flags, DebugNodeArray Elements,
-                     unsigned RuntimeLang, MDTypeRef VTableHolder,
-                     MDTemplateParameterArray TemplateParams = nullptr,
+                     unsigned Flags, DINodeArray Elements, unsigned RuntimeLang,
+                     DITypeRef VTableHolder,
+                     DITemplateParameterArray TemplateParams = nullptr,
                      StringRef Identifier = ""),
                     (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
                      AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
                      VTableHolder, TemplateParams, Identifier))
-  DEFINE_MDNODE_GET(MDCompositeType,
+  DEFINE_MDNODE_GET(DICompositeType,
                     (unsigned Tag, MDString *Name, Metadata *File,
                      unsigned Line, Metadata *Scope, Metadata *BaseType,
                      uint64_t SizeInBits, uint64_t AlignInBits,
@@ -905,71 +899,71 @@ public:
                      AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
                      VTableHolder, TemplateParams, Identifier))
 
-  TempMDCompositeType clone() const { return cloneImpl(); }
+  TempDICompositeType clone() const { return cloneImpl(); }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDCompositeTypeKind;
+    return MD->getMetadataID() == DICompositeTypeKind;
   }
 };
 
-template <class T> TypedDebugNodeRef<T> TypedDebugNodeRef<T>::get(const T *N) {
+template <class T> TypedDINodeRef<T> TypedDINodeRef<T>::get(const T *N) {
   if (N)
-    if (auto *Composite = dyn_cast<MDCompositeType>(N))
+    if (auto *Composite = dyn_cast<DICompositeType>(N))
       if (auto *S = Composite->getRawIdentifier())
-        return TypedDebugNodeRef<T>(S);
-  return TypedDebugNodeRef<T>(N);
+        return TypedDINodeRef<T>(S);
+  return TypedDINodeRef<T>(N);
 }
 
 /// \brief Type array for a subprogram.
 ///
 /// TODO: Detach from CompositeType, and fold the array of types in directly
 /// as operands.
-class MDSubroutineType : public MDCompositeTypeBase {
+class DISubroutineType : public DICompositeTypeBase {
   friend class LLVMContextImpl;
   friend class MDNode;
 
-  MDSubroutineType(LLVMContext &C, StorageType Storage, unsigned Flags,
+  DISubroutineType(LLVMContext &C, StorageType Storage, unsigned Flags,
                    ArrayRef<Metadata *> Ops)
-      : MDCompositeTypeBase(C, MDSubroutineTypeKind, Storage,
+      : DICompositeTypeBase(C, DISubroutineTypeKind, Storage,
                             dwarf::DW_TAG_subroutine_type, 0, 0, 0, 0, 0, Flags,
                             Ops) {}
-  ~MDSubroutineType() = default;
+  ~DISubroutineType() = default;
 
-  static MDSubroutineType *getImpl(LLVMContext &Context, unsigned Flags,
-                                   MDTypeRefArray TypeArray,
+  static DISubroutineType *getImpl(LLVMContext &Context, unsigned Flags,
+                                   DITypeRefArray TypeArray,
                                    StorageType Storage,
                                    bool ShouldCreate = true) {
     return getImpl(Context, Flags, TypeArray.get(), Storage, ShouldCreate);
   }
-  static MDSubroutineType *getImpl(LLVMContext &Context, unsigned Flags,
+  static DISubroutineType *getImpl(LLVMContext &Context, unsigned Flags,
                                    Metadata *TypeArray, StorageType Storage,
                                    bool ShouldCreate = true);
 
-  TempMDSubroutineType cloneImpl() const {
+  TempDISubroutineType cloneImpl() const {
     return getTemporary(getContext(), getFlags(), getTypeArray());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDSubroutineType,
-                    (unsigned Flags, MDTypeRefArray TypeArray),
+  DEFINE_MDNODE_GET(DISubroutineType,
+                    (unsigned Flags, DITypeRefArray TypeArray),
                     (Flags, TypeArray))
-  DEFINE_MDNODE_GET(MDSubroutineType, (unsigned Flags, Metadata *TypeArray),
+  DEFINE_MDNODE_GET(DISubroutineType, (unsigned Flags, Metadata *TypeArray),
                     (Flags, TypeArray))
 
-  TempMDSubroutineType clone() const { return cloneImpl(); }
+  TempDISubroutineType clone() const { return cloneImpl(); }
 
-  MDTypeRefArray getTypeArray() const {
+  DITypeRefArray getTypeArray() const {
     return cast_or_null<MDTuple>(getRawTypeArray());
   }
   Metadata *getRawTypeArray() const { return getRawElements(); }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDSubroutineTypeKind;
+    return MD->getMetadataID() == DISubroutineTypeKind;
   }
 };
 
 /// \brief Compile unit.
-class MDCompileUnit : public MDScope {
+class DICompileUnit : public DIScope {
   friend class LLVMContextImpl;
   friend class MDNode;
 
@@ -978,22 +972,22 @@ class MDCompileUnit : public MDScope {
   unsigned RuntimeVersion;
   unsigned EmissionKind;
 
-  MDCompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage,
+  DICompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage,
                 bool IsOptimized, unsigned RuntimeVersion,
                 unsigned EmissionKind, ArrayRef<Metadata *> Ops)
-      : MDScope(C, MDCompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
+      : DIScope(C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
         SourceLanguage(SourceLanguage), IsOptimized(IsOptimized),
         RuntimeVersion(RuntimeVersion), EmissionKind(EmissionKind) {}
-  ~MDCompileUnit() = default;
+  ~DICompileUnit() = default;
 
-  static MDCompileUnit *
-  getImpl(LLVMContext &Context, unsigned SourceLanguage, MDFile *File,
+  static DICompileUnit *
+  getImpl(LLVMContext &Context, unsigned SourceLanguage, DIFile *File,
           StringRef Producer, bool IsOptimized, StringRef Flags,
           unsigned RuntimeVersion, StringRef SplitDebugFilename,
-          unsigned EmissionKind, MDCompositeTypeArray EnumTypes,
-          MDTypeArray RetainedTypes, MDSubprogramArray Subprograms,
-          MDGlobalVariableArray GlobalVariables,
-          MDImportedEntityArray ImportedEntities, StorageType Storage,
+          unsigned EmissionKind, DICompositeTypeArray EnumTypes,
+          DITypeArray RetainedTypes, DISubprogramArray Subprograms,
+          DIGlobalVariableArray GlobalVariables,
+          DIImportedEntityArray ImportedEntities, StorageType Storage,
           bool ShouldCreate = true) {
     return getImpl(
         Context, SourceLanguage, File, getCanonicalMDString(Context, Producer),
@@ -1002,7 +996,7 @@ class MDCompileUnit : public MDScope {
         EnumTypes.get(), RetainedTypes.get(), Subprograms.get(),
         GlobalVariables.get(), ImportedEntities.get(), Storage, ShouldCreate);
   }
-  static MDCompileUnit *
+  static DICompileUnit *
   getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
           MDString *Producer, bool IsOptimized, MDString *Flags,
           unsigned RuntimeVersion, MDString *SplitDebugFilename,
@@ -1011,7 +1005,7 @@ class MDCompileUnit : public MDScope {
           Metadata *ImportedEntities, StorageType Storage,
           bool ShouldCreate = true);
 
-  TempMDCompileUnit cloneImpl() const {
+  TempDICompileUnit cloneImpl() const {
     return getTemporary(
         getContext(), getSourceLanguage(), getFile(), getProducer(),
         isOptimized(), getFlags(), getRuntimeVersion(), getSplitDebugFilename(),
@@ -1020,19 +1014,19 @@ class MDCompileUnit : public MDScope {
   }
 
 public:
-  DEFINE_MDNODE_GET(MDCompileUnit,
-                    (unsigned SourceLanguage, MDFile *File, StringRef Producer,
+  DEFINE_MDNODE_GET(DICompileUnit,
+                    (unsigned SourceLanguage, DIFile *File, StringRef Producer,
                      bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,
                      StringRef SplitDebugFilename, unsigned EmissionKind,
-                     MDCompositeTypeArray EnumTypes, MDTypeArray RetainedTypes,
-                     MDSubprogramArray Subprograms,
-                     MDGlobalVariableArray GlobalVariables,
-                     MDImportedEntityArray ImportedEntities),
+                     DICompositeTypeArray EnumTypes, DITypeArray RetainedTypes,
+                     DISubprogramArray Subprograms,
+                     DIGlobalVariableArray GlobalVariables,
+                     DIImportedEntityArray ImportedEntities),
                     (SourceLanguage, File, Producer, IsOptimized, Flags,
                      RuntimeVersion, SplitDebugFilename, EmissionKind,
                      EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
                      ImportedEntities))
-  DEFINE_MDNODE_GET(MDCompileUnit,
+  DEFINE_MDNODE_GET(DICompileUnit,
                     (unsigned SourceLanguage, Metadata *File,
                      MDString *Producer, bool IsOptimized, MDString *Flags,
                      unsigned RuntimeVersion, MDString *SplitDebugFilename,
@@ -1044,7 +1038,7 @@ public:
                      EnumTypes, RetainedTypes, Subprograms, GlobalVariables,
                      ImportedEntities))
 
-  TempMDCompileUnit clone() const { return cloneImpl(); }
+  TempDICompileUnit clone() const { return cloneImpl(); }
 
   unsigned getSourceLanguage() const { return SourceLanguage; }
   bool isOptimized() const { return IsOptimized; }
@@ -1053,19 +1047,19 @@ public:
   StringRef getProducer() const { return getStringOperand(1); }
   StringRef getFlags() const { return getStringOperand(2); }
   StringRef getSplitDebugFilename() const { return getStringOperand(3); }
-  MDCompositeTypeArray getEnumTypes() const {
+  DICompositeTypeArray getEnumTypes() const {
     return cast_or_null<MDTuple>(getRawEnumTypes());
   }
-  MDTypeArray getRetainedTypes() const {
+  DITypeArray getRetainedTypes() const {
     return cast_or_null<MDTuple>(getRawRetainedTypes());
   }
-  MDSubprogramArray getSubprograms() const {
+  DISubprogramArray getSubprograms() const {
     return cast_or_null<MDTuple>(getRawSubprograms());
   }
-  MDGlobalVariableArray getGlobalVariables() const {
+  DIGlobalVariableArray getGlobalVariables() const {
     return cast_or_null<MDTuple>(getRawGlobalVariables());
   }
-  MDImportedEntityArray getImportedEntities() const {
+  DIImportedEntityArray getImportedEntities() const {
     return cast_or_null<MDTuple>(getRawImportedEntities());
   }
 
@@ -1084,71 +1078,71 @@ public:
   ///
   /// If this \a isUniqued() and not \a isResolved(), it will be RAUW'ed and
   /// deleted on a uniquing collision.  In practice, uniquing collisions on \a
-  /// MDCompileUnit should be fairly rare.
+  /// DICompileUnit should be fairly rare.
   /// @{
-  void replaceSubprograms(MDSubprogramArray N) {
+  void replaceSubprograms(DISubprogramArray N) {
     replaceOperandWith(6, N.get());
   }
-  void replaceGlobalVariables(MDGlobalVariableArray N) {
+  void replaceGlobalVariables(DIGlobalVariableArray N) {
     replaceOperandWith(7, N.get());
   }
   /// @}
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDCompileUnitKind;
+    return MD->getMetadataID() == DICompileUnitKind;
   }
 };
 
 /// \brief A scope for locals.
 ///
 /// A legal scope for lexical blocks, local variables, and debug info
-/// locations.  Subclasses are \a MDSubprogram, \a MDLexicalBlock, and \a
-/// MDLexicalBlockFile.
-class MDLocalScope : public MDScope {
+/// locations.  Subclasses are \a DISubprogram, \a DILexicalBlock, and \a
+/// DILexicalBlockFile.
+class DILocalScope : public DIScope {
 protected:
-  MDLocalScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
+  DILocalScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
                ArrayRef<Metadata *> Ops)
-      : MDScope(C, ID, Storage, Tag, Ops) {}
-  ~MDLocalScope() = default;
+      : DIScope(C, ID, Storage, Tag, Ops) {}
+  ~DILocalScope() = default;
 
 public:
   /// \brief Get the subprogram for this scope.
   ///
-  /// Return this if it's an \a MDSubprogram; otherwise, look up the scope
+  /// Return this if it's an \a DISubprogram; otherwise, look up the scope
   /// chain.
-  MDSubprogram *getSubprogram() const;
+  DISubprogram *getSubprogram() const;
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDSubprogramKind ||
-           MD->getMetadataID() == MDLexicalBlockKind ||
-           MD->getMetadataID() == MDLexicalBlockFileKind;
+    return MD->getMetadataID() == DISubprogramKind ||
+           MD->getMetadataID() == DILexicalBlockKind ||
+           MD->getMetadataID() == DILexicalBlockFileKind;
   }
 };
 
 /// \brief Debug location.
 ///
 /// A debug location in source code, used for debug info and otherwise.
-class MDLocation : public MDNode {
+class DILocation : public MDNode {
   friend class LLVMContextImpl;
   friend class MDNode;
 
-  MDLocation(LLVMContext &C, StorageType Storage, unsigned Line,
+  DILocation(LLVMContext &C, StorageType Storage, unsigned Line,
              unsigned Column, ArrayRef<Metadata *> MDs);
-  ~MDLocation() { dropAllReferences(); }
+  ~DILocation() { dropAllReferences(); }
 
-  static MDLocation *getImpl(LLVMContext &Context, unsigned Line,
+  static DILocation *getImpl(LLVMContext &Context, unsigned Line,
                              unsigned Column, Metadata *Scope,
                              Metadata *InlinedAt, StorageType Storage,
                              bool ShouldCreate = true);
-  static MDLocation *getImpl(LLVMContext &Context, unsigned Line,
-                             unsigned Column, MDLocalScope *Scope,
-                             MDLocation *InlinedAt, StorageType Storage,
+  static DILocation *getImpl(LLVMContext &Context, unsigned Line,
+                             unsigned Column, DILocalScope *Scope,
+                             DILocation *InlinedAt, StorageType Storage,
                              bool ShouldCreate = true) {
     return getImpl(Context, Line, Column, static_cast<Metadata *>(Scope),
                    static_cast<Metadata *>(InlinedAt), Storage, ShouldCreate);
   }
 
-  TempMDLocation cloneImpl() const {
+  TempDILocation cloneImpl() const {
     return getTemporary(getContext(), getLine(), getColumn(), getScope(),
                         getInlinedAt());
   }
@@ -1157,28 +1151,26 @@ class MDLocation : public MDNode {
   void replaceOperandWith(unsigned I, Metadata *New) = delete;
 
 public:
-  DEFINE_MDNODE_GET(MDLocation,
+  DEFINE_MDNODE_GET(DILocation,
                     (unsigned Line, unsigned Column, Metadata *Scope,
                      Metadata *InlinedAt = nullptr),
                     (Line, Column, Scope, InlinedAt))
-  DEFINE_MDNODE_GET(MDLocation,
-                    (unsigned Line, unsigned Column, MDLocalScope *Scope,
-                     MDLocation *InlinedAt = nullptr),
+  DEFINE_MDNODE_GET(DILocation,
+                    (unsigned Line, unsigned Column, DILocalScope *Scope,
+                     DILocation *InlinedAt = nullptr),
                     (Line, Column, Scope, InlinedAt))
 
   /// \brief Return a (temporary) clone of this.
-  TempMDLocation clone() const { return cloneImpl(); }
+  TempDILocation clone() const { return cloneImpl(); }
 
   unsigned getLine() const { return SubclassData32; }
   unsigned getColumn() const { return SubclassData16; }
-  MDLocalScope *getScope() const {
-    return cast<MDLocalScope>(getRawScope());
-  }
-  MDLocation *getInlinedAt() const {
-    return cast_or_null<MDLocation>(getRawInlinedAt());
+  DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
+  DILocation *getInlinedAt() const {
+    return cast_or_null<DILocation>(getRawInlinedAt());
   }
 
-  MDFile *getFile() const { return getScope()->getFile(); }
+  DIFile *getFile() const { return getScope()->getFile(); }
   StringRef getFilename() const { return getScope()->getFilename(); }
   StringRef getDirectory() const { return getScope()->getDirectory(); }
 
@@ -1186,7 +1178,7 @@ public:
   ///
   /// Walk through \a getInlinedAt() and return \a getScope() from the deepest
   /// location.
-  MDLocalScope *getInlinedAtScope() const {
+  DILocalScope *getInlinedAtScope() const {
     if (auto *IA = getInlinedAt())
       return IA->getInlinedAtScope();
     return getScope();
@@ -1205,7 +1197,7 @@ public:
   /// FIXME: Add a check for getColumn().
   /// FIXME: Change the getFilename() check to getFile() (or add one for
   /// getDirectory()).
-  bool canDiscriminate(const MDLocation &RHS) const {
+  bool canDiscriminate(const DILocation &RHS) const {
     return getFilename() != RHS.getFilename() || getLine() != RHS.getLine();
   }
 
@@ -1232,7 +1224,7 @@ public:
   }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDLocationKind;
+    return MD->getMetadataID() == DILocationKind;
   }
 };
 
@@ -1240,7 +1232,7 @@ public:
 ///
 /// TODO: Remove DisplayName.  It's always equal to Name.
 /// TODO: Split up flags.
-class MDSubprogram : public MDLocalScope {
+class DISubprogram : public DILocalScope {
   friend class LLVMContextImpl;
   friend class MDNode;
 
@@ -1253,25 +1245,25 @@ class MDSubprogram : public MDLocalScope {
   bool IsDefinition;
   bool IsOptimized;
 
-  MDSubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
+  DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
                unsigned ScopeLine, unsigned Virtuality, unsigned VirtualIndex,
                unsigned Flags, bool IsLocalToUnit, bool IsDefinition,
                bool IsOptimized, ArrayRef<Metadata *> Ops)
-      : MDLocalScope(C, MDSubprogramKind, Storage, dwarf::DW_TAG_subprogram,
+      : DILocalScope(C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram,
                      Ops),
         Line(Line), ScopeLine(ScopeLine), Virtuality(Virtuality),
         VirtualIndex(VirtualIndex), Flags(Flags), IsLocalToUnit(IsLocalToUnit),
         IsDefinition(IsDefinition), IsOptimized(IsOptimized) {}
-  ~MDSubprogram() = default;
+  ~DISubprogram() = default;
 
-  static MDSubprogram *
-  getImpl(LLVMContext &Context, MDScopeRef Scope, StringRef Name,
-          StringRef LinkageName, MDFile *File, unsigned Line,
-          MDSubroutineType *Type, bool IsLocalToUnit, bool IsDefinition,
-          unsigned ScopeLine, MDTypeRef ContainingType, unsigned Virtuality,
+  static DISubprogram *
+  getImpl(LLVMContext &Context, DIScopeRef Scope, StringRef Name,
+          StringRef LinkageName, DIFile *File, unsigned Line,
+          DISubroutineType *Type, bool IsLocalToUnit, bool IsDefinition,
+          unsigned ScopeLine, DITypeRef ContainingType, unsigned Virtuality,
           unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
-          Constant *Function, MDTemplateParameterArray TemplateParams,
-          MDSubprogram *Declaration, MDLocalVariableArray Variables,
+          Constant *Function, DITemplateParameterArray TemplateParams,
+          DISubprogram *Declaration, DILocalVariableArray Variables,
           StorageType Storage, bool ShouldCreate = true) {
     return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
                    getCanonicalMDString(Context, LinkageName), File, Line, Type,
@@ -1281,7 +1273,7 @@ class MDSubprogram : public MDLocalScope {
                    TemplateParams.get(), Declaration, Variables.get(), Storage,
                    ShouldCreate);
   }
-  static MDSubprogram *
+  static DISubprogram *
   getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
           MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
           bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
@@ -1290,7 +1282,7 @@ class MDSubprogram : public MDLocalScope {
           Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables,
           StorageType Storage, bool ShouldCreate = true);
 
-  TempMDSubprogram cloneImpl() const {
+  TempDISubprogram cloneImpl() const {
     return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
                         getFile(), getLine(), getType(), isLocalToUnit(),
                         isDefinition(), getScopeLine(), getContainingType(),
@@ -1300,22 +1292,22 @@ class MDSubprogram : public MDLocalScope {
   }
 
 public:
-  DEFINE_MDNODE_GET(MDSubprogram,
-                    (MDScopeRef Scope, StringRef Name, StringRef LinkageName,
-                     MDFile *File, unsigned Line, MDSubroutineType *Type,
+  DEFINE_MDNODE_GET(DISubprogram,
+                    (DIScopeRef Scope, StringRef Name, StringRef LinkageName,
+                     DIFile *File, unsigned Line, DISubroutineType *Type,
                      bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
-                     MDTypeRef ContainingType, unsigned Virtuality,
+                     DITypeRef ContainingType, unsigned Virtuality,
                      unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
                      Constant *Function = nullptr,
-                     MDTemplateParameterArray TemplateParams = nullptr,
-                     MDSubprogram *Declaration = nullptr,
-                     MDLocalVariableArray Variables = nullptr),
+                     DITemplateParameterArray TemplateParams = nullptr,
+                     DISubprogram *Declaration = nullptr,
+                     DILocalVariableArray Variables = nullptr),
                     (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
                      IsDefinition, ScopeLine, ContainingType, Virtuality,
                      VirtualIndex, Flags, IsOptimized, Function, TemplateParams,
                      Declaration, Variables))
   DEFINE_MDNODE_GET(
-      MDSubprogram,
+      DISubprogram,
       (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File,
        unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
        unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality,
@@ -1326,7 +1318,7 @@ public:
        ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags, IsOptimized,
        Function, TemplateParams, Declaration, Variables))
 
-  TempMDSubprogram clone() const { return cloneImpl(); }
+  TempDISubprogram clone() const { return cloneImpl(); }
 
 public:
   unsigned getLine() const { return Line; }
@@ -1367,7 +1359,7 @@ public:
     return getFlags() & FlagRValueReference;
   }
 
-  MDScopeRef getScope() const { return MDScopeRef(getRawScope()); }
+  DIScopeRef getScope() const { return DIScopeRef(getRawScope()); }
 
   StringRef getName() const { return getStringOperand(2); }
   StringRef getDisplayName() const { return getStringOperand(3); }
@@ -1376,11 +1368,11 @@ public:
   MDString *getRawName() const { return getOperandAs<MDString>(2); }
   MDString *getRawLinkageName() const { return getOperandAs<MDString>(4); }
 
-  MDSubroutineType *getType() const {
-    return cast_or_null<MDSubroutineType>(getRawType());
+  DISubroutineType *getType() const {
+    return cast_or_null<DISubroutineType>(getRawType());
   }
-  MDTypeRef getContainingType() const {
-    return MDTypeRef(getRawContainingType());
+  DITypeRef getContainingType() const {
+    return DITypeRef(getRawContainingType());
   }
 
   Constant *getFunctionConstant() const {
@@ -1388,13 +1380,13 @@ public:
       return C->getValue();
     return nullptr;
   }
-  MDTemplateParameterArray getTemplateParams() const {
+  DITemplateParameterArray getTemplateParams() const {
     return cast_or_null<MDTuple>(getRawTemplateParams());
   }
-  MDSubprogram *getDeclaration() const {
-    return cast_or_null<MDSubprogram>(getRawDeclaration());
+  DISubprogram *getDeclaration() const {
+    return cast_or_null<DISubprogram>(getRawDeclaration());
   }
-  MDLocalVariableArray getVariables() const {
+  DILocalVariableArray getVariables() const {
     return cast_or_null<MDTuple>(getRawVariables());
   }
 
@@ -1430,50 +1422,50 @@ public:
   bool describes(const Function *F) const;
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDSubprogramKind;
+    return MD->getMetadataID() == DISubprogramKind;
   }
 };
 
-class MDLexicalBlockBase : public MDLocalScope {
+class DILexicalBlockBase : public DILocalScope {
 protected:
-  MDLexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage,
+  DILexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage,
                      ArrayRef<Metadata *> Ops)
-      : MDLocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
-  ~MDLexicalBlockBase() = default;
+      : DILocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
+  ~DILexicalBlockBase() = default;
 
 public:
-  MDLocalScope *getScope() const { return cast<MDLocalScope>(getRawScope()); }
+  DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
 
   Metadata *getRawScope() const { return getOperand(1); }
 
   /// \brief Forwarding accessors to LexicalBlock.
   ///
-  /// TODO: Remove these and update code to use \a MDLexicalBlock directly.
+  /// TODO: Remove these and update code to use \a DILexicalBlock directly.
   /// @{
   inline unsigned getLine() const;
   inline unsigned getColumn() const;
   /// @}
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDLexicalBlockKind ||
-           MD->getMetadataID() == MDLexicalBlockFileKind;
+    return MD->getMetadataID() == DILexicalBlockKind ||
+           MD->getMetadataID() == DILexicalBlockFileKind;
   }
 };
 
-class MDLexicalBlock : public MDLexicalBlockBase {
+class DILexicalBlock : public DILexicalBlockBase {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned Line;
   unsigned Column;
 
-  MDLexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line,
+  DILexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line,
                  unsigned Column, ArrayRef<Metadata *> Ops)
-      : MDLexicalBlockBase(C, MDLexicalBlockKind, Storage, Ops), Line(Line),
+      : DILexicalBlockBase(C, DILexicalBlockKind, Storage, Ops), Line(Line),
         Column(Column) {}
-  ~MDLexicalBlock() = default;
+  ~DILexicalBlock() = default;
 
-  static MDLexicalBlock *getImpl(LLVMContext &Context, MDLocalScope *Scope,
-                                 MDFile *File, unsigned Line, unsigned Column,
+  static DILexicalBlock *getImpl(LLVMContext &Context, DILocalScope *Scope,
+                                 DIFile *File, unsigned Line, unsigned Column,
                                  StorageType Storage,
                                  bool ShouldCreate = true) {
     return getImpl(Context, static_cast<Metadata *>(Scope),
@@ -1481,59 +1473,59 @@ class MDLexicalBlock : public MDLexicalBlockBase {
                    ShouldCreate);
   }
 
-  static MDLexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope,
+  static DILexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope,
                                  Metadata *File, unsigned Line, unsigned Column,
                                  StorageType Storage, bool ShouldCreate = true);
 
-  TempMDLexicalBlock cloneImpl() const {
+  TempDILexicalBlock cloneImpl() const {
     return getTemporary(getContext(), getScope(), getFile(), getLine(),
                         getColumn());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDLexicalBlock, (MDLocalScope * Scope, MDFile *File,
+  DEFINE_MDNODE_GET(DILexicalBlock, (DILocalScope * Scope, DIFile *File,
                                      unsigned Line, unsigned Column),
                     (Scope, File, Line, Column))
-  DEFINE_MDNODE_GET(MDLexicalBlock, (Metadata * Scope, Metadata *File,
+  DEFINE_MDNODE_GET(DILexicalBlock, (Metadata * Scope, Metadata *File,
                                      unsigned Line, unsigned Column),
                     (Scope, File, Line, Column))
 
-  TempMDLexicalBlock clone() const { return cloneImpl(); }
+  TempDILexicalBlock clone() const { return cloneImpl(); }
 
   unsigned getLine() const { return Line; }
   unsigned getColumn() const { return Column; }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDLexicalBlockKind;
+    return MD->getMetadataID() == DILexicalBlockKind;
   }
 };
 
-unsigned MDLexicalBlockBase::getLine() const {
-  if (auto *N = dyn_cast<MDLexicalBlock>(this))
+unsigned DILexicalBlockBase::getLine() const {
+  if (auto *N = dyn_cast<DILexicalBlock>(this))
     return N->getLine();
   return 0;
 }
 
-unsigned MDLexicalBlockBase::getColumn() const {
-  if (auto *N = dyn_cast<MDLexicalBlock>(this))
+unsigned DILexicalBlockBase::getColumn() const {
+  if (auto *N = dyn_cast<DILexicalBlock>(this))
     return N->getColumn();
   return 0;
 }
 
-class MDLexicalBlockFile : public MDLexicalBlockBase {
+class DILexicalBlockFile : public DILexicalBlockBase {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned Discriminator;
 
-  MDLexicalBlockFile(LLVMContext &C, StorageType Storage,
+  DILexicalBlockFile(LLVMContext &C, StorageType Storage,
                      unsigned Discriminator, ArrayRef<Metadata *> Ops)
-      : MDLexicalBlockBase(C, MDLexicalBlockFileKind, Storage, Ops),
+      : DILexicalBlockBase(C, DILexicalBlockFileKind, Storage, Ops),
         Discriminator(Discriminator) {}
-  ~MDLexicalBlockFile() = default;
+  ~DILexicalBlockFile() = default;
 
-  static MDLexicalBlockFile *getImpl(LLVMContext &Context, MDLocalScope *Scope,
-                                     MDFile *File, unsigned Discriminator,
+  static DILexicalBlockFile *getImpl(LLVMContext &Context, DILocalScope *Scope,
+                                     DIFile *File, unsigned Discriminator,
                                      StorageType Storage,
                                      bool ShouldCreate = true) {
     return getImpl(Context, static_cast<Metadata *>(Scope),
@@ -1541,213 +1533,213 @@ class MDLexicalBlockFile : public MDLexicalBlockBase {
                    ShouldCreate);
   }
 
-  static MDLexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope,
+  static DILexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope,
                                      Metadata *File, unsigned Discriminator,
                                      StorageType Storage,
                                      bool ShouldCreate = true);
 
-  TempMDLexicalBlockFile cloneImpl() const {
+  TempDILexicalBlockFile cloneImpl() const {
     return getTemporary(getContext(), getScope(), getFile(),
                         getDiscriminator());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDLexicalBlockFile, (MDLocalScope * Scope, MDFile *File,
+  DEFINE_MDNODE_GET(DILexicalBlockFile, (DILocalScope * Scope, DIFile *File,
                                          unsigned Discriminator),
                     (Scope, File, Discriminator))
-  DEFINE_MDNODE_GET(MDLexicalBlockFile,
+  DEFINE_MDNODE_GET(DILexicalBlockFile,
                     (Metadata * Scope, Metadata *File, unsigned Discriminator),
                     (Scope, File, Discriminator))
 
-  TempMDLexicalBlockFile clone() const { return cloneImpl(); }
+  TempDILexicalBlockFile clone() const { return cloneImpl(); }
 
-  // TODO: Remove these once they're gone from MDLexicalBlockBase.
+  // TODO: Remove these once they're gone from DILexicalBlockBase.
   unsigned getLine() const = delete;
   unsigned getColumn() const = delete;
 
   unsigned getDiscriminator() const { return Discriminator; }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDLexicalBlockFileKind;
+    return MD->getMetadataID() == DILexicalBlockFileKind;
   }
 };
 
-unsigned MDLocation::getDiscriminator() const {
-  if (auto *F = dyn_cast<MDLexicalBlockFile>(getScope()))
+unsigned DILocation::getDiscriminator() const {
+  if (auto *F = dyn_cast<DILexicalBlockFile>(getScope()))
     return F->getDiscriminator();
   return 0;
 }
 
-class MDNamespace : public MDScope {
+class DINamespace : public DIScope {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned Line;
 
-  MDNamespace(LLVMContext &Context, StorageType Storage, unsigned Line,
+  DINamespace(LLVMContext &Context, StorageType Storage, unsigned Line,
               ArrayRef<Metadata *> Ops)
-      : MDScope(Context, MDNamespaceKind, Storage, dwarf::DW_TAG_namespace,
+      : DIScope(Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace,
                 Ops),
         Line(Line) {}
-  ~MDNamespace() = default;
+  ~DINamespace() = default;
 
-  static MDNamespace *getImpl(LLVMContext &Context, MDScope *Scope,
-                              MDFile *File, StringRef Name, unsigned Line,
+  static DINamespace *getImpl(LLVMContext &Context, DIScope *Scope,
+                              DIFile *File, StringRef Name, unsigned Line,
                               StorageType Storage, bool ShouldCreate = true) {
     return getImpl(Context, Scope, File, getCanonicalMDString(Context, Name),
                    Line, Storage, ShouldCreate);
   }
-  static MDNamespace *getImpl(LLVMContext &Context, Metadata *Scope,
+  static DINamespace *getImpl(LLVMContext &Context, Metadata *Scope,
                               Metadata *File, MDString *Name, unsigned Line,
                               StorageType Storage, bool ShouldCreate = true);
 
-  TempMDNamespace cloneImpl() const {
+  TempDINamespace cloneImpl() const {
     return getTemporary(getContext(), getScope(), getFile(), getName(),
                         getLine());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDNamespace, (MDScope * Scope, MDFile *File, StringRef Name,
+  DEFINE_MDNODE_GET(DINamespace, (DIScope * Scope, DIFile *File, StringRef Name,
                                   unsigned Line),
                     (Scope, File, Name, Line))
-  DEFINE_MDNODE_GET(MDNamespace, (Metadata * Scope, Metadata *File,
+  DEFINE_MDNODE_GET(DINamespace, (Metadata * Scope, Metadata *File,
                                   MDString *Name, unsigned Line),
                     (Scope, File, Name, Line))
 
-  TempMDNamespace clone() const { return cloneImpl(); }
+  TempDINamespace clone() const { return cloneImpl(); }
 
   unsigned getLine() const { return Line; }
-  MDScope *getScope() const { return cast_or_null<MDScope>(getRawScope()); }
+  DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
   StringRef getName() const { return getStringOperand(2); }
 
   Metadata *getRawScope() const { return getOperand(1); }
   MDString *getRawName() const { return getOperandAs<MDString>(2); }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDNamespaceKind;
+    return MD->getMetadataID() == DINamespaceKind;
   }
 };
 
 /// \brief Base class for template parameters.
-class MDTemplateParameter : public DebugNode {
+class DITemplateParameter : public DINode {
 protected:
-  MDTemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
+  DITemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
                       unsigned Tag, ArrayRef<Metadata *> Ops)
-      : DebugNode(Context, ID, Storage, Tag, Ops) {}
-  ~MDTemplateParameter() = default;
+      : DINode(Context, ID, Storage, Tag, Ops) {}
+  ~DITemplateParameter() = default;
 
 public:
   StringRef getName() const { return getStringOperand(0); }
-  MDTypeRef getType() const { return MDTypeRef(getRawType()); }
+  DITypeRef getType() const { return DITypeRef(getRawType()); }
 
   MDString *getRawName() const { return getOperandAs<MDString>(0); }
   Metadata *getRawType() const { return getOperand(1); }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDTemplateTypeParameterKind ||
-           MD->getMetadataID() == MDTemplateValueParameterKind;
+    return MD->getMetadataID() == DITemplateTypeParameterKind ||
+           MD->getMetadataID() == DITemplateValueParameterKind;
   }
 };
 
-class MDTemplateTypeParameter : public MDTemplateParameter {
+class DITemplateTypeParameter : public DITemplateParameter {
   friend class LLVMContextImpl;
   friend class MDNode;
 
-  MDTemplateTypeParameter(LLVMContext &Context, StorageType Storage,
+  DITemplateTypeParameter(LLVMContext &Context, StorageType Storage,
                           ArrayRef<Metadata *> Ops)
-      : MDTemplateParameter(Context, MDTemplateTypeParameterKind, Storage,
+      : DITemplateParameter(Context, DITemplateTypeParameterKind, Storage,
                             dwarf::DW_TAG_template_type_parameter, Ops) {}
-  ~MDTemplateTypeParameter() = default;
+  ~DITemplateTypeParameter() = default;
 
-  static MDTemplateTypeParameter *getImpl(LLVMContext &Context, StringRef Name,
-                                          MDTypeRef Type, StorageType Storage,
+  static DITemplateTypeParameter *getImpl(LLVMContext &Context, StringRef Name,
+                                          DITypeRef Type, StorageType Storage,
                                           bool ShouldCreate = true) {
     return getImpl(Context, getCanonicalMDString(Context, Name), Type, Storage,
                    ShouldCreate);
   }
-  static MDTemplateTypeParameter *getImpl(LLVMContext &Context, MDString *Name,
+  static DITemplateTypeParameter *getImpl(LLVMContext &Context, MDString *Name,
                                           Metadata *Type, StorageType Storage,
                                           bool ShouldCreate = true);
 
-  TempMDTemplateTypeParameter cloneImpl() const {
+  TempDITemplateTypeParameter cloneImpl() const {
     return getTemporary(getContext(), getName(), getType());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDTemplateTypeParameter, (StringRef Name, MDTypeRef Type),
+  DEFINE_MDNODE_GET(DITemplateTypeParameter, (StringRef Name, DITypeRef Type),
                     (Name, Type))
-  DEFINE_MDNODE_GET(MDTemplateTypeParameter, (MDString * Name, Metadata *Type),
+  DEFINE_MDNODE_GET(DITemplateTypeParameter, (MDString * Name, Metadata *Type),
                     (Name, Type))
 
-  TempMDTemplateTypeParameter clone() const { return cloneImpl(); }
+  TempDITemplateTypeParameter clone() const { return cloneImpl(); }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDTemplateTypeParameterKind;
+    return MD->getMetadataID() == DITemplateTypeParameterKind;
   }
 };
 
-class MDTemplateValueParameter : public MDTemplateParameter {
+class DITemplateValueParameter : public DITemplateParameter {
   friend class LLVMContextImpl;
   friend class MDNode;
 
-  MDTemplateValueParameter(LLVMContext &Context, StorageType Storage,
+  DITemplateValueParameter(LLVMContext &Context, StorageType Storage,
                            unsigned Tag, ArrayRef<Metadata *> Ops)
-      : MDTemplateParameter(Context, MDTemplateValueParameterKind, Storage, Tag,
+      : DITemplateParameter(Context, DITemplateValueParameterKind, Storage, Tag,
                             Ops) {}
-  ~MDTemplateValueParameter() = default;
+  ~DITemplateValueParameter() = default;
 
-  static MDTemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
-                                           StringRef Name, MDTypeRef Type,
+  static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
+                                           StringRef Name, DITypeRef Type,
                                            Metadata *Value, StorageType Storage,
                                            bool ShouldCreate = true) {
     return getImpl(Context, Tag, getCanonicalMDString(Context, Name), Type,
                    Value, Storage, ShouldCreate);
   }
-  static MDTemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
+  static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag,
                                            MDString *Name, Metadata *Type,
                                            Metadata *Value, StorageType Storage,
                                            bool ShouldCreate = true);
 
-  TempMDTemplateValueParameter cloneImpl() const {
+  TempDITemplateValueParameter cloneImpl() const {
     return getTemporary(getContext(), getTag(), getName(), getType(),
                         getValue());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDTemplateValueParameter, (unsigned Tag, StringRef Name,
-                                               MDTypeRef Type, Metadata *Value),
+  DEFINE_MDNODE_GET(DITemplateValueParameter, (unsigned Tag, StringRef Name,
+                                               DITypeRef Type, Metadata *Value),
                     (Tag, Name, Type, Value))
-  DEFINE_MDNODE_GET(MDTemplateValueParameter, (unsigned Tag, MDString *Name,
+  DEFINE_MDNODE_GET(DITemplateValueParameter, (unsigned Tag, MDString *Name,
                                                Metadata *Type, Metadata *Value),
                     (Tag, Name, Type, Value))
 
-  TempMDTemplateValueParameter clone() const { return cloneImpl(); }
+  TempDITemplateValueParameter clone() const { return cloneImpl(); }
 
   Metadata *getValue() const { return getOperand(2); }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDTemplateValueParameterKind;
+    return MD->getMetadataID() == DITemplateValueParameterKind;
   }
 };
 
 /// \brief Base class for variables.
 ///
 /// TODO: Hardcode to DW_TAG_variable.
-class MDVariable : public DebugNode {
+class DIVariable : public DINode {
   unsigned Line;
 
 protected:
-  MDVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
+  DIVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
              unsigned Line, ArrayRef<Metadata *> Ops)
-      : DebugNode(C, ID, Storage, Tag, Ops), Line(Line) {}
-  ~MDVariable() = default;
+      : DINode(C, ID, Storage, Tag, Ops), Line(Line) {}
+  ~DIVariable() = default;
 
 public:
   unsigned getLine() const { return Line; }
-  MDScope *getScope() const { return cast_or_null<MDScope>(getRawScope()); }
+  DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
   StringRef getName() const { return getStringOperand(1); }
-  MDFile *getFile() const { return cast_or_null<MDFile>(getRawFile()); }
-  MDTypeRef getType() const { return MDTypeRef(getRawType()); }
+  DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
+  DITypeRef getType() const { return DITypeRef(getRawType()); }
 
   StringRef getFilename() const {
     if (auto *F = getFile())
@@ -1766,34 +1758,34 @@ public:
   Metadata *getRawType() const { return getOperand(3); }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDLocalVariableKind ||
-           MD->getMetadataID() == MDGlobalVariableKind;
+    return MD->getMetadataID() == DILocalVariableKind ||
+           MD->getMetadataID() == DIGlobalVariableKind;
   }
 };
 
 /// \brief Global variables.
 ///
 /// TODO: Remove DisplayName.  It's always equal to Name.
-class MDGlobalVariable : public MDVariable {
+class DIGlobalVariable : public DIVariable {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   bool IsLocalToUnit;
   bool IsDefinition;
 
-  MDGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
+  DIGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
                    bool IsLocalToUnit, bool IsDefinition,
                    ArrayRef<Metadata *> Ops)
-      : MDVariable(C, MDGlobalVariableKind, Storage, dwarf::DW_TAG_variable,
+      : DIVariable(C, DIGlobalVariableKind, Storage, dwarf::DW_TAG_variable,
                    Line, Ops),
         IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {}
-  ~MDGlobalVariable() = default;
+  ~DIGlobalVariable() = default;
 
-  static MDGlobalVariable *
-  getImpl(LLVMContext &Context, MDScope *Scope, StringRef Name,
-          StringRef LinkageName, MDFile *File, unsigned Line, MDTypeRef Type,
+  static DIGlobalVariable *
+  getImpl(LLVMContext &Context, DIScope *Scope, StringRef Name,
+          StringRef LinkageName, DIFile *File, unsigned Line, DITypeRef Type,
           bool IsLocalToUnit, bool IsDefinition, Constant *Variable,
-          MDDerivedType *StaticDataMemberDeclaration, StorageType Storage,
+          DIDerivedType *StaticDataMemberDeclaration, StorageType Storage,
           bool ShouldCreate = true) {
     return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
                    getCanonicalMDString(Context, LinkageName), File, Line, Type,
@@ -1801,14 +1793,14 @@ class MDGlobalVariable : public MDVariable {
                    Variable ? ConstantAsMetadata::get(Variable) : nullptr,
                    StaticDataMemberDeclaration, Storage, ShouldCreate);
   }
-  static MDGlobalVariable *
+  static DIGlobalVariable *
   getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
           MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
           bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
           Metadata *StaticDataMemberDeclaration, StorageType Storage,
           bool ShouldCreate = true);
 
-  TempMDGlobalVariable cloneImpl() const {
+  TempDIGlobalVariable cloneImpl() const {
     return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
                         getFile(), getLine(), getType(), isLocalToUnit(),
                         isDefinition(), getVariable(),
@@ -1816,14 +1808,14 @@ class MDGlobalVariable : public MDVariable {
   }
 
 public:
-  DEFINE_MDNODE_GET(MDGlobalVariable,
-                    (MDScope * Scope, StringRef Name, StringRef LinkageName,
-                     MDFile *File, unsigned Line, MDTypeRef Type,
+  DEFINE_MDNODE_GET(DIGlobalVariable,
+                    (DIScope * Scope, StringRef Name, StringRef LinkageName,
+                     DIFile *File, unsigned Line, DITypeRef Type,
                      bool IsLocalToUnit, bool IsDefinition, Constant *Variable,
-                     MDDerivedType *StaticDataMemberDeclaration),
+                     DIDerivedType *StaticDataMemberDeclaration),
                     (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
                      IsDefinition, Variable, StaticDataMemberDeclaration))
-  DEFINE_MDNODE_GET(MDGlobalVariable,
+  DEFINE_MDNODE_GET(DIGlobalVariable,
                     (Metadata * Scope, MDString *Name, MDString *LinkageName,
                      Metadata *File, unsigned Line, Metadata *Type,
                      bool IsLocalToUnit, bool IsDefinition, Metadata *Variable,
@@ -1831,7 +1823,7 @@ public:
                     (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
                      IsDefinition, Variable, StaticDataMemberDeclaration))
 
-  TempMDGlobalVariable clone() const { return cloneImpl(); }
+  TempDIGlobalVariable clone() const { return cloneImpl(); }
 
   bool isLocalToUnit() const { return IsLocalToUnit; }
   bool isDefinition() const { return IsDefinition; }
@@ -1842,8 +1834,8 @@ public:
       return dyn_cast<Constant>(C->getValue());
     return nullptr;
   }
-  MDDerivedType *getStaticDataMemberDeclaration() const {
-    return cast_or_null<MDDerivedType>(getRawStaticDataMemberDeclaration());
+  DIDerivedType *getStaticDataMemberDeclaration() const {
+    return cast_or_null<DIDerivedType>(getRawStaticDataMemberDeclaration());
   }
 
   MDString *getRawLinkageName() const { return getOperandAs<MDString>(5); }
@@ -1851,7 +1843,7 @@ public:
   Metadata *getRawStaticDataMemberDeclaration() const { return getOperand(7); }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDGlobalVariableKind;
+    return MD->getMetadataID() == DIGlobalVariableKind;
   }
 };
 
@@ -1860,57 +1852,57 @@ public:
 /// TODO: Split between arguments and otherwise.
 /// TODO: Use \c DW_TAG_variable instead of fake tags.
 /// TODO: Split up flags.
-class MDLocalVariable : public MDVariable {
+class DILocalVariable : public DIVariable {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned Arg;
   unsigned Flags;
 
-  MDLocalVariable(LLVMContext &C, StorageType Storage, unsigned Tag,
+  DILocalVariable(LLVMContext &C, StorageType Storage, unsigned Tag,
                   unsigned Line, unsigned Arg, unsigned Flags,
                   ArrayRef<Metadata *> Ops)
-      : MDVariable(C, MDLocalVariableKind, Storage, Tag, Line, Ops), Arg(Arg),
+      : DIVariable(C, DILocalVariableKind, Storage, Tag, Line, Ops), Arg(Arg),
         Flags(Flags) {}
-  ~MDLocalVariable() = default;
+  ~DILocalVariable() = default;
 
-  static MDLocalVariable *getImpl(LLVMContext &Context, unsigned Tag,
-                                  MDScope *Scope, StringRef Name, MDFile *File,
-                                  unsigned Line, MDTypeRef Type, unsigned Arg,
+  static DILocalVariable *getImpl(LLVMContext &Context, unsigned Tag,
+                                  DIScope *Scope, StringRef Name, DIFile *File,
+                                  unsigned Line, DITypeRef Type, unsigned Arg,
                                   unsigned Flags, StorageType Storage,
                                   bool ShouldCreate = true) {
     return getImpl(Context, Tag, Scope, getCanonicalMDString(Context, Name),
                    File, Line, Type, Arg, Flags, Storage, ShouldCreate);
   }
-  static MDLocalVariable *
+  static DILocalVariable *
   getImpl(LLVMContext &Context, unsigned Tag, Metadata *Scope, MDString *Name,
           Metadata *File, unsigned Line, Metadata *Type, unsigned Arg,
           unsigned Flags, StorageType Storage, bool ShouldCreate = true);
 
-  TempMDLocalVariable cloneImpl() const {
+  TempDILocalVariable cloneImpl() const {
     return getTemporary(getContext(), getTag(), getScope(), getName(),
                         getFile(), getLine(), getType(), getArg(), getFlags());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDLocalVariable,
-                    (unsigned Tag, MDLocalScope *Scope, StringRef Name,
-                     MDFile *File, unsigned Line, MDTypeRef Type, unsigned Arg,
+  DEFINE_MDNODE_GET(DILocalVariable,
+                    (unsigned Tag, DILocalScope *Scope, StringRef Name,
+                     DIFile *File, unsigned Line, DITypeRef Type, unsigned Arg,
                      unsigned Flags),
                     (Tag, Scope, Name, File, Line, Type, Arg, Flags))
-  DEFINE_MDNODE_GET(MDLocalVariable,
+  DEFINE_MDNODE_GET(DILocalVariable,
                     (unsigned Tag, Metadata *Scope, MDString *Name,
                      Metadata *File, unsigned Line, Metadata *Type,
                      unsigned Arg, unsigned Flags),
                     (Tag, Scope, Name, File, Line, Type, Arg, Flags))
 
-  TempMDLocalVariable clone() const { return cloneImpl(); }
+  TempDILocalVariable clone() const { return cloneImpl(); }
 
   /// \brief Get the local scope for this variable.
   ///
   /// Variables must be defined in a local scope.
-  MDLocalScope *getScope() const {
-    return cast<MDLocalScope>(MDVariable::getScope());
+  DILocalScope *getScope() const {
+    return cast<DILocalScope>(DIVariable::getScope());
   }
 
   unsigned getArg() const { return Arg; }
@@ -1924,12 +1916,12 @@ public:
   /// Check that \c DL exists, is in the same subprogram, and has the same
   /// inlined-at location as \c this.  (Otherwise, it's not a valid attachemnt
   /// to a \a DbgInfoIntrinsic.)
-  bool isValidLocationForIntrinsic(const MDLocation *DL) const {
+  bool isValidLocationForIntrinsic(const DILocation *DL) const {
     return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
   }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDLocalVariableKind;
+    return MD->getMetadataID() == DILocalVariableKind;
   }
 };
 
@@ -1944,29 +1936,29 @@ public:
 /// TODO: Co-allocate the expression elements.
 /// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary
 /// storage types.
-class MDExpression : public MDNode {
+class DIExpression : public MDNode {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   std::vector<uint64_t> Elements;
 
-  MDExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements)
-      : MDNode(C, MDExpressionKind, Storage, None),
+  DIExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements)
+      : MDNode(C, DIExpressionKind, Storage, None),
         Elements(Elements.begin(), Elements.end()) {}
-  ~MDExpression() = default;
+  ~DIExpression() = default;
 
-  static MDExpression *getImpl(LLVMContext &Context,
+  static DIExpression *getImpl(LLVMContext &Context,
                                ArrayRef<uint64_t> Elements, StorageType Storage,
                                bool ShouldCreate = true);
 
-  TempMDExpression cloneImpl() const {
+  TempDIExpression cloneImpl() const {
     return getTemporary(getContext(), getElements());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDExpression, (ArrayRef<uint64_t> Elements), (Elements))
+  DEFINE_MDNODE_GET(DIExpression, (ArrayRef<uint64_t> Elements), (Elements))
 
-  TempMDExpression clone() const { return cloneImpl(); }
+  TempDIExpression clone() const { return cloneImpl(); }
 
   ArrayRef<uint64_t> getElements() const { return Elements; }
 
@@ -1991,7 +1983,7 @@ public:
 
   /// \brief A lightweight wrapper around an expression operand.
   ///
-  /// TODO: Store arguments directly and change \a MDExpression to store a
+  /// TODO: Store arguments directly and change \a DIExpression to store a
   /// range of these.
   class ExprOperand {
     const uint64_t *Op;
@@ -2076,65 +2068,65 @@ public:
   bool isValid() const;
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDExpressionKind;
+    return MD->getMetadataID() == DIExpressionKind;
   }
 };
 
-class MDObjCProperty : public DebugNode {
+class DIObjCProperty : public DINode {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned Line;
   unsigned Attributes;
 
-  MDObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line,
+  DIObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line,
                  unsigned Attributes, ArrayRef<Metadata *> Ops)
-      : DebugNode(C, MDObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property,
-                  Ops),
+      : DINode(C, DIObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property,
+               Ops),
         Line(Line), Attributes(Attributes) {}
-  ~MDObjCProperty() = default;
+  ~DIObjCProperty() = default;
 
-  static MDObjCProperty *
-  getImpl(LLVMContext &Context, StringRef Name, MDFile *File, unsigned Line,
+  static DIObjCProperty *
+  getImpl(LLVMContext &Context, StringRef Name, DIFile *File, unsigned Line,
           StringRef GetterName, StringRef SetterName, unsigned Attributes,
-          MDType *Type, StorageType Storage, bool ShouldCreate = true) {
+          DIType *Type, StorageType Storage, bool ShouldCreate = true) {
     return getImpl(Context, getCanonicalMDString(Context, Name), File, Line,
                    getCanonicalMDString(Context, GetterName),
                    getCanonicalMDString(Context, SetterName), Attributes, Type,
                    Storage, ShouldCreate);
   }
-  static MDObjCProperty *getImpl(LLVMContext &Context, MDString *Name,
+  static DIObjCProperty *getImpl(LLVMContext &Context, MDString *Name,
                                  Metadata *File, unsigned Line,
                                  MDString *GetterName, MDString *SetterName,
                                  unsigned Attributes, Metadata *Type,
                                  StorageType Storage, bool ShouldCreate = true);
 
-  TempMDObjCProperty cloneImpl() const {
+  TempDIObjCProperty cloneImpl() const {
     return getTemporary(getContext(), getName(), getFile(), getLine(),
                         getGetterName(), getSetterName(), getAttributes(),
                         getType());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDObjCProperty,
-                    (StringRef Name, MDFile *File, unsigned Line,
+  DEFINE_MDNODE_GET(DIObjCProperty,
+                    (StringRef Name, DIFile *File, unsigned Line,
                      StringRef GetterName, StringRef SetterName,
-                     unsigned Attributes, MDType *Type),
+                     unsigned Attributes, DIType *Type),
                     (Name, File, Line, GetterName, SetterName, Attributes,
                      Type))
-  DEFINE_MDNODE_GET(MDObjCProperty,
+  DEFINE_MDNODE_GET(DIObjCProperty,
                     (MDString * Name, Metadata *File, unsigned Line,
                      MDString *GetterName, MDString *SetterName,
                      unsigned Attributes, Metadata *Type),
                     (Name, File, Line, GetterName, SetterName, Attributes,
                      Type))
 
-  TempMDObjCProperty clone() const { return cloneImpl(); }
+  TempDIObjCProperty clone() const { return cloneImpl(); }
 
   unsigned getLine() const { return Line; }
   unsigned getAttributes() const { return Attributes; }
   StringRef getName() const { return getStringOperand(0); }
-  MDFile *getFile() const { return cast_or_null<MDFile>(getRawFile()); }
+  DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
   StringRef getGetterName() const { return getStringOperand(2); }
   StringRef getSetterName() const { return getStringOperand(3); }
 
@@ -2142,7 +2134,7 @@ public:
   ///
   /// \note Objective-C doesn't have an ODR, so there is no benefit in storing
   /// a type ref here.
-  MDType *getType() const { return cast_or_null<MDType>(getRawType()); }
+  DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
 
   StringRef getFilename() const {
     if (auto *F = getFile())
@@ -2162,56 +2154,56 @@ public:
   Metadata *getRawType() const { return getOperand(4); }
 
   static bool classof(const Metadata *MD) {
-    return MD->getMetadataID() == MDObjCPropertyKind;
+    return MD->getMetadataID() == DIObjCPropertyKind;
   }
 };
 
 /// \brief An imported module (C++ using directive or similar).
-class MDImportedEntity : public DebugNode {
+class DIImportedEntity : public DINode {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned Line;
 
-  MDImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag,
+  DIImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag,
                    unsigned Line, ArrayRef<Metadata *> Ops)
-      : DebugNode(C, MDImportedEntityKind, Storage, Tag, Ops), Line(Line) {}
-  ~MDImportedEntity() = default;
+      : DINode(C, DIImportedEntityKind, Storage, Tag, Ops), Line(Line) {}
+  ~DIImportedEntity() = default;
 
-  static MDImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
-                                   MDScope *Scope, DebugNodeRef Entity,
+  static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
+                                   DIScope *Scope, DINodeRef Entity,
                                    unsigned Line, StringRef Name,
                                    StorageType Storage,
                                    bool ShouldCreate = true) {
     return getImpl(Context, Tag, Scope, Entity, Line,
                    getCanonicalMDString(Context, Name), Storage, ShouldCreate);
   }
-  static MDImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
+  static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
                                    Metadata *Scope, Metadata *Entity,
                                    unsigned Line, MDString *Name,
                                    StorageType Storage,
                                    bool ShouldCreate = true);
 
-  TempMDImportedEntity cloneImpl() const {
+  TempDIImportedEntity cloneImpl() const {
     return getTemporary(getContext(), getTag(), getScope(), getEntity(),
                         getLine(), getName());
   }
 
 public:
-  DEFINE_MDNODE_GET(MDImportedEntity,
-                    (unsigned Tag, MDScope *Scope, DebugNodeRef Entity,
+  DEFINE_MDNODE_GET(DIImportedEntity,
+                    (unsigned Tag, DIScope *Scope, DINodeRef Entity,
                      unsigned Line, StringRef Name = ""),
                     (Tag, Scope, Entity, Line, Name))
-  DEFINE_MDNODE_GET(MDImportedEntity,
+  DEFINE_MDNODE_GET(DIImportedEntity,
                     (unsigned Tag, Metadata *Scope, Metadata *Entity,
                      unsigned Line, MDString *Name),
                     (Tag, Scope, Entity, Line, Name))
 
-  TempMDImportedEntity clone() const { return cloneImpl(); }
<