DebugInfo: support for DWARFv5 DW_AT_alignment attribute

[vleschuk]

Summary

• Assume that clang passes non-zero alignment value to DIBuilder only in case when it was forced by C++11 'alignas', C11 '_Alignas' or compiler attribute '__attribute((aligned (N)))'.
• Emit DW_AT_alignment if alignment is specified for type/object. See: http://www.dwarfstd.org/ShowIssue.php?issue=140528.1 for more details.

[dblaikie]

What's the purpose of the flag? Could we just use the non-zero value of the alignment attribute as the signal of whether to emit the DW_AT_alignment attribute? (eg: if the alignment is specified, emit it - simple?)

[probinson]

DW_FORM_data8 seems wasteful. I'd rather see DW_FORM_udata.

[vleschuk]

In D24425#539028, @dblaikie wrote:

What's the purpose of the flag? Could we just use the non-zero value of the alignment attribute as the signal of whether to emit the DW_AT_alignment attribute? (eg: if the alignment is specified, emit it - simple?)

The alignment could be not specified and default alignment is used. Consider the following example:

struct S {
} s;

This will result in the following IR code:

!5 = !DICompositeType(tag: DW_TAG_structure_type, name: "S", file: !1, line: 1, align: 8, elements: !2)

And getAlignInBits() will return 8. Thus we need to mark entities with non-default alignment.

[vleschuk]

In D24425#539081, @probinson wrote:

DW_FORM_data8 seems wasteful. I'd rather see DW_FORM_udata.

Agreed. I also had a thought that data8 is too large for that. I just (for some reason) was sure that DWARF document explicitly stated that value should be 64 bit. Rechecked now: there is no such info in that doc, I was mistaken. Will fix.

[vleschuk]

Switched from DW_FORM_data8 to DW_FORM_udata for DW_AT_alignment.

[dblaikie]

In D24425#539340, @vleschuk wrote:

In D24425#539028, @dblaikie wrote:

What's the purpose of the flag? Could we just use the non-zero value of the alignment attribute as the signal of whether to emit the DW_AT_alignment attribute? (eg: if the alignment is specified, emit it - simple?)

The alignment could be not specified and default alignment is used. Consider the following example:

struct S {
} s;

This will result in the following IR code:

!5 = !DICompositeType(tag: DW_TAG_structure_type, name: "S", file: !1, line: 1, align: 8, elements: !2)

And getAlignInBits() will return 8. Thus we need to mark entities with non-default alignment.

Is the alignment used for anything in this case? Could we just remove it & make it so that whenever it's present we put the DW_AT_alignment attribute on the entity?

[vleschuk]

In D24425#539393, @dblaikie wrote:

In D24425#539340, @vleschuk wrote:

In D24425#539028, @dblaikie wrote:

What's the purpose of the flag? Could we just use the non-zero value of the alignment attribute as the signal of whether to emit the DW_AT_alignment attribute? (eg: if the alignment is specified, emit it - simple?)

The alignment could be not specified and default alignment is used. Consider the following example:

struct S {
} s;

This will result in the following IR code:

!5 = !DICompositeType(tag: DW_TAG_structure_type, name: "S", file: !1, line: 1, align: 8, elements: !2)

And getAlignInBits() will return 8. Thus we need to mark entities with non-default alignment.

Is the alignment used for anything in this case? Could we just remove it & make it so that whenever it's present we put the DW_AT_alignment attribute on the entity?

The DW_AT_alignment is intended to be emitted only if object's alignment is not default. In case above the default alignment for struct S is 1 byte but C++11 and C11 (or compiler-specific directives) allows user to specify different alignment value.

Alignment value (whether it is default or user-defined) must be present in IR in order to be able to generate correct code, as for new DWARF attribute: we just give debuggers information that user has explicitly set the alignment value. This knowledge can be useful in case a debugger needs to create an object for use with some expressions to be evaluated.

[vleschuk]

In D24425#539028, @dblaikie wrote:

Alignment value (whether it is default or user-defined) must be present in IR in order to be able to generate correct code,

I'm not sure I follow this ^ - the metadata here is only for debug info. It's not used for correctness of the resulting program. (the alignment of pointers in the IR for actual code generation is stored separately).

Correct. Debug Info dump doesn't influence code generation. Bad example from my side.

I'll try to rephrase:

Is the alignment currently emitted in the debug info IR metadata used for anything? Seems it's used for bitfield related things, but perhaps that's not the right solution/we could do that another way? So that the alignment just corresponds directly to the DW_AT_alignment (eg: when present, emit an alignment attribute, otherwise don't) to keep the metadata simple.

Ah, I got it now. You suggest the following way:

• Do not add DINode::FlagAlignment
• Do not add alignment to DI* objects when creating them unless alignment was forced by user
• When generating DWARF output emit DW_AT_alignment if DI* object has non-zero alignment field

I have looked through the code and you seem to be correct, actually the align value from DI* objects is used only when working with bitfields. I think I should consult with llvm-dev@ before breaking anything.

[vleschuk]

Got rid of DINode::FlagAlignment: now we assume that clang passes non-zero align value to DIBuilder only in case if alignment was forced. Thus we just check for non-zero align value and if true, emit DW_AT_alignment. Also updated related tests according to new behavior.

[dblaikie]

This might be a bit easier to review if it were broken into separate patches - it looks like there's orthogonal functionality in here (ie: some code to add the alignment attribute to global variables, some to add it to types, etc) - is that the case? Do those changes have some pieces in common that needs to be staged together in some way?

[vleschuk]

In D24425#540448, @dblaikie wrote:

This might be a bit easier to review if it were broken into separate patches - it looks like there's orthogonal functionality in here (ie: some code to add the alignment attribute to global variables, some to add it to types, etc) - is that the case? Do those changes have some pieces in common that needs to be staged together in some way?

Yep, some code can be moved to separate patch. Will create a new review and put it into relationship with this one. Thanks for advice.

[vleschuk]

• Separated part of code which adds alignment param to DI*Variable family into https://reviews.llvm.org/D25073
• Update ll tests to actual ll format

[aprantl]

include/llvm/IR/DIBuilder.h

139

What is the motivation to change this to bytes? This kind of API change looks dangerous to me because frontends won't even get a type error to notify them that the API has changed.

[vleschuk]

include/llvm/IR/DIBuilder.h

139

Hmm, yep, I think you are right. I thought it would be better to pass bytes from frontend to backend as frontend has special CharUnits class for this purpose, however such changes in API can affect another frontends. Will change it back to bits and convert in backend.

[vleschuk]

Revert API changes: DIBuilder create* methods now take alignment in bits instead of bytes, like before (conversion is done when emitting DW_AT_alignment).

[aprantl]

include/llvm/IR/DIBuilder.h

212

This should be a separate NFC commit.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

779

Can this ever be 0?

lib/Support/Dwarf.cpp

152

For consistency with the rest of the file, I would put this on the same line.

test/DebugInfo/X86/align_c11.ll

52

We typically get rid of all unnecessary attributes (= everything in quotes).

test/DebugInfo/X86/align_cpp11.ll

114

same here

unittests/Transforms/Utils/Cloning.cpp

256

This should be a separate NFC commit.

[vleschuk]

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

779

I think it can be NULL: class DbgVariable doesn't check its DILocalVariable * member for being NULL when being constructed or accessed.

lib/Support/Dwarf.cpp

152

See DW_AT_MIPS_software_pipeline_depth it has same formatting (as requires coding standard and clang-format), so we already have this file formatting inconsistent. I'd prefer keeping clang-format silent on changes rather them keeping current formatting intact manually.

[vleschuk]

• Reverted unnecessary format changes
• Removed unnecessary context from tests
• Updated documentation for SourceLevelDebugging.rst

[aprantl]

docs/SourceLevelDebugging.rst

450 ↗

(On Diff #73775)

Thanks!!

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

779

Hmm. I don't think it makes sense to ever construct a DbgVariable without a variable. We should probably change it to a reference at some point. Thanks for checking.

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

1415

What about packed structs?

Sorry, I'm just being very cautious about any changes here, because every single time I touched this code in that past I broke the either LLDB or GDB ;-)

A couple of examples from the testsuite you can run through clang with both -gdwarf-2 and -gdwarf-4 and verify that the DWARF output didn't change:

#pragma pack(1)
    struct PackedBits
     {
        char a;
        uint32_t b : 5,
        c : 27
      } s;
   #pragma pack()

 struct bitfield {
    int a : 2;
    int b : 32;
    int c : 1;
    int d : 28;
}

struct size8 {
  int i : 4;
  long long l : 60;
};


struct layout0 {
  char l0_ofs0;
  struct size8 l0_ofs8;
  int l0_ofs16 : 1;
};

struct size8_anon {
  int : 4;
  long long : 60;
};
struct layout1 {
  char l1_ofs0;
  struct size8_anon l1_ofs1;
  int l1_ofs9 : 1;
};

#pragma pack(1)
struct size8_pack1 {
  int i : 4;
  long long l : 60;
};
struct layout2 {
  char l2_ofs0;
  struct size8_pack1 l2_ofs1;
  int l2_ofs9 : 1;
};
#pragma pack()

#pragma pack(4)
struct size8_pack4 {
  int i : 4;
  long long l : 60;
};
struct layout3 {
  char l3_ofs0;
  struct size8_pack4 l3_ofs4;
  int l3_ofs12 : 1;
};
#pragma pack()

[vleschuk]

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

1415

We already have test for that: DebugInfo/X86/debug-info-packed-struct.ll - its based on debug-info-packed-struct.c from clang (the one you quoted). I also manually checked this both with dwarf-2 and dwarf-4, dwarf output is the same for clang 3.9 release and current build with my changes.

[vleschuk]

• Fix mistype in SourceLevelDebugging.rst (attribute() -> attribute__()).

[aprantl]

Thanks, this looks good to me!

[vleschuk]

• Use DIAlignment type instead of uint64_t for alignment in DebugInfo

[RKSimon]

In D24425#570483, @vleschuk wrote:

• Use DIAlignment type instead of uint64_t for alignment in DebugInfo

DIAlignment was never typedef'd so causes compile failures ;-(

include/llvm/IR/DIBuilder.h

public:
     DIDerivedType *createQualifiedType(unsigned Tag, DIType *FromTy);
 
     /// Create debugging information entry for a pointer.
     /// \param PointeeTy   Type pointed by this pointer.
     /// \param SizeInBits  Size.
     /// \param AlignInBits Alignment. (optional)
     /// \param Name        Pointer type name. (optional)
     DIDerivedType *createPointerType(DIType *PointeeTy, uint64_t SizeInBits,
                                      uint64_t AlignInBits = 0,
                                      StringRef Name = "");
 
     /// Create debugging information entry for a pointer to member.
     /// \param PointeeTy Type pointed to by this pointer.
     /// \param SizeInBits  Size.
     /// \param AlignInBits Alignment. (optional)
     /// \param Class Type for which this pointer points to members of.
     DIDerivedType *
public:
     /// \param Name                Member name.
     /// \param File                File where this member is defined.
     /// \param LineNo              Line number.
     /// \param SizeInBits          Member size.
     /// \param OffsetInBits        Member offset.
     /// \param StorageOffsetInBits Member storage offset.
     /// \param Flags               Flags to encode member attribute.
     /// \param Ty                  Parent type.
-    DIDerivedType *createBitFieldMemberType(
-        DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo,
-        uint64_t SizeInBits, uint64_t OffsetInBits,
-        uint64_t StorageOffsetInBits, DINode::DIFlags Flags, DIType *Ty);
+    DIDerivedType *createBitFieldMemberType(DIScope *Scope, StringRef Name,
+                                            DIFile *File, unsigned LineNo,
+                                            uint64_t SizeInBits,
+                                            uint64_t OffsetInBits,
+                                            uint64_t StorageOffsetInBits,
+                                            DINode::DIFlags Flags, DIType *Ty);
 
     /// Create debugging information entry for a
     /// C++ static data member.
     /// \param Scope      Member scope.
     /// \param Name       Member name.
     /// \param File       File where this member is declared.
     /// \param LineNo     Line number.
     /// \param Ty         Type of the static member.

include/llvm/IR/DebugInfoMetadata.h

 public:
   TempDIType clone() const {
     return TempDIType(cast<DIType>(MDNode::clone().release()));
   }
 
   unsigned getLine() const { return Line; }
   uint64_t getSizeInBits() const { return SizeInBits; }
   uint64_t getAlignInBits() const { return AlignInBits; }
+  uint64_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT; }
   uint64_t getOffsetInBits() const { return OffsetInBits; }
   DIFlags getFlags() const { return Flags; }
 
   DIScopeRef getScope() const { return DIScopeRef(getRawScope()); }
   StringRef getName() const { return getStringOperand(2); }
 
 
   Metadata *getRawScope() const { return getOperand(1); }

 
 public:
   unsigned getLine() const { return Line; }
   DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
   StringRef getName() const { return getStringOperand(1); }
   DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
   DITypeRef getType() const { return DITypeRef(getRawType()); }
   uint64_t getAlignInBits() const { return AlignInBits; }
+  uint64_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT; }
 
   StringRef getFilename() const {
     if (auto *F = getFile())
       return F->getFilename();
     return "";
   }
   StringRef getDirectory() const {
     if (auto *F = getFile())

include/llvm/Support/Dwarf.h

enum Attribute : uint16_t {
   DW_AT_addr_base = 0x73,
   DW_AT_ranges_base = 0x74,
   DW_AT_dwo_id = 0x75,
   DW_AT_dwo_name = 0x76,
   DW_AT_reference = 0x77,
   DW_AT_rvalue_reference = 0x78,
   DW_AT_macros = 0x79,
   DW_AT_noreturn = 0x87,
+  DW_AT_alignment = 0x88,
 
   DW_AT_lo_user = 0x2000,
   DW_AT_hi_user = 0x3fff,
 
   DW_AT_MIPS_loop_begin = 0x2002,
   DW_AT_MIPS_tail_loop_begin = 0x2003,
   DW_AT_MIPS_epilog_begin = 0x2004,
   DW_AT_MIPS_loop_unroll_factor = 0x2005,

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
     addSourceLine(*VariableDIE, GV);
   }
 
   if (!GV->isDefinition())
     addFlag(*VariableDIE, dwarf::DW_AT_declaration);
   else
     addGlobalName(GV->getName(), *VariableDIE, DeclContext);
 
+  if (uint64_t AlignInBytes = GV->getAlignInBytes())
+    addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
+            AlignInBytes);
+
   // Add location.
   bool addToAccelTable = false;
 
   DIExpression *Expr = GV->getExpr();
 
   // For compatibility with DWARF 3 and earlier,
   // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) becomes
   // DW_AT_const_value(X).
void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
   Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index));
 }
 
 void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var,
                                                DIE &VariableDie) {
   StringRef Name = Var.getName();
   if (!Name.empty())
     addString(VariableDie, dwarf::DW_AT_name, Name);
-  addSourceLine(VariableDie, Var.getVariable());
+  const auto *DIVar = Var.getVariable();
+  if (DIVar)
+    if (uint64_t AlignInBytes = DIVar->getAlignInBytes())
+      addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
+              AlignInBytes);
+
+  addSourceLine(VariableDie, DIVar);
   addType(VariableDie, Var.getType());
   if (Var.isArtificial())
     addFlag(VariableDie, dwarf::DW_AT_artificial);
 }
 
 /// Add a Dwarf expression attribute data and value.
 void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form,
                                const MCExpr *Expr) {

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

if (Tag == dwarf::DW_TAG_enumeration_type ||
     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 (uint64_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 (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
     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);
+    uint64_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.
       uint64_t AlignInBits = FieldSize;
       uint64_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())
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 (uint64_t AlignInBytes = DT->getAlignInBytes())
+    addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
+            AlignInBytes);
+
   return &StaticMemberDIE;
 }
 
 void DwarfUnit::emitHeader(bool UseOffsets) {
   // Emit size of content not including length itself
   Asm->OutStreamer->AddComment("Length of Unit");
   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
 

lib/Support/Dwarf.cpp

const char *llvm::dwarf::AttributeString(unsigned Attribute) {
   case DW_AT_str_offsets_base:           return "DW_AT_str_offsets_base";
   case DW_AT_addr_base:                  return "DW_AT_addr_base";
   case DW_AT_ranges_base:                return "DW_AT_ranges_base";
   case DW_AT_dwo_id:                     return "DW_AT_dwo_id";
   case DW_AT_dwo_name:                   return "DW_AT_dwo_name";
   case DW_AT_reference:                  return "DW_AT_reference";
   case DW_AT_rvalue_reference:           return "DW_AT_rvalue_reference";
   case DW_AT_noreturn:                   return "DW_AT_noreturn";
+  case DW_AT_alignment:
+    return "DW_AT_alignment";
   case DW_AT_MIPS_loop_begin:            return "DW_AT_MIPS_loop_begin";
   case DW_AT_MIPS_tail_loop_begin:       return "DW_AT_MIPS_tail_loop_begin";
   case DW_AT_MIPS_epilog_begin:          return "DW_AT_MIPS_epilog_begin";
   case DW_AT_MIPS_loop_unroll_factor:    return "DW_AT_MIPS_loop_unroll_factor";
   case DW_AT_MIPS_software_pipeline_depth:
     return "DW_AT_MIPS_software_pipeline_depth";
   case DW_AT_MIPS_linkage_name:          return "DW_AT_MIPS_linkage_name";
   case DW_AT_MIPS_stride:                return "DW_AT_MIPS_stride";

test/DebugInfo/X86/align_c11.ll

+; RUN: %llc_dwarf -filetype=obj < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+; REQUIRES: object-emission
+
+; Generated by clang -c -g -std=c11 -S -emit-llvm from the following C11 source
+;
+; // every object of type struct data will be aligned to 128-byte boundary
+; struct data {
+;   char x;
+;   _Alignas(128) char arr[2];
+; };
+;
+; _Alignas(2048) struct data d; // this instance of data is aligned even stricter
+; int foo(void)
+; {
+;     struct data local_data;
+;     return 0;
+; }
+
+; CHECK: DW_TAG_variable
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name{{.*}}"d"
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_alignment{{.*}}2048
+; CHECK: DW_TAG_structure_type
+; CHECK: DW_TAG_member
+; CHECK: DW_TAG_member
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name{{.*}}"arr"
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_alignment{{.*}}128
+
+; ModuleID = 'test.c'
+source_filename = "test.c"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+%struct.data = type { i8, [127 x i8], [2 x i8], [126 x i8] }
+
+@d = common global %struct.data zeroinitializer, align 2048, !dbg !0
+
+; Function Attrs: nounwind uwtable
+define i32 @foo() #0 !dbg !17 {
+entry:
+  %local_data = alloca %struct.data, align 128
+  call void @llvm.dbg.declare(metadata %struct.data* %local_data, metadata !21, metadata !22), !dbg !23
+  ret i32 0, !dbg !24
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!1}
+!llvm.module.flags = !{!14, !15}
+!llvm.ident = !{!16}
+
+!0 = distinct !DIGlobalVariable(name: "d", scope: !1, file: !5, line: 7, type: !6, isLocal: false, isDefinition: true, align: 16384)
+!1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, producer: "clang version 4.0.0 (http://llvm.org/git/clang.git 9ce5220b821054019059c2ac4a9b132c7723832d) (http://llvm.org/git/llvm.git 9a6298be89ce0359b151c0a37af2776a12c69e85)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !3, globals: !4)
+!2 = !DIFile(filename: "test.c", directory: "/tmp")
+!3 = !{}
+!4 = !{!0}
+!5 = !DIFile(filename: "test.c", directory: "/tmp")
+!6 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "data", file: !5, line: 2, size: 2048, elements: !7)
+!7 = !{!8, !10}
+!8 = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: !6, file: !5, line: 3, baseType: !9, size: 8)
+!9 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!10 = !DIDerivedType(tag: DW_TAG_member, name: "arr", scope: !6, file: !5, line: 4, baseType: !11, size: 16, align: 1024, offset: 1024)
+!11 = !DICompositeType(tag: DW_TAG_array_type, baseType: !9, size: 16, elements: !12)
+!12 = !{!13}
+!13 = !DISubrange(count: 2)
+!14 = !{i32 2, !"Dwarf Version", i32 4}
+!15 = !{i32 2, !"Debug Info Version", i32 3}
+!16 = !{!"clang version 4.0.0 (http://llvm.org/git/clang.git 9ce5220b821054019059c2ac4a9b132c7723832d) (http://llvm.org/git/llvm.git 9a6298be89ce0359b151c0a37af2776a12c69e85)"}
+!17 = distinct !DISubprogram(name: "foo", scope: !5, file: !5, line: 8, type: !18, isLocal: false, isDefinition: true, scopeLine: 9, flags: DIFlagPrototyped, isOptimized: false, unit: !1, variables: !3)
+!18 = !DISubroutineType(types: !19)
+!19 = !{!20}
+!20 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!21 = !DILocalVariable(name: "local_data", scope: !17, file: !5, line: 10, type: !6)
+!22 = !DIExpression()
+!23 = !DILocation(line: 10, column: 17, scope: !17)
+!24 = !DILocation(line: 11, column: 5, scope: !17)

test/DebugInfo/X86/align_cpp11.ll

+; RUN: %llc_dwarf -filetype=obj < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+; REQUIRES: object-emission
+
+; Generated by clang++ -c -g -std=c++11 -S -emit-llvm from the following C++11 source
+; struct S {
+;   char x;
+;   alignas(128) char xx;
+; };
+;
+; class alignas(64) C0 {
+; };
+;
+; class C1 {
+;   alignas(64) static void *p;
+; };
+;
+; enum alignas(16) E {
+;   A,
+;   B,
+;   C,
+; };
+;
+; C0 c0;
+;
+; alignas(2048) S s;
+;
+; void foo()
+; {
+;     S ss;
+;     E e;
+;     C1 c1;
+;     alignas(32) int i = 42;
+;     auto Lambda = [i](){};
+; }
+
+; CHECK: DW_TAG_class_type
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name{{.*}}"C0"
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_alignment{{.*}}64
+
+; CHECK: DW_TAG_variable
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name{{.*}}"s"
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_alignment{{.*}}2048
+
+; CHECK: DW_TAG_structure_type
+; CHECK: DW_TAG_member
+; CHECK: DW_AT_name{{.*}}"xx"
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_alignment{{.*}}128
+
+; CHECK: DW_TAG_enumeration_type
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_alignment{{.*}}16
+
+; CHECK: DW_TAG_variable
+; CHECK: DW_AT_name{{.*}}"i"
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_alignment{{.*}}32
+; CHECK: DW_TAG_class_type
+; CHECK: DW_TAG_member
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name{{.*}}"i"
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_alignment{{.*}}32
+
+; CHECK: DW_TAG_class_type
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name{{.*}}"C1"
+; CHECK: DW_TAG_member
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name{{.*}}"p"
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_alignment{{.*}}64
+
+; ModuleID = 'test.cpp'
+source_filename = "test.cpp"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+%class.C0 = type { [64 x i8] }
+%struct.S = type { i8, [127 x i8], i8, [127 x i8] }
+%class.C1 = type { i8 }
+%class.anon = type { i32 }
+
+@c0 = global %class.C0 zeroinitializer, align 64, !dbg !0
+@s = global %struct.S zeroinitializer, align 2048, !dbg !11
+
+; Function Attrs: nounwind uwtable
+define void @_Z3foov() #0 !dbg !22 {
+entry:
+  %ss = alloca %struct.S, align 128
+  %e = alloca i32, align 16
+  %c1 = alloca %class.C1, align 1
+  %i = alloca i32, align 32
+  %Lambda = alloca %class.anon, align 4
+  call void @llvm.dbg.declare(metadata %struct.S* %ss, metadata !25, metadata !26), !dbg !27
+  call void @llvm.dbg.declare(metadata i32* %e, metadata !28, metadata !26), !dbg !29
+  call void @llvm.dbg.declare(metadata %class.C1* %c1, metadata !30, metadata !26), !dbg !35
+  call void @llvm.dbg.declare(metadata i32* %i, metadata !36, metadata !26), !dbg !38
+  store i32 42, i32* %i, align 32, !dbg !38
+  call void @llvm.dbg.declare(metadata %class.anon* %Lambda, metadata !39, metadata !26), !dbg !48
+  %0 = getelementptr inbounds %class.anon, %class.anon* %Lambda, i32 0, i32 0, !dbg !49
+  %1 = load i32, i32* %i, align 32, !dbg !50
+  store i32 %1, i32* %0, align 4, !dbg !49
+  ret void, !dbg !51
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!1}
+!llvm.module.flags = !{!19, !20}
+!llvm.ident = !{!21}
+
+!0 = distinct !DIGlobalVariable(name: "c0", scope: !1, file: !5, line: 19, type: !17, isLocal: false, isDefinition: true)
+!1 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "clang version 4.0.0 (http://llvm.org/git/clang.git 9ce5220b821054019059c2ac4a9b132c7723832d) (http://llvm.org/git/llvm.git 9a6298be89ce0359b151c0a37af2776a12c69e85)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !3, globals: !10)
+!2 = !DIFile(filename: "test.cpp", directory: "/tmp")
+!3 = !{!4}
+!4 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E", file: !5, line: 13, size: 32, align: 128, elements: !6, identifier: "_ZTS1E")
+!5 = !DIFile(filename: "./test.cpp", directory: "/tmp")
+!6 = !{!7, !8, !9}
+!7 = !DIEnumerator(name: "A", value: 0)
+!8 = !DIEnumerator(name: "B", value: 1)
+!9 = !DIEnumerator(name: "C", value: 2)
+!10 = !{!0, !11}
+!11 = distinct !DIGlobalVariable(name: "s", scope: !1, file: !5, line: 21, type: !12, isLocal: false, isDefinition: true, align: 16384)
+!12 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "S", file: !5, line: 1, size: 2048, elements: !13, identifier: "_ZTS1S")
+!13 = !{!14, !16}
+!14 = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: !12, file: !5, line: 2, baseType: !15, size: 8)
+!15 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!16 = !DIDerivedType(tag: DW_TAG_member, name: "xx", scope: !12, file: !5, line: 3, baseType: !15, size: 8, align: 1024, offset: 1024)
+!17 = distinct !DICompositeType(tag: DW_TAG_class_type, name: "C0", file: !5, line: 6, size: 512, align: 512, elements: !18, identifier: "_ZTS2C0")
+!18 = !{}
+!19 = !{i32 2, !"Dwarf Version", i32 4}
+!20 = !{i32 2, !"Debug Info Version", i32 3}
+!21 = !{!"clang version 4.0.0 (http://llvm.org/git/clang.git 9ce5220b821054019059c2ac4a9b132c7723832d) (http://llvm.org/git/llvm.git 9a6298be89ce0359b151c0a37af2776a12c69e85)"}
+!22 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !5, file: !5, line: 23, type: !23, isLocal: false, isDefinition: true, scopeLine: 24, flags: DIFlagPrototyped, isOptimized: false, unit: !1, variables: !18)
+!23 = !DISubroutineType(types: !24)
+!24 = !{null}
+!25 = !DILocalVariable(name: "ss", scope: !22, file: !5, line: 25, type: !12)
+!26 = !DIExpression()
+!27 = !DILocation(line: 25, column: 7, scope: !22)
+!28 = !DILocalVariable(name: "e", scope: !22, file: !5, line: 26, type: !4)
+!29 = !DILocation(line: 26, column: 7, scope: !22)
+!30 = !DILocalVariable(name: "c1", scope: !22, file: !5, line: 27, type: !31)
+!31 = distinct !DICompositeType(tag: DW_TAG_class_type, name: "C1", file: !5, line: 9, size: 8, elements: !32, identifier: "_ZTS2C1")
+!32 = !{!33}
+!33 = !DIDerivedType(tag: DW_TAG_member, name: "p", scope: !31, file: !5, line: 10, baseType: !34, align: 512, flags: DIFlagStaticMember)
+!34 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: null, size: 64)
+!35 = !DILocation(line: 27, column: 8, scope: !22)
+!36 = !DILocalVariable(name: "i", scope: !22, file: !5, line: 28, type: !37, align: 256)
+!37 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!38 = !DILocation(line: 28, column: 21, scope: !22)
+!39 = !DILocalVariable(name: "Lambda", scope: !22, file: !5, line: 29, type: !40)
+!40 = distinct !DICompositeType(tag: DW_TAG_class_type, scope: !22, file: !5, line: 29, size: 32, elements: !41)
+!41 = !{!42, !43}
+!42 = !DIDerivedType(tag: DW_TAG_member, name: "i", scope: !40, file: !5, line: 29, baseType: !37, size: 32, align: 256)
+!43 = !DISubprogram(name: "operator()", scope: !40, file: !5, line: 29, type: !44, isLocal: false, isDefinition: false, scopeLine: 29, flags: DIFlagPublic | DIFlagPrototyped, isOptimized: false)
+!44 = !DISubroutineType(types: !45)
+!45 = !{null, !46}
+!46 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !47, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!47 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !40)
+!48 = !DILocation(line: 29, column: 10, scope: !22)
+!49 = !DILocation(line: 29, column: 19, scope: !22)
+!50 = !DILocation(line: 29, column: 20, scope: !22)
+!51 = !DILocation(line: 30, column: 1, scope: !22)

test/DebugInfo/X86/align_objc.ll

+; RUN: %llc_dwarf -filetype=obj < %s | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+; REQUIRES: object-emission
+
+; typedef struct __attribute__((aligned (128))) {
+;   char c;
+; } S0;
+;
+; typedef struct {
+;   __attribute__((aligned (64))) char c;
+; } S1;
+;
+; S0 s0;
+;
+; void f() {
+;   S1 s1;
+;   __attribute__((aligned (32))) int i;
+; }
+
+; CHECK: DW_TAG_typedef
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name{{.*}}"S0"
+; CHECK: DW_TAG_structure_type
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_alignment{{.*}}128
+
+; CHECK: DW_TAG_variable
+; CHECK: DW_AT_name{{.*}}"i"
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_alignment{{.*}}32
+
+; CHECK: DW_TAG_typedef
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name{{.*}}"S1"
+; CHECK: DW_TAG_structure_type
+; CHECK: DW_TAG_member
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name{{.*}}"c"
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_alignment{{.*}}64
+
+; ModuleID = 'test.m'
+source_filename = "test.m"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+%struct.S0 = type { i8, [127 x i8] }
+%struct.S1 = type { i8, [63 x i8] }
+
+@s0 = common global %struct.S0 zeroinitializer, align 128, !dbg !0
+
+; Function Attrs: nounwind uwtable
+define void @f() #0 !dbg !14 {
+entry:
+  %s1 = alloca %struct.S1, align 64
+  %i = alloca i32, align 32
+  call void @llvm.dbg.declare(metadata %struct.S1* %s1, metadata !17, metadata !22), !dbg !23
+  call void @llvm.dbg.declare(metadata i32* %i, metadata !24, metadata !22), !dbg !26
+  ret void, !dbg !27
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!1}
+!llvm.module.flags = !{!11, !12}
+!llvm.ident = !{!13}
+
+!0 = distinct !DIGlobalVariable(name: "s0", scope: !1, file: !5, line: 10, type: !6, isLocal: false, isDefinition: true)
+!1 = distinct !DICompileUnit(language: DW_LANG_ObjC, file: !2, producer: "clang version 4.0.0 (http://llvm.org/git/clang.git 9ce5220b821054019059c2ac4a9b132c7723832d) (http://llvm.org/git/llvm.git 9a6298be89ce0359b151c0a37af2776a12c69e85)", isOptimized: false, runtimeVersion: 1, emissionKind: FullDebug, enums: !3, globals: !4)
+!2 = !DIFile(filename: "test.m", directory: "/tmp")
+!3 = !{}
+!4 = !{!0}
+!5 = !DIFile(filename: "test.m", directory: "/tmp")
+!6 = !DIDerivedType(tag: DW_TAG_typedef, name: "S0", file: !5, line: 3, baseType: !7)
+!7 = distinct !DICompositeType(tag: DW_TAG_structure_type, file: !5, line: 1, size: 1024, align: 1024, elements: !8)
+!8 = !{!9}
+!9 = !DIDerivedType(tag: DW_TAG_member, name: "c", scope: !7, file: !5, line: 2, baseType: !10, size: 8)
+!10 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!11 = !{i32 2, !"Dwarf Version", i32 4}
+!12 = !{i32 2, !"Debug Info Version", i32 3}
+!13 = !{!"clang version 4.0.0 (http://llvm.org/git/clang.git 9ce5220b821054019059c2ac4a9b132c7723832d) (http://llvm.org/git/llvm.git 9a6298be89ce0359b151c0a37af2776a12c69e85)"}
+!14 = distinct !DISubprogram(name: "f", scope: !5, file: !5, line: 12, type: !15, isLocal: false, isDefinition: true, scopeLine: 12, isOptimized: false, unit: !1, variables: !3)
+!15 = !DISubroutineType(types: !16)
+!16 = !{null}
+!17 = !DILocalVariable(name: "s1", scope: !14, file: !5, line: 13, type: !18)
+!18 = !DIDerivedType(tag: DW_TAG_typedef, name: "S1", file: !5, line: 8, baseType: !19)
+!19 = distinct !DICompositeType(tag: DW_TAG_structure_type, file: !5, line: 6, size: 512, elements: !20)
+!20 = !{!21}
+!21 = !DIDerivedType(tag: DW_TAG_member, name: "c", scope: !19, file: !5, line: 7, baseType: !10, size: 8, align: 512)
+!22 = !DIExpression()
+!23 = !DILocation(line: 13, column: 6, scope: !14)
+!24 = !DILocalVariable(name: "i", scope: !14, file: !5, line: 14, type: !25, align: 256)
+!25 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!26 = !DILocation(line: 14, column: 37, scope: !14)
+!27 = !DILocation(line: 15, column: 1, scope: !14)

test/DebugInfo/X86/dwarf-public-names.ll

 !llvm.module.flags = !{!38}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, producer: "clang version 3.3 (http://llvm.org/git/clang.git a09cd8103a6a719cb2628cdf0c91682250a17bd2) (http://llvm.org/git/llvm.git 47d03cec0afca0c01ae42b82916d1d731716cd20)", isOptimized: false, emissionKind: FullDebug, file: !37, enums: !1, retainedTypes: !1, globals: !24, imports:  !1)
 !1 = !{}
 !3 = distinct !DISubprogram(name: "member_function", linkageName: "_ZN1C15member_functionEv", line: 9, isLocal: false, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !0, scopeLine: 9, file: !4, scope: null, type: !5, declaration: !12, variables: !1)
 !4 = !DIFile(filename: "dwarf-public-names.cpp", directory: "/usr2/kparzysz/s.hex/t")
 !5 = !DISubroutineType(types: !6)
 !6 = !{null, !7}
-!7 = !DIDerivedType(tag: DW_TAG_pointer_type, size: 64, align: 64, flags: DIFlagArtificial | DIFlagObjectPointer, baseType: !8)
-!8 = !DICompositeType(tag: DW_TAG_structure_type, name: "C", line: 1, size: 8, align: 8, file: !37, elements: !9)
+!7 = !DIDerivedType(tag: DW_TAG_pointer_type, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer, baseType: !8)
+!8 = !DICompositeType(tag: DW_TAG_structure_type, name: "C", line: 1, size: 8, file: !37, elements: !9)
 !9 = !{!10, !12, !14}
 !10 = !DIDerivedType(tag: DW_TAG_member, name: "static_member_variable", line: 4, flags: DIFlagStaticMember, file: !37, scope: !8, baseType: !11)
-!11 = !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!11 = !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, encoding: DW_ATE_signed)
 !12 = !DISubprogram(name: "member_function", linkageName: "_ZN1C15member_functionEv", line: 2, isLocal: false, isDefinition: false, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, scopeLine: 2, file: !4, scope: !8, type: !5, variables: !13)
 !13 = !{} ; previously: invalid DW_TAG_base_type
 !14 = !DISubprogram(name: "static_member_function", linkageName: "_ZN1C22static_member_functionEv", line: 3, isLocal: false, isDefinition: false, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, scopeLine: 3, file: !4, scope: !8, type: !15, variables: !17)
 !15 = !DISubroutineType(types: !16)
 !16 = !{!11}
 !17 = !{} ; previously: invalid DW_TAG_base_type
 !18 = distinct !DISubprogram(name: "static_member_function", linkageName: "_ZN1C22static_member_functionEv", line: 13, isLocal: false, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !0, scopeLine: 13, file: !4, scope: null, type: !15, declaration: !14, variables: !1)
 !19 = distinct !DISubprogram(name: "global_function", linkageName: "_Z15global_functionv", line: 19, isLocal: false, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !0, scopeLine: 19, file: !4, scope: !4, type: !15, variables: !1)
 !20 = distinct !DISubprogram(name: "global_namespace_function", linkageName: "_ZN2ns25global_namespace_functionEv", line: 24, isLocal: false, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !0, scopeLine: 24, file: !4, scope: !21, type: !22, variables: !1)
 !21 = !DINamespace(name: "ns", line: 23, file: !4, scope: null)
 !22 = !DISubroutineType(types: !23)
 !23 = !{null}
 !24 = !{!25, !26, !27}
 !25 = !DIGlobalVariable(name: "static_member_variable", linkageName: "_ZN1C22static_member_variableE", line: 7, isLocal: false, isDefinition: true, scope: !8, file: !4, type: !11, declaration: !10)
 !26 = !DIGlobalVariable(name: "global_variable", line: 17, isLocal: false, isDefinition: true, scope: null, file: !4, type: !8)
 !27 = !DIGlobalVariable(name: "global_namespace_variable", linkageName: "_ZN2ns25global_namespace_variableE", line: 27, isLocal: false, isDefinition: true, scope: !21, file: !4, type: !11)
 !28 = !DILocalVariable(name: "this", line: 9, arg: 1, flags: DIFlagArtificial | DIFlagObjectPointer, scope: !3, file: !4, type: !29)
-!29 = !DIDerivedType(tag: DW_TAG_pointer_type, size: 64, align: 64, baseType: !8)
+!29 = !DIDerivedType(tag: DW_TAG_pointer_type, size: 64, baseType: !8)
 !30 = !DILocation(line: 9, scope: !3)
 !31 = !DILocation(line: 10, scope: !3)
 !32 = !DILocation(line: 11, scope: !3)
 !33 = !DILocation(line: 14, scope: !18)
 !34 = !DILocation(line: 20, scope: !19)
 !35 = !DILocation(line: 25, scope: !20)
 !36 = !DILocation(line: 26, scope: !20)
 !37 = !DIFile(filename: "dwarf-public-names.cpp", directory: "/usr2/kparzysz/s.hex/t")
 !38 = !{i32 1, !"Debug Info Version", i32 3}

unittests/Transforms/Utils/Cloning.cpp

void CreateOldFunctionBodyAndDI() {
     AllocaInst* Alloca = IBuilder.CreateAlloca(IntegerType::getInt32Ty(C));
     IBuilder.SetCurrentDebugLocation(DebugLoc::get(4, 2, Subprogram));
     Value* AllocaContent = IBuilder.getInt32(1);
     Instruction* Store = IBuilder.CreateStore(AllocaContent, Alloca);
     IBuilder.SetCurrentDebugLocation(DebugLoc::get(5, 2, Subprogram));
     Instruction* Terminator = IBuilder.CreateRetVoid();
 
     // Create a local variable around the alloca
-    auto *IntType =
-        DBuilder.createBasicType("int", 32, dwarf::DW_ATE_signed);
+    auto *IntType = DBuilder.createBasicType("int", 32, dwarf::DW_ATE_signed);
     auto *E = DBuilder.createExpression();
     auto *Variable =
         DBuilder.createAutoVariable(Subprogram, "x", File, 5, IntType, true);
     auto *DL = DILocation::get(Subprogram->getContext(), 5, 0, Subprogram);
     DBuilder.insertDeclare(Alloca, Variable, E, DL, Store);
     DBuilder.insertDbgValueIntrinsic(AllocaContent, 0, Variable, E, DL,
                                      Terminator);
     // Finalize the debug info