[DebugInfo] Move all DWARF headers to the public include directory.

[friss]

Summary

dsymutil needs access to DWARF specific inforamtion, the small DIContext
wrapper isn't sufficient. Other DWARF consumers might want to use it too
(I'm looking at you lldb).

I have discussed that briefly with David at the dev meeting, it seemed
OK.

[dblaikie]

Fine by me - happy to discuss it with Alexey & Eric post-commit if there's anything more to consider.

[echristo]

Nah. Go ahead.

include/llvm/DebugInfo/DWARFAbbreviationDeclaration.h

 //===-- DWARFAbbreviationDeclaration.h --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFABBREVIATIONDECLARATION_H
 #define LLVM_LIB_DEBUGINFO_DWARFABBREVIATIONDECLARATION_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/DataExtractor.h"
 
 namespace llvm {
 
 class raw_ostream;
 
 class DWARFAbbreviationDeclaration {
   uint32_t Code;
   uint32_t Tag;
   bool HasChildren;
 
   struct AttributeSpec {
     AttributeSpec(uint16_t Attr, uint16_t Form) : Attr(Attr), Form(Form) {}
     uint16_t Attr;
     uint16_t Form;
   };
   typedef SmallVector<AttributeSpec, 8> AttributeSpecVector;
   AttributeSpecVector AttributeSpecs;
 public:
   DWARFAbbreviationDeclaration();
 
   uint32_t getCode() const { return Code; }
   uint32_t getTag() const { return Tag; }
   bool hasChildren() const { return HasChildren; }
 
   typedef iterator_range<AttributeSpecVector::const_iterator>
   attr_iterator_range;
 
   attr_iterator_range attributes() const {
     return attr_iterator_range(AttributeSpecs.begin(), AttributeSpecs.end());
   }
 
   uint16_t getFormByIndex(uint32_t idx) const {
     return idx < AttributeSpecs.size() ? AttributeSpecs[idx].Form : 0;
   }
 
   uint32_t findAttributeIndex(uint16_t attr) const;
   bool extract(DataExtractor Data, uint32_t* OffsetPtr);
   void dump(raw_ostream &OS) const;
 
 private:
   void clear();
 };
 
 }
 
 #endif

include/llvm/DebugInfo/DWARFAcceleratorTable.h

 //===--- DWARFAcceleratorTable.h --------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFRelocMap.h"
+#include "llvm/DebugInfo/DWARFRelocMap.h"
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/DWARFFormValue.h"
 
 #include <cstdint>
 
 namespace llvm {
 

include/llvm/DebugInfo/DWARFCompileUnit.h

 //===-- DWARFCompileUnit.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFCOMPILEUNIT_H
 #define LLVM_LIB_DEBUGINFO_DWARFCOMPILEUNIT_H
 
-#include "DWARFUnit.h"
+#include "llvm/DebugInfo/DWARFUnit.h"
 
 namespace llvm {
 
 class DWARFCompileUnit : public DWARFUnit {
 public:
   DWARFCompileUnit(DWARFContext &Context, const DWARFSection &Section,
                    const DWARFDebugAbbrev *DA, StringRef RS, StringRef SS,
                    StringRef SOS, StringRef AOS, bool LE,

include/llvm/DebugInfo/DWARFContext.h

 //===-- DWARFContext.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===/
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFCONTEXT_H
 #define LLVM_LIB_DEBUGINFO_DWARFCONTEXT_H
 
-#include "DWARFCompileUnit.h"
-#include "DWARFDebugAranges.h"
-#include "DWARFDebugFrame.h"
-#include "DWARFDebugLine.h"
-#include "DWARFDebugLoc.h"
-#include "DWARFDebugRangeList.h"
-#include "DWARFSection.h"
-#include "DWARFTypeUnit.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/DebugInfo/DWARFCompileUnit.h"
+#include "llvm/DebugInfo/DWARFDebugAranges.h"
+#include "llvm/DebugInfo/DWARFDebugFrame.h"
+#include "llvm/DebugInfo/DWARFDebugLine.h"
+#include "llvm/DebugInfo/DWARFDebugLoc.h"
+#include "llvm/DebugInfo/DWARFDebugRangeList.h"
+#include "llvm/DebugInfo/DWARFSection.h"
+#include "llvm/DebugInfo/DWARFTypeUnit.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include <vector>
 
 namespace llvm {
 
 /// DWARFContext
 /// This data structure is the top level entity that deals with dwarf debug
 /// information parsing. The actual data is supplied through pure virtual

include/llvm/DebugInfo/DWARFDebugAbbrev.h

 //===-- DWARFDebugAbbrev.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFDEBUGABBREV_H
 #define LLVM_LIB_DEBUGINFO_DWARFDEBUGABBREV_H
 
-#include "DWARFAbbreviationDeclaration.h"
+#include "llvm/DebugInfo/DWARFAbbreviationDeclaration.h"
 #include <list>
 #include <map>
 #include <vector>
 
 namespace llvm {
 
 class DWARFAbbreviationDeclarationSet {
   uint32_t Offset;

include/llvm/DebugInfo/DWARFDebugArangeSet.h

 //===-- DWARFDebugArangeSet.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFDEBUGARANGESET_H
 #define LLVM_LIB_DEBUGINFO_DWARFDEBUGARANGESET_H
 
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/DataExtractor.h"
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 
 class DWARFDebugArangeSet {
 public:
   struct Header {
     // The total length of the entries for that set, not including the length
     // field itself.
     uint32_t Length;
     // The offset from the beginning of the .debug_info section of the
     // compilation unit entry referenced by the table.
     uint32_t CuOffset;
     // The DWARF version number.
     uint16_t Version;
     // The size in bytes of an address on the target architecture. For segmented
     // addressing, this is the size of the offset portion of the address.
     uint8_t AddrSize;
     // The size in bytes of a segment descriptor on the target architecture.
     // If the target system uses a flat address space, this value is 0.
     uint8_t SegSize;
   };
 
   struct Descriptor {
     uint64_t Address;
     uint64_t Length;
     uint64_t getEndAddress() const { return Address + Length; }
   };
 
 private:
   typedef std::vector<Descriptor> DescriptorColl;
   typedef iterator_range<DescriptorColl::const_iterator> desc_iterator_range;
 
   uint32_t Offset;
   Header HeaderData;
   DescriptorColl ArangeDescriptors;
 
 public:
   DWARFDebugArangeSet() { clear(); }
   void clear();
   bool extract(DataExtractor data, uint32_t *offset_ptr);
   void dump(raw_ostream &OS) const;
 
   uint32_t getCompileUnitDIEOffset() const { return HeaderData.CuOffset; }
 
   desc_iterator_range descriptors() const {
     return desc_iterator_range(ArangeDescriptors.begin(),
                                ArangeDescriptors.end());
   }
 };
 
 }
 
 #endif

include/llvm/DebugInfo/DWARFDebugAranges.h

 //===-- DWARFDebugAranges.h -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFDEBUGARANGES_H
 #define LLVM_LIB_DEBUGINFO_DWARFDEBUGARANGES_H
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/DataExtractor.h"
 #include <vector>
 
 namespace llvm {
 
 class DWARFContext;
 
 class DWARFDebugAranges {
 public:
   void generate(DWARFContext *CTX);
   uint32_t findAddress(uint64_t Address) const;
 
 private:
   void clear();
   void extract(DataExtractor DebugArangesData);
 
   // Call appendRange multiple times and then call construct.
   void appendRange(uint32_t CUOffset, uint64_t LowPC, uint64_t HighPC);
   void construct();
 
   struct Range {
     explicit Range(uint64_t LowPC = -1ULL, uint64_t HighPC = -1ULL,
                    uint32_t CUOffset = -1U)
       : LowPC(LowPC), Length(HighPC - LowPC), CUOffset(CUOffset) {}
 
     void setHighPC(uint64_t HighPC) {
       if (HighPC == -1ULL || HighPC <= LowPC)
         Length = 0;
       else
         Length = HighPC - LowPC;
     }
     uint64_t HighPC() const {
       if (Length)
         return LowPC + Length;
       return -1ULL;
     }
 
     bool containsAddress(uint64_t Address) const {
       return LowPC <= Address && Address < HighPC();
     }
     bool operator<(const Range &other) const {
       return LowPC < other.LowPC;
     }
 
     uint64_t LowPC; // Start of address range.
     uint32_t Length; // End of address range (not including this address).
     uint32_t CUOffset; // Offset of the compile unit or die.
   };
 
   struct RangeEndpoint {
     uint64_t Address;
     uint32_t CUOffset;
     bool IsRangeStart;
 
     RangeEndpoint(uint64_t Address, uint32_t CUOffset, bool IsRangeStart)
         : Address(Address), CUOffset(CUOffset), IsRangeStart(IsRangeStart) {}
 
     bool operator<(const RangeEndpoint &Other) const {
       return Address < Other.Address;
     }
   };
 
 
   typedef std::vector<Range>              RangeColl;
   typedef RangeColl::const_iterator       RangeCollIterator;
 
   std::vector<RangeEndpoint> Endpoints;
   RangeColl Aranges;
   DenseSet<uint32_t> ParsedCUOffsets;
 };
 
 }
 
 #endif

include/llvm/DebugInfo/DWARFDebugFrame.h

 //===-- DWARFDebugFrame.h - Parsing of .debug_frame -------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFDEBUGFRAME_H
 #define LLVM_LIB_DEBUGINFO_DWARFDEBUGFRAME_H
 
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 #include <vector>
 
 namespace llvm {
 
 class FrameEntry;
 
 /// \brief A parsed .debug_frame section
 ///
 class DWARFDebugFrame {
 public:
   DWARFDebugFrame();
   ~DWARFDebugFrame();
 
   /// \brief Dump the section data into the given stream.
   void dump(raw_ostream &OS) const;
 
   /// \brief Parse the section from raw data.
   /// data is assumed to be pointing to the beginning of the section.
   void parse(DataExtractor Data);
 
 private:
   std::vector<std::unique_ptr<FrameEntry>> Entries;
 };
 
 
 } // namespace llvm
 
 #endif

include/llvm/DebugInfo/DWARFDebugInfoEntry.h

 //===-- DWARFDebugInfoEntry.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFDEBUGINFOENTRY_H
 #define LLVM_LIB_DEBUGINFO_DWARFDEBUGINFOENTRY_H
 
-#include "DWARFAbbreviationDeclaration.h"
-#include "DWARFDebugRangeList.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/DIContext.h"
+#include "llvm/DebugInfo/DWARFAbbreviationDeclaration.h"
+#include "llvm/DebugInfo/DWARFDebugRangeList.h"
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
 
 class DWARFDebugAranges;
 class DWARFCompileUnit;
 class DWARFUnit;
 class DWARFContext;

include/llvm/DebugInfo/DWARFDebugLine.h

 //===-- DWARFDebugLine.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFDEBUGLINE_H
 #define LLVM_LIB_DEBUGINFO_DWARFDEBUGLINE_H
 
-#include "DWARFRelocMap.h"
 #include "llvm/DebugInfo/DIContext.h"
+#include "llvm/DebugInfo/DWARFRelocMap.h"
 #include "llvm/Support/DataExtractor.h"
 #include <map>
 #include <string>
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;

include/llvm/DebugInfo/DWARFDebugLoc.h

 //===-- DWARFDebugLoc.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFDEBUGLOC_H
 #define LLVM_LIB_DEBUGINFO_DWARFDEBUGLOC_H
 
-#include "DWARFRelocMap.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/DebugInfo/DWARFRelocMap.h"
 #include "llvm/Support/DataExtractor.h"
 
 namespace llvm {
 
 class raw_ostream;
 
 class DWARFDebugLoc {
   /// A single location within a location list.

include/llvm/DebugInfo/DWARFDebugRangeList.h

 //===-- DWARFDebugRangeList.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFDEBUGRANGELIST_H
 #define LLVM_LIB_DEBUGINFO_DWARFDEBUGRANGELIST_H
 
 #include "llvm/Support/DataExtractor.h"
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 
 /// DWARFAddressRangesVector - represents a set of absolute address ranges.
 typedef std::vector<std::pair<uint64_t, uint64_t>> DWARFAddressRangesVector;
 
 class DWARFDebugRangeList {
 public:
   struct RangeListEntry {
     // A beginning address offset. This address offset has the size of an
     // address and is relative to the applicable base address of the
     // compilation unit referencing this range list. It marks the beginning
     // of an address range.
     uint64_t StartAddress;
     // An ending address offset. This address offset again has the size of
     // an address and is relative to the applicable base address of the
     // compilation unit referencing this range list. It marks the first
     // address past the end of the address range. The ending address must
     // be greater than or equal to the beginning address.
     uint64_t EndAddress;
     // The end of any given range list is marked by an end of list entry,
     // which consists of a 0 for the beginning address offset
     // and a 0 for the ending address offset.
     bool isEndOfListEntry() const {
       return (StartAddress == 0) && (EndAddress == 0);
     }
     // A base address selection entry consists of:
     // 1. The value of the largest representable address offset
     // (for example, 0xffffffff when the size of an address is 32 bits).
     // 2. An address, which defines the appropriate base address for
     // use in interpreting the beginning and ending address offsets of
     // subsequent entries of the location list.
     bool isBaseAddressSelectionEntry(uint8_t AddressSize) const {
       assert(AddressSize == 4 || AddressSize == 8);
       if (AddressSize == 4)
         return StartAddress == -1U;
       else
         return StartAddress == -1ULL;
     }
   };
 
 private:
   // Offset in .debug_ranges section.
   uint32_t Offset;
   uint8_t AddressSize;
   std::vector<RangeListEntry> Entries;
 
 public:
   DWARFDebugRangeList() { clear(); }
   void clear();
   void dump(raw_ostream &OS) const;
   bool extract(DataExtractor data, uint32_t *offset_ptr);
   /// getAbsoluteRanges - Returns absolute address ranges defined by this range
   /// list. Has to be passed base address of the compile unit referencing this
   /// range list.
   DWARFAddressRangesVector getAbsoluteRanges(uint64_t BaseAddress) const;
 };
 
 }  // namespace llvm
 
 #endif  // LLVM_DEBUGINFO_DWARFDEBUGRANGELIST_H

include/llvm/DebugInfo/DWARFRelocMap.h

 //===-- DWARFRelocMap.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFRELOCMAP_H
 #define LLVM_LIB_DEBUGINFO_DWARFRELOCMAP_H
 
 #include "llvm/ADT/DenseMap.h"
 
 namespace llvm {
 
 typedef DenseMap<uint64_t, std::pair<uint8_t, int64_t> > RelocAddrMap;
 
 } // namespace llvm
 
 #endif
 

include/llvm/DebugInfo/DWARFSection.h

 //===-- DWARFSection.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFSECTION_H
 #define LLVM_LIB_DEBUGINFO_DWARFSECTION_H
 
-#include "DWARFRelocMap.h"
+#include "llvm/DebugInfo/DWARFRelocMap.h"
 
 namespace llvm {
 
 struct DWARFSection {
   StringRef Data;
   RelocAddrMap Relocs;
 };
 
 }
 
 #endif

include/llvm/DebugInfo/DWARFTypeUnit.h

 //===-- DWARFTypeUnit.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFTYPEUNIT_H
 #define LLVM_LIB_DEBUGINFO_DWARFTYPEUNIT_H
 
-#include "DWARFUnit.h"
+#include "llvm/DebugInfo/DWARFUnit.h"
 
 namespace llvm {
 
 class DWARFTypeUnit : public DWARFUnit {
 private:
   uint64_t TypeHash;
   uint32_t TypeOffset;
 public:

include/llvm/DebugInfo/DWARFUnit.h

 //===-- DWARFUnit.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFUNIT_H
 #define LLVM_LIB_DEBUGINFO_DWARFUNIT_H
 
-#include "DWARFDebugAbbrev.h"
-#include "DWARFDebugInfoEntry.h"
-#include "DWARFDebugRangeList.h"
-#include "DWARFRelocMap.h"
-#include "DWARFSection.h"
+#include "llvm/DebugInfo/DWARFDebugAbbrev.h"
+#include "llvm/DebugInfo/DWARFDebugInfoEntry.h"
+#include "llvm/DebugInfo/DWARFDebugRangeList.h"
+#include "llvm/DebugInfo/DWARFRelocMap.h"
+#include "llvm/DebugInfo/DWARFSection.h"
 #include <vector>
 
 namespace llvm {
 
 namespace object {
 class ObjectFile;
 }
 

lib/DebugInfo/DIContext.cpp

 //===-- DIContext.cpp -----------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DIContext.h"
-#include "DWARFContext.h"
+#include "llvm/DebugInfo/DWARFContext.h"
 using namespace llvm;
 
 DIContext::~DIContext() {}
 
 DIContext *DIContext::getDWARFContext(const object::ObjectFile &Obj) {
   return new DWARFContextInMemory(Obj);
 }

lib/DebugInfo/DWARFAbbreviationDeclaration.cpp

 //===-- DWARFAbbreviationDeclaration.cpp ----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFAbbreviationDeclaration.h"
+#include "llvm/DebugInfo/DWARFAbbreviationDeclaration.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 using namespace dwarf;
 
 void DWARFAbbreviationDeclaration::clear() {
   Code = 0;

lib/DebugInfo/DWARFAcceleratorTable.cpp

 //===--- DWARFAcceleratorTable.cpp ----------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFAcceleratorTable.h"
+#include "llvm/DebugInfo/DWARFAcceleratorTable.h"
 
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
 bool DWARFAcceleratorTable::extract() {

lib/DebugInfo/DWARFCompileUnit.cpp

 //===-- DWARFCompileUnit.cpp ----------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFCompileUnit.h"
+#include "llvm/DebugInfo/DWARFCompileUnit.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 void DWARFCompileUnit::dump(raw_ostream &OS) {
   OS << format("0x%08x", getOffset()) << ": Compile Unit:"
      << " length = " << format("0x%08x", getLength())

lib/DebugInfo/DWARFContext.cpp

 //===-- DWARFContext.cpp --------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFContext.h"
-#include "DWARFDebugArangeSet.h"
-#include "DWARFAcceleratorTable.h"
+#include "llvm/DebugInfo/DWARFContext.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/DebugInfo/DWARFDebugArangeSet.h"
+#include "llvm/DebugInfo/DWARFAcceleratorTable.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 using namespace llvm;
 using namespace dwarf;

lib/DebugInfo/DWARFDebugAbbrev.cpp

 //===-- DWARFDebugAbbrev.cpp ----------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFDebugAbbrev.h"
+#include "llvm/DebugInfo/DWARFDebugAbbrev.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 DWARFAbbreviationDeclarationSet::DWARFAbbreviationDeclarationSet() {
   clear();
 }
 

lib/DebugInfo/DWARFDebugArangeSet.cpp

 //===-- DWARFDebugArangeSet.cpp -------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFDebugArangeSet.h"
+#include "llvm/DebugInfo/DWARFDebugArangeSet.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 using namespace llvm;
 
 void DWARFDebugArangeSet::clear() {
   Offset = -1U;

lib/DebugInfo/DWARFDebugAranges.cpp

 //===-- DWARFDebugAranges.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFDebugAranges.h"
-#include "DWARFCompileUnit.h"
-#include "DWARFContext.h"
-#include "DWARFDebugArangeSet.h"
+#include "llvm/DebugInfo/DWARFDebugAranges.h"
+#include "llvm/DebugInfo/DWARFCompileUnit.h"
+#include "llvm/DebugInfo/DWARFContext.h"
+#include "llvm/DebugInfo/DWARFDebugArangeSet.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <set>
 using namespace llvm;
 
 void DWARFDebugAranges::extract(DataExtractor DebugArangesData) {

lib/DebugInfo/DWARFDebugFrame.cpp

 //===-- DWARFDebugFrame.h - Parsing of .debug_frame -------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFDebugFrame.h"
+#include "llvm/DebugInfo/DWARFDebugFrame.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <string>
 #include <vector>

lib/DebugInfo/DWARFDebugInfoEntry.cpp

 //===-- DWARFDebugInfoEntry.cpp -------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFDebugInfoEntry.h"
-#include "DWARFCompileUnit.h"
-#include "DWARFContext.h"
-#include "DWARFDebugAbbrev.h"
+#include "llvm/DebugInfo/DWARFDebugInfoEntry.h"
+#include "llvm/DebugInfo/DWARFCompileUnit.h"
+#include "llvm/DebugInfo/DWARFContext.h"
+#include "llvm/DebugInfo/DWARFDebugAbbrev.h"
 #include "llvm/DebugInfo/DWARFFormValue.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 using namespace dwarf;

lib/DebugInfo/DWARFDebugLine.cpp

 //===-- DWARFDebugLine.cpp ------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFDebugLine.h"
+#include "llvm/DebugInfo/DWARFDebugLine.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 using namespace llvm;
 using namespace dwarf;
 typedef DILineInfoSpecifier::FileLineInfoKind FileLineInfoKind;

lib/DebugInfo/DWARFDebugLoc.cpp

 //===-- DWARFDebugLoc.cpp -------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFDebugLoc.h"
+#include "llvm/DebugInfo/DWARFDebugLoc.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/Dwarf.h"
 
 using namespace llvm;
 
 void DWARFDebugLoc::dump(raw_ostream &OS) const {

lib/DebugInfo/DWARFDebugRangeList.cpp

 //===-- DWARFDebugRangesList.cpp ------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFDebugRangeList.h"
+#include "llvm/DebugInfo/DWARFDebugRangeList.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 void DWARFDebugRangeList::clear() {
   Offset = -1U;
   AddressSize = 0;

lib/DebugInfo/DWARFFormValue.cpp

 //===-- DWARFFormValue.cpp ------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARFFormValue.h"
-#include "DWARFCompileUnit.h"
-#include "DWARFContext.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/DWARFCompileUnit.h"
+#include "llvm/DebugInfo/DWARFContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 using namespace llvm;
 using namespace dwarf;
 

lib/DebugInfo/DWARFTypeUnit.cpp

 //===-- DWARFTypeUnit.cpp -------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFTypeUnit.h"
+#include "llvm/DebugInfo/DWARFTypeUnit.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 bool DWARFTypeUnit::extractImpl(DataExtractor debug_info,
                                 uint32_t *offset_ptr) {
   if (!DWARFUnit::extractImpl(debug_info, offset_ptr))

lib/DebugInfo/DWARFUnit.cpp

 //===-- DWARFUnit.cpp -----------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DWARFUnit.h"
-#include "DWARFContext.h"
+#include "llvm/DebugInfo/DWARFUnit.h"
+#include "llvm/DebugInfo/DWARFContext.h"
 #include "llvm/DebugInfo/DWARFFormValue.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Path.h"
 #include <cstdio>
 
 using namespace llvm;
 using namespace dwarf;