Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 1 of 2.

1 files changed, 1647 insertions, 1647 deletions

diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
index 118b5fcc3b..d5f6a03686 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
@@ -1,691 +1,691 @@
-//===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains support for constructing a dwarf compile unit.
-//
-//===----------------------------------------------------------------------===//
-
-#include "DwarfUnit.h"
-#include "AddressPool.h"
-#include "DwarfCompileUnit.h"
-#include "DwarfExpression.h"
-#include "llvm/ADT/APFloat.h"
-#include "llvm/ADT/APInt.h"
-#include "llvm/ADT/None.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/ADT/iterator_range.h"
-#include "llvm/CodeGen/MachineFunction.h"
-#include "llvm/CodeGen/MachineOperand.h"
-#include "llvm/CodeGen/TargetRegisterInfo.h"
-#include "llvm/CodeGen/TargetSubtargetInfo.h"
-#include "llvm/IR/Constants.h"
-#include "llvm/IR/DataLayout.h"
-#include "llvm/IR/GlobalValue.h"
-#include "llvm/IR/Metadata.h"
-#include "llvm/MC/MCAsmInfo.h"
-#include "llvm/MC/MCContext.h"
-#include "llvm/MC/MCDwarf.h"
-#include "llvm/MC/MCSection.h"
-#include "llvm/MC/MCStreamer.h"
-#include "llvm/MC/MachineLocation.h"
-#include "llvm/Support/Casting.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Target/TargetLoweringObjectFile.h"
-#include <cassert>
-#include <cstdint>
-#include <string>
-#include <utility>
-
-using namespace llvm;
-
-#define DEBUG_TYPE "dwarfdebug"
-
-DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP,
-                                       DwarfCompileUnit &CU, DIELoc &DIE)
-    : DwarfExpression(AP.getDwarfVersion(), CU), AP(AP), OutDIE(DIE) {}
-
-void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) {
-  CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1, Op);
-}
-
-void DIEDwarfExpression::emitSigned(int64_t Value) {
-  CU.addSInt(getActiveDIE(), dwarf::DW_FORM_sdata, Value);
-}
-
-void DIEDwarfExpression::emitUnsigned(uint64_t Value) {
-  CU.addUInt(getActiveDIE(), dwarf::DW_FORM_udata, Value);
-}
-
-void DIEDwarfExpression::emitData1(uint8_t Value) {
-  CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1, Value);
-}
-
-void DIEDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
-  CU.addBaseTypeRef(getActiveDIE(), Idx);
-}
-
-void DIEDwarfExpression::enableTemporaryBuffer() {
-  assert(!IsBuffering && "Already buffering?");
-  IsBuffering = true;
-}
-
-void DIEDwarfExpression::disableTemporaryBuffer() { IsBuffering = false; }
-
-unsigned DIEDwarfExpression::getTemporaryBufferSize() {
-  return TmpDIE.ComputeSize(&AP);
-}
-
-void DIEDwarfExpression::commitTemporaryBuffer() { OutDIE.takeValues(TmpDIE); }
-
-bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
+//===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===// 
+// 
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
+// See https://llvm.org/LICENSE.txt for license information. 
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
+// 
+//===----------------------------------------------------------------------===// 
+// 
+// This file contains support for constructing a dwarf compile unit. 
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#include "DwarfUnit.h" 
+#include "AddressPool.h" 
+#include "DwarfCompileUnit.h" 
+#include "DwarfExpression.h" 
+#include "llvm/ADT/APFloat.h" 
+#include "llvm/ADT/APInt.h" 
+#include "llvm/ADT/None.h" 
+#include "llvm/ADT/StringExtras.h" 
+#include "llvm/ADT/iterator_range.h" 
+#include "llvm/CodeGen/MachineFunction.h" 
+#include "llvm/CodeGen/MachineOperand.h" 
+#include "llvm/CodeGen/TargetRegisterInfo.h" 
+#include "llvm/CodeGen/TargetSubtargetInfo.h" 
+#include "llvm/IR/Constants.h" 
+#include "llvm/IR/DataLayout.h" 
+#include "llvm/IR/GlobalValue.h" 
+#include "llvm/IR/Metadata.h" 
+#include "llvm/MC/MCAsmInfo.h" 
+#include "llvm/MC/MCContext.h" 
+#include "llvm/MC/MCDwarf.h" 
+#include "llvm/MC/MCSection.h" 
+#include "llvm/MC/MCStreamer.h" 
+#include "llvm/MC/MachineLocation.h" 
+#include "llvm/Support/Casting.h" 
+#include "llvm/Support/CommandLine.h" 
+#include "llvm/Target/TargetLoweringObjectFile.h" 
+#include <cassert> 
+#include <cstdint> 
+#include <string> 
+#include <utility> 
+ 
+using namespace llvm; 
+ 
+#define DEBUG_TYPE "dwarfdebug" 
+ 
+DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP, 
+                                       DwarfCompileUnit &CU, DIELoc &DIE) 
+    : DwarfExpression(AP.getDwarfVersion(), CU), AP(AP), OutDIE(DIE) {} 
+ 
+void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) { 
+  CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1, Op); 
+} 
+ 
+void DIEDwarfExpression::emitSigned(int64_t Value) { 
+  CU.addSInt(getActiveDIE(), dwarf::DW_FORM_sdata, Value); 
+} 
+ 
+void DIEDwarfExpression::emitUnsigned(uint64_t Value) { 
+  CU.addUInt(getActiveDIE(), dwarf::DW_FORM_udata, Value); 
+} 
+ 
+void DIEDwarfExpression::emitData1(uint8_t Value) { 
+  CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1, Value); 
+} 
+ 
+void DIEDwarfExpression::emitBaseTypeRef(uint64_t Idx) { 
+  CU.addBaseTypeRef(getActiveDIE(), Idx); 
+} 
+ 
+void DIEDwarfExpression::enableTemporaryBuffer() { 
+  assert(!IsBuffering && "Already buffering?"); 
+  IsBuffering = true; 
+} 
+ 
+void DIEDwarfExpression::disableTemporaryBuffer() { IsBuffering = false; } 
+ 
+unsigned DIEDwarfExpression::getTemporaryBufferSize() { 
+  return TmpDIE.ComputeSize(&AP); 
+} 
+ 
+void DIEDwarfExpression::commitTemporaryBuffer() { OutDIE.takeValues(TmpDIE); } 
+ 
+bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI, 
                                          llvm::Register MachineReg) {
-  return MachineReg == TRI.getFrameRegister(*AP.MF);
-}
-
-DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node,
-                     AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
+  return MachineReg == TRI.getFrameRegister(*AP.MF); 
+} 
+ 
+DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node, 
+                     AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU) 
     : DIEUnit(UnitTag), CUNode(Node), Asm(A), DD(DW), DU(DWU),
       IndexTyDie(nullptr) {}
-
-DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
-                             DwarfDebug *DW, DwarfFile *DWU,
-                             MCDwarfDwoLineTable *SplitLineTable)
-    : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU),
-      SplitLineTable(SplitLineTable) {
-}
-
-DwarfUnit::~DwarfUnit() {
-  for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
-    DIEBlocks[j]->~DIEBlock();
-  for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
-    DIELocs[j]->~DIELoc();
-}
-
-int64_t DwarfUnit::getDefaultLowerBound() const {
-  switch (getLanguage()) {
-  default:
-    break;
-
-  // The languages below have valid values in all DWARF versions.
-  case dwarf::DW_LANG_C:
-  case dwarf::DW_LANG_C89:
-  case dwarf::DW_LANG_C_plus_plus:
-    return 0;
-
-  case dwarf::DW_LANG_Fortran77:
-  case dwarf::DW_LANG_Fortran90:
-    return 1;
-
-  // The languages below have valid values only if the DWARF version >= 3.
-  case dwarf::DW_LANG_C99:
-  case dwarf::DW_LANG_ObjC:
-  case dwarf::DW_LANG_ObjC_plus_plus:
-    if (DD->getDwarfVersion() >= 3)
-      return 0;
-    break;
-
-  case dwarf::DW_LANG_Fortran95:
-    if (DD->getDwarfVersion() >= 3)
-      return 1;
-    break;
-
-  // Starting with DWARF v4, all defined languages have valid values.
-  case dwarf::DW_LANG_D:
-  case dwarf::DW_LANG_Java:
-  case dwarf::DW_LANG_Python:
-  case dwarf::DW_LANG_UPC:
-    if (DD->getDwarfVersion() >= 4)
-      return 0;
-    break;
-
-  case dwarf::DW_LANG_Ada83:
-  case dwarf::DW_LANG_Ada95:
-  case dwarf::DW_LANG_Cobol74:
-  case dwarf::DW_LANG_Cobol85:
-  case dwarf::DW_LANG_Modula2:
-  case dwarf::DW_LANG_Pascal83:
-  case dwarf::DW_LANG_PLI:
-    if (DD->getDwarfVersion() >= 4)
-      return 1;
-    break;
-
-  // The languages below are new in DWARF v5.
-  case dwarf::DW_LANG_BLISS:
-  case dwarf::DW_LANG_C11:
-  case dwarf::DW_LANG_C_plus_plus_03:
-  case dwarf::DW_LANG_C_plus_plus_11:
-  case dwarf::DW_LANG_C_plus_plus_14:
-  case dwarf::DW_LANG_Dylan:
-  case dwarf::DW_LANG_Go:
-  case dwarf::DW_LANG_Haskell:
-  case dwarf::DW_LANG_OCaml:
-  case dwarf::DW_LANG_OpenCL:
-  case dwarf::DW_LANG_RenderScript:
-  case dwarf::DW_LANG_Rust:
-  case dwarf::DW_LANG_Swift:
-    if (DD->getDwarfVersion() >= 5)
-      return 0;
-    break;
-
-  case dwarf::DW_LANG_Fortran03:
-  case dwarf::DW_LANG_Fortran08:
-  case dwarf::DW_LANG_Julia:
-  case dwarf::DW_LANG_Modula3:
-    if (DD->getDwarfVersion() >= 5)
-      return 1;
-    break;
-  }
-
-  return -1;
-}
-
-/// Check whether the DIE for this MDNode can be shared across CUs.
-bool DwarfUnit::isShareableAcrossCUs(const DINode *D) const {
-  // When the MDNode can be part of the type system (this includes subprogram
-  // declarations *and* subprogram definitions, even local definitions), the
-  // DIE must be shared across CUs.
-  // Combining type units and cross-CU DIE sharing is lower value (since
-  // cross-CU DIE sharing is used in LTO and removes type redundancy at that
-  // level already) but may be implementable for some value in projects
-  // building multiple independent libraries with LTO and then linking those
-  // together.
-  if (isDwoUnit() && !DD->shareAcrossDWOCUs())
-    return false;
-  return (isa<DIType>(D) || isa<DISubprogram>(D)) && !DD->generateTypeUnits();
-}
-
-DIE *DwarfUnit::getDIE(const DINode *D) const {
-  if (isShareableAcrossCUs(D))
-    return DU->getDIE(D);
-  return MDNodeToDieMap.lookup(D);
-}
-
-void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
-  if (isShareableAcrossCUs(Desc)) {
-    DU->insertDIE(Desc, D);
-    return;
-  }
-  MDNodeToDieMap.insert(std::make_pair(Desc, D));
-}
-
-void DwarfUnit::insertDIE(DIE *D) {
-  MDNodeToDieMap.insert(std::make_pair(nullptr, D));
-}
-
-void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
-  if (DD->getDwarfVersion() >= 4)
-    Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag_present,
-                 DIEInteger(1));
-  else
-    Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag,
-                 DIEInteger(1));
-}
-
-void DwarfUnit::addUInt(DIEValueList &Die, dwarf::Attribute Attribute,
-                        Optional<dwarf::Form> Form, uint64_t Integer) {
-  if (!Form)
-    Form = DIEInteger::BestForm(false, Integer);
-  assert(Form != dwarf::DW_FORM_implicit_const &&
-         "DW_FORM_implicit_const is used only for signed integers");
-  Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
-}
-
-void DwarfUnit::addUInt(DIEValueList &Block, dwarf::Form Form,
-                        uint64_t Integer) {
-  addUInt(Block, (dwarf::Attribute)0, Form, Integer);
-}
-
-void DwarfUnit::addSInt(DIEValueList &Die, dwarf::Attribute Attribute,
-                        Optional<dwarf::Form> Form, int64_t Integer) {
-  if (!Form)
-    Form = DIEInteger::BestForm(true, Integer);
-  Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
-}
-
-void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
-                        int64_t Integer) {
-  addSInt(Die, (dwarf::Attribute)0, Form, Integer);
-}
-
-void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
-                          StringRef String) {
-  if (CUNode->isDebugDirectivesOnly())
-    return;
-
-  if (DD->useInlineStrings()) {
-    Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_string,
-                 new (DIEValueAllocator)
-                     DIEInlineString(String, DIEValueAllocator));
-    return;
-  }
-  dwarf::Form IxForm =
-      isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp;
-
-  auto StringPoolEntry =
-      useSegmentedStringOffsetsTable() || IxForm == dwarf::DW_FORM_GNU_str_index
-          ? DU->getStringPool().getIndexedEntry(*Asm, String)
-          : DU->getStringPool().getEntry(*Asm, String);
-
-  // For DWARF v5 and beyond, use the smallest strx? form possible.
-  if (useSegmentedStringOffsetsTable()) {
-    IxForm = dwarf::DW_FORM_strx1;
-    unsigned Index = StringPoolEntry.getIndex();
-    if (Index > 0xffffff)
-      IxForm = dwarf::DW_FORM_strx4;
-    else if (Index > 0xffff)
-      IxForm = dwarf::DW_FORM_strx3;
-    else if (Index > 0xff)
-      IxForm = dwarf::DW_FORM_strx2;
-  }
-  Die.addValue(DIEValueAllocator, Attribute, IxForm,
-               DIEString(StringPoolEntry));
-}
-
-DIEValueList::value_iterator DwarfUnit::addLabel(DIEValueList &Die,
-                                                 dwarf::Attribute Attribute,
-                                                 dwarf::Form Form,
-                                                 const MCSymbol *Label) {
-  return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label));
-}
-
-void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
-  addLabel(Die, (dwarf::Attribute)0, Form, Label);
-}
-
-void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
-                                 uint64_t Integer) {
+ 
+DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A, 
+                             DwarfDebug *DW, DwarfFile *DWU, 
+                             MCDwarfDwoLineTable *SplitLineTable) 
+    : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU), 
+      SplitLineTable(SplitLineTable) { 
+} 
+ 
+DwarfUnit::~DwarfUnit() { 
+  for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j) 
+    DIEBlocks[j]->~DIEBlock(); 
+  for (unsigned j = 0, M = DIELocs.size(); j < M; ++j) 
+    DIELocs[j]->~DIELoc(); 
+} 
+ 
+int64_t DwarfUnit::getDefaultLowerBound() const { 
+  switch (getLanguage()) { 
+  default: 
+    break; 
+ 
+  // The languages below have valid values in all DWARF versions. 
+  case dwarf::DW_LANG_C: 
+  case dwarf::DW_LANG_C89: 
+  case dwarf::DW_LANG_C_plus_plus: 
+    return 0; 
+ 
+  case dwarf::DW_LANG_Fortran77: 
+  case dwarf::DW_LANG_Fortran90: 
+    return 1; 
+ 
+  // The languages below have valid values only if the DWARF version >= 3. 
+  case dwarf::DW_LANG_C99: 
+  case dwarf::DW_LANG_ObjC: 
+  case dwarf::DW_LANG_ObjC_plus_plus: 
+    if (DD->getDwarfVersion() >= 3) 
+      return 0; 
+    break; 
+ 
+  case dwarf::DW_LANG_Fortran95: 
+    if (DD->getDwarfVersion() >= 3) 
+      return 1; 
+    break; 
+ 
+  // Starting with DWARF v4, all defined languages have valid values. 
+  case dwarf::DW_LANG_D: 
+  case dwarf::DW_LANG_Java: 
+  case dwarf::DW_LANG_Python: 
+  case dwarf::DW_LANG_UPC: 
+    if (DD->getDwarfVersion() >= 4) 
+      return 0; 
+    break; 
+ 
+  case dwarf::DW_LANG_Ada83: 
+  case dwarf::DW_LANG_Ada95: 
+  case dwarf::DW_LANG_Cobol74: 
+  case dwarf::DW_LANG_Cobol85: 
+  case dwarf::DW_LANG_Modula2: 
+  case dwarf::DW_LANG_Pascal83: 
+  case dwarf::DW_LANG_PLI: 
+    if (DD->getDwarfVersion() >= 4) 
+      return 1; 
+    break; 
+ 
+  // The languages below are new in DWARF v5. 
+  case dwarf::DW_LANG_BLISS: 
+  case dwarf::DW_LANG_C11: 
+  case dwarf::DW_LANG_C_plus_plus_03: 
+  case dwarf::DW_LANG_C_plus_plus_11: 
+  case dwarf::DW_LANG_C_plus_plus_14: 
+  case dwarf::DW_LANG_Dylan: 
+  case dwarf::DW_LANG_Go: 
+  case dwarf::DW_LANG_Haskell: 
+  case dwarf::DW_LANG_OCaml: 
+  case dwarf::DW_LANG_OpenCL: 
+  case dwarf::DW_LANG_RenderScript: 
+  case dwarf::DW_LANG_Rust: 
+  case dwarf::DW_LANG_Swift: 
+    if (DD->getDwarfVersion() >= 5) 
+      return 0; 
+    break; 
+ 
+  case dwarf::DW_LANG_Fortran03: 
+  case dwarf::DW_LANG_Fortran08: 
+  case dwarf::DW_LANG_Julia: 
+  case dwarf::DW_LANG_Modula3: 
+    if (DD->getDwarfVersion() >= 5) 
+      return 1; 
+    break; 
+  } 
+ 
+  return -1; 
+} 
+ 
+/// Check whether the DIE for this MDNode can be shared across CUs. 
+bool DwarfUnit::isShareableAcrossCUs(const DINode *D) const { 
+  // When the MDNode can be part of the type system (this includes subprogram 
+  // declarations *and* subprogram definitions, even local definitions), the 
+  // DIE must be shared across CUs. 
+  // Combining type units and cross-CU DIE sharing is lower value (since 
+  // cross-CU DIE sharing is used in LTO and removes type redundancy at that 
+  // level already) but may be implementable for some value in projects 
+  // building multiple independent libraries with LTO and then linking those 
+  // together. 
+  if (isDwoUnit() && !DD->shareAcrossDWOCUs()) 
+    return false; 
+  return (isa<DIType>(D) || isa<DISubprogram>(D)) && !DD->generateTypeUnits(); 
+} 
+ 
+DIE *DwarfUnit::getDIE(const DINode *D) const { 
+  if (isShareableAcrossCUs(D)) 
+    return DU->getDIE(D); 
+  return MDNodeToDieMap.lookup(D); 
+} 
+ 
+void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) { 
+  if (isShareableAcrossCUs(Desc)) { 
+    DU->insertDIE(Desc, D); 
+    return; 
+  } 
+  MDNodeToDieMap.insert(std::make_pair(Desc, D)); 
+} 
+ 
+void DwarfUnit::insertDIE(DIE *D) { 
+  MDNodeToDieMap.insert(std::make_pair(nullptr, D)); 
+} 
+ 
+void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) { 
+  if (DD->getDwarfVersion() >= 4) 
+    Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag_present, 
+                 DIEInteger(1)); 
+  else 
+    Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag, 
+                 DIEInteger(1)); 
+} 
+ 
+void DwarfUnit::addUInt(DIEValueList &Die, dwarf::Attribute Attribute, 
+                        Optional<dwarf::Form> Form, uint64_t Integer) { 
+  if (!Form) 
+    Form = DIEInteger::BestForm(false, Integer); 
+  assert(Form != dwarf::DW_FORM_implicit_const && 
+         "DW_FORM_implicit_const is used only for signed integers"); 
+  Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer)); 
+} 
+ 
+void DwarfUnit::addUInt(DIEValueList &Block, dwarf::Form Form, 
+                        uint64_t Integer) { 
+  addUInt(Block, (dwarf::Attribute)0, Form, Integer); 
+} 
+ 
+void DwarfUnit::addSInt(DIEValueList &Die, dwarf::Attribute Attribute, 
+                        Optional<dwarf::Form> Form, int64_t Integer) { 
+  if (!Form) 
+    Form = DIEInteger::BestForm(true, Integer); 
+  Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer)); 
+} 
+ 
+void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form, 
+                        int64_t Integer) { 
+  addSInt(Die, (dwarf::Attribute)0, Form, Integer); 
+} 
+ 
+void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute, 
+                          StringRef String) { 
+  if (CUNode->isDebugDirectivesOnly()) 
+    return; 
+ 
+  if (DD->useInlineStrings()) { 
+    Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_string, 
+                 new (DIEValueAllocator) 
+                     DIEInlineString(String, DIEValueAllocator)); 
+    return; 
+  } 
+  dwarf::Form IxForm = 
+      isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp; 
+ 
+  auto StringPoolEntry = 
+      useSegmentedStringOffsetsTable() || IxForm == dwarf::DW_FORM_GNU_str_index 
+          ? DU->getStringPool().getIndexedEntry(*Asm, String) 
+          : DU->getStringPool().getEntry(*Asm, String); 
+ 
+  // For DWARF v5 and beyond, use the smallest strx? form possible. 
+  if (useSegmentedStringOffsetsTable()) { 
+    IxForm = dwarf::DW_FORM_strx1; 
+    unsigned Index = StringPoolEntry.getIndex(); 
+    if (Index > 0xffffff) 
+      IxForm = dwarf::DW_FORM_strx4; 
+    else if (Index > 0xffff) 
+      IxForm = dwarf::DW_FORM_strx3; 
+    else if (Index > 0xff) 
+      IxForm = dwarf::DW_FORM_strx2; 
+  } 
+  Die.addValue(DIEValueAllocator, Attribute, IxForm, 
+               DIEString(StringPoolEntry)); 
+} 
+ 
+DIEValueList::value_iterator DwarfUnit::addLabel(DIEValueList &Die, 
+                                                 dwarf::Attribute Attribute, 
+                                                 dwarf::Form Form, 
+                                                 const MCSymbol *Label) { 
+  return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label)); 
+} 
+ 
+void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) { 
+  addLabel(Die, (dwarf::Attribute)0, Form, Label); 
+} 
+ 
+void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute, 
+                                 uint64_t Integer) { 
   addUInt(Die, Attribute, DD->getDwarfSectionOffsetForm(), Integer);
-}
-
-unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
-  if (!SplitLineTable)
-    return getCU().getOrCreateSourceID(File);
-  if (!UsedLineTable) {
-    UsedLineTable = true;
-    // This is a split type unit that needs a line table.
-    addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
-  }
+} 
+ 
+unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) { 
+  if (!SplitLineTable) 
+    return getCU().getOrCreateSourceID(File); 
+  if (!UsedLineTable) { 
+    UsedLineTable = true; 
+    // This is a split type unit that needs a line table. 
+    addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0); 
+  } 
   return SplitLineTable->getFile(
       File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File),
       Asm->OutContext.getDwarfVersion(), File->getSource());
-}
-
-void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
-  if (DD->getDwarfVersion() >= 5) {
-    addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addrx);
-    addUInt(Die, dwarf::DW_FORM_addrx, DD->getAddressPool().getIndex(Sym));
-    return;
-  }
-
-  if (DD->useSplitDwarf()) {
-    addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
-    addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
-            DD->getAddressPool().getIndex(Sym));
-    return;
-  }
-
-  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
+} 
+ 
+void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) { 
+  if (DD->getDwarfVersion() >= 5) { 
+    addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addrx); 
+    addUInt(Die, dwarf::DW_FORM_addrx, DD->getAddressPool().getIndex(Sym)); 
+    return; 
+  } 
+ 
+  if (DD->useSplitDwarf()) { 
+    addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index); 
+    addUInt(Die, dwarf::DW_FORM_GNU_addr_index, 
+            DD->getAddressPool().getIndex(Sym)); 
+    return; 
+  } 
+ 
+  addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 
   addLabel(Die, dwarf::DW_FORM_addr, Sym);
-}
-
-void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
-                              const MCSymbol *Hi, const MCSymbol *Lo) {
-  Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_data4,
-               new (DIEValueAllocator) DIEDelta(Hi, Lo));
-}
-
-void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
-  addDIEEntry(Die, Attribute, DIEEntry(Entry));
-}
-
-void DwarfUnit::addDIETypeSignature(DIE &Die, uint64_t Signature) {
-  // Flag the type unit reference as a declaration so that if it contains
-  // members (implicit special members, static data member definitions, member
-  // declarations for definitions in this CU, etc) consumers don't get confused
-  // and think this is a full definition.
-  addFlag(Die, dwarf::DW_AT_declaration);
-
-  Die.addValue(DIEValueAllocator, dwarf::DW_AT_signature,
-               dwarf::DW_FORM_ref_sig8, DIEInteger(Signature));
-}
-
-void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
-                            DIEEntry Entry) {
-  const DIEUnit *CU = Die.getUnit();
-  const DIEUnit *EntryCU = Entry.getEntry().getUnit();
-  if (!CU)
-    // We assume that Die belongs to this CU, if it is not linked to any CU yet.
-    CU = getUnitDie().getUnit();
-  if (!EntryCU)
-    EntryCU = getUnitDie().getUnit();
-  Die.addValue(DIEValueAllocator, Attribute,
-               EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
-               Entry);
-}
-
-DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
-  DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
-  if (N)
-    insertDIE(N, &Die);
-  return Die;
-}
-
-void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
-  Loc->ComputeSize(Asm);
-  DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
-  Die.addValue(DIEValueAllocator, Attribute,
-               Loc->BestForm(DD->getDwarfVersion()), Loc);
-}
-
-void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
-                         DIEBlock *Block) {
-  Block->ComputeSize(Asm);
-  DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
-  Die.addValue(DIEValueAllocator, Attribute, Block->BestForm(), Block);
-}
-
-void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) {
-  if (Line == 0)
-    return;
-
-  unsigned FileID = getOrCreateSourceID(File);
-  addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
-  addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
-}
-
-void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
-  assert(V);
-
-  addSourceLine(Die, V->getLine(), V->getFile());
-}
-
-void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) {
-  assert(G);
-
-  addSourceLine(Die, G->getLine(), G->getFile());
-}
-
-void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) {
-  assert(SP);
-
-  addSourceLine(Die, SP->getLine(), SP->getFile());
-}
-
-void DwarfUnit::addSourceLine(DIE &Die, const DILabel *L) {
-  assert(L);
-
-  addSourceLine(Die, L->getLine(), L->getFile());
-}
-
-void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
-  assert(Ty);
-
-  addSourceLine(Die, Ty->getLine(), Ty->getFile());
-}
-
-void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) {
-  assert(Ty);
-
-  addSourceLine(Die, Ty->getLine(), Ty->getFile());
-}
-
-void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
-  // Pass this down to addConstantValue as an unsigned bag of bits.
-  addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
-}
-
-void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
-                                 const DIType *Ty) {
-  addConstantValue(Die, CI->getValue(), Ty);
-}
-
-void DwarfUnit::addConstantValue(DIE &Die, uint64_t Val, const DIType *Ty) {
+} 
+ 
+void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute, 
+                              const MCSymbol *Hi, const MCSymbol *Lo) { 
+  Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_data4, 
+               new (DIEValueAllocator) DIEDelta(Hi, Lo)); 
+} 
+ 
+void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) { 
+  addDIEEntry(Die, Attribute, DIEEntry(Entry)); 
+} 
+ 
+void DwarfUnit::addDIETypeSignature(DIE &Die, uint64_t Signature) { 
+  // Flag the type unit reference as a declaration so that if it contains 
+  // members (implicit special members, static data member definitions, member 
+  // declarations for definitions in this CU, etc) consumers don't get confused 
+  // and think this is a full definition. 
+  addFlag(Die, dwarf::DW_AT_declaration); 
+ 
+  Die.addValue(DIEValueAllocator, dwarf::DW_AT_signature, 
+               dwarf::DW_FORM_ref_sig8, DIEInteger(Signature)); 
+} 
+ 
+void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, 
+                            DIEEntry Entry) { 
+  const DIEUnit *CU = Die.getUnit(); 
+  const DIEUnit *EntryCU = Entry.getEntry().getUnit(); 
+  if (!CU) 
+    // We assume that Die belongs to this CU, if it is not linked to any CU yet. 
+    CU = getUnitDie().getUnit(); 
+  if (!EntryCU) 
+    EntryCU = getUnitDie().getUnit(); 
+  Die.addValue(DIEValueAllocator, Attribute, 
+               EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr, 
+               Entry); 
+} 
+ 
+DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) { 
+  DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag)); 
+  if (N) 
+    insertDIE(N, &Die); 
+  return Die; 
+} 
+ 
+void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) { 
+  Loc->ComputeSize(Asm); 
+  DIELocs.push_back(Loc); // Memoize so we can call the destructor later on. 
+  Die.addValue(DIEValueAllocator, Attribute, 
+               Loc->BestForm(DD->getDwarfVersion()), Loc); 
+} 
+ 
+void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, 
+                         DIEBlock *Block) { 
+  Block->ComputeSize(Asm); 
+  DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on. 
+  Die.addValue(DIEValueAllocator, Attribute, Block->BestForm(), Block); 
+} 
+ 
+void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) { 
+  if (Line == 0) 
+    return; 
+ 
+  unsigned FileID = getOrCreateSourceID(File); 
+  addUInt(Die, dwarf::DW_AT_decl_file, None, FileID); 
+  addUInt(Die, dwarf::DW_AT_decl_line, None, Line); 
+} 
+ 
+void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) { 
+  assert(V); 
+ 
+  addSourceLine(Die, V->getLine(), V->getFile()); 
+} 
+ 
+void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) { 
+  assert(G); 
+ 
+  addSourceLine(Die, G->getLine(), G->getFile()); 
+} 
+ 
+void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) { 
+  assert(SP); 
+ 
+  addSourceLine(Die, SP->getLine(), SP->getFile()); 
+} 
+ 
+void DwarfUnit::addSourceLine(DIE &Die, const DILabel *L) { 
+  assert(L); 
+ 
+  addSourceLine(Die, L->getLine(), L->getFile()); 
+} 
+ 
+void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) { 
+  assert(Ty); 
+ 
+  addSourceLine(Die, Ty->getLine(), Ty->getFile()); 
+} 
+ 
+void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) { 
+  assert(Ty); 
+ 
+  addSourceLine(Die, Ty->getLine(), Ty->getFile()); 
+} 
+ 
+void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) { 
+  // Pass this down to addConstantValue as an unsigned bag of bits. 
+  addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true); 
+} 
+ 
+void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, 
+                                 const DIType *Ty) { 
+  addConstantValue(Die, CI->getValue(), Ty); 
+} 
+ 
+void DwarfUnit::addConstantValue(DIE &Die, uint64_t Val, const DIType *Ty) { 
   addConstantValue(Die, DD->isUnsignedDIType(Ty), Val);
-}
-
-void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
-  // FIXME: This is a bit conservative/simple - it emits negative values always
-  // sign extended to 64 bits rather than minimizing the number of bytes.
-  addUInt(Die, dwarf::DW_AT_const_value,
-          Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
-}
-
-void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
+} 
+ 
+void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) { 
+  // FIXME: This is a bit conservative/simple - it emits negative values always 
+  // sign extended to 64 bits rather than minimizing the number of bytes. 
+  addUInt(Die, dwarf::DW_AT_const_value, 
+          Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val); 
+} 
+ 
+void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) { 
   addConstantValue(Die, Val, DD->isUnsignedDIType(Ty));
-}
-
-void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
-  unsigned CIBitWidth = Val.getBitWidth();
-  if (CIBitWidth <= 64) {
-    addConstantValue(Die, Unsigned,
-                     Unsigned ? Val.getZExtValue() : Val.getSExtValue());
-    return;
-  }
-
-  DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
-
-  // Get the raw data form of the large APInt.
-  const uint64_t *Ptr64 = Val.getRawData();
-
-  int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
-  bool LittleEndian = Asm->getDataLayout().isLittleEndian();
-
-  // Output the constant to DWARF one byte at a time.
-  for (int i = 0; i < NumBytes; i++) {
-    uint8_t c;
-    if (LittleEndian)
-      c = Ptr64[i / 8] >> (8 * (i & 7));
-    else
-      c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
-    addUInt(*Block, dwarf::DW_FORM_data1, c);
-  }
-
-  addBlock(Die, dwarf::DW_AT_const_value, Block);
-}
-
-void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
-  if (!LinkageName.empty())
-    addString(Die,
-              DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
-                                         : dwarf::DW_AT_MIPS_linkage_name,
-              GlobalValue::dropLLVMManglingEscape(LinkageName));
-}
-
-void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
-  // Add template parameters.
-  for (const auto *Element : TParams) {
-    if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
-      constructTemplateTypeParameterDIE(Buffer, TTP);
-    else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
-      constructTemplateValueParameterDIE(Buffer, TVP);
-  }
-}
-
-/// Add thrown types.
-void DwarfUnit::addThrownTypes(DIE &Die, DINodeArray ThrownTypes) {
-  for (const auto *Ty : ThrownTypes) {
-    DIE &TT = createAndAddDIE(dwarf::DW_TAG_thrown_type, Die);
-    addType(TT, cast<DIType>(Ty));
-  }
-}
-
-DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
-  if (!Context || isa<DIFile>(Context))
-    return &getUnitDie();
-  if (auto *T = dyn_cast<DIType>(Context))
-    return getOrCreateTypeDIE(T);
-  if (auto *NS = dyn_cast<DINamespace>(Context))
-    return getOrCreateNameSpace(NS);
-  if (auto *SP = dyn_cast<DISubprogram>(Context))
-    return getOrCreateSubprogramDIE(SP);
-  if (auto *M = dyn_cast<DIModule>(Context))
-    return getOrCreateModule(M);
-  return getDIE(Context);
-}
-
-DIE *DwarfUnit::createTypeDIE(const DICompositeType *Ty) {
-  auto *Context = Ty->getScope();
-  DIE *ContextDIE = getOrCreateContextDIE(Context);
-
-  if (DIE *TyDIE = getDIE(Ty))
-    return TyDIE;
-
-  // Create new type.
-  DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
-
-  constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
-
-  updateAcceleratorTables(Context, Ty, TyDIE);
-  return &TyDIE;
-}
-
-DIE *DwarfUnit::createTypeDIE(const DIScope *Context, DIE &ContextDIE,
-                              const DIType *Ty) {
-  // Create new type.
-  DIE &TyDIE = createAndAddDIE(Ty->getTag(), ContextDIE, Ty);
-
-  updateAcceleratorTables(Context, Ty, TyDIE);
-
-  if (auto *BT = dyn_cast<DIBasicType>(Ty))
-    constructTypeDIE(TyDIE, BT);
+} 
+ 
+void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) { 
+  unsigned CIBitWidth = Val.getBitWidth(); 
+  if (CIBitWidth <= 64) { 
+    addConstantValue(Die, Unsigned, 
+                     Unsigned ? Val.getZExtValue() : Val.getSExtValue()); 
+    return; 
+  } 
+ 
+  DIEBlock *Block = new (DIEValueAllocator) DIEBlock; 
+ 
+  // Get the raw data form of the large APInt. 
+  const uint64_t *Ptr64 = Val.getRawData(); 
+ 
+  int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte. 
+  bool LittleEndian = Asm->getDataLayout().isLittleEndian(); 
+ 
+  // Output the constant to DWARF one byte at a time. 
+  for (int i = 0; i < NumBytes; i++) { 
+    uint8_t c; 
+    if (LittleEndian) 
+      c = Ptr64[i / 8] >> (8 * (i & 7)); 
+    else 
+      c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7)); 
+    addUInt(*Block, dwarf::DW_FORM_data1, c); 
+  } 
+ 
+  addBlock(Die, dwarf::DW_AT_const_value, Block); 
+} 
+ 
+void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) { 
+  if (!LinkageName.empty()) 
+    addString(Die, 
+              DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name 
+                                         : dwarf::DW_AT_MIPS_linkage_name, 
+              GlobalValue::dropLLVMManglingEscape(LinkageName)); 
+} 
+ 
+void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) { 
+  // Add template parameters. 
+  for (const auto *Element : TParams) { 
+    if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element)) 
+      constructTemplateTypeParameterDIE(Buffer, TTP); 
+    else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element)) 
+      constructTemplateValueParameterDIE(Buffer, TVP); 
+  } 
+} 
+ 
+/// Add thrown types. 
+void DwarfUnit::addThrownTypes(DIE &Die, DINodeArray ThrownTypes) { 
+  for (const auto *Ty : ThrownTypes) { 
+    DIE &TT = createAndAddDIE(dwarf::DW_TAG_thrown_type, Die); 
+    addType(TT, cast<DIType>(Ty)); 
+  } 
+} 
+ 
+DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) { 
+  if (!Context || isa<DIFile>(Context)) 
+    return &getUnitDie(); 
+  if (auto *T = dyn_cast<DIType>(Context)) 
+    return getOrCreateTypeDIE(T); 
+  if (auto *NS = dyn_cast<DINamespace>(Context)) 
+    return getOrCreateNameSpace(NS); 
+  if (auto *SP = dyn_cast<DISubprogram>(Context)) 
+    return getOrCreateSubprogramDIE(SP); 
+  if (auto *M = dyn_cast<DIModule>(Context)) 
+    return getOrCreateModule(M); 
+  return getDIE(Context); 
+} 
+ 
+DIE *DwarfUnit::createTypeDIE(const DICompositeType *Ty) { 
+  auto *Context = Ty->getScope(); 
+  DIE *ContextDIE = getOrCreateContextDIE(Context); 
+ 
+  if (DIE *TyDIE = getDIE(Ty)) 
+    return TyDIE; 
+ 
+  // Create new type. 
+  DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty); 
+ 
+  constructTypeDIE(TyDIE, cast<DICompositeType>(Ty)); 
+ 
+  updateAcceleratorTables(Context, Ty, TyDIE); 
+  return &TyDIE; 
+} 
+ 
+DIE *DwarfUnit::createTypeDIE(const DIScope *Context, DIE &ContextDIE, 
+                              const DIType *Ty) { 
+  // Create new type. 
+  DIE &TyDIE = createAndAddDIE(Ty->getTag(), ContextDIE, Ty); 
+ 
+  updateAcceleratorTables(Context, Ty, TyDIE); 
+ 
+  if (auto *BT = dyn_cast<DIBasicType>(Ty)) 
+    constructTypeDIE(TyDIE, BT); 
   else if (auto *ST = dyn_cast<DIStringType>(Ty))
     constructTypeDIE(TyDIE, ST);
-  else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
-    constructTypeDIE(TyDIE, STy);
-  else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
-    if (DD->generateTypeUnits() && !Ty->isForwardDecl() &&
-        (Ty->getRawName() || CTy->getRawIdentifier())) {
-      // Skip updating the accelerator tables since this is not the full type.
-      if (MDString *TypeId = CTy->getRawIdentifier())
-        DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
-      else {
-        auto X = DD->enterNonTypeUnitContext();
-        finishNonUnitTypeDIE(TyDIE, CTy);
-      }
-      return &TyDIE;
-    }
-    constructTypeDIE(TyDIE, CTy);
-  } else {
-    constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
-  }
-
-  return &TyDIE;
-}
-
-DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
-  if (!TyNode)
-    return nullptr;
-
-  auto *Ty = cast<DIType>(TyNode);
-
-  // DW_TAG_restrict_type is not supported in DWARF2
-  if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
-    return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType());
-
-  // DW_TAG_atomic_type is not supported in DWARF < 5
-  if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5)
-    return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType());
-
-  // Construct the context before querying for the existence of the DIE in case
-  // such construction creates the DIE.
-  auto *Context = Ty->getScope();
-  DIE *ContextDIE = getOrCreateContextDIE(Context);
-  assert(ContextDIE);
-
-  if (DIE *TyDIE = getDIE(Ty))
-    return TyDIE;
-
-  return static_cast<DwarfUnit *>(ContextDIE->getUnit())
-      ->createTypeDIE(Context, *ContextDIE, Ty);
-}
-
-void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
-                                        const DIType *Ty, const DIE &TyDIE) {
-  if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
-    bool IsImplementation = false;
-    if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
-      // A runtime language of 0 actually means C/C++ and that any
-      // non-negative value is some version of Objective-C/C++.
-      IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
-    }
-    unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
-    DD->addAccelType(*CUNode, Ty->getName(), TyDIE, Flags);
-
-    if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
-        isa<DINamespace>(Context) || isa<DICommonBlock>(Context))
-      addGlobalType(Ty, TyDIE, Context);
-  }
-}
-
-void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
-                        dwarf::Attribute Attribute) {
-  assert(Ty && "Trying to add a type that doesn't exist?");
-  addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
-}
-
-std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
-  if (!Context)
-    return "";
-
-  // FIXME: Decide whether to implement this for non-C++ languages.
-  if (!dwarf::isCPlusPlus((dwarf::SourceLanguage)getLanguage()))
-    return "";
-
-  std::string CS;
-  SmallVector<const DIScope *, 1> Parents;
-  while (!isa<DICompileUnit>(Context)) {
-    Parents.push_back(Context);
-    if (const DIScope *S = Context->getScope())
-      Context = S;
-    else
-      // Structure, etc types will have a NULL context if they're at the top
-      // level.
-      break;
-  }
-
-  // Reverse iterate over our list to go from the outermost construct to the
-  // innermost.
-  for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) {
-    StringRef Name = Ctx->getName();
-    if (Name.empty() && isa<DINamespace>(Ctx))
-      Name = "(anonymous namespace)";
-    if (!Name.empty()) {
-      CS += Name;
-      CS += "::";
-    }
-  }
-  return CS;
-}
-
-void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
-  // Get core information.
-  StringRef Name = BTy->getName();
-  // Add name if not anonymous or intermediate type.
-  if (!Name.empty())
-    addString(Buffer, dwarf::DW_AT_name, Name);
-
-  // An unspecified type only has a name attribute.
-  if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
-    return;
-
+  else if (auto *STy = dyn_cast<DISubroutineType>(Ty)) 
+    constructTypeDIE(TyDIE, STy); 
+  else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) { 
+    if (DD->generateTypeUnits() && !Ty->isForwardDecl() && 
+        (Ty->getRawName() || CTy->getRawIdentifier())) { 
+      // Skip updating the accelerator tables since this is not the full type. 
+      if (MDString *TypeId = CTy->getRawIdentifier()) 
+        DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy); 
+      else { 
+        auto X = DD->enterNonTypeUnitContext(); 
+        finishNonUnitTypeDIE(TyDIE, CTy); 
+      } 
+      return &TyDIE; 
+    } 
+    constructTypeDIE(TyDIE, CTy); 
+  } else { 
+    constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty)); 
+  } 
+ 
+  return &TyDIE; 
+} 
+ 
+DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) { 
+  if (!TyNode) 
+    return nullptr; 
+ 
+  auto *Ty = cast<DIType>(TyNode); 
+ 
+  // DW_TAG_restrict_type is not supported in DWARF2 
+  if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2) 
+    return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType()); 
+ 
+  // DW_TAG_atomic_type is not supported in DWARF < 5 
+  if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5) 
+    return getOrCreateTypeDIE(cast<DIDerivedType>(Ty)->getBaseType()); 
+ 
+  // Construct the context before querying for the existence of the DIE in case 
+  // such construction creates the DIE. 
+  auto *Context = Ty->getScope(); 
+  DIE *ContextDIE = getOrCreateContextDIE(Context); 
+  assert(ContextDIE); 
+ 
+  if (DIE *TyDIE = getDIE(Ty)) 
+    return TyDIE; 
+ 
+  return static_cast<DwarfUnit *>(ContextDIE->getUnit()) 
+      ->createTypeDIE(Context, *ContextDIE, Ty); 
+} 
+ 
+void DwarfUnit::updateAcceleratorTables(const DIScope *Context, 
+                                        const DIType *Ty, const DIE &TyDIE) { 
+  if (!Ty->getName().empty() && !Ty->isForwardDecl()) { 
+    bool IsImplementation = false; 
+    if (auto *CT = dyn_cast<DICompositeType>(Ty)) { 
+      // A runtime language of 0 actually means C/C++ and that any 
+      // non-negative value is some version of Objective-C/C++. 
+      IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete(); 
+    } 
+    unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0; 
+    DD->addAccelType(*CUNode, Ty->getName(), TyDIE, Flags); 
+ 
+    if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) || 
+        isa<DINamespace>(Context) || isa<DICommonBlock>(Context)) 
+      addGlobalType(Ty, TyDIE, Context); 
+  } 
+} 
+ 
+void DwarfUnit::addType(DIE &Entity, const DIType *Ty, 
+                        dwarf::Attribute Attribute) { 
+  assert(Ty && "Trying to add a type that doesn't exist?"); 
+  addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty))); 
+} 
+ 
+std::string DwarfUnit::getParentContextString(const DIScope *Context) const { 
+  if (!Context) 
+    return ""; 
+ 
+  // FIXME: Decide whether to implement this for non-C++ languages. 
+  if (!dwarf::isCPlusPlus((dwarf::SourceLanguage)getLanguage())) 
+    return ""; 
+ 
+  std::string CS; 
+  SmallVector<const DIScope *, 1> Parents; 
+  while (!isa<DICompileUnit>(Context)) { 
+    Parents.push_back(Context); 
+    if (const DIScope *S = Context->getScope()) 
+      Context = S; 
+    else 
+      // Structure, etc types will have a NULL context if they're at the top 
+      // level. 
+      break; 
+  } 
+ 
+  // Reverse iterate over our list to go from the outermost construct to the 
+  // innermost. 
+  for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) { 
+    StringRef Name = Ctx->getName(); 
+    if (Name.empty() && isa<DINamespace>(Ctx)) 
+      Name = "(anonymous namespace)"; 
+    if (!Name.empty()) { 
+      CS += Name; 
+      CS += "::"; 
+    } 
+  } 
+  return CS; 
+} 
+ 
+void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) { 
+  // Get core information. 
+  StringRef Name = BTy->getName(); 
+  // Add name if not anonymous or intermediate type. 
+  if (!Name.empty()) 
+    addString(Buffer, dwarf::DW_AT_name, Name); 
+ 
+  // An unspecified type only has a name attribute. 
+  if (BTy->getTag() == dwarf::DW_TAG_unspecified_type) 
+    return; 
+ 
   if (BTy->getTag() != dwarf::DW_TAG_string_type)
     addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
             BTy->getEncoding());
-
-  uint64_t Size = BTy->getSizeInBits() >> 3;
-  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
-
-  if (BTy->isBigEndian())
-    addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_big);
-  else if (BTy->isLittleEndian())
-    addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_little);
-}
-
+ 
+  uint64_t Size = BTy->getSizeInBits() >> 3; 
+  addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 
+ 
+  if (BTy->isBigEndian()) 
+    addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_big); 
+  else if (BTy->isLittleEndian()) 
+    addUInt(Buffer, dwarf::DW_AT_endianity, None, dwarf::DW_END_little); 
+} 
+ 
 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIStringType *STy) {
   // Get core information.
   StringRef Name = STy->getName();
@@ -717,610 +717,610 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIStringType *STy) {
   }
 }
 
-void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
-  // Get core information.
-  StringRef Name = DTy->getName();
-  uint64_t Size = DTy->getSizeInBits() >> 3;
-  uint16_t Tag = Buffer.getTag();
-
-  // Map to main type, void will not have a type.
-  const DIType *FromTy = DTy->getBaseType();
-  if (FromTy)
-    addType(Buffer, FromTy);
-
-  // Add name if not anonymous or intermediate type.
-  if (!Name.empty())
-    addString(Buffer, dwarf::DW_AT_name, Name);
-
-  // If alignment is specified for a typedef , create and insert DW_AT_alignment
-  // attribute in DW_TAG_typedef DIE.
-  if (Tag == dwarf::DW_TAG_typedef && DD->getDwarfVersion() >= 5) {
-    uint32_t AlignInBytes = DTy->getAlignInBytes();
-    if (AlignInBytes > 0)
-      addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
-              AlignInBytes);
-  }
-
-  // Add size if non-zero (derived types might be zero-sized.)
-  if (Size && Tag != dwarf::DW_TAG_pointer_type
-           && Tag != dwarf::DW_TAG_ptr_to_member_type
-           && Tag != dwarf::DW_TAG_reference_type
-           && Tag != dwarf::DW_TAG_rvalue_reference_type)
-    addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
-
-  if (Tag == dwarf::DW_TAG_ptr_to_member_type)
-    addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
-                *getOrCreateTypeDIE(cast<DIDerivedType>(DTy)->getClassType()));
-  // Add source line info if available and TyDesc is not a forward declaration.
-  if (!DTy->isForwardDecl())
-    addSourceLine(Buffer, DTy);
-
-  // If DWARF address space value is other than None, add it.  The IR
-  // verifier checks that DWARF address space only exists for pointer
-  // or reference types.
-  if (DTy->getDWARFAddressSpace())
-    addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4,
-            DTy->getDWARFAddressSpace().getValue());
-}
-
-void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
-  for (unsigned i = 1, N = Args.size(); i < N; ++i) {
-    const DIType *Ty = Args[i];
-    if (!Ty) {
-      assert(i == N-1 && "Unspecified parameter must be the last argument");
-      createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
-    } else {
-      DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
-      addType(Arg, Ty);
-      if (Ty->isArtificial())
-        addFlag(Arg, dwarf::DW_AT_artificial);
-    }
-  }
-}
-
-void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
-  // Add return type.  A void return won't have a type.
-  auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
-  if (Elements.size())
-    if (auto RTy = Elements[0])
-      addType(Buffer, RTy);
-
-  bool isPrototyped = true;
-  if (Elements.size() == 2 && !Elements[1])
-    isPrototyped = false;
-
-  constructSubprogramArguments(Buffer, Elements);
-
-  // Add prototype flag if we're dealing with a C language and the function has
-  // been prototyped.
-  uint16_t Language = getLanguage();
-  if (isPrototyped &&
-      (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
-       Language == dwarf::DW_LANG_ObjC))
-    addFlag(Buffer, dwarf::DW_AT_prototyped);
-
-  // Add a DW_AT_calling_convention if this has an explicit convention.
-  if (CTy->getCC() && CTy->getCC() != dwarf::DW_CC_normal)
-    addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
-            CTy->getCC());
-
-  if (CTy->isLValueReference())
-    addFlag(Buffer, dwarf::DW_AT_reference);
-
-  if (CTy->isRValueReference())
-    addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
-}
-
-void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
-  // Add name if not anonymous or intermediate type.
-  StringRef Name = CTy->getName();
-
-  uint64_t Size = CTy->getSizeInBits() >> 3;
-  uint16_t Tag = Buffer.getTag();
-
-  switch (Tag) {
-  case dwarf::DW_TAG_array_type:
-    constructArrayTypeDIE(Buffer, CTy);
-    break;
-  case dwarf::DW_TAG_enumeration_type:
-    constructEnumTypeDIE(Buffer, CTy);
-    break;
-  case dwarf::DW_TAG_variant_part:
-  case dwarf::DW_TAG_structure_type:
-  case dwarf::DW_TAG_union_type:
-  case dwarf::DW_TAG_class_type: {
-    // Emit the discriminator for a variant part.
-    DIDerivedType *Discriminator = nullptr;
-    if (Tag == dwarf::DW_TAG_variant_part) {
-      Discriminator = CTy->getDiscriminator();
-      if (Discriminator) {
-        // DWARF says:
-        //    If the variant part has a discriminant, the discriminant is
-        //    represented by a separate debugging information entry which is
-        //    a child of the variant part entry.
-        DIE &DiscMember = constructMemberDIE(Buffer, Discriminator);
-        addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember);
-      }
-    }
-
+void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) { 
+  // Get core information. 
+  StringRef Name = DTy->getName(); 
+  uint64_t Size = DTy->getSizeInBits() >> 3; 
+  uint16_t Tag = Buffer.getTag(); 
+ 
+  // Map to main type, void will not have a type. 
+  const DIType *FromTy = DTy->getBaseType(); 
+  if (FromTy) 
+    addType(Buffer, FromTy); 
+ 
+  // Add name if not anonymous or intermediate type. 
+  if (!Name.empty()) 
+    addString(Buffer, dwarf::DW_AT_name, Name); 
+ 
+  // If alignment is specified for a typedef , create and insert DW_AT_alignment 
+  // attribute in DW_TAG_typedef DIE. 
+  if (Tag == dwarf::DW_TAG_typedef && DD->getDwarfVersion() >= 5) { 
+    uint32_t AlignInBytes = DTy->getAlignInBytes(); 
+    if (AlignInBytes > 0) 
+      addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, 
+              AlignInBytes); 
+  } 
+ 
+  // Add size if non-zero (derived types might be zero-sized.) 
+  if (Size && Tag != dwarf::DW_TAG_pointer_type 
+           && Tag != dwarf::DW_TAG_ptr_to_member_type 
+           && Tag != dwarf::DW_TAG_reference_type 
+           && Tag != dwarf::DW_TAG_rvalue_reference_type) 
+    addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 
+ 
+  if (Tag == dwarf::DW_TAG_ptr_to_member_type) 
+    addDIEEntry(Buffer, dwarf::DW_AT_containing_type, 
+                *getOrCreateTypeDIE(cast<DIDerivedType>(DTy)->getClassType())); 
+  // Add source line info if available and TyDesc is not a forward declaration. 
+  if (!DTy->isForwardDecl()) 
+    addSourceLine(Buffer, DTy); 
+ 
+  // If DWARF address space value is other than None, add it.  The IR 
+  // verifier checks that DWARF address space only exists for pointer 
+  // or reference types. 
+  if (DTy->getDWARFAddressSpace()) 
+    addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4, 
+            DTy->getDWARFAddressSpace().getValue()); 
+} 
+ 
+void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) { 
+  for (unsigned i = 1, N = Args.size(); i < N; ++i) { 
+    const DIType *Ty = Args[i]; 
+    if (!Ty) { 
+      assert(i == N-1 && "Unspecified parameter must be the last argument"); 
+      createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer); 
+    } else { 
+      DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer); 
+      addType(Arg, Ty); 
+      if (Ty->isArtificial()) 
+        addFlag(Arg, dwarf::DW_AT_artificial); 
+    } 
+  } 
+} 
+ 
+void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) { 
+  // Add return type.  A void return won't have a type. 
+  auto Elements = cast<DISubroutineType>(CTy)->getTypeArray(); 
+  if (Elements.size()) 
+    if (auto RTy = Elements[0]) 
+      addType(Buffer, RTy); 
+ 
+  bool isPrototyped = true; 
+  if (Elements.size() == 2 && !Elements[1]) 
+    isPrototyped = false; 
+ 
+  constructSubprogramArguments(Buffer, Elements); 
+ 
+  // Add prototype flag if we're dealing with a C language and the function has 
+  // been prototyped. 
+  uint16_t Language = getLanguage(); 
+  if (isPrototyped && 
+      (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 || 
+       Language == dwarf::DW_LANG_ObjC)) 
+    addFlag(Buffer, dwarf::DW_AT_prototyped); 
+ 
+  // Add a DW_AT_calling_convention if this has an explicit convention. 
+  if (CTy->getCC() && CTy->getCC() != dwarf::DW_CC_normal) 
+    addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, 
+            CTy->getCC()); 
+ 
+  if (CTy->isLValueReference()) 
+    addFlag(Buffer, dwarf::DW_AT_reference); 
+ 
+  if (CTy->isRValueReference()) 
+    addFlag(Buffer, dwarf::DW_AT_rvalue_reference); 
+} 
+ 
+void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) { 
+  // Add name if not anonymous or intermediate type. 
+  StringRef Name = CTy->getName(); 
+ 
+  uint64_t Size = CTy->getSizeInBits() >> 3; 
+  uint16_t Tag = Buffer.getTag(); 
+ 
+  switch (Tag) { 
+  case dwarf::DW_TAG_array_type: 
+    constructArrayTypeDIE(Buffer, CTy); 
+    break; 
+  case dwarf::DW_TAG_enumeration_type: 
+    constructEnumTypeDIE(Buffer, CTy); 
+    break; 
+  case dwarf::DW_TAG_variant_part: 
+  case dwarf::DW_TAG_structure_type: 
+  case dwarf::DW_TAG_union_type: 
+  case dwarf::DW_TAG_class_type: { 
+    // Emit the discriminator for a variant part. 
+    DIDerivedType *Discriminator = nullptr; 
+    if (Tag == dwarf::DW_TAG_variant_part) { 
+      Discriminator = CTy->getDiscriminator(); 
+      if (Discriminator) { 
+        // DWARF says: 
+        //    If the variant part has a discriminant, the discriminant is 
+        //    represented by a separate debugging information entry which is 
+        //    a child of the variant part entry. 
+        DIE &DiscMember = constructMemberDIE(Buffer, Discriminator); 
+        addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember); 
+      } 
+    } 
+ 
     // Add template parameters to a class, structure or union types.
     if (Tag == dwarf::DW_TAG_class_type ||
         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
       addTemplateParams(Buffer, CTy->getTemplateParams());
 
-    // Add elements to structure type.
-    DINodeArray Elements = CTy->getElements();
-    for (const auto *Element : Elements) {
-      if (!Element)
-        continue;
-      if (auto *SP = dyn_cast<DISubprogram>(Element))
-        getOrCreateSubprogramDIE(SP);
-      else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
-        if (DDTy->getTag() == dwarf::DW_TAG_friend) {
-          DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
-          addType(ElemDie, DDTy->getBaseType(), dwarf::DW_AT_friend);
-        } else if (DDTy->isStaticMember()) {
-          getOrCreateStaticMemberDIE(DDTy);
-        } else if (Tag == dwarf::DW_TAG_variant_part) {
-          // When emitting a variant part, wrap each member in
-          // DW_TAG_variant.
-          DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer);
-          if (const ConstantInt *CI =
-              dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
+    // Add elements to structure type. 
+    DINodeArray Elements = CTy->getElements(); 
+    for (const auto *Element : Elements) { 
+      if (!Element) 
+        continue; 
+      if (auto *SP = dyn_cast<DISubprogram>(Element)) 
+        getOrCreateSubprogramDIE(SP); 
+      else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) { 
+        if (DDTy->getTag() == dwarf::DW_TAG_friend) { 
+          DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer); 
+          addType(ElemDie, DDTy->getBaseType(), dwarf::DW_AT_friend); 
+        } else if (DDTy->isStaticMember()) { 
+          getOrCreateStaticMemberDIE(DDTy); 
+        } else if (Tag == dwarf::DW_TAG_variant_part) { 
+          // When emitting a variant part, wrap each member in 
+          // DW_TAG_variant. 
+          DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer); 
+          if (const ConstantInt *CI = 
+              dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) { 
             if (DD->isUnsignedDIType(Discriminator->getBaseType()))
-              addUInt(Variant, dwarf::DW_AT_discr_value, None, CI->getZExtValue());
-            else
-              addSInt(Variant, dwarf::DW_AT_discr_value, None, CI->getSExtValue());
-          }
-          constructMemberDIE(Variant, DDTy);
-        } else {
-          constructMemberDIE(Buffer, DDTy);
-        }
-      } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
-        DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
-        StringRef PropertyName = Property->getName();
-        addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
-        if (Property->getType())
-          addType(ElemDie, Property->getType());
-        addSourceLine(ElemDie, Property);
-        StringRef GetterName = Property->getGetterName();
-        if (!GetterName.empty())
-          addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
-        StringRef SetterName = Property->getSetterName();
-        if (!SetterName.empty())
-          addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
-        if (unsigned PropertyAttributes = Property->getAttributes())
-          addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
-                  PropertyAttributes);
-      } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
-        if (Composite->getTag() == dwarf::DW_TAG_variant_part) {
-          DIE &VariantPart = createAndAddDIE(Composite->getTag(), Buffer);
-          constructTypeDIE(VariantPart, Composite);
-        }
-      }
-    }
-
-    if (CTy->isAppleBlockExtension())
-      addFlag(Buffer, dwarf::DW_AT_APPLE_block);
-
-    if (CTy->getExportSymbols())
-      addFlag(Buffer, dwarf::DW_AT_export_symbols);
-
-    // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
-    // inside C++ composite types to point to the base class with the vtable.
-    // Rust uses DW_AT_containing_type to link a vtable to the type
-    // for which it was created.
-    if (auto *ContainingType = CTy->getVTableHolder())
-      addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
-                  *getOrCreateTypeDIE(ContainingType));
-
-    if (CTy->isObjcClassComplete())
-      addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
-
-    // Add the type's non-standard calling convention.
-    uint8_t CC = 0;
-    if (CTy->isTypePassByValue())
-      CC = dwarf::DW_CC_pass_by_value;
-    else if (CTy->isTypePassByReference())
-      CC = dwarf::DW_CC_pass_by_reference;
-    if (CC)
-      addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
-              CC);
-    break;
-  }
-  default:
-    break;
-  }
-
-  // Add name if not anonymous or intermediate type.
-  if (!Name.empty())
-    addString(Buffer, dwarf::DW_AT_name, Name);
-
-  if (Tag == dwarf::DW_TAG_enumeration_type ||
-      Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
-      Tag == dwarf::DW_TAG_union_type) {
-    // Add size if non-zero (derived types might be zero-sized.)
+              addUInt(Variant, dwarf::DW_AT_discr_value, None, CI->getZExtValue()); 
+            else 
+              addSInt(Variant, dwarf::DW_AT_discr_value, None, CI->getSExtValue()); 
+          } 
+          constructMemberDIE(Variant, DDTy); 
+        } else { 
+          constructMemberDIE(Buffer, DDTy); 
+        } 
+      } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) { 
+        DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer); 
+        StringRef PropertyName = Property->getName(); 
+        addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName); 
+        if (Property->getType()) 
+          addType(ElemDie, Property->getType()); 
+        addSourceLine(ElemDie, Property); 
+        StringRef GetterName = Property->getGetterName(); 
+        if (!GetterName.empty()) 
+          addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName); 
+        StringRef SetterName = Property->getSetterName(); 
+        if (!SetterName.empty()) 
+          addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName); 
+        if (unsigned PropertyAttributes = Property->getAttributes()) 
+          addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None, 
+                  PropertyAttributes); 
+      } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) { 
+        if (Composite->getTag() == dwarf::DW_TAG_variant_part) { 
+          DIE &VariantPart = createAndAddDIE(Composite->getTag(), Buffer); 
+          constructTypeDIE(VariantPart, Composite); 
+        } 
+      } 
+    } 
+ 
+    if (CTy->isAppleBlockExtension()) 
+      addFlag(Buffer, dwarf::DW_AT_APPLE_block); 
+ 
+    if (CTy->getExportSymbols()) 
+      addFlag(Buffer, dwarf::DW_AT_export_symbols); 
+ 
+    // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type 
+    // inside C++ composite types to point to the base class with the vtable. 
+    // Rust uses DW_AT_containing_type to link a vtable to the type 
+    // for which it was created. 
+    if (auto *ContainingType = CTy->getVTableHolder()) 
+      addDIEEntry(Buffer, dwarf::DW_AT_containing_type, 
+                  *getOrCreateTypeDIE(ContainingType)); 
+ 
+    if (CTy->isObjcClassComplete()) 
+      addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type); 
+ 
+    // Add the type's non-standard calling convention. 
+    uint8_t CC = 0; 
+    if (CTy->isTypePassByValue()) 
+      CC = dwarf::DW_CC_pass_by_value; 
+    else if (CTy->isTypePassByReference()) 
+      CC = dwarf::DW_CC_pass_by_reference; 
+    if (CC) 
+      addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, 
+              CC); 
+    break; 
+  } 
+  default: 
+    break; 
+  } 
+ 
+  // Add name if not anonymous or intermediate type. 
+  if (!Name.empty()) 
+    addString(Buffer, dwarf::DW_AT_name, Name); 
+ 
+  if (Tag == dwarf::DW_TAG_enumeration_type || 
+      Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type || 
+      Tag == dwarf::DW_TAG_union_type) { 
+    // Add size if non-zero (derived types might be zero-sized.) 
     // Ignore the size if it's a non-enum forward decl.
-    // TODO: Do we care about size for enum forward declarations?
+    // TODO: Do we care about size for enum forward declarations? 
     if (Size &&
         (!CTy->isForwardDecl() || Tag == dwarf::DW_TAG_enumeration_type))
-      addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
-    else if (!CTy->isForwardDecl())
-      // Add zero size if it is not a forward declaration.
-      addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
-
-    // If we're a forward decl, say so.
-    if (CTy->isForwardDecl())
-      addFlag(Buffer, dwarf::DW_AT_declaration);
-
-    // Add source line info if available.
-    if (!CTy->isForwardDecl())
-      addSourceLine(Buffer, CTy);
-
-    // No harm in adding the runtime language to the declaration.
-    unsigned RLang = CTy->getRuntimeLang();
-    if (RLang)
-      addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
-              RLang);
-
-    // Add align info if available.
-    if (uint32_t AlignInBytes = CTy->getAlignInBytes())
-      addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
-              AlignInBytes);
-  }
-}
-
-void DwarfUnit::constructTemplateTypeParameterDIE(
-    DIE &Buffer, const DITemplateTypeParameter *TP) {
-  DIE &ParamDIE =
-      createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
-  // Add the type if it exists, it could be void and therefore no type.
-  if (TP->getType())
-    addType(ParamDIE, TP->getType());
-  if (!TP->getName().empty())
-    addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
-  if (TP->isDefault() && (DD->getDwarfVersion() >= 5))
-    addFlag(ParamDIE, dwarf::DW_AT_default_value);
-}
-
-void DwarfUnit::constructTemplateValueParameterDIE(
-    DIE &Buffer, const DITemplateValueParameter *VP) {
-  DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
-
-  // Add the type if there is one, template template and template parameter
-  // packs will not have a type.
-  if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
-    addType(ParamDIE, VP->getType());
-  if (!VP->getName().empty())
-    addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
-  if (VP->isDefault() && (DD->getDwarfVersion() >= 5))
-    addFlag(ParamDIE, dwarf::DW_AT_default_value);
-  if (Metadata *Val = VP->getValue()) {
-    if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
-      addConstantValue(ParamDIE, CI, VP->getType());
-    else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
-      // We cannot describe the location of dllimport'd entities: the
-      // computation of their address requires loads from the IAT.
-      if (!GV->hasDLLImportStorageClass()) {
-        // For declaration non-type template parameters (such as global values
-        // and functions)
-        DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-        addOpAddress(*Loc, Asm->getSymbol(GV));
-        // Emit DW_OP_stack_value to use the address as the immediate value of
-        // the parameter, rather than a pointer to it.
-        addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
-        addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
-      }
-    } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
-      assert(isa<MDString>(Val));
-      addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
-                cast<MDString>(Val)->getString());
-    } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
-      addTemplateParams(ParamDIE, cast<MDTuple>(Val));
-    }
-  }
-}
-
-DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
-  // Construct the context before querying for the existence of the DIE in case
-  // such construction creates the DIE.
-  DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
-
-  if (DIE *NDie = getDIE(NS))
-    return NDie;
-  DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
-
-  StringRef Name = NS->getName();
-  if (!Name.empty())
-    addString(NDie, dwarf::DW_AT_name, NS->getName());
-  else
-    Name = "(anonymous namespace)";
-  DD->addAccelNamespace(*CUNode, Name, NDie);
-  addGlobalName(Name, NDie, NS->getScope());
-  if (NS->getExportSymbols())
-    addFlag(NDie, dwarf::DW_AT_export_symbols);
-  return &NDie;
-}
-
-DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
-  // Construct the context before querying for the existence of the DIE in case
-  // such construction creates the DIE.
-  DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
-
-  if (DIE *MDie = getDIE(M))
-    return MDie;
-  DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
-
-  if (!M->getName().empty()) {
-    addString(MDie, dwarf::DW_AT_name, M->getName());
-    addGlobalName(M->getName(), MDie, M->getScope());
-  }
-  if (!M->getConfigurationMacros().empty())
-    addString(MDie, dwarf::DW_AT_LLVM_config_macros,
-              M->getConfigurationMacros());
-  if (!M->getIncludePath().empty())
-    addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
-  if (!M->getAPINotesFile().empty())
-    addString(MDie, dwarf::DW_AT_LLVM_apinotes, M->getAPINotesFile());
-  if (M->getFile())
-    addUInt(MDie, dwarf::DW_AT_decl_file, None,
-            getOrCreateSourceID(M->getFile()));
-  if (M->getLineNo())
-    addUInt(MDie, dwarf::DW_AT_decl_line, None, M->getLineNo());
+      addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 
+    else if (!CTy->isForwardDecl()) 
+      // Add zero size if it is not a forward declaration. 
+      addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0); 
+ 
+    // If we're a forward decl, say so. 
+    if (CTy->isForwardDecl()) 
+      addFlag(Buffer, dwarf::DW_AT_declaration); 
+ 
+    // Add source line info if available. 
+    if (!CTy->isForwardDecl()) 
+      addSourceLine(Buffer, CTy); 
+ 
+    // No harm in adding the runtime language to the declaration. 
+    unsigned RLang = CTy->getRuntimeLang(); 
+    if (RLang) 
+      addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1, 
+              RLang); 
+ 
+    // Add align info if available. 
+    if (uint32_t AlignInBytes = CTy->getAlignInBytes()) 
+      addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, 
+              AlignInBytes); 
+  } 
+} 
+ 
+void DwarfUnit::constructTemplateTypeParameterDIE( 
+    DIE &Buffer, const DITemplateTypeParameter *TP) { 
+  DIE &ParamDIE = 
+      createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer); 
+  // Add the type if it exists, it could be void and therefore no type. 
+  if (TP->getType()) 
+    addType(ParamDIE, TP->getType()); 
+  if (!TP->getName().empty()) 
+    addString(ParamDIE, dwarf::DW_AT_name, TP->getName()); 
+  if (TP->isDefault() && (DD->getDwarfVersion() >= 5)) 
+    addFlag(ParamDIE, dwarf::DW_AT_default_value); 
+} 
+ 
+void DwarfUnit::constructTemplateValueParameterDIE( 
+    DIE &Buffer, const DITemplateValueParameter *VP) { 
+  DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer); 
+ 
+  // Add the type if there is one, template template and template parameter 
+  // packs will not have a type. 
+  if (VP->getTag() == dwarf::DW_TAG_template_value_parameter) 
+    addType(ParamDIE, VP->getType()); 
+  if (!VP->getName().empty()) 
+    addString(ParamDIE, dwarf::DW_AT_name, VP->getName()); 
+  if (VP->isDefault() && (DD->getDwarfVersion() >= 5)) 
+    addFlag(ParamDIE, dwarf::DW_AT_default_value); 
+  if (Metadata *Val = VP->getValue()) { 
+    if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val)) 
+      addConstantValue(ParamDIE, CI, VP->getType()); 
+    else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) { 
+      // We cannot describe the location of dllimport'd entities: the 
+      // computation of their address requires loads from the IAT. 
+      if (!GV->hasDLLImportStorageClass()) { 
+        // For declaration non-type template parameters (such as global values 
+        // and functions) 
+        DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+        addOpAddress(*Loc, Asm->getSymbol(GV)); 
+        // Emit DW_OP_stack_value to use the address as the immediate value of 
+        // the parameter, rather than a pointer to it. 
+        addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value); 
+        addBlock(ParamDIE, dwarf::DW_AT_location, Loc); 
+      } 
+    } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) { 
+      assert(isa<MDString>(Val)); 
+      addString(ParamDIE, dwarf::DW_AT_GNU_template_name, 
+                cast<MDString>(Val)->getString()); 
+    } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) { 
+      addTemplateParams(ParamDIE, cast<MDTuple>(Val)); 
+    } 
+  } 
+} 
+ 
+DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) { 
+  // Construct the context before querying for the existence of the DIE in case 
+  // such construction creates the DIE. 
+  DIE *ContextDIE = getOrCreateContextDIE(NS->getScope()); 
+ 
+  if (DIE *NDie = getDIE(NS)) 
+    return NDie; 
+  DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS); 
+ 
+  StringRef Name = NS->getName(); 
+  if (!Name.empty()) 
+    addString(NDie, dwarf::DW_AT_name, NS->getName()); 
+  else 
+    Name = "(anonymous namespace)"; 
+  DD->addAccelNamespace(*CUNode, Name, NDie); 
+  addGlobalName(Name, NDie, NS->getScope()); 
+  if (NS->getExportSymbols()) 
+    addFlag(NDie, dwarf::DW_AT_export_symbols); 
+  return &NDie; 
+} 
+ 
+DIE *DwarfUnit::getOrCreateModule(const DIModule *M) { 
+  // Construct the context before querying for the existence of the DIE in case 
+  // such construction creates the DIE. 
+  DIE *ContextDIE = getOrCreateContextDIE(M->getScope()); 
+ 
+  if (DIE *MDie = getDIE(M)) 
+    return MDie; 
+  DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M); 
+ 
+  if (!M->getName().empty()) { 
+    addString(MDie, dwarf::DW_AT_name, M->getName()); 
+    addGlobalName(M->getName(), MDie, M->getScope()); 
+  } 
+  if (!M->getConfigurationMacros().empty()) 
+    addString(MDie, dwarf::DW_AT_LLVM_config_macros, 
+              M->getConfigurationMacros()); 
+  if (!M->getIncludePath().empty()) 
+    addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath()); 
+  if (!M->getAPINotesFile().empty()) 
+    addString(MDie, dwarf::DW_AT_LLVM_apinotes, M->getAPINotesFile()); 
+  if (M->getFile()) 
+    addUInt(MDie, dwarf::DW_AT_decl_file, None, 
+            getOrCreateSourceID(M->getFile())); 
+  if (M->getLineNo()) 
+    addUInt(MDie, dwarf::DW_AT_decl_line, None, M->getLineNo()); 
   if (M->getIsDecl())
     addFlag(MDie, dwarf::DW_AT_declaration);
-
-  return &MDie;
-}
-
-DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
-  // Construct the context before querying for the existence of the DIE in case
-  // such construction creates the DIE (as is the case for member function
-  // declarations).
-  DIE *ContextDIE =
-      Minimal ? &getUnitDie() : getOrCreateContextDIE(SP->getScope());
-
-  if (DIE *SPDie = getDIE(SP))
-    return SPDie;
-
-  if (auto *SPDecl = SP->getDeclaration()) {
-    if (!Minimal) {
-      // Add subprogram definitions to the CU die directly.
-      ContextDIE = &getUnitDie();
-      // Build the decl now to ensure it precedes the definition.
-      getOrCreateSubprogramDIE(SPDecl);
-    }
-  }
-
-  // DW_TAG_inlined_subroutine may refer to this DIE.
-  DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
-
-  // Stop here and fill this in later, depending on whether or not this
-  // subprogram turns out to have inlined instances or not.
-  if (SP->isDefinition())
-    return &SPDie;
-
-  static_cast<DwarfUnit *>(SPDie.getUnit())
-      ->applySubprogramAttributes(SP, SPDie);
-  return &SPDie;
-}
-
-bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
-                                                    DIE &SPDie) {
-  DIE *DeclDie = nullptr;
-  StringRef DeclLinkageName;
-  if (auto *SPDecl = SP->getDeclaration()) {
-    DITypeRefArray DeclArgs, DefinitionArgs;
-    DeclArgs = SPDecl->getType()->getTypeArray();
-    DefinitionArgs = SP->getType()->getTypeArray();
-
-    if (DeclArgs.size() && DefinitionArgs.size())
-      if (DefinitionArgs[0] != NULL && DeclArgs[0] != DefinitionArgs[0])
-        addType(SPDie, DefinitionArgs[0]);
-
-    DeclDie = getDIE(SPDecl);
-    assert(DeclDie && "This DIE should've already been constructed when the "
-                      "definition DIE was created in "
-                      "getOrCreateSubprogramDIE");
-    // Look at the Decl's linkage name only if we emitted it.
-    if (DD->useAllLinkageNames())
-      DeclLinkageName = SPDecl->getLinkageName();
-    unsigned DeclID = getOrCreateSourceID(SPDecl->getFile());
-    unsigned DefID = getOrCreateSourceID(SP->getFile());
-    if (DeclID != DefID)
-      addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID);
-
-    if (SP->getLine() != SPDecl->getLine())
-      addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine());
-  }
-
-  // Add function template parameters.
-  addTemplateParams(SPDie, SP->getTemplateParams());
-
-  // Add the linkage name if we have one and it isn't in the Decl.
-  StringRef LinkageName = SP->getLinkageName();
-  assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
-          LinkageName == DeclLinkageName) &&
-         "decl has a linkage name and it is different");
-  if (DeclLinkageName.empty() &&
-      // Always emit it for abstract subprograms.
-      (DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP)))
-    addLinkageName(SPDie, LinkageName);
-
-  if (!DeclDie)
-    return false;
-
-  // Refer to the function declaration where all the other attributes will be
-  // found.
-  addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
-  return true;
-}
-
-void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
-                                          bool SkipSPAttributes) {
-  // If -fdebug-info-for-profiling is enabled, need to emit the subprogram
-  // and its source location.
-  bool SkipSPSourceLocation = SkipSPAttributes &&
-                              !CUNode->getDebugInfoForProfiling();
-  if (!SkipSPSourceLocation)
-    if (applySubprogramDefinitionAttributes(SP, SPDie))
-      return;
-
-  // Constructors and operators for anonymous aggregates do not have names.
-  if (!SP->getName().empty())
-    addString(SPDie, dwarf::DW_AT_name, SP->getName());
-
-  if (!SkipSPSourceLocation)
-    addSourceLine(SPDie, SP);
-
-  // Skip the rest of the attributes under -gmlt to save space.
-  if (SkipSPAttributes)
-    return;
-
-  // Add the prototype if we have a prototype and we have a C like
-  // language.
-  uint16_t Language = getLanguage();
-  if (SP->isPrototyped() &&
-      (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
-       Language == dwarf::DW_LANG_ObjC))
-    addFlag(SPDie, dwarf::DW_AT_prototyped);
-
-  if (SP->isObjCDirect())
-    addFlag(SPDie, dwarf::DW_AT_APPLE_objc_direct);
-
-  unsigned CC = 0;
-  DITypeRefArray Args;
-  if (const DISubroutineType *SPTy = SP->getType()) {
-    Args = SPTy->getTypeArray();
-    CC = SPTy->getCC();
-  }
-
-  // Add a DW_AT_calling_convention if this has an explicit convention.
-  if (CC && CC != dwarf::DW_CC_normal)
-    addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC);
-
-  // Add a return type. If this is a type like a C/C++ void type we don't add a
-  // return type.
-  if (Args.size())
-    if (auto Ty = Args[0])
-      addType(SPDie, Ty);
-
-  unsigned VK = SP->getVirtuality();
-  if (VK) {
-    addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
-    if (SP->getVirtualIndex() != -1u) {
-      DIELoc *Block = getDIELoc();
-      addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
-      addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
-      addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
-    }
-    ContainingTypeMap.insert(std::make_pair(&SPDie, SP->getContainingType()));
-  }
-
-  if (!SP->isDefinition()) {
-    addFlag(SPDie, dwarf::DW_AT_declaration);
-
-    // Add arguments. Do not add arguments for subprogram definition. They will
-    // be handled while processing variables.
-    constructSubprogramArguments(SPDie, Args);
-  }
-
-  addThrownTypes(SPDie, SP->getThrownTypes());
-
-  if (SP->isArtificial())
-    addFlag(SPDie, dwarf::DW_AT_artificial);
-
-  if (!SP->isLocalToUnit())
-    addFlag(SPDie, dwarf::DW_AT_external);
-
-  if (DD->useAppleExtensionAttributes()) {
-    if (SP->isOptimized())
-      addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
-
-    if (unsigned isa = Asm->getISAEncoding())
-      addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
-  }
-
-  if (SP->isLValueReference())
-    addFlag(SPDie, dwarf::DW_AT_reference);
-
-  if (SP->isRValueReference())
-    addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
-
-  if (SP->isNoReturn())
-    addFlag(SPDie, dwarf::DW_AT_noreturn);
-
-  if (SP->isProtected())
-    addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
-            dwarf::DW_ACCESS_protected);
-  else if (SP->isPrivate())
-    addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
-            dwarf::DW_ACCESS_private);
-  else if (SP->isPublic())
-    addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
-            dwarf::DW_ACCESS_public);
-
-  if (SP->isExplicit())
-    addFlag(SPDie, dwarf::DW_AT_explicit);
-
-  if (SP->isMainSubprogram())
-    addFlag(SPDie, dwarf::DW_AT_main_subprogram);
-  if (SP->isPure())
-    addFlag(SPDie, dwarf::DW_AT_pure);
-  if (SP->isElemental())
-    addFlag(SPDie, dwarf::DW_AT_elemental);
-  if (SP->isRecursive())
-    addFlag(SPDie, dwarf::DW_AT_recursive);
-
-  if (DD->getDwarfVersion() >= 5 && SP->isDeleted())
-    addFlag(SPDie, dwarf::DW_AT_deleted);
-}
-
-void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
-                                     DIE *IndexTy) {
-  DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
-  addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
-
-  // The LowerBound value defines the lower bounds which is typically zero for
-  // C/C++. The Count value is the number of elements.  Values are 64 bit. If
-  // Count == -1 then the array is unbounded and we do not emit
-  // DW_AT_lower_bound and DW_AT_count attributes.
-  int64_t DefaultLowerBound = getDefaultLowerBound();
-  int64_t Count = -1;
-  if (auto *CI = SR->getCount().dyn_cast<ConstantInt*>())
-    Count = CI->getSExtValue();
-
+ 
+  return &MDie; 
+} 
+ 
+DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) { 
+  // Construct the context before querying for the existence of the DIE in case 
+  // such construction creates the DIE (as is the case for member function 
+  // declarations). 
+  DIE *ContextDIE = 
+      Minimal ? &getUnitDie() : getOrCreateContextDIE(SP->getScope()); 
+ 
+  if (DIE *SPDie = getDIE(SP)) 
+    return SPDie; 
+ 
+  if (auto *SPDecl = SP->getDeclaration()) { 
+    if (!Minimal) { 
+      // Add subprogram definitions to the CU die directly. 
+      ContextDIE = &getUnitDie(); 
+      // Build the decl now to ensure it precedes the definition. 
+      getOrCreateSubprogramDIE(SPDecl); 
+    } 
+  } 
+ 
+  // DW_TAG_inlined_subroutine may refer to this DIE. 
+  DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP); 
+ 
+  // Stop here and fill this in later, depending on whether or not this 
+  // subprogram turns out to have inlined instances or not. 
+  if (SP->isDefinition()) 
+    return &SPDie; 
+ 
+  static_cast<DwarfUnit *>(SPDie.getUnit()) 
+      ->applySubprogramAttributes(SP, SPDie); 
+  return &SPDie; 
+} 
+ 
+bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP, 
+                                                    DIE &SPDie) { 
+  DIE *DeclDie = nullptr; 
+  StringRef DeclLinkageName; 
+  if (auto *SPDecl = SP->getDeclaration()) { 
+    DITypeRefArray DeclArgs, DefinitionArgs; 
+    DeclArgs = SPDecl->getType()->getTypeArray(); 
+    DefinitionArgs = SP->getType()->getTypeArray(); 
+ 
+    if (DeclArgs.size() && DefinitionArgs.size()) 
+      if (DefinitionArgs[0] != NULL && DeclArgs[0] != DefinitionArgs[0]) 
+        addType(SPDie, DefinitionArgs[0]); 
+ 
+    DeclDie = getDIE(SPDecl); 
+    assert(DeclDie && "This DIE should've already been constructed when the " 
+                      "definition DIE was created in " 
+                      "getOrCreateSubprogramDIE"); 
+    // Look at the Decl's linkage name only if we emitted it. 
+    if (DD->useAllLinkageNames()) 
+      DeclLinkageName = SPDecl->getLinkageName(); 
+    unsigned DeclID = getOrCreateSourceID(SPDecl->getFile()); 
+    unsigned DefID = getOrCreateSourceID(SP->getFile()); 
+    if (DeclID != DefID) 
+      addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID); 
+ 
+    if (SP->getLine() != SPDecl->getLine()) 
+      addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine()); 
+  } 
+ 
+  // Add function template parameters. 
+  addTemplateParams(SPDie, SP->getTemplateParams()); 
+ 
+  // Add the linkage name if we have one and it isn't in the Decl. 
+  StringRef LinkageName = SP->getLinkageName(); 
+  assert(((LinkageName.empty() || DeclLinkageName.empty()) || 
+          LinkageName == DeclLinkageName) && 
+         "decl has a linkage name and it is different"); 
+  if (DeclLinkageName.empty() && 
+      // Always emit it for abstract subprograms. 
+      (DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP))) 
+    addLinkageName(SPDie, LinkageName); 
+ 
+  if (!DeclDie) 
+    return false; 
+ 
+  // Refer to the function declaration where all the other attributes will be 
+  // found. 
+  addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie); 
+  return true; 
+} 
+ 
+void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie, 
+                                          bool SkipSPAttributes) { 
+  // If -fdebug-info-for-profiling is enabled, need to emit the subprogram 
+  // and its source location. 
+  bool SkipSPSourceLocation = SkipSPAttributes && 
+                              !CUNode->getDebugInfoForProfiling(); 
+  if (!SkipSPSourceLocation) 
+    if (applySubprogramDefinitionAttributes(SP, SPDie)) 
+      return; 
+ 
+  // Constructors and operators for anonymous aggregates do not have names. 
+  if (!SP->getName().empty()) 
+    addString(SPDie, dwarf::DW_AT_name, SP->getName()); 
+ 
+  if (!SkipSPSourceLocation) 
+    addSourceLine(SPDie, SP); 
+ 
+  // Skip the rest of the attributes under -gmlt to save space. 
+  if (SkipSPAttributes) 
+    return; 
+ 
+  // Add the prototype if we have a prototype and we have a C like 
+  // language. 
+  uint16_t Language = getLanguage(); 
+  if (SP->isPrototyped() && 
+      (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 || 
+       Language == dwarf::DW_LANG_ObjC)) 
+    addFlag(SPDie, dwarf::DW_AT_prototyped); 
+ 
+  if (SP->isObjCDirect()) 
+    addFlag(SPDie, dwarf::DW_AT_APPLE_objc_direct); 
+ 
+  unsigned CC = 0; 
+  DITypeRefArray Args; 
+  if (const DISubroutineType *SPTy = SP->getType()) { 
+    Args = SPTy->getTypeArray(); 
+    CC = SPTy->getCC(); 
+  } 
+ 
+  // Add a DW_AT_calling_convention if this has an explicit convention. 
+  if (CC && CC != dwarf::DW_CC_normal) 
+    addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC); 
+ 
+  // Add a return type. If this is a type like a C/C++ void type we don't add a 
+  // return type. 
+  if (Args.size()) 
+    if (auto Ty = Args[0]) 
+      addType(SPDie, Ty); 
+ 
+  unsigned VK = SP->getVirtuality(); 
+  if (VK) { 
+    addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK); 
+    if (SP->getVirtualIndex() != -1u) { 
+      DIELoc *Block = getDIELoc(); 
+      addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 
+      addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex()); 
+      addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block); 
+    } 
+    ContainingTypeMap.insert(std::make_pair(&SPDie, SP->getContainingType())); 
+  } 
+ 
+  if (!SP->isDefinition()) { 
+    addFlag(SPDie, dwarf::DW_AT_declaration); 
+ 
+    // Add arguments. Do not add arguments for subprogram definition. They will 
+    // be handled while processing variables. 
+    constructSubprogramArguments(SPDie, Args); 
+  } 
+ 
+  addThrownTypes(SPDie, SP->getThrownTypes()); 
+ 
+  if (SP->isArtificial()) 
+    addFlag(SPDie, dwarf::DW_AT_artificial); 
+ 
+  if (!SP->isLocalToUnit()) 
+    addFlag(SPDie, dwarf::DW_AT_external); 
+ 
+  if (DD->useAppleExtensionAttributes()) { 
+    if (SP->isOptimized()) 
+      addFlag(SPDie, dwarf::DW_AT_APPLE_optimized); 
+ 
+    if (unsigned isa = Asm->getISAEncoding()) 
+      addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa); 
+  } 
+ 
+  if (SP->isLValueReference()) 
+    addFlag(SPDie, dwarf::DW_AT_reference); 
+ 
+  if (SP->isRValueReference()) 
+    addFlag(SPDie, dwarf::DW_AT_rvalue_reference); 
+ 
+  if (SP->isNoReturn()) 
+    addFlag(SPDie, dwarf::DW_AT_noreturn); 
+ 
+  if (SP->isProtected()) 
+    addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 
+            dwarf::DW_ACCESS_protected); 
+  else if (SP->isPrivate()) 
+    addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 
+            dwarf::DW_ACCESS_private); 
+  else if (SP->isPublic()) 
+    addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 
+            dwarf::DW_ACCESS_public); 
+ 
+  if (SP->isExplicit()) 
+    addFlag(SPDie, dwarf::DW_AT_explicit); 
+ 
+  if (SP->isMainSubprogram()) 
+    addFlag(SPDie, dwarf::DW_AT_main_subprogram); 
+  if (SP->isPure()) 
+    addFlag(SPDie, dwarf::DW_AT_pure); 
+  if (SP->isElemental()) 
+    addFlag(SPDie, dwarf::DW_AT_elemental); 
+  if (SP->isRecursive()) 
+    addFlag(SPDie, dwarf::DW_AT_recursive); 
+ 
+  if (DD->getDwarfVersion() >= 5 && SP->isDeleted()) 
+    addFlag(SPDie, dwarf::DW_AT_deleted); 
+} 
+ 
+void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR, 
+                                     DIE *IndexTy) { 
+  DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer); 
+  addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy); 
+ 
+  // The LowerBound value defines the lower bounds which is typically zero for 
+  // C/C++. The Count value is the number of elements.  Values are 64 bit. If 
+  // Count == -1 then the array is unbounded and we do not emit 
+  // DW_AT_lower_bound and DW_AT_count attributes. 
+  int64_t DefaultLowerBound = getDefaultLowerBound(); 
+  int64_t Count = -1; 
+  if (auto *CI = SR->getCount().dyn_cast<ConstantInt*>()) 
+    Count = CI->getSExtValue(); 
+ 
   auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
-                               DISubrange::BoundType Bound) -> void {
-    if (auto *BV = Bound.dyn_cast<DIVariable *>()) {
-      if (auto *VarDIE = getDIE(BV))
-        addDIEEntry(DW_Subrange, Attr, *VarDIE);
-    } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) {
-      DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-      DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
-      DwarfExpr.setMemoryLocationKind();
-      DwarfExpr.addExpression(BE);
-      addBlock(DW_Subrange, Attr, DwarfExpr.finalize());
-    } else if (auto *BI = Bound.dyn_cast<ConstantInt *>()) {
-      if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
-          BI->getSExtValue() != DefaultLowerBound)
-        addSInt(DW_Subrange, Attr, dwarf::DW_FORM_sdata, BI->getSExtValue());
-    }
-  };
-
+                               DISubrange::BoundType Bound) -> void { 
+    if (auto *BV = Bound.dyn_cast<DIVariable *>()) { 
+      if (auto *VarDIE = getDIE(BV)) 
+        addDIEEntry(DW_Subrange, Attr, *VarDIE); 
+    } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) { 
+      DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+      DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); 
+      DwarfExpr.setMemoryLocationKind(); 
+      DwarfExpr.addExpression(BE); 
+      addBlock(DW_Subrange, Attr, DwarfExpr.finalize()); 
+    } else if (auto *BI = Bound.dyn_cast<ConstantInt *>()) { 
+      if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 || 
+          BI->getSExtValue() != DefaultLowerBound) 
+        addSInt(DW_Subrange, Attr, dwarf::DW_FORM_sdata, BI->getSExtValue()); 
+    } 
+  }; 
+ 
   AddBoundTypeEntry(dwarf::DW_AT_lower_bound, SR->getLowerBound());
-
-  if (auto *CV = SR->getCount().dyn_cast<DIVariable*>()) {
-    if (auto *CountVarDIE = getDIE(CV))
-      addDIEEntry(DW_Subrange, dwarf::DW_AT_count, *CountVarDIE);
-  } else if (Count != -1)
-    addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
-
+ 
+  if (auto *CV = SR->getCount().dyn_cast<DIVariable*>()) { 
+    if (auto *CountVarDIE = getDIE(CV)) 
+      addDIEEntry(DW_Subrange, dwarf::DW_AT_count, *CountVarDIE); 
+  } else if (Count != -1) 
+    addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count); 
+ 
   AddBoundTypeEntry(dwarf::DW_AT_upper_bound, SR->getUpperBound());
-
+ 
   AddBoundTypeEntry(dwarf::DW_AT_byte_stride, SR->getStride());
-}
-
+} 
+ 
 void DwarfUnit::constructGenericSubrangeDIE(DIE &Buffer,
                                             const DIGenericSubrange *GSR,
                                             DIE *IndexTy) {
@@ -1357,68 +1357,68 @@ void DwarfUnit::constructGenericSubrangeDIE(DIE &Buffer,
   AddBoundTypeEntry(dwarf::DW_AT_byte_stride, GSR->getStride());
 }
 
-DIE *DwarfUnit::getIndexTyDie() {
-  if (IndexTyDie)
-    return IndexTyDie;
-  // Construct an integer type to use for indexes.
-  IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie());
-  StringRef Name = "__ARRAY_SIZE_TYPE__";
-  addString(*IndexTyDie, dwarf::DW_AT_name, Name);
-  addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
-  addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
-          dwarf::DW_ATE_unsigned);
-  DD->addAccelType(*CUNode, Name, *IndexTyDie, /*Flags*/ 0);
-  return IndexTyDie;
-}
-
-/// Returns true if the vector's size differs from the sum of sizes of elements
-/// the user specified.  This can occur if the vector has been rounded up to
-/// fit memory alignment constraints.
-static bool hasVectorBeenPadded(const DICompositeType *CTy) {
-  assert(CTy && CTy->isVector() && "Composite type is not a vector");
-  const uint64_t ActualSize = CTy->getSizeInBits();
-
-  // Obtain the size of each element in the vector.
-  DIType *BaseTy = CTy->getBaseType();
-  assert(BaseTy && "Unknown vector element type.");
-  const uint64_t ElementSize = BaseTy->getSizeInBits();
-
-  // Locate the number of elements in the vector.
-  const DINodeArray Elements = CTy->getElements();
-  assert(Elements.size() == 1 &&
-         Elements[0]->getTag() == dwarf::DW_TAG_subrange_type &&
-         "Invalid vector element array, expected one element of type subrange");
-  const auto Subrange = cast<DISubrange>(Elements[0]);
-  const auto NumVecElements =
-      Subrange->getCount()
-          ? Subrange->getCount().get<ConstantInt *>()->getSExtValue()
-          : 0;
-
-  // Ensure we found the element count and that the actual size is wide
-  // enough to contain the requested size.
-  assert(ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size");
-  return ActualSize != (NumVecElements * ElementSize);
-}
-
-void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
-  if (CTy->isVector()) {
-    addFlag(Buffer, dwarf::DW_AT_GNU_vector);
-    if (hasVectorBeenPadded(CTy))
-      addUInt(Buffer, dwarf::DW_AT_byte_size, None,
-              CTy->getSizeInBits() / CHAR_BIT);
-  }
-
-  if (DIVariable *Var = CTy->getDataLocation()) {
-    if (auto *VarDIE = getDIE(Var))
-      addDIEEntry(Buffer, dwarf::DW_AT_data_location, *VarDIE);
-  } else if (DIExpression *Expr = CTy->getDataLocationExp()) {
-    DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
-    DwarfExpr.setMemoryLocationKind();
-    DwarfExpr.addExpression(Expr);
-    addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize());
-  }
-
+DIE *DwarfUnit::getIndexTyDie() { 
+  if (IndexTyDie) 
+    return IndexTyDie; 
+  // Construct an integer type to use for indexes. 
+  IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie()); 
+  StringRef Name = "__ARRAY_SIZE_TYPE__"; 
+  addString(*IndexTyDie, dwarf::DW_AT_name, Name); 
+  addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t)); 
+  addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 
+          dwarf::DW_ATE_unsigned); 
+  DD->addAccelType(*CUNode, Name, *IndexTyDie, /*Flags*/ 0); 
+  return IndexTyDie; 
+} 
+ 
+/// Returns true if the vector's size differs from the sum of sizes of elements 
+/// the user specified.  This can occur if the vector has been rounded up to 
+/// fit memory alignment constraints. 
+static bool hasVectorBeenPadded(const DICompositeType *CTy) { 
+  assert(CTy && CTy->isVector() && "Composite type is not a vector"); 
+  const uint64_t ActualSize = CTy->getSizeInBits(); 
+ 
+  // Obtain the size of each element in the vector. 
+  DIType *BaseTy = CTy->getBaseType(); 
+  assert(BaseTy && "Unknown vector element type."); 
+  const uint64_t ElementSize = BaseTy->getSizeInBits(); 
+ 
+  // Locate the number of elements in the vector. 
+  const DINodeArray Elements = CTy->getElements(); 
+  assert(Elements.size() == 1 && 
+         Elements[0]->getTag() == dwarf::DW_TAG_subrange_type && 
+         "Invalid vector element array, expected one element of type subrange"); 
+  const auto Subrange = cast<DISubrange>(Elements[0]); 
+  const auto NumVecElements = 
+      Subrange->getCount() 
+          ? Subrange->getCount().get<ConstantInt *>()->getSExtValue() 
+          : 0; 
+ 
+  // Ensure we found the element count and that the actual size is wide 
+  // enough to contain the requested size. 
+  assert(ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size"); 
+  return ActualSize != (NumVecElements * ElementSize); 
+} 
+ 
+void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) { 
+  if (CTy->isVector()) { 
+    addFlag(Buffer, dwarf::DW_AT_GNU_vector); 
+    if (hasVectorBeenPadded(CTy)) 
+      addUInt(Buffer, dwarf::DW_AT_byte_size, None, 
+              CTy->getSizeInBits() / CHAR_BIT); 
+  } 
+ 
+  if (DIVariable *Var = CTy->getDataLocation()) { 
+    if (auto *VarDIE = getDIE(Var)) 
+      addDIEEntry(Buffer, dwarf::DW_AT_data_location, *VarDIE); 
+  } else if (DIExpression *Expr = CTy->getDataLocationExp()) { 
+    DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); 
+    DwarfExpr.setMemoryLocationKind(); 
+    DwarfExpr.addExpression(Expr); 
+    addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize()); 
+  } 
+ 
   if (DIVariable *Var = CTy->getAssociated()) {
     if (auto *VarDIE = getDIE(Var))
       addDIEEntry(Buffer, dwarf::DW_AT_associated, *VarDIE);
@@ -1452,339 +1452,339 @@ void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
     addBlock(Buffer, dwarf::DW_AT_rank, DwarfExpr.finalize());
   }
 
-  // Emit the element type.
-  addType(Buffer, CTy->getBaseType());
-
-  // Get an anonymous type for index type.
-  // FIXME: This type should be passed down from the front end
-  // as different languages may have different sizes for indexes.
-  DIE *IdxTy = getIndexTyDie();
-
-  // Add subranges to array type.
-  DINodeArray Elements = CTy->getElements();
-  for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
-    // FIXME: Should this really be such a loose cast?
+  // Emit the element type. 
+  addType(Buffer, CTy->getBaseType()); 
+ 
+  // Get an anonymous type for index type. 
+  // FIXME: This type should be passed down from the front end 
+  // as different languages may have different sizes for indexes. 
+  DIE *IdxTy = getIndexTyDie(); 
+ 
+  // Add subranges to array type. 
+  DINodeArray Elements = CTy->getElements(); 
+  for (unsigned i = 0, N = Elements.size(); i < N; ++i) { 
+    // FIXME: Should this really be such a loose cast? 
     if (auto *Element = dyn_cast_or_null<DINode>(Elements[i])) {
-      if (Element->getTag() == dwarf::DW_TAG_subrange_type)
-        constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
+      if (Element->getTag() == dwarf::DW_TAG_subrange_type) 
+        constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy); 
       else if (Element->getTag() == dwarf::DW_TAG_generic_subrange)
         constructGenericSubrangeDIE(Buffer, cast<DIGenericSubrange>(Element),
                                     IdxTy);
     }
-  }
-}
-
-void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
-  const DIType *DTy = CTy->getBaseType();
+  } 
+} 
+ 
+void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) { 
+  const DIType *DTy = CTy->getBaseType(); 
   bool IsUnsigned = DTy && DD->isUnsignedDIType(DTy);
-  if (DTy) {
-    if (DD->getDwarfVersion() >= 3)
-      addType(Buffer, DTy);
-    if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagEnumClass))
-      addFlag(Buffer, dwarf::DW_AT_enum_class);
-  }
-
-  auto *Context = CTy->getScope();
-  bool IndexEnumerators = !Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
-      isa<DINamespace>(Context) || isa<DICommonBlock>(Context);
-  DINodeArray Elements = CTy->getElements();
-
-  // Add enumerators to enumeration type.
-  for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
-    auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
-    if (Enum) {
-      DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
-      StringRef Name = Enum->getName();
-      addString(Enumerator, dwarf::DW_AT_name, Name);
-      addConstantValue(Enumerator, Enum->getValue(), IsUnsigned);
-      if (IndexEnumerators)
-        addGlobalName(Name, Enumerator, Context);
-    }
-  }
-}
-
-void DwarfUnit::constructContainingTypeDIEs() {
-  for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
-       CI != CE; ++CI) {
-    DIE &SPDie = *CI->first;
-    const DINode *D = CI->second;
-    if (!D)
-      continue;
-    DIE *NDie = getDIE(D);
-    if (!NDie)
-      continue;
-    addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
-  }
-}
-
-DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
-  DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
-  StringRef Name = DT->getName();
-  if (!Name.empty())
-    addString(MemberDie, dwarf::DW_AT_name, Name);
-
-  if (DIType *Resolved = DT->getBaseType())
-    addType(MemberDie, Resolved);
-
-  addSourceLine(MemberDie, DT);
-
-  if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
-
-    // For C++, virtual base classes are not at fixed offset. Use following
-    // expression to extract appropriate offset from vtable.
-    // BaseAddr = ObAddr + *((*ObAddr) - Offset)
-
-    DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
-    addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
-    addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
-    addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
-    addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
-    addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
-    addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
-    addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
-
-    addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
-  } else {
-    uint64_t Size = DT->getSizeInBits();
-    uint64_t FieldSize = DD->getBaseTypeSize(DT);
-    uint32_t AlignInBytes = DT->getAlignInBytes();
-    uint64_t OffsetInBytes;
-
-    bool IsBitfield = FieldSize && Size != FieldSize;
-    if (IsBitfield) {
-      // Handle bitfield, assume bytes are 8 bits.
-      if (DD->useDWARF2Bitfields())
-        addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
-      addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
-
-      uint64_t Offset = DT->getOffsetInBits();
-      // We can't use DT->getAlignInBits() here: AlignInBits for member type
-      // is non-zero if and only if alignment was forced (e.g. _Alignas()),
-      // which can't be done with bitfields. Thus we use FieldSize here.
-      uint32_t AlignInBits = FieldSize;
-      uint32_t AlignMask = ~(AlignInBits - 1);
-      // The bits from the start of the storage unit to the start of the field.
-      uint64_t StartBitOffset = Offset - (Offset & AlignMask);
-      // The byte offset of the field's aligned storage unit inside the struct.
-      OffsetInBytes = (Offset - StartBitOffset) / 8;
-
-      if (DD->useDWARF2Bitfields()) {
-        uint64_t HiMark = (Offset + FieldSize) & AlignMask;
-        uint64_t FieldOffset = (HiMark - FieldSize);
-        Offset -= FieldOffset;
-
-        // Maybe we need to work from the other end.
-        if (Asm->getDataLayout().isLittleEndian())
-          Offset = FieldSize - (Offset + Size);
-
-        addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
-        OffsetInBytes = FieldOffset >> 3;
-      } else {
-        addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset);
-      }
-    } else {
-      // This is not a bitfield.
-      OffsetInBytes = DT->getOffsetInBits() / 8;
-      if (AlignInBytes)
-        addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
-                AlignInBytes);
-    }
-
-    if (DD->getDwarfVersion() <= 2) {
-      DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
-      addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
-      addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
-      addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
-    } else if (!IsBitfield || DD->useDWARF2Bitfields())
-      addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
-              OffsetInBytes);
-  }
-
-  if (DT->isProtected())
-    addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
-            dwarf::DW_ACCESS_protected);
-  else if (DT->isPrivate())
-    addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
-            dwarf::DW_ACCESS_private);
-  // Otherwise C++ member and base classes are considered public.
-  else if (DT->isPublic())
-    addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
-            dwarf::DW_ACCESS_public);
-  if (DT->isVirtual())
-    addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
-            dwarf::DW_VIRTUALITY_virtual);
-
-  // Objective-C properties.
-  if (DINode *PNode = DT->getObjCProperty())
-    if (DIE *PDie = getDIE(PNode))
-      MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
-                         dwarf::DW_FORM_ref4, DIEEntry(*PDie));
-
-  if (DT->isArtificial())
-    addFlag(MemberDie, dwarf::DW_AT_artificial);
-
-  return MemberDie;
-}
-
-DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
-  if (!DT)
-    return nullptr;
-
-  // Construct the context before querying for the existence of the DIE in case
-  // such construction creates the DIE.
-  DIE *ContextDIE = getOrCreateContextDIE(DT->getScope());
-  assert(dwarf::isType(ContextDIE->getTag()) &&
-         "Static member should belong to a type.");
-
-  if (DIE *StaticMemberDIE = getDIE(DT))
-    return StaticMemberDIE;
-
-  DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
-
-  const DIType *Ty = DT->getBaseType();
-
-  addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
-  addType(StaticMemberDIE, Ty);
-  addSourceLine(StaticMemberDIE, DT);
-  addFlag(StaticMemberDIE, dwarf::DW_AT_external);
-  addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
-
-  // FIXME: We could omit private if the parent is a class_type, and
-  // public if the parent is something else.
-  if (DT->isProtected())
-    addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
-            dwarf::DW_ACCESS_protected);
-  else if (DT->isPrivate())
-    addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
-            dwarf::DW_ACCESS_private);
-  else if (DT->isPublic())
-    addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
-            dwarf::DW_ACCESS_public);
-
-  if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
-    addConstantValue(StaticMemberDIE, CI, Ty);
-  if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
-    addConstantFPValue(StaticMemberDIE, CFP);
-
-  if (uint32_t AlignInBytes = DT->getAlignInBytes())
-    addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
-            AlignInBytes);
-
-  return &StaticMemberDIE;
-}
-
-void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) {
-  // Emit size of content not including length itself
-  if (!DD->useSectionsAsReferences()) {
-    StringRef Prefix = isDwoUnit() ? "debug_info_dwo_" : "debug_info_";
-    MCSymbol *BeginLabel = Asm->createTempSymbol(Prefix + "start");
-    EndLabel = Asm->createTempSymbol(Prefix + "end");
+  if (DTy) { 
+    if (DD->getDwarfVersion() >= 3) 
+      addType(Buffer, DTy); 
+    if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagEnumClass)) 
+      addFlag(Buffer, dwarf::DW_AT_enum_class); 
+  } 
+ 
+  auto *Context = CTy->getScope(); 
+  bool IndexEnumerators = !Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) || 
+      isa<DINamespace>(Context) || isa<DICommonBlock>(Context); 
+  DINodeArray Elements = CTy->getElements(); 
+ 
+  // Add enumerators to enumeration type. 
+  for (unsigned i = 0, N = Elements.size(); i < N; ++i) { 
+    auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]); 
+    if (Enum) { 
+      DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer); 
+      StringRef Name = Enum->getName(); 
+      addString(Enumerator, dwarf::DW_AT_name, Name); 
+      addConstantValue(Enumerator, Enum->getValue(), IsUnsigned); 
+      if (IndexEnumerators) 
+        addGlobalName(Name, Enumerator, Context); 
+    } 
+  } 
+} 
+ 
+void DwarfUnit::constructContainingTypeDIEs() { 
+  for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end(); 
+       CI != CE; ++CI) { 
+    DIE &SPDie = *CI->first; 
+    const DINode *D = CI->second; 
+    if (!D) 
+      continue; 
+    DIE *NDie = getDIE(D); 
+    if (!NDie) 
+      continue; 
+    addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie); 
+  } 
+} 
+ 
+DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) { 
+  DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer); 
+  StringRef Name = DT->getName(); 
+  if (!Name.empty()) 
+    addString(MemberDie, dwarf::DW_AT_name, Name); 
+ 
+  if (DIType *Resolved = DT->getBaseType()) 
+    addType(MemberDie, Resolved); 
+ 
+  addSourceLine(MemberDie, DT); 
+ 
+  if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) { 
+ 
+    // For C++, virtual base classes are not at fixed offset. Use following 
+    // expression to extract appropriate offset from vtable. 
+    // BaseAddr = ObAddr + *((*ObAddr) - Offset) 
+ 
+    DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc; 
+    addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup); 
+    addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 
+    addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 
+    addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits()); 
+    addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus); 
+    addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 
+    addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 
+ 
+    addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie); 
+  } else { 
+    uint64_t Size = DT->getSizeInBits(); 
+    uint64_t FieldSize = DD->getBaseTypeSize(DT); 
+    uint32_t AlignInBytes = DT->getAlignInBytes(); 
+    uint64_t OffsetInBytes; 
+ 
+    bool IsBitfield = FieldSize && Size != FieldSize; 
+    if (IsBitfield) { 
+      // Handle bitfield, assume bytes are 8 bits. 
+      if (DD->useDWARF2Bitfields()) 
+        addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8); 
+      addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size); 
+ 
+      uint64_t Offset = DT->getOffsetInBits(); 
+      // We can't use DT->getAlignInBits() here: AlignInBits for member type 
+      // is non-zero if and only if alignment was forced (e.g. _Alignas()), 
+      // which can't be done with bitfields. Thus we use FieldSize here. 
+      uint32_t AlignInBits = FieldSize; 
+      uint32_t AlignMask = ~(AlignInBits - 1); 
+      // The bits from the start of the storage unit to the start of the field. 
+      uint64_t StartBitOffset = Offset - (Offset & AlignMask); 
+      // The byte offset of the field's aligned storage unit inside the struct. 
+      OffsetInBytes = (Offset - StartBitOffset) / 8; 
+ 
+      if (DD->useDWARF2Bitfields()) { 
+        uint64_t HiMark = (Offset + FieldSize) & AlignMask; 
+        uint64_t FieldOffset = (HiMark - FieldSize); 
+        Offset -= FieldOffset; 
+ 
+        // Maybe we need to work from the other end. 
+        if (Asm->getDataLayout().isLittleEndian()) 
+          Offset = FieldSize - (Offset + Size); 
+ 
+        addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset); 
+        OffsetInBytes = FieldOffset >> 3; 
+      } else { 
+        addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset); 
+      } 
+    } else { 
+      // This is not a bitfield. 
+      OffsetInBytes = DT->getOffsetInBits() / 8; 
+      if (AlignInBytes) 
+        addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, 
+                AlignInBytes); 
+    } 
+ 
+    if (DD->getDwarfVersion() <= 2) { 
+      DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc; 
+      addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 
+      addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes); 
+      addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie); 
+    } else if (!IsBitfield || DD->useDWARF2Bitfields()) 
+      addUInt(MemberDie, dwarf::DW_AT_data_member_location, None, 
+              OffsetInBytes); 
+  } 
+ 
+  if (DT->isProtected()) 
+    addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 
+            dwarf::DW_ACCESS_protected); 
+  else if (DT->isPrivate()) 
+    addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 
+            dwarf::DW_ACCESS_private); 
+  // Otherwise C++ member and base classes are considered public. 
+  else if (DT->isPublic()) 
+    addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 
+            dwarf::DW_ACCESS_public); 
+  if (DT->isVirtual()) 
+    addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, 
+            dwarf::DW_VIRTUALITY_virtual); 
+ 
+  // Objective-C properties. 
+  if (DINode *PNode = DT->getObjCProperty()) 
+    if (DIE *PDie = getDIE(PNode)) 
+      MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property, 
+                         dwarf::DW_FORM_ref4, DIEEntry(*PDie)); 
+ 
+  if (DT->isArtificial()) 
+    addFlag(MemberDie, dwarf::DW_AT_artificial); 
+ 
+  return MemberDie; 
+} 
+ 
+DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) { 
+  if (!DT) 
+    return nullptr; 
+ 
+  // Construct the context before querying for the existence of the DIE in case 
+  // such construction creates the DIE. 
+  DIE *ContextDIE = getOrCreateContextDIE(DT->getScope()); 
+  assert(dwarf::isType(ContextDIE->getTag()) && 
+         "Static member should belong to a type."); 
+ 
+  if (DIE *StaticMemberDIE = getDIE(DT)) 
+    return StaticMemberDIE; 
+ 
+  DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT); 
+ 
+  const DIType *Ty = DT->getBaseType(); 
+ 
+  addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName()); 
+  addType(StaticMemberDIE, Ty); 
+  addSourceLine(StaticMemberDIE, DT); 
+  addFlag(StaticMemberDIE, dwarf::DW_AT_external); 
+  addFlag(StaticMemberDIE, dwarf::DW_AT_declaration); 
+ 
+  // FIXME: We could omit private if the parent is a class_type, and 
+  // public if the parent is something else. 
+  if (DT->isProtected()) 
+    addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 
+            dwarf::DW_ACCESS_protected); 
+  else if (DT->isPrivate()) 
+    addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 
+            dwarf::DW_ACCESS_private); 
+  else if (DT->isPublic()) 
+    addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 
+            dwarf::DW_ACCESS_public); 
+ 
+  if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant())) 
+    addConstantValue(StaticMemberDIE, CI, Ty); 
+  if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant())) 
+    addConstantFPValue(StaticMemberDIE, CFP); 
+ 
+  if (uint32_t AlignInBytes = DT->getAlignInBytes()) 
+    addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata, 
+            AlignInBytes); 
+ 
+  return &StaticMemberDIE; 
+} 
+ 
+void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) { 
+  // Emit size of content not including length itself 
+  if (!DD->useSectionsAsReferences()) { 
+    StringRef Prefix = isDwoUnit() ? "debug_info_dwo_" : "debug_info_"; 
+    MCSymbol *BeginLabel = Asm->createTempSymbol(Prefix + "start"); 
+    EndLabel = Asm->createTempSymbol(Prefix + "end"); 
     Asm->emitDwarfUnitLength(EndLabel, BeginLabel, "Length of Unit");
-    Asm->OutStreamer->emitLabel(BeginLabel);
-  } else
+    Asm->OutStreamer->emitLabel(BeginLabel); 
+  } else 
     Asm->emitDwarfUnitLength(getHeaderSize() + getUnitDie().getSize(),
                              "Length of Unit");
-
-  Asm->OutStreamer->AddComment("DWARF version number");
-  unsigned Version = DD->getDwarfVersion();
-  Asm->emitInt16(Version);
-
-  // DWARF v5 reorders the address size and adds a unit type.
-  if (Version >= 5) {
-    Asm->OutStreamer->AddComment("DWARF Unit Type");
-    Asm->emitInt8(UT);
-    Asm->OutStreamer->AddComment("Address Size (in bytes)");
-    Asm->emitInt8(Asm->MAI->getCodePointerSize());
-  }
-
-  // We share one abbreviations table across all units so it's always at the
-  // start of the section. Use a relocatable offset where needed to ensure
-  // linking doesn't invalidate that offset.
-  Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
-  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
-  if (UseOffsets)
+ 
+  Asm->OutStreamer->AddComment("DWARF version number"); 
+  unsigned Version = DD->getDwarfVersion(); 
+  Asm->emitInt16(Version); 
+ 
+  // DWARF v5 reorders the address size and adds a unit type. 
+  if (Version >= 5) { 
+    Asm->OutStreamer->AddComment("DWARF Unit Type"); 
+    Asm->emitInt8(UT); 
+    Asm->OutStreamer->AddComment("Address Size (in bytes)"); 
+    Asm->emitInt8(Asm->MAI->getCodePointerSize()); 
+  } 
+ 
+  // We share one abbreviations table across all units so it's always at the 
+  // start of the section. Use a relocatable offset where needed to ensure 
+  // linking doesn't invalidate that offset. 
+  Asm->OutStreamer->AddComment("Offset Into Abbrev. Section"); 
+  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 
+  if (UseOffsets) 
     Asm->emitDwarfLengthOrOffset(0);
-  else
-    Asm->emitDwarfSymbolReference(
-        TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
-
-  if (Version <= 4) {
-    Asm->OutStreamer->AddComment("Address Size (in bytes)");
-    Asm->emitInt8(Asm->MAI->getCodePointerSize());
-  }
-}
-
-void DwarfTypeUnit::emitHeader(bool UseOffsets) {
-  DwarfUnit::emitCommonHeader(UseOffsets,
-                              DD->useSplitDwarf() ? dwarf::DW_UT_split_type
-                                                  : dwarf::DW_UT_type);
-  Asm->OutStreamer->AddComment("Type Signature");
-  Asm->OutStreamer->emitIntValue(TypeSignature, sizeof(TypeSignature));
-  Asm->OutStreamer->AddComment("Type DIE Offset");
-  // In a skeleton type unit there is no type DIE so emit a zero offset.
+  else 
+    Asm->emitDwarfSymbolReference( 
+        TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false); 
+ 
+  if (Version <= 4) { 
+    Asm->OutStreamer->AddComment("Address Size (in bytes)"); 
+    Asm->emitInt8(Asm->MAI->getCodePointerSize()); 
+  } 
+} 
+ 
+void DwarfTypeUnit::emitHeader(bool UseOffsets) { 
+  DwarfUnit::emitCommonHeader(UseOffsets, 
+                              DD->useSplitDwarf() ? dwarf::DW_UT_split_type 
+                                                  : dwarf::DW_UT_type); 
+  Asm->OutStreamer->AddComment("Type Signature"); 
+  Asm->OutStreamer->emitIntValue(TypeSignature, sizeof(TypeSignature)); 
+  Asm->OutStreamer->AddComment("Type DIE Offset"); 
+  // In a skeleton type unit there is no type DIE so emit a zero offset. 
   Asm->emitDwarfLengthOrOffset(Ty ? Ty->getOffset() : 0);
-}
-
-DIE::value_iterator
-DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
-                           const MCSymbol *Hi, const MCSymbol *Lo) {
-  return Die.addValue(DIEValueAllocator, Attribute,
+} 
+ 
+DIE::value_iterator 
+DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute, 
+                           const MCSymbol *Hi, const MCSymbol *Lo) { 
+  return Die.addValue(DIEValueAllocator, Attribute, 
                       DD->getDwarfSectionOffsetForm(),
-                      new (DIEValueAllocator) DIEDelta(Hi, Lo));
-}
-
-DIE::value_iterator
-DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
-                           const MCSymbol *Label, const MCSymbol *Sec) {
-  if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
+                      new (DIEValueAllocator) DIEDelta(Hi, Lo)); 
+} 
+ 
+DIE::value_iterator 
+DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute, 
+                           const MCSymbol *Label, const MCSymbol *Sec) { 
+  if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 
     return addLabel(Die, Attribute, DD->getDwarfSectionOffsetForm(), Label);
-  return addSectionDelta(Die, Attribute, Label, Sec);
-}
-
-bool DwarfTypeUnit::isDwoUnit() const {
-  // Since there are no skeleton type units, all type units are dwo type units
-  // when split DWARF is being used.
-  return DD->useSplitDwarf();
-}
-
-void DwarfTypeUnit::addGlobalName(StringRef Name, const DIE &Die,
-                                  const DIScope *Context) {
-  getCU().addGlobalNameForTypeUnit(Name, Context);
-}
-
-void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die,
-                                  const DIScope *Context) {
-  getCU().addGlobalTypeUnitType(Ty, Context);
-}
-
-const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
-  if (!Asm->MAI->doesDwarfUseRelocationsAcrossSections())
-    return nullptr;
-  if (isDwoUnit())
-    return nullptr;
-  return getSection()->getBeginSymbol();
-}
-
-void DwarfUnit::addStringOffsetsStart() {
-  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
-  addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base,
-                  DU->getStringOffsetsStartSym(),
-                  TLOF.getDwarfStrOffSection()->getBeginSymbol());
-}
-
-void DwarfUnit::addRnglistsBase() {
-  assert(DD->getDwarfVersion() >= 5 &&
-         "DW_AT_rnglists_base requires DWARF version 5 or later");
-  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
-  addSectionLabel(getUnitDie(), dwarf::DW_AT_rnglists_base,
-                  DU->getRnglistsTableBaseSym(),
-                  TLOF.getDwarfRnglistsSection()->getBeginSymbol());
-}
-
-void DwarfTypeUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) {
-  addFlag(D, dwarf::DW_AT_declaration);
-  StringRef Name = CTy->getName();
-  if (!Name.empty())
-    addString(D, dwarf::DW_AT_name, Name);
-  getCU().createTypeDIE(CTy);
-}
+  return addSectionDelta(Die, Attribute, Label, Sec); 
+} 
+ 
+bool DwarfTypeUnit::isDwoUnit() const { 
+  // Since there are no skeleton type units, all type units are dwo type units 
+  // when split DWARF is being used. 
+  return DD->useSplitDwarf(); 
+} 
+ 
+void DwarfTypeUnit::addGlobalName(StringRef Name, const DIE &Die, 
+                                  const DIScope *Context) { 
+  getCU().addGlobalNameForTypeUnit(Name, Context); 
+} 
+ 
+void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die, 
+                                  const DIScope *Context) { 
+  getCU().addGlobalTypeUnitType(Ty, Context); 
+} 
+ 
+const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const { 
+  if (!Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 
+    return nullptr; 
+  if (isDwoUnit()) 
+    return nullptr; 
+  return getSection()->getBeginSymbol(); 
+} 
+ 
+void DwarfUnit::addStringOffsetsStart() { 
+  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 
+  addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base, 
+                  DU->getStringOffsetsStartSym(), 
+                  TLOF.getDwarfStrOffSection()->getBeginSymbol()); 
+} 
+ 
+void DwarfUnit::addRnglistsBase() { 
+  assert(DD->getDwarfVersion() >= 5 && 
+         "DW_AT_rnglists_base requires DWARF version 5 or later"); 
+  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 
+  addSectionLabel(getUnitDie(), dwarf::DW_AT_rnglists_base, 
+                  DU->getRnglistsTableBaseSym(), 
+                  TLOF.getDwarfRnglistsSection()->getBeginSymbol()); 
+} 
+ 
+void DwarfTypeUnit::finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) { 
+  addFlag(D, dwarf::DW_AT_declaration); 
+  StringRef Name = CTy->getName(); 
+  if (!Name.empty()) 
+    addString(D, dwarf::DW_AT_name, Name); 
+  getCU().createTypeDIE(CTy); 
+}