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

1 files changed, 146 insertions, 146 deletions

diff --git a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.cpp b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
index 118b5fcc3b..61f2eafa87 100644
--- a/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
+++ b/contrib/libs/llvm12/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
@@ -83,14 +83,14 @@ unsigned DIEDwarfExpression::getTemporaryBufferSize() {
 void DIEDwarfExpression::commitTemporaryBuffer() { OutDIE.takeValues(TmpDIE); }
 
 bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
-                                         llvm::Register MachineReg) {
+                                         llvm::Register MachineReg) { 
   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) {}
+    : DIEUnit(UnitTag), CUNode(Node), Asm(A), DD(DW), DU(DWU), 
+      IndexTyDie(nullptr) {} 
 
 DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
                              DwarfDebug *DW, DwarfFile *DWU,
@@ -299,7 +299,7 @@ void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
 
 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
                                  uint64_t Integer) {
-  addUInt(Die, Attribute, DD->getDwarfSectionOffsetForm(), Integer);
+  addUInt(Die, Attribute, DD->getDwarfSectionOffsetForm(), Integer); 
 }
 
 unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
@@ -310,9 +310,9 @@ unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
     // 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());
+  return SplitLineTable->getFile( 
+      File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File), 
+      Asm->OutContext.getDwarfVersion(), File->getSource()); 
 }
 
 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
@@ -330,7 +330,7 @@ void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
   }
 
   addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
-  addLabel(Die, dwarf::DW_FORM_addr, Sym);
+  addLabel(Die, dwarf::DW_FORM_addr, Sym); 
 }
 
 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
@@ -445,7 +445,7 @@ void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
 }
 
 void DwarfUnit::addConstantValue(DIE &Die, uint64_t Val, const DIType *Ty) {
-  addConstantValue(Die, DD->isUnsignedDIType(Ty), Val);
+  addConstantValue(Die, DD->isUnsignedDIType(Ty), Val); 
 }
 
 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
@@ -456,7 +456,7 @@ void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
 }
 
 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
-  addConstantValue(Die, Val, DD->isUnsignedDIType(Ty));
+  addConstantValue(Die, Val, DD->isUnsignedDIType(Ty)); 
 }
 
 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
@@ -553,8 +553,8 @@ DIE *DwarfUnit::createTypeDIE(const DIScope *Context, DIE &ContextDIE,
 
   if (auto *BT = dyn_cast<DIBasicType>(Ty))
     constructTypeDIE(TyDIE, BT);
-  else if (auto *ST = dyn_cast<DIStringType>(Ty))
-    constructTypeDIE(TyDIE, ST);
+  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)) {
@@ -673,9 +673,9 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
   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());
+  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);
@@ -686,37 +686,37 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
     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();
-  // Add name if not anonymous or intermediate type.
-  if (!Name.empty())
-    addString(Buffer, dwarf::DW_AT_name, Name);
-
-  if (DIVariable *Var = STy->getStringLength()) {
-    if (auto *VarDIE = getDIE(Var))
-      addDIEEntry(Buffer, dwarf::DW_AT_string_length, *VarDIE);
-  } else if (DIExpression *Expr = STy->getStringLengthExp()) {
-    DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
-    // This is to describe the memory location of the
-    // length of a Fortran deferred length string, so
-    // lock it down as such.
-    DwarfExpr.setMemoryLocationKind();
-    DwarfExpr.addExpression(Expr);
-    addBlock(Buffer, dwarf::DW_AT_string_length, DwarfExpr.finalize());
-  } else {
-    uint64_t Size = STy->getSizeInBits() >> 3;
-    addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
-  }
-
-  if (STy->getEncoding()) {
-    // For eventual Unicode support.
-    addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
-            STy->getEncoding());
-  }
-}
-
+void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIStringType *STy) { 
+  // Get core information. 
+  StringRef Name = STy->getName(); 
+  // Add name if not anonymous or intermediate type. 
+  if (!Name.empty()) 
+    addString(Buffer, dwarf::DW_AT_name, Name); 
+ 
+  if (DIVariable *Var = STy->getStringLength()) { 
+    if (auto *VarDIE = getDIE(Var)) 
+      addDIEEntry(Buffer, dwarf::DW_AT_string_length, *VarDIE); 
+  } else if (DIExpression *Expr = STy->getStringLengthExp()) { 
+    DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); 
+    // This is to describe the memory location of the 
+    // length of a Fortran deferred length string, so 
+    // lock it down as such. 
+    DwarfExpr.setMemoryLocationKind(); 
+    DwarfExpr.addExpression(Expr); 
+    addBlock(Buffer, dwarf::DW_AT_string_length, DwarfExpr.finalize()); 
+  } else { 
+    uint64_t Size = STy->getSizeInBits() >> 3; 
+    addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 
+  } 
+ 
+  if (STy->getEncoding()) { 
+    // For eventual Unicode support. 
+    addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 
+            STy->getEncoding()); 
+  } 
+} 
+ 
 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
   // Get core information.
   StringRef Name = DTy->getName();
@@ -843,11 +843,11 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
       }
     }
 
-    // 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 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) {
@@ -867,7 +867,7 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
           DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer);
           if (const ConstantInt *CI =
               dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
-            if (DD->isUnsignedDIType(Discriminator->getBaseType()))
+            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());
@@ -940,10 +940,10 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
       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.
+    // Ignore the size if it's a non-enum forward decl. 
     // TODO: Do we care about size for enum forward declarations?
-    if (Size &&
-        (!CTy->isForwardDecl() || Tag == dwarf::DW_TAG_enumeration_type))
+    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.
@@ -1067,8 +1067,8 @@ DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
             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);
+  if (M->getIsDecl()) 
+    addFlag(MDie, dwarf::DW_AT_declaration); 
 
   return &MDie;
 }
@@ -1290,7 +1290,7 @@ void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
   if (auto *CI = SR->getCount().dyn_cast<ConstantInt*>())
     Count = CI->getSExtValue();
 
-  auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
+  auto AddBoundTypeEntry = [&](dwarf::Attribute Attr, 
                                DISubrange::BoundType Bound) -> void {
     if (auto *BV = Bound.dyn_cast<DIVariable *>()) {
       if (auto *VarDIE = getDIE(BV))
@@ -1308,7 +1308,7 @@ void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
     }
   };
 
-  AddBoundTypeEntry(dwarf::DW_AT_lower_bound, SR->getLowerBound());
+  AddBoundTypeEntry(dwarf::DW_AT_lower_bound, SR->getLowerBound()); 
 
   if (auto *CV = SR->getCount().dyn_cast<DIVariable*>()) {
     if (auto *CountVarDIE = getDIE(CV))
@@ -1316,47 +1316,47 @@ void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
   } 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) {
-  DIE &DwGenericSubrange =
-      createAndAddDIE(dwarf::DW_TAG_generic_subrange, Buffer);
-  addDIEEntry(DwGenericSubrange, dwarf::DW_AT_type, *IndexTy);
-
-  int64_t DefaultLowerBound = getDefaultLowerBound();
-
-  auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
-                               DIGenericSubrange::BoundType Bound) -> void {
-    if (auto *BV = Bound.dyn_cast<DIVariable *>()) {
-      if (auto *VarDIE = getDIE(BV))
-        addDIEEntry(DwGenericSubrange, Attr, *VarDIE);
-    } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) {
-      if (BE->isSignedConstant()) {
-        if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
-            static_cast<int64_t>(BE->getElement(1)) != DefaultLowerBound)
-          addSInt(DwGenericSubrange, Attr, dwarf::DW_FORM_sdata,
-                  BE->getElement(1));
-      } else {
-        DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-        DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
-        DwarfExpr.setMemoryLocationKind();
-        DwarfExpr.addExpression(BE);
-        addBlock(DwGenericSubrange, Attr, DwarfExpr.finalize());
-      }
-    }
-  };
-
-  AddBoundTypeEntry(dwarf::DW_AT_lower_bound, GSR->getLowerBound());
-  AddBoundTypeEntry(dwarf::DW_AT_count, GSR->getCount());
-  AddBoundTypeEntry(dwarf::DW_AT_upper_bound, GSR->getUpperBound());
-  AddBoundTypeEntry(dwarf::DW_AT_byte_stride, GSR->getStride());
-}
-
+  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) { 
+  DIE &DwGenericSubrange = 
+      createAndAddDIE(dwarf::DW_TAG_generic_subrange, Buffer); 
+  addDIEEntry(DwGenericSubrange, dwarf::DW_AT_type, *IndexTy); 
+ 
+  int64_t DefaultLowerBound = getDefaultLowerBound(); 
+ 
+  auto AddBoundTypeEntry = [&](dwarf::Attribute Attr, 
+                               DIGenericSubrange::BoundType Bound) -> void { 
+    if (auto *BV = Bound.dyn_cast<DIVariable *>()) { 
+      if (auto *VarDIE = getDIE(BV)) 
+        addDIEEntry(DwGenericSubrange, Attr, *VarDIE); 
+    } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) { 
+      if (BE->isSignedConstant()) { 
+        if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 || 
+            static_cast<int64_t>(BE->getElement(1)) != DefaultLowerBound) 
+          addSInt(DwGenericSubrange, Attr, dwarf::DW_FORM_sdata, 
+                  BE->getElement(1)); 
+      } else { 
+        DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+        DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); 
+        DwarfExpr.setMemoryLocationKind(); 
+        DwarfExpr.addExpression(BE); 
+        addBlock(DwGenericSubrange, Attr, DwarfExpr.finalize()); 
+      } 
+    } 
+  }; 
+ 
+  AddBoundTypeEntry(dwarf::DW_AT_lower_bound, GSR->getLowerBound()); 
+  AddBoundTypeEntry(dwarf::DW_AT_count, GSR->getCount()); 
+  AddBoundTypeEntry(dwarf::DW_AT_upper_bound, GSR->getUpperBound()); 
+  AddBoundTypeEntry(dwarf::DW_AT_byte_stride, GSR->getStride()); 
+} 
+ 
 DIE *DwarfUnit::getIndexTyDie() {
   if (IndexTyDie)
     return IndexTyDie;
@@ -1419,39 +1419,39 @@ void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
     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);
-  } else if (DIExpression *Expr = CTy->getAssociatedExp()) {
-    DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
-    DwarfExpr.setMemoryLocationKind();
-    DwarfExpr.addExpression(Expr);
-    addBlock(Buffer, dwarf::DW_AT_associated, DwarfExpr.finalize());
-  }
-
-  if (DIVariable *Var = CTy->getAllocated()) {
-    if (auto *VarDIE = getDIE(Var))
-      addDIEEntry(Buffer, dwarf::DW_AT_allocated, *VarDIE);
-  } else if (DIExpression *Expr = CTy->getAllocatedExp()) {
-    DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
-    DwarfExpr.setMemoryLocationKind();
-    DwarfExpr.addExpression(Expr);
-    addBlock(Buffer, dwarf::DW_AT_allocated, DwarfExpr.finalize());
-  }
-
-  if (auto *RankConst = CTy->getRankConst()) {
-    addSInt(Buffer, dwarf::DW_AT_rank, dwarf::DW_FORM_sdata,
-            RankConst->getSExtValue());
-  } else if (auto *RankExpr = CTy->getRankExp()) {
-    DIELoc *Loc = new (DIEValueAllocator) DIELoc;
-    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
-    DwarfExpr.setMemoryLocationKind();
-    DwarfExpr.addExpression(RankExpr);
-    addBlock(Buffer, dwarf::DW_AT_rank, DwarfExpr.finalize());
-  }
-
+  if (DIVariable *Var = CTy->getAssociated()) { 
+    if (auto *VarDIE = getDIE(Var)) 
+      addDIEEntry(Buffer, dwarf::DW_AT_associated, *VarDIE); 
+  } else if (DIExpression *Expr = CTy->getAssociatedExp()) { 
+    DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); 
+    DwarfExpr.setMemoryLocationKind(); 
+    DwarfExpr.addExpression(Expr); 
+    addBlock(Buffer, dwarf::DW_AT_associated, DwarfExpr.finalize()); 
+  } 
+ 
+  if (DIVariable *Var = CTy->getAllocated()) { 
+    if (auto *VarDIE = getDIE(Var)) 
+      addDIEEntry(Buffer, dwarf::DW_AT_allocated, *VarDIE); 
+  } else if (DIExpression *Expr = CTy->getAllocatedExp()) { 
+    DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); 
+    DwarfExpr.setMemoryLocationKind(); 
+    DwarfExpr.addExpression(Expr); 
+    addBlock(Buffer, dwarf::DW_AT_allocated, DwarfExpr.finalize()); 
+  } 
+ 
+  if (auto *RankConst = CTy->getRankConst()) { 
+    addSInt(Buffer, dwarf::DW_AT_rank, dwarf::DW_FORM_sdata, 
+            RankConst->getSExtValue()); 
+  } else if (auto *RankExpr = CTy->getRankExp()) { 
+    DIELoc *Loc = new (DIEValueAllocator) DIELoc; 
+    DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc); 
+    DwarfExpr.setMemoryLocationKind(); 
+    DwarfExpr.addExpression(RankExpr); 
+    addBlock(Buffer, dwarf::DW_AT_rank, DwarfExpr.finalize()); 
+  } 
+ 
   // Emit the element type.
   addType(Buffer, CTy->getBaseType());
 
@@ -1464,19 +1464,19 @@ void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
   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 (auto *Element = dyn_cast_or_null<DINode>(Elements[i])) { 
       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);
-    }
+      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();
-  bool IsUnsigned = DTy && DD->isUnsignedDIType(DTy);
+  bool IsUnsigned = DTy && DD->isUnsignedDIType(DTy); 
   if (DTy) {
     if (DD->getDwarfVersion() >= 3)
       addType(Buffer, DTy);
@@ -1679,11 +1679,11 @@ void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) {
     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->emitDwarfUnitLength(EndLabel, BeginLabel, "Length of Unit"); 
     Asm->OutStreamer->emitLabel(BeginLabel);
   } else
-    Asm->emitDwarfUnitLength(getHeaderSize() + getUnitDie().getSize(),
-                             "Length of Unit");
+    Asm->emitDwarfUnitLength(getHeaderSize() + getUnitDie().getSize(), 
+                             "Length of Unit"); 
 
   Asm->OutStreamer->AddComment("DWARF version number");
   unsigned Version = DD->getDwarfVersion();
@@ -1703,7 +1703,7 @@ void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) {
   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
   if (UseOffsets)
-    Asm->emitDwarfLengthOrOffset(0);
+    Asm->emitDwarfLengthOrOffset(0); 
   else
     Asm->emitDwarfSymbolReference(
         TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
@@ -1722,14 +1722,14 @@ void DwarfTypeUnit::emitHeader(bool UseOffsets) {
   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);
+  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,
-                      DD->getDwarfSectionOffsetForm(),
+                      DD->getDwarfSectionOffsetForm(), 
                       new (DIEValueAllocator) DIEDelta(Hi, Lo));
 }
 
@@ -1737,7 +1737,7 @@ 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 addLabel(Die, Attribute, DD->getDwarfSectionOffsetForm(), Label); 
   return addSectionDelta(Die, Attribute, Label, Sec);
 }