DebugInfo: use uint32_t instead of uint64_t for alignment

[vleschuk]

Summary

Introduce DIAlignment typedef, actually change alignment type from uint64_t to uint32_t to save space. In dependent patches we shall have alignment field added to DIVariable family and switching from uint64_t to uint32_t will save 4 bytes per variable.

[aprantl]

I support this.

One question: What happens when we read bitcode that contains an alignment field with a value larger > 2^32?
Does the bitcode reader throw an error? Do we even care to support a non-breaking upgrade path for this?

[probinson]

include/llvm/IR/DebugInfoMetadata.h

518

I think AlignInBits should come after OffsetInBits now, rather than between the two uint64_t fields?

[vleschuk]

include/llvm/IR/DebugInfoMetadata.h

518

Agreed, will fix.

[vleschuk]

In D25620#570582, @aprantl wrote:

I support this.

One question: What happens when we read bitcode that contains an alignment field with a value larger > 2^32?
Does the bitcode reader throw an error? Do we even care to support a non-breaking upgrade path for this?

We already do check this in frontend (Sema):

// Alignment calculations can wrap around if it's greater than 2**28.         
unsigned MaxValidAlignment =                                                  
    Context.getTargetInfo().getTriple().isOSBinFormatCOFF() ? 8192            
                                                            : 268435456;

I have added check in BitcodeReader just in case.

[aprantl]

After letting this sit for a few days, I think that using an unsigned (there doesn't seem to be much precedent for uint32_t) is the way to go. It's more readable than an opaque DIAlignment type (whose size isn't obvious from the name).

[vleschuk]

In D25620#571724, @aprantl wrote:

After letting this sit for a few days, I think that using an unsigned (there doesn't seem to be much precedent for uint32_t) is the way to go. It's more readable than an opaque DIAlignment type (whose size isn't obvious from the name).

What about platforms where sizeof(unsigned) could be 2, standard does allow that, I'd rather use cstdint types.

[vleschuk]

• Use uint32_t directly instead of new typedef
• Place uint32_t alignment member after all uint64_t members in DIType class

[aprantl]

Small nitpicks inline, but otherwise this looks good to me!

lib/IR/LLVMContextImpl.h

352

Here we could reorder the fields so AlignInBits isn't stuck between two 64-bit values.

433

Same here.

[vleschuk]

In D25620#572108, @aprantl wrote:

Small nitpicks inline, but otherwise this looks good to me!

Thanks a lot! Fixed these. Will commit as soon as https://reviews.llvm.org/D25621 is accepted.

bindings/go/llvm/DIBuilderBindings.h

 LLVMMetadataRef LLVMDIBuilderCreateParameterVariable(
     LLVMDIBuilderRef D, LLVMMetadataRef Scope, const char *Name, unsigned ArgNo,
     LLVMMetadataRef File, unsigned Line, LLVMMetadataRef Ty, int AlwaysPreserve,
     unsigned Flags);
 
 LLVMMetadataRef LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef D,
                                              const char *Name,
                                              uint64_t SizeInBits,
-                                             uint64_t AlignInBits,
+                                             DIAlignment AlignInBits,
                                              unsigned Encoding);
 
 LLVMMetadataRef LLVMDIBuilderCreatePointerType(LLVMDIBuilderRef D,
                                                LLVMMetadataRef PointeeType,
                                                uint64_t SizeInBits,
-                                               uint64_t AlignInBits,
+                                               DIAlignment AlignInBits,
                                                const char *Name);
 
 LLVMMetadataRef
 LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef D, LLVMMetadataRef File,
                                   LLVMMetadataRef ParameterTypes);
 
 LLVMMetadataRef LLVMDIBuilderCreateStructType(
     LLVMDIBuilderRef D, LLVMMetadataRef Scope, const char *Name,
     LLVMMetadataRef File, unsigned Line, uint64_t SizeInBits,
-    uint64_t AlignInBits, unsigned Flags, LLVMMetadataRef DerivedFrom,
+    DIAlignment AlignInBits, unsigned Flags, LLVMMetadataRef DerivedFrom,
     LLVMMetadataRef ElementTypes);
 
 LLVMMetadataRef LLVMDIBuilderCreateReplaceableCompositeType(
     LLVMDIBuilderRef D, unsigned Tag, const char *Name, LLVMMetadataRef Scope,
     LLVMMetadataRef File, unsigned Line, unsigned RuntimeLang,
-    uint64_t SizeInBits, uint64_t AlignInBits, unsigned Flags);
+    uint64_t SizeInBits, DIAlignment AlignInBits, unsigned Flags);
 
 LLVMMetadataRef
 LLVMDIBuilderCreateMemberType(LLVMDIBuilderRef D, LLVMMetadataRef Scope,
                               const char *Name, LLVMMetadataRef File,
                               unsigned Line, uint64_t SizeInBits,
-                              uint64_t AlignInBits, uint64_t OffsetInBits,
+                              DIAlignment AlignInBits, uint64_t OffsetInBits,
                               unsigned Flags, LLVMMetadataRef Ty);
 
 LLVMMetadataRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef D,
                                              uint64_t SizeInBits,
-                                             uint64_t AlignInBits,
+                                             DIAlignment AlignInBits,
                                              LLVMMetadataRef ElementType,
                                              LLVMMetadataRef Subscripts);
 
 LLVMMetadataRef LLVMDIBuilderCreateTypedef(LLVMDIBuilderRef D,
                                            LLVMMetadataRef Ty, const char *Name,
                                            LLVMMetadataRef File, unsigned Line,
                                            LLVMMetadataRef Context);
 

bindings/go/llvm/DIBuilderBindings.cpp

LLVMMetadataRef LLVMDIBuilderCreateParameterVariable(
   return wrap(D->createParameterVariable(
       unwrap<DIScope>(Scope), Name, ArgNo, unwrap<DIFile>(File), Line,
       unwrap<DIType>(Ty), AlwaysPreserve, static_cast<DINode::DIFlags>(Flags)));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateBasicType(LLVMDIBuilderRef Dref,
                                              const char *Name,
                                              uint64_t SizeInBits,
-                                             uint64_t AlignInBits,
+                                             DIAlignment AlignInBits,
                                              unsigned Encoding) {
   DIBuilder *D = unwrap(Dref);
   return wrap(D->createBasicType(Name, SizeInBits, AlignInBits, Encoding));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreatePointerType(LLVMDIBuilderRef Dref,
                                                LLVMMetadataRef PointeeType,
                                                uint64_t SizeInBits,
-                                               uint64_t AlignInBits,
+                                               DIAlignment AlignInBits,
                                                const char *Name) {
   DIBuilder *D = unwrap(Dref);
   return wrap(D->createPointerType(unwrap<DIType>(PointeeType), SizeInBits,
                                    AlignInBits, Name));
 }
 
 LLVMMetadataRef
 LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Dref, LLVMMetadataRef File,
                                   LLVMMetadataRef ParameterTypes) {
   DIBuilder *D = unwrap(Dref);
   return wrap(
       D->createSubroutineType(DITypeRefArray(unwrap<MDTuple>(ParameterTypes))));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateStructType(
     LLVMDIBuilderRef Dref, LLVMMetadataRef Scope, const char *Name,
     LLVMMetadataRef File, unsigned Line, uint64_t SizeInBits,
-    uint64_t AlignInBits, unsigned Flags, LLVMMetadataRef DerivedFrom,
+    DIAlignment AlignInBits, unsigned Flags, LLVMMetadataRef DerivedFrom,
     LLVMMetadataRef ElementTypes) {
   DIBuilder *D = unwrap(Dref);
   return wrap(D->createStructType(
       unwrap<DIScope>(Scope), Name, File ? unwrap<DIFile>(File) : nullptr, Line,
       SizeInBits, AlignInBits, static_cast<DINode::DIFlags>(Flags),
       DerivedFrom ? unwrap<DIType>(DerivedFrom) : nullptr,
       ElementTypes ? DINodeArray(unwrap<MDTuple>(ElementTypes)) : nullptr));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateReplaceableCompositeType(
     LLVMDIBuilderRef Dref, unsigned Tag, const char *Name,
     LLVMMetadataRef Scope, LLVMMetadataRef File, unsigned Line,
-    unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
+    unsigned RuntimeLang, uint64_t SizeInBits, DIAlignment AlignInBits,
     unsigned Flags) {
   DIBuilder *D = unwrap(Dref);
   return wrap(D->createReplaceableCompositeType(
       Tag, Name, unwrap<DIScope>(Scope), File ? unwrap<DIFile>(File) : nullptr,
       Line, RuntimeLang, SizeInBits, AlignInBits,
       static_cast<DINode::DIFlags>(Flags)));
 }
 
 LLVMMetadataRef
 LLVMDIBuilderCreateMemberType(LLVMDIBuilderRef Dref, LLVMMetadataRef Scope,
                               const char *Name, LLVMMetadataRef File,
                               unsigned Line, uint64_t SizeInBits,
-                              uint64_t AlignInBits, uint64_t OffsetInBits,
+                              DIAlignment AlignInBits, uint64_t OffsetInBits,
                               unsigned Flags, LLVMMetadataRef Ty) {
   DIBuilder *D = unwrap(Dref);
   return wrap(D->createMemberType(
       unwrap<DIScope>(Scope), Name, File ? unwrap<DIFile>(File) : nullptr, Line,
       SizeInBits, AlignInBits, OffsetInBits,
       static_cast<DINode::DIFlags>(Flags), unwrap<DIType>(Ty)));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateArrayType(LLVMDIBuilderRef Dref,
                                              uint64_t SizeInBits,
-                                             uint64_t AlignInBits,
+                                             DIAlignment AlignInBits,
                                              LLVMMetadataRef ElementType,
                                              LLVMMetadataRef Subscripts) {
   DIBuilder *D = unwrap(Dref);
   return wrap(D->createArrayType(SizeInBits, AlignInBits,
                                  unwrap<DIType>(ElementType),
                                  DINodeArray(unwrap<MDTuple>(Subscripts))));
 }
 

bindings/go/llvm/dibuilder.go

func (d *DIBuilder) CreateParameterVariable(scope Metadata, v DIParameterVariable) Metadata {
   )
   return Metadata{C: result}
 }
 
 // DIBasicType holds the values for creating basic type debug metadata.
 type DIBasicType struct {
   Name        string
   SizeInBits  uint64
-  AlignInBits uint64
+  AlignInBits uint32
   Encoding    DwarfTypeEncoding
 }
 
 // CreateBasicType creates basic type debug metadata.
 func (d *DIBuilder) CreateBasicType(t DIBasicType) Metadata {
   name := C.CString(t.Name)
   defer C.free(unsafe.Pointer(name))
   result := C.LLVMDIBuilderCreateBasicType(
     d.ref,
     name,
     C.uint64_t(t.SizeInBits),
-    C.uint64_t(t.AlignInBits),
+    C.uint32_t(t.AlignInBits),
     C.unsigned(t.Encoding),
   )
   return Metadata{C: result}
 }
 
 // DIPointerType holds the values for creating pointer type debug metadata.
 type DIPointerType struct {
   Pointee     Metadata
   SizeInBits  uint64
-  AlignInBits uint64 // optional
+  AlignInBits uint32 // optional
   Name        string // optional
 }
 
 // CreateBasicType creates basic type debug metadata.
 func (d *DIBuilder) CreatePointerType(t DIPointerType) Metadata {
   name := C.CString(t.Name)
   defer C.free(unsafe.Pointer(name))
   result := C.LLVMDIBuilderCreatePointerType(
     d.ref,
     t.Pointee.C,
     C.uint64_t(t.SizeInBits),
-    C.uint64_t(t.AlignInBits),
+    C.uint32_t(t.AlignInBits),
     name,
   )
   return Metadata{C: result}
 }
 
 // DISubroutineType holds the values for creating subroutine type debug metadata.
 type DISubroutineType struct {
   // File is the file in which the subroutine type is defined.

 }
 
 // DIStructType holds the values for creating struct type debug metadata.
 type DIStructType struct {
   Name        string
   File        Metadata
   Line        int
   SizeInBits  uint64
-  AlignInBits uint64
+  AlignInBits uint32
   Flags       int
   DerivedFrom Metadata
   Elements    []Metadata
 }
 
 // CreateStructType creates struct type debug metadata.
 func (d *DIBuilder) CreateStructType(scope Metadata, t DIStructType) Metadata {
   elements := d.getOrCreateArray(t.Elements)
   name := C.CString(t.Name)
   defer C.free(unsafe.Pointer(name))
   result := C.LLVMDIBuilderCreateStructType(
     d.ref,
     scope.C,
     name,
     t.File.C,
     C.unsigned(t.Line),
     C.uint64_t(t.SizeInBits),
-    C.uint64_t(t.AlignInBits),
+    C.uint32_t(t.AlignInBits),
     C.unsigned(t.Flags),
     t.DerivedFrom.C,
     elements.C,
   )
   return Metadata{C: result}
 }
 
 // DIReplaceableCompositeType holds the values for creating replaceable
 // composite type debug metadata.
 type DIReplaceableCompositeType struct {
   Tag         dwarf.Tag
   Name        string
   File        Metadata
   Line        int
   RuntimeLang int
   SizeInBits  uint64
-  AlignInBits uint64
+  AlignInBits uint32
   Flags       int
 }
 
 // CreateReplaceableCompositeType creates replaceable composite type debug metadata.
 func (d *DIBuilder) CreateReplaceableCompositeType(scope Metadata, t DIReplaceableCompositeType) Metadata {
   name := C.CString(t.Name)
   defer C.free(unsafe.Pointer(name))
   result := C.LLVMDIBuilderCreateReplaceableCompositeType(
     d.ref,
     C.unsigned(t.Tag),
     name,
     scope.C,
     t.File.C,
     C.unsigned(t.Line),
     C.unsigned(t.RuntimeLang),
     C.uint64_t(t.SizeInBits),
-    C.uint64_t(t.AlignInBits),
+    C.uint32_t(t.AlignInBits),
     C.unsigned(t.Flags),
   )
   return Metadata{C: result}
 }
 
 // DIMemberType holds the values for creating member type debug metadata.
 type DIMemberType struct {
   Name         string
   File         Metadata
   Line         int
   SizeInBits   uint64
-  AlignInBits  uint64
+  AlignInBits  uint32
   OffsetInBits uint64
   Flags        int
   Type         Metadata
 }
 
 // CreateMemberType creates struct type debug metadata.
 func (d *DIBuilder) CreateMemberType(scope Metadata, t DIMemberType) Metadata {
   name := C.CString(t.Name)
   defer C.free(unsafe.Pointer(name))
   result := C.LLVMDIBuilderCreateMemberType(
     d.ref,
     scope.C,
     name,
     t.File.C,
     C.unsigned(t.Line),
     C.uint64_t(t.SizeInBits),
-    C.uint64_t(t.AlignInBits),
+    C.uint32_t(t.AlignInBits),
     C.uint64_t(t.OffsetInBits),
     C.unsigned(t.Flags),
     t.Type.C,
   )
   return Metadata{C: result}
 }
 
 // DISubrange describes an integer value range.
 type DISubrange struct {
   Lo    int64
   Count int64
 }
 
 // DIArrayType holds the values for creating array type debug metadata.
 type DIArrayType struct {
   SizeInBits  uint64
-  AlignInBits uint64
+  AlignInBits uint32
   ElementType Metadata
   Subscripts  []DISubrange
 }
 
 // CreateArrayType creates struct type debug metadata.
 func (d *DIBuilder) CreateArrayType(t DIArrayType) Metadata {
   subscriptsSlice := make([]Metadata, len(t.Subscripts))
   for i, s := range t.Subscripts {
     subscriptsSlice[i] = d.getOrCreateSubrange(s.Lo, s.Count)
   }
   subscripts := d.getOrCreateArray(subscriptsSlice)
   result := C.LLVMDIBuilderCreateArrayType(
     d.ref,
     C.uint64_t(t.SizeInBits),
-    C.uint64_t(t.AlignInBits),
+    C.uint32_t(t.AlignInBits),
     t.ElementType.C,
     subscripts.C,
   )
   return Metadata{C: result}
 }
 
 // DITypedef holds the values for creating typedef type debug metadata.
 type DITypedef struct {

include/llvm/IR/DIBuilder.h

public:
 
     /// Create debugging information entry for a basic
     /// type.
     /// \param Name        Type name.
     /// \param SizeInBits  Size of the type.
     /// \param AlignInBits Type alignment.
     /// \param Encoding    DWARF encoding code, e.g. dwarf::DW_ATE_float.
     DIBasicType *createBasicType(StringRef Name, uint64_t SizeInBits,
-                                 uint64_t AlignInBits, unsigned Encoding);
+                                 DIAlignment AlignInBits, unsigned Encoding);
 
     /// Create debugging information entry for a qualified
     /// type, e.g. 'const int'.
     /// \param Tag         Tag identifing type, e.g. dwarf::TAG_volatile_type
     /// \param FromTy      Base Type.
     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,
+                                     DIAlignment 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 *
     createMemberPointerType(DIType *PointeeTy, DIType *Class,
-                            uint64_t SizeInBits, uint64_t AlignInBits = 0,
+                            uint64_t SizeInBits, DIAlignment AlignInBits = 0,
                             DINode::DIFlags Flags = DINode::FlagZero);
 
     /// Create debugging information entry for a c++
     /// style reference or rvalue reference type.
     DIDerivedType *createReferenceType(unsigned Tag, DIType *RTy,
                                        uint64_t SizeInBits = 0,
-                                       uint64_t AlignInBits = 0);
+                                       DIAlignment AlignInBits = 0);
 
     /// Create debugging information entry for a typedef.
     /// \param Ty          Original type.
     /// \param Name        Typedef name.
     /// \param File        File where this type is defined.
     /// \param LineNo      Line number.
     /// \param Context     The surrounding context for the typedef.
     DIDerivedType *createTypedef(DIType *Ty, StringRef Name, DIFile *File,
public:
     /// \param LineNo       Line number.
     /// \param SizeInBits   Member size.
     /// \param AlignInBits  Member alignment.
     /// \param OffsetInBits Member offset.
     /// \param Flags        Flags to encode member attribute, e.g. private
     /// \param Ty           Parent type.
     DIDerivedType *createMemberType(DIScope *Scope, StringRef Name,
                                     DIFile *File, unsigned LineNo,
-                                    uint64_t SizeInBits, uint64_t AlignInBits,
+                                    uint64_t SizeInBits,
+                                    DIAlignment AlignInBits,
                                     uint64_t OffsetInBits,
                                     DINode::DIFlags Flags, DIType *Ty);
 
     /// Create debugging information entry for a bit field member.
     /// \param Scope               Member scope.
     /// \param Name                Member name.
     /// \param File                File where this member is defined.
     /// \param LineNo              Line number.
     /// \param SizeInBits          Member size.
     /// \param AlignInBits         Member alignment.
     /// \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 AlignInBits, uint64_t OffsetInBits,
+        uint64_t SizeInBits, DIAlignment AlignInBits, 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.
public:
     /// \param LineNo       Line number.
     /// \param SizeInBits   Member size.
     /// \param AlignInBits  Member alignment.
     /// \param OffsetInBits Member offset.
     /// \param Flags        Flags to encode member attribute, e.g. private
     /// \param Ty           Parent type.
     /// \param PropertyNode Property associated with this ivar.
     DIDerivedType *createObjCIVar(StringRef Name, DIFile *File, unsigned LineNo,
-                                  uint64_t SizeInBits, uint64_t AlignInBits,
+                                  uint64_t SizeInBits, DIAlignment AlignInBits,
                                   uint64_t OffsetInBits, DINode::DIFlags Flags,
                                   DIType *Ty, MDNode *PropertyNode);
 
     /// Create debugging information entry for Objective-C
     /// property.
     /// \param Name         Property name.
     /// \param File         File where this property is defined.
     /// \param LineNumber   Line number.
public:
     /// \param VTableHolder Debug info of the base class that contains vtable
     ///                     for this type. This is used in
     ///                     DW_AT_containing_type. See DWARF documentation
     ///                     for more info.
     /// \param TemplateParms Template type parameters.
     /// \param UniqueIdentifier A unique identifier for the class.
     DICompositeType *createClassType(
         DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
-        uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
+        uint64_t SizeInBits, DIAlignment AlignInBits, uint64_t OffsetInBits,
         DINode::DIFlags Flags, DIType *DerivedFrom, DINodeArray Elements,
         DIType *VTableHolder = nullptr, MDNode *TemplateParms = nullptr,
         StringRef UniqueIdentifier = "");
 
     /// Create debugging information entry for a struct.
     /// \param Scope        Scope in which this struct is defined.
     /// \param Name         Struct name.
     /// \param File         File where this member is defined.
     /// \param LineNumber   Line number.
     /// \param SizeInBits   Member size.
     /// \param AlignInBits  Member alignment.
     /// \param Flags        Flags to encode member attribute, e.g. private
     /// \param Elements     Struct elements.
     /// \param RunTimeLang  Optional parameter, Objective-C runtime version.
     /// \param UniqueIdentifier A unique identifier for the struct.
     DICompositeType *createStructType(
         DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
-        uint64_t SizeInBits, uint64_t AlignInBits, DINode::DIFlags Flags,
+        uint64_t SizeInBits, DIAlignment AlignInBits, DINode::DIFlags Flags,
         DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang = 0,
         DIType *VTableHolder = nullptr, StringRef UniqueIdentifier = "");
 
     /// Create debugging information entry for an union.
     /// \param Scope        Scope in which this union is defined.
     /// \param Name         Union name.
     /// \param File         File where this member is defined.
     /// \param LineNumber   Line number.
     /// \param SizeInBits   Member size.
     /// \param AlignInBits  Member alignment.
     /// \param Flags        Flags to encode member attribute, e.g. private
     /// \param Elements     Union elements.
     /// \param RunTimeLang  Optional parameter, Objective-C runtime version.
     /// \param UniqueIdentifier A unique identifier for the union.
     DICompositeType *createUnionType(DIScope *Scope, StringRef Name,
                                      DIFile *File, unsigned LineNumber,
-                                     uint64_t SizeInBits, uint64_t AlignInBits,
+                                     uint64_t SizeInBits,
+                                     DIAlignment AlignInBits,
                                      DINode::DIFlags Flags,
                                      DINodeArray Elements,
                                      unsigned RunTimeLang = 0,
                                      StringRef UniqueIdentifier = "");
 
     /// Create debugging information for template
     /// type parameter.
     /// \param Scope        Scope in which this type is defined.
DITemplateValueParameter *createTemplateParameterPack(DIScope *Scope,
                                                           DIType *Ty,
                                                           DINodeArray Val);
 
     /// Create debugging information entry for an array.
     /// \param Size         Array size.
     /// \param AlignInBits  Alignment.
     /// \param Ty           Element type.
     /// \param Subscripts   Subscripts.
-    DICompositeType *createArrayType(uint64_t Size, uint64_t AlignInBits,
+    DICompositeType *createArrayType(uint64_t Size, DIAlignment AlignInBits,
                                      DIType *Ty, DINodeArray Subscripts);
 
     /// Create debugging information entry for a vector type.
     /// \param Size         Array size.
     /// \param AlignInBits  Alignment.
     /// \param Ty           Element type.
     /// \param Subscripts   Subscripts.
-    DICompositeType *createVectorType(uint64_t Size, uint64_t AlignInBits,
+    DICompositeType *createVectorType(uint64_t Size, DIAlignment AlignInBits,
                                       DIType *Ty, DINodeArray Subscripts);
 
     /// Create debugging information entry for an
     /// enumeration.
     /// \param Scope          Scope in which this enumeration is defined.
     /// \param Name           Union name.
     /// \param File           File where this member is defined.
     /// \param LineNumber     Line number.
     /// \param SizeInBits     Member size.
     /// \param AlignInBits    Member alignment.
     /// \param Elements       Enumeration elements.
     /// \param UnderlyingType Underlying type of a C++11/ObjC fixed enum.
     /// \param UniqueIdentifier A unique identifier for the enum.
     DICompositeType *createEnumerationType(
         DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
-        uint64_t SizeInBits, uint64_t AlignInBits, DINodeArray Elements,
+        uint64_t SizeInBits, DIAlignment AlignInBits, DINodeArray Elements,
         DIType *UnderlyingType, StringRef UniqueIdentifier = "");
 
     /// Create subroutine type.
     /// \param ParameterTypes  An array of subroutine parameter types. This
     ///                        includes return type at 0th index.
     /// \param Flags           E.g.: LValueReference.
     ///                        These flags are used to emit dwarf attributes.
     /// \param CC              Calling convention, e.g. dwarf::DW_CC_normal
public:
     /// flag set.
     DIType *createObjectPointerType(DIType *Ty);
 
     /// Create a permanent forward-declared type.
     DICompositeType *createForwardDecl(unsigned Tag, StringRef Name,
                                        DIScope *Scope, DIFile *F, unsigned Line,
                                        unsigned RuntimeLang = 0,
                                        uint64_t SizeInBits = 0,
-                                       uint64_t AlignInBits = 0,
+                                       DIAlignment AlignInBits = 0,
                                        StringRef UniqueIdentifier = "");
 
     /// Create a temporary forward-declared type.
     DICompositeType *createReplaceableCompositeType(
         unsigned Tag, StringRef Name, DIScope *Scope, DIFile *F, unsigned Line,
         unsigned RuntimeLang = 0, uint64_t SizeInBits = 0,
-        uint64_t AlignInBits = 0, DINode::DIFlags Flags = DINode::FlagFwdDecl,
+        DIAlignment AlignInBits = 0,
+        DINode::DIFlags Flags = DINode::FlagFwdDecl,
         StringRef UniqueIdentifier = "");
 
     /// Retain DIScope* in a module even if it is not referenced
     /// through debug info anchors.
     void retainType(DIScope *T);
 
     /// Create unspecified parameter type
     /// for a subroutine type.

include/llvm/IR/DebugInfoMetadata.h

 }
 
 StringRef DIScope::getDirectory() const {
   if (auto *F = getFile())
     return F->getDirectory();
   return "";
 }
 
+typedef uint32_t DIAlignment;
+
 /// \brief Base class for types.
 ///
 /// TODO: Remove the hardcoded name and context, since many types don't use
 /// them.
 /// TODO: Split up flags.
 class DIType : public DIScope {
   unsigned Line;
   DIFlags Flags;
   uint64_t SizeInBits;
-  uint64_t AlignInBits;
+  DIAlignment AlignInBits;
   uint64_t OffsetInBits;
 
 protected:
   DIType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
-         unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
+         unsigned Line, uint64_t SizeInBits, DIAlignment AlignInBits,
          uint64_t OffsetInBits, DIFlags Flags, ArrayRef<Metadata *> Ops)
       : DIScope(C, ID, Storage, Tag, Ops) {
     init(Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
   }
   ~DIType() = default;
 
-  void init(unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
+  void init(unsigned Line, uint64_t SizeInBits, DIAlignment AlignInBits,
             uint64_t OffsetInBits, DIFlags Flags) {
     this->Line = Line;
     this->Flags = Flags;
     this->SizeInBits = SizeInBits;
     this->AlignInBits = AlignInBits;
     this->OffsetInBits = OffsetInBits;
   }
 
   /// Change fields in place.
   void mutate(unsigned Tag, unsigned Line, uint64_t SizeInBits,
-              uint64_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags) {
+              DIAlignment AlignInBits, uint64_t OffsetInBits, DIFlags Flags) {
     assert(isDistinct() && "Only distinct nodes can mutate");
     setTag(Tag);
     init(Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
   }
 
 public:
   TempDIType clone() const {
     return TempDIType(cast<DIType>(MDNode::clone().release()));

 /// TODO: Drop unused accessors.
 class DIBasicType : public DIType {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned Encoding;
 
   DIBasicType(LLVMContext &C, StorageType Storage, unsigned Tag,
-              uint64_t SizeInBits, uint64_t AlignInBits, unsigned Encoding,
+              uint64_t SizeInBits, DIAlignment AlignInBits, unsigned Encoding,
               ArrayRef<Metadata *> Ops)
       : DIType(C, DIBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0,
                FlagZero, Ops),
         Encoding(Encoding) {}
   ~DIBasicType() = default;
 
   static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
                               StringRef Name, uint64_t SizeInBits,
-                              uint64_t AlignInBits, unsigned Encoding,
+                              DIAlignment AlignInBits, unsigned Encoding,
                               StorageType Storage, bool ShouldCreate = true) {
     return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
                    SizeInBits, AlignInBits, Encoding, Storage, ShouldCreate);
   }
   static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
                               MDString *Name, uint64_t SizeInBits,
-                              uint64_t AlignInBits, unsigned Encoding,
+                              DIAlignment AlignInBits, unsigned Encoding,
                               StorageType Storage, bool ShouldCreate = true);
 
   TempDIBasicType cloneImpl() const {
     return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
                         getAlignInBits(), getEncoding());
   }
 
 public:
   DEFINE_MDNODE_GET(DIBasicType, (unsigned Tag, StringRef Name),
                     (Tag, Name, 0, 0, 0))
   DEFINE_MDNODE_GET(DIBasicType,
                     (unsigned Tag, StringRef Name, uint64_t SizeInBits,
-                     uint64_t AlignInBits, unsigned Encoding),
+                     DIAlignment AlignInBits, unsigned Encoding),
                     (Tag, Name, SizeInBits, AlignInBits, Encoding))
   DEFINE_MDNODE_GET(DIBasicType,
                     (unsigned Tag, MDString *Name, uint64_t SizeInBits,
-                     uint64_t AlignInBits, unsigned Encoding),
+                     DIAlignment AlignInBits, unsigned Encoding),
                     (Tag, Name, SizeInBits, AlignInBits, Encoding))
 
   TempDIBasicType clone() const { return cloneImpl(); }
 
   unsigned getEncoding() const { return Encoding; }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIBasicTypeKind;
   }
 };
 
 /// \brief Derived types.
 ///
 /// This includes qualified types, pointers, references, friends, typedefs, and
 /// class members.
 ///
 /// TODO: Split out members (inheritance, fields, methods, etc.).
 class DIDerivedType : public DIType {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   DIDerivedType(LLVMContext &C, StorageType Storage, unsigned Tag,
-                unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits,
+                unsigned Line, uint64_t SizeInBits, DIAlignment AlignInBits,
                 uint64_t OffsetInBits, DIFlags Flags, ArrayRef<Metadata *> Ops)
       : DIType(C, DIDerivedTypeKind, Storage, Tag, Line, SizeInBits,
                AlignInBits, OffsetInBits, Flags, Ops) {}
   ~DIDerivedType() = default;
 
   static DIDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
                                 StringRef Name, DIFile *File, unsigned Line,
                                 DIScopeRef Scope, DITypeRef BaseType,
-                                uint64_t SizeInBits, uint64_t AlignInBits,
+                                uint64_t SizeInBits, DIAlignment AlignInBits,
                                 uint64_t OffsetInBits, DIFlags Flags,
                                 Metadata *ExtraData, StorageType Storage,
                                 bool ShouldCreate = true) {
     return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File,
                    Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits,
                    Flags, ExtraData, Storage, ShouldCreate);
   }
   static DIDerivedType *getImpl(LLVMContext &Context, unsigned Tag,
                                 MDString *Name, Metadata *File, unsigned Line,
                                 Metadata *Scope, Metadata *BaseType,
-                                uint64_t SizeInBits, uint64_t AlignInBits,
+                                uint64_t SizeInBits, DIAlignment AlignInBits,
                                 uint64_t OffsetInBits, DIFlags Flags,
                                 Metadata *ExtraData, StorageType Storage,
                                 bool ShouldCreate = true);
 
   TempDIDerivedType cloneImpl() const {
     return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
                         getScope(), getBaseType(), getSizeInBits(),
                         getAlignInBits(), getOffsetInBits(), getFlags(),
                         getExtraData());
   }
 
 public:
   DEFINE_MDNODE_GET(DIDerivedType,
                     (unsigned Tag, MDString *Name, Metadata *File,
                      unsigned Line, Metadata *Scope, Metadata *BaseType,
-                     uint64_t SizeInBits, uint64_t AlignInBits,
+                     uint64_t SizeInBits, DIAlignment AlignInBits,
                      uint64_t OffsetInBits, DIFlags Flags,
                      Metadata *ExtraData = nullptr),
                     (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
                      AlignInBits, OffsetInBits, Flags, ExtraData))
   DEFINE_MDNODE_GET(DIDerivedType,
                     (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
                      DIScopeRef Scope, DITypeRef BaseType, uint64_t SizeInBits,
-                     uint64_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
-                     Metadata *ExtraData = nullptr),
+                     DIAlignment AlignInBits, uint64_t OffsetInBits,
+                     DIFlags Flags, Metadata *ExtraData = nullptr),
                     (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
                      AlignInBits, OffsetInBits, Flags, ExtraData))
 
   TempDIDerivedType clone() const { return cloneImpl(); }
 
   //// Get the base type this is derived from.
   DITypeRef getBaseType() const { return DITypeRef(getRawBaseType()); }
   Metadata *getRawBaseType() const { return getOperand(3); }

 class DICompositeType : public DIType {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned RuntimeLang;
 
   DICompositeType(LLVMContext &C, StorageType Storage, unsigned Tag,
                   unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits,
-                  uint64_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
+                  DIAlignment AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
                   ArrayRef<Metadata *> Ops)
       : DIType(C, DICompositeTypeKind, Storage, Tag, Line, SizeInBits,
                AlignInBits, OffsetInBits, Flags, Ops),
         RuntimeLang(RuntimeLang) {}
   ~DICompositeType() = default;
 
   /// Change fields in place.
   void mutate(unsigned Tag, unsigned Line, unsigned RuntimeLang,
-              uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
-              DIFlags Flags) {
+              uint64_t SizeInBits, DIAlignment AlignInBits,
+              uint64_t OffsetInBits, DIFlags Flags) {
     assert(isDistinct() && "Only distinct nodes can mutate");
     assert(getRawIdentifier() && "Only ODR-uniqued nodes should mutate");
     this->RuntimeLang = RuntimeLang;
     DIType::mutate(Tag, Line, SizeInBits, AlignInBits, OffsetInBits, Flags);
   }
 
   static DICompositeType *
   getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, Metadata *File,
           unsigned Line, DIScopeRef Scope, DITypeRef BaseType,
-          uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
+          uint64_t SizeInBits, DIAlignment AlignInBits, uint64_t OffsetInBits,
           DIFlags Flags, DINodeArray Elements, unsigned RuntimeLang,
           DITypeRef VTableHolder, DITemplateParameterArray TemplateParams,
           StringRef Identifier, StorageType Storage, bool ShouldCreate = true) {
     return getImpl(
         Context, Tag, getCanonicalMDString(Context, Name), File, Line, Scope,
         BaseType, SizeInBits, AlignInBits, OffsetInBits, Flags, Elements.get(),
         RuntimeLang, VTableHolder, TemplateParams.get(),
         getCanonicalMDString(Context, Identifier), Storage, ShouldCreate);
   }
   static DICompositeType *
   getImpl(LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
           unsigned Line, Metadata *Scope, Metadata *BaseType,
-          uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
+          uint64_t SizeInBits, DIAlignment AlignInBits, uint64_t OffsetInBits,
           DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
           Metadata *VTableHolder, Metadata *TemplateParams,
           MDString *Identifier, StorageType Storage, bool ShouldCreate = true);
 
   TempDICompositeType cloneImpl() const {
     return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(),
                         getScope(), getBaseType(), getSizeInBits(),
                         getAlignInBits(), getOffsetInBits(), getFlags(),
                         getElements(), getRuntimeLang(), getVTableHolder(),
                         getTemplateParams(), getIdentifier());
   }
 
 public:
   DEFINE_MDNODE_GET(DICompositeType,
                     (unsigned Tag, StringRef Name, DIFile *File, unsigned Line,
                      DIScopeRef Scope, DITypeRef BaseType, uint64_t SizeInBits,
-                     uint64_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
-                     DINodeArray Elements, unsigned RuntimeLang,
+                     DIAlignment AlignInBits, uint64_t OffsetInBits,
+                     DIFlags Flags, DINodeArray Elements, unsigned RuntimeLang,
                      DITypeRef VTableHolder,
                      DITemplateParameterArray TemplateParams = nullptr,
                      StringRef Identifier = ""),
                     (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
                      AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
                      VTableHolder, TemplateParams, Identifier))
   DEFINE_MDNODE_GET(DICompositeType,
                     (unsigned Tag, MDString *Name, Metadata *File,
                      unsigned Line, Metadata *Scope, Metadata *BaseType,
-                     uint64_t SizeInBits, uint64_t AlignInBits,
+                     uint64_t SizeInBits, DIAlignment AlignInBits,
                      uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
                      unsigned RuntimeLang, Metadata *VTableHolder,
                      Metadata *TemplateParams = nullptr,
                      MDString *Identifier = nullptr),
                     (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
                      AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
                      VTableHolder, TemplateParams, Identifier))
 
   TempDICompositeType clone() const { return cloneImpl(); }
 
   /// Get a DICompositeType with the given ODR identifier.
   ///
   /// If \a LLVMContext::isODRUniquingDebugTypes(), gets the mapped
   /// DICompositeType for the given ODR \c Identifier.  If none exists, creates
   /// a new node.
   ///
   /// Else, returns \c nullptr.
   static DICompositeType *
   getODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag,
              MDString *Name, Metadata *File, unsigned Line, Metadata *Scope,
-             Metadata *BaseType, uint64_t SizeInBits, uint64_t AlignInBits,
+             Metadata *BaseType, uint64_t SizeInBits, DIAlignment AlignInBits,
              uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
              unsigned RuntimeLang, Metadata *VTableHolder,
              Metadata *TemplateParams);
   static DICompositeType *getODRTypeIfExists(LLVMContext &Context,
                                              MDString &Identifier);
 
   /// Build a DICompositeType with the given ODR identifier.
   ///
   /// Looks up the mapped DICompositeType for the given ODR \c Identifier.  If
   /// it doesn't exist, creates a new one.  If it does exist and \a
   /// isForwardDecl(), and the new arguments would be a definition, mutates the
   /// the type in place.  In either case, returns the type.
   ///
   /// If not \a LLVMContext::isODRUniquingDebugTypes(), this function returns
   /// nullptr.
   static DICompositeType *
   buildODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag,
                MDString *Name, Metadata *File, unsigned Line, Metadata *Scope,
-               Metadata *BaseType, uint64_t SizeInBits, uint64_t AlignInBits,
+               Metadata *BaseType, uint64_t SizeInBits, DIAlignment AlignInBits,
                uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
                unsigned RuntimeLang, Metadata *VTableHolder,
                Metadata *TemplateParams);
 
   DITypeRef getBaseType() const { return DITypeRef(getRawBaseType()); }
   DINodeArray getElements() const {
     return cast_or_null<MDTuple>(getRawElements());
   }

lib/AsmParser/LLParser.cpp

 
 /// ParseDIBasicType:
 ///   ::= !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32)
 bool LLParser::ParseDIBasicType(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type));                     \
   OPTIONAL(name, MDStringField, );                                             \
   OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX));                            \
-  OPTIONAL(align, MDUnsignedField, (0, UINT64_MAX));                           \
+  OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX));                           \
   OPTIONAL(encoding, DwarfAttEncodingField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
   Result = GET_OR_DISTINCT(DIBasicType, (Context, tag.Val, name.Val, size.Val,
                                          align.Val, encoding.Val));
   return false;
 }
 
 /// ParseDIDerivedType:
 ///   ::= !DIDerivedType(tag: DW_TAG_pointer_type, name: "int", file: !0,
 ///                      line: 7, scope: !1, baseType: !2, size: 32,
 ///                      align: 32, offset: 0, flags: 0, extraData: !3)
 bool LLParser::ParseDIDerivedType(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(tag, DwarfTagField, );                                              \
   OPTIONAL(name, MDStringField, );                                             \
   OPTIONAL(file, MDField, );                                                   \
   OPTIONAL(line, LineField, );                                                 \
   OPTIONAL(scope, MDField, );                                                  \
   REQUIRED(baseType, MDField, );                                               \
   OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX));                            \
-  OPTIONAL(align, MDUnsignedField, (0, UINT64_MAX));                           \
+  OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX));                           \
   OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX));                          \
   OPTIONAL(flags, DIFlagField, );                                              \
   OPTIONAL(extraData, MDField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
   Result = GET_OR_DISTINCT(DIDerivedType,
                            (Context, tag.Val, name.Val, file.Val, line.Val,
                             scope.Val, baseType.Val, size.Val, align.Val,
                             offset.Val, flags.Val, extraData.Val));
   return false;
 }
 
 bool LLParser::ParseDICompositeType(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(tag, DwarfTagField, );                                              \
   OPTIONAL(name, MDStringField, );                                             \
   OPTIONAL(file, MDField, );                                                   \
   OPTIONAL(line, LineField, );                                                 \
   OPTIONAL(scope, MDField, );                                                  \
   OPTIONAL(baseType, MDField, );                                               \
   OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX));                            \
-  OPTIONAL(align, MDUnsignedField, (0, UINT64_MAX));                           \
+  OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX));                           \
   OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX));                          \
   OPTIONAL(flags, DIFlagField, );                                              \
   OPTIONAL(elements, MDField, );                                               \
   OPTIONAL(runtimeLang, DwarfLangField, );                                     \
   OPTIONAL(vtableHolder, MDField, );                                           \
   OPTIONAL(templateParams, MDField, );                                         \
   OPTIONAL(identifier, MDStringField, );
   PARSE_MD_FIELDS();

lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::METADATA_COMPOSITE_TYPE: {
       bool IsNotUsedInTypeRef = Record[0] >= 2;
       unsigned Tag = Record[1];
       MDString *Name = getMDString(Record[2]);
       Metadata *File = getMDOrNull(Record[3]);
       unsigned Line = Record[4];
       Metadata *Scope = getDITypeRefOrNull(Record[5]);
       Metadata *BaseType = getDITypeRefOrNull(Record[6]);
       uint64_t SizeInBits = Record[7];
-      uint64_t AlignInBits = Record[8];
+      DIAlignment AlignInBits = Record[8];
       uint64_t OffsetInBits = Record[9];
       DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[10]);
       Metadata *Elements = getMDOrNull(Record[11]);
       unsigned RuntimeLang = Record[12];
       Metadata *VTableHolder = getDITypeRefOrNull(Record[13]);
       Metadata *TemplateParams = getMDOrNull(Record[14]);
       auto *Identifier = getMDString(Record[15]);
       DICompositeType *CT = nullptr;

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
     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();
-      uint64_t Align = DT->getAlignInBits() ? DT->getAlignInBits() : FieldSize;
-      uint64_t AlignMask = ~(Align - 1);
+      DIAlignment Align = DT->getAlignInBits() ? DT->getAlignInBits()
+                                               : FieldSize;
+      DIAlignment AlignMask = ~(Align - 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);

lib/IR/DIBuilder.cpp

DIBasicType *DIBuilder::createUnspecifiedType(StringRef Name) {
   return DIBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name);
 }
 
 DIBasicType *DIBuilder::createNullPtrType() {
   return createUnspecifiedType("decltype(nullptr)");
 }
 
 DIBasicType *DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
-                                        uint64_t AlignInBits,
+                                        DIAlignment AlignInBits,
                                         unsigned Encoding) {
   assert(!Name.empty() && "Unable to create type without name");
   return DIBasicType::get(VMContext, dwarf::DW_TAG_base_type, Name, SizeInBits,
                           AlignInBits, Encoding);
 }
 
 DIDerivedType *DIBuilder::createQualifiedType(unsigned Tag, DIType *FromTy) {
   return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, FromTy, 0,
                             0, 0, DINode::FlagZero);
 }
 
 DIDerivedType *DIBuilder::createPointerType(DIType *PointeeTy,
                                             uint64_t SizeInBits,
-                                            uint64_t AlignInBits,
+                                            DIAlignment AlignInBits,
                                             StringRef Name) {
   // FIXME: Why is there a name here?
   return DIDerivedType::get(VMContext, dwarf::DW_TAG_pointer_type, Name,
                             nullptr, 0, nullptr, PointeeTy, SizeInBits,
                             AlignInBits, 0, DINode::FlagZero);
 }
 
 DIDerivedType *DIBuilder::createMemberPointerType(DIType *PointeeTy,
                                                   DIType *Base,
                                                   uint64_t SizeInBits,
-                                                  uint64_t AlignInBits,
+                                                  DIAlignment AlignInBits,
                                                   DINode::DIFlags Flags) {
   return DIDerivedType::get(VMContext, dwarf::DW_TAG_ptr_to_member_type, "",
                             nullptr, 0, nullptr, PointeeTy, SizeInBits,
                             AlignInBits, 0, Flags, Base);
 }
 
 DIDerivedType *DIBuilder::createReferenceType(unsigned Tag, DIType *RTy,
                                               uint64_t SizeInBits,
-                                              uint64_t AlignInBits) {
+                                              DIAlignment AlignInBits) {
   assert(RTy && "Unable to create reference type");
   return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, RTy,
                             SizeInBits, AlignInBits, 0, DINode::FlagZero);
 }
 
 DIDerivedType *DIBuilder::createTypedef(DIType *Ty, StringRef Name,
                                         DIFile *File, unsigned LineNo,
                                         DIScope *Context) {
DIDerivedType *DIBuilder::createInheritance(DIType *Ty, DIType *BaseTy,
   assert(Ty && "Unable to create inheritance");
   return DIDerivedType::get(VMContext, dwarf::DW_TAG_inheritance, "", nullptr,
                             0, Ty, BaseTy, 0, 0, BaseOffset, Flags);
 }
 
 DIDerivedType *DIBuilder::createMemberType(DIScope *Scope, StringRef Name,
                                            DIFile *File, unsigned LineNumber,
                                            uint64_t SizeInBits,
-                                           uint64_t AlignInBits,
+                                           DIAlignment AlignInBits,
                                            uint64_t OffsetInBits,
                                            DINode::DIFlags Flags, DIType *Ty) {
   return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File,
                             LineNumber, getNonCompileUnitScope(Scope), Ty,
                             SizeInBits, AlignInBits, OffsetInBits, Flags);
 }
 
 static ConstantAsMetadata *getConstantOrNull(Constant *C) {
   if (C)
     return ConstantAsMetadata::get(C);
   return nullptr;
 }
 
 DIDerivedType *DIBuilder::createBitFieldMemberType(
     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
-    uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
+    uint64_t SizeInBits, DIAlignment AlignInBits, uint64_t OffsetInBits,
     uint64_t StorageOffsetInBits, DINode::DIFlags Flags, DIType *Ty) {
   Flags |= DINode::FlagBitField;
   return DIDerivedType::get(
       VMContext, dwarf::DW_TAG_member, Name, File, LineNumber,
       getNonCompileUnitScope(Scope), Ty, SizeInBits, AlignInBits, OffsetInBits,
       Flags, ConstantAsMetadata::get(ConstantInt::get(
                  IntegerType::get(VMContext, 64), StorageOffsetInBits)));
 }
 
 DIDerivedType *
 DIBuilder::createStaticMemberType(DIScope *Scope, StringRef Name, DIFile *File,
                                   unsigned LineNumber, DIType *Ty,
                                   DINode::DIFlags Flags, llvm::Constant *Val) {
   Flags |= DINode::FlagStaticMember;
   return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File,
                             LineNumber, getNonCompileUnitScope(Scope), Ty, 0, 0,
                             0, Flags, getConstantOrNull(Val));
 }
 
 DIDerivedType *
 DIBuilder::createObjCIVar(StringRef Name, DIFile *File, unsigned LineNumber,
-                          uint64_t SizeInBits, uint64_t AlignInBits,
+                          uint64_t SizeInBits, DIAlignment AlignInBits,
                           uint64_t OffsetInBits, DINode::DIFlags Flags,
                           DIType *Ty, MDNode *PropertyNode) {
   return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File,
                             LineNumber, getNonCompileUnitScope(File), Ty,
                             SizeInBits, AlignInBits, OffsetInBits, Flags,
                             PropertyNode);
 }
 
DIBuilder::createTemplateParameterPack(DIScope *Context, StringRef Name,
                                        DIType *Ty, DINodeArray Val) {
   return createTemplateValueParameterHelper(
       VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
       Val.get());
 }
 
 DICompositeType *DIBuilder::createClassType(
     DIScope *Context, StringRef Name, DIFile *File, unsigned LineNumber,
-    uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
+    uint64_t SizeInBits, DIAlignment AlignInBits, uint64_t OffsetInBits,
     DINode::DIFlags Flags, DIType *DerivedFrom, DINodeArray Elements,
     DIType *VTableHolder, MDNode *TemplateParams, StringRef UniqueIdentifier) {
   assert((!Context || isa<DIScope>(Context)) &&
          "createClassType should be called with a valid Context");
 
   auto *R = DICompositeType::get(
       VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
       getNonCompileUnitScope(Context), DerivedFrom, SizeInBits, AlignInBits,
       OffsetInBits, Flags, Elements, 0, VTableHolder,
       cast_or_null<MDTuple>(TemplateParams), UniqueIdentifier);
   trackIfUnresolved(R);
   return R;
 }
 
 DICompositeType *DIBuilder::createStructType(
     DIScope *Context, StringRef Name, DIFile *File, unsigned LineNumber,
-    uint64_t SizeInBits, uint64_t AlignInBits, DINode::DIFlags Flags,
+    uint64_t SizeInBits, DIAlignment AlignInBits, DINode::DIFlags Flags,
     DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang,
     DIType *VTableHolder, StringRef UniqueIdentifier) {
   auto *R = DICompositeType::get(
       VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
       getNonCompileUnitScope(Context), DerivedFrom, SizeInBits, AlignInBits, 0,
       Flags, Elements, RunTimeLang, VTableHolder, nullptr, UniqueIdentifier);
   trackIfUnresolved(R);
   return R;
 }
 
 DICompositeType *DIBuilder::createUnionType(
     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
-    uint64_t SizeInBits, uint64_t AlignInBits, DINode::DIFlags Flags,
+    uint64_t SizeInBits, DIAlignment AlignInBits, DINode::DIFlags Flags,
     DINodeArray Elements, unsigned RunTimeLang, StringRef UniqueIdentifier) {
   auto *R = DICompositeType::get(
       VMContext, dwarf::DW_TAG_union_type, Name, File, LineNumber,
       getNonCompileUnitScope(Scope), nullptr, SizeInBits, AlignInBits, 0, Flags,
       Elements, RunTimeLang, nullptr, nullptr, UniqueIdentifier);
   trackIfUnresolved(R);
   return R;
 }
DICompositeType *DIBuilder::createExternalTypeRef(unsigned Tag, DIFile *File,
   assert(!UniqueIdentifier.empty() && "external type ref without uid");
   return DICompositeType::get(VMContext, Tag, "", nullptr, 0, nullptr, nullptr,
                               0, 0, 0, DINode::FlagExternalTypeRef, nullptr, 0,
                               nullptr, nullptr, UniqueIdentifier);
 }
 
 DICompositeType *DIBuilder::createEnumerationType(
     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
-    uint64_t SizeInBits, uint64_t AlignInBits, DINodeArray Elements,
+    uint64_t SizeInBits, DIAlignment AlignInBits, DINodeArray Elements,
     DIType *UnderlyingType, StringRef UniqueIdentifier) {
   auto *CTy = DICompositeType::get(
       VMContext, dwarf::DW_TAG_enumeration_type, Name, File, LineNumber,
       getNonCompileUnitScope(Scope), UnderlyingType, SizeInBits, AlignInBits, 0,
       DINode::FlagZero, Elements, 0, nullptr, nullptr, UniqueIdentifier);
   AllEnumTypes.push_back(CTy);
   trackIfUnresolved(CTy);
   return CTy;
 }
 
-DICompositeType *DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
+DICompositeType *DIBuilder::createArrayType(uint64_t Size,
+                                            DIAlignment AlignInBits,
                                             DIType *Ty,
                                             DINodeArray Subscripts) {
   auto *R = DICompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
                                  nullptr, 0, nullptr, Ty, Size, AlignInBits, 0,
                                  DINode::FlagZero, Subscripts, 0, nullptr);
   trackIfUnresolved(R);
   return R;
 }
 
 DICompositeType *DIBuilder::createVectorType(uint64_t Size,
-                                             uint64_t AlignInBits, DIType *Ty,
+                                             DIAlignment AlignInBits,
+                                             DIType *Ty,
                                              DINodeArray Subscripts) {
   auto *R = DICompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
                                  nullptr, 0, nullptr, Ty, Size, AlignInBits, 0,
                                  DINode::FlagVector, Subscripts, 0, nullptr);
   trackIfUnresolved(R);
   return R;
 }
 
void DIBuilder::retainType(DIScope *T) {
   AllRetainTypes.emplace_back(T);
 }
 
 DIBasicType *DIBuilder::createUnspecifiedParameter() { return nullptr; }
 
 DICompositeType *
 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIScope *Scope,
                              DIFile *F, unsigned Line, unsigned RuntimeLang,
-                             uint64_t SizeInBits, uint64_t AlignInBits,
+                             uint64_t SizeInBits, DIAlignment AlignInBits,
                              StringRef UniqueIdentifier) {
   // FIXME: Define in terms of createReplaceableForwardDecl() by calling
   // replaceWithUniqued().
   auto *RetTy = DICompositeType::get(
       VMContext, Tag, Name, F, Line, getNonCompileUnitScope(Scope), nullptr,
       SizeInBits, AlignInBits, 0, DINode::FlagFwdDecl, nullptr, RuntimeLang,
       nullptr, nullptr, UniqueIdentifier);
   trackIfUnresolved(RetTy);
   return RetTy;
 }
 
 DICompositeType *DIBuilder::createReplaceableCompositeType(
     unsigned Tag, StringRef Name, DIScope *Scope, DIFile *F, unsigned Line,
-    unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
+    unsigned RuntimeLang, uint64_t SizeInBits, DIAlignment AlignInBits,
     DINode::DIFlags Flags, StringRef UniqueIdentifier) {
   auto *RetTy =
       DICompositeType::getTemporary(
           VMContext, Tag, Name, F, Line, getNonCompileUnitScope(Scope), nullptr,
           SizeInBits, AlignInBits, 0, Flags, nullptr, RuntimeLang, nullptr,
           nullptr, UniqueIdentifier)
           .release();
   trackIfUnresolved(RetTy);

lib/IR/DebugInfoMetadata.cpp

DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, int64_t Value,
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, Name));
   Metadata *Ops[] = {Name};
   DEFINE_GETIMPL_STORE(DIEnumerator, (Value), Ops);
 }
 
 DIBasicType *DIBasicType::getImpl(LLVMContext &Context, unsigned Tag,
                                   MDString *Name, uint64_t SizeInBits,
-                                  uint64_t AlignInBits, unsigned Encoding,
+                                  DIAlignment AlignInBits, unsigned Encoding,
                                   StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIBasicType,
                         (Tag, Name, SizeInBits, AlignInBits, Encoding));
   Metadata *Ops[] = {nullptr, nullptr, Name};
   DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding),
                        Ops);
 }
 
 DIDerivedType *DIDerivedType::getImpl(
     LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
     unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
-    uint64_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
+    DIAlignment AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
     Metadata *ExtraData, StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIDerivedType,
                         (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
                          AlignInBits, OffsetInBits, Flags, ExtraData));
   Metadata *Ops[] = {File, Scope, Name, BaseType, ExtraData};
   DEFINE_GETIMPL_STORE(
       DIDerivedType, (Tag, Line, SizeInBits, AlignInBits, OffsetInBits, Flags),
       Ops);
 }
 
 DICompositeType *DICompositeType::getImpl(
     LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
     unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
-    uint64_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
+    DIAlignment AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
     Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder,
     Metadata *TemplateParams, MDString *Identifier, StorageType Storage,
     bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
 
   // Keep this in sync with buildODRType.
   DEFINE_GETIMPL_LOOKUP(
       DICompositeType, (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
                         AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
                         VTableHolder, TemplateParams, Identifier));
   Metadata *Ops[] = {File,     Scope,        Name,           BaseType,
                      Elements, VTableHolder, TemplateParams, Identifier};
   DEFINE_GETIMPL_STORE(DICompositeType, (Tag, Line, RuntimeLang, SizeInBits,
                                          AlignInBits, OffsetInBits, Flags),
                        Ops);
 }
 
 DICompositeType *DICompositeType::buildODRType(
     LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name,
     Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType,
-    uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
+    uint64_t SizeInBits, DIAlignment AlignInBits, uint64_t OffsetInBits,
     DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
     Metadata *VTableHolder, Metadata *TemplateParams) {
   assert(!Identifier.getString().empty() && "Expected valid identifier");
   if (!Context.isODRUniquingDebugTypes())
     return nullptr;
   auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
   if (!CT)
     return CT = DICompositeType::getDistinct(
for (unsigned I = 0, E = CT->getNumOperands(); I != E; ++I)
     if (Ops[I] != CT->getOperand(I))
       CT->setOperand(I, Ops[I]);
   return CT;
 }
 
 DICompositeType *DICompositeType::getODRType(
     LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name,
     Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType,
-    uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
+    uint64_t SizeInBits, DIAlignment AlignInBits, uint64_t OffsetInBits,
     DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
     Metadata *VTableHolder, Metadata *TemplateParams) {
   assert(!Identifier.getString().empty() && "Expected valid identifier");
   if (!Context.isODRUniquingDebugTypes())
     return nullptr;
   auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
   if (!CT)
     CT = DICompositeType::getDistinct(

lib/IR/LLVMContextImpl.h

template <> struct MDNodeKeyImpl<DIEnumerator> {
   }
   unsigned getHashValue() const { return hash_combine(Value, Name); }
 };
 
 template <> struct MDNodeKeyImpl<DIBasicType> {
   unsigned Tag;
   MDString *Name;
   uint64_t SizeInBits;
-  uint64_t AlignInBits;
+  DIAlignment AlignInBits;
   unsigned Encoding;
 
   MDNodeKeyImpl(unsigned Tag, MDString *Name, uint64_t SizeInBits,
-                uint64_t AlignInBits, unsigned Encoding)
+                DIAlignment AlignInBits, unsigned Encoding)
       : Tag(Tag), Name(Name), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
         Encoding(Encoding) {}
   MDNodeKeyImpl(const DIBasicType *N)
       : Tag(N->getTag()), Name(N->getRawName()), SizeInBits(N->getSizeInBits()),
         AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()) {}
 
   bool isKeyOf(const DIBasicType *RHS) const {
     return Tag == RHS->getTag() && Name == RHS->getRawName() &&

 template <> struct MDNodeKeyImpl<DIDerivedType> {
   unsigned Tag;
   MDString *Name;
   Metadata *File;
   unsigned Line;
   Metadata *Scope;
   Metadata *BaseType;
   uint64_t SizeInBits;
-  uint64_t AlignInBits;
+  DIAlignment AlignInBits;
   uint64_t OffsetInBits;
   unsigned Flags;
   Metadata *ExtraData;
 
   MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
                 Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
-                uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
+                DIAlignment AlignInBits, uint64_t OffsetInBits, unsigned Flags,
                 Metadata *ExtraData)
       : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
         BaseType(BaseType), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
         OffsetInBits(OffsetInBits), Flags(Flags), ExtraData(ExtraData) {}
   MDNodeKeyImpl(const DIDerivedType *N)
       : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
         Line(N->getLine()), Scope(N->getRawScope()),
         BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),

 template <> struct MDNodeKeyImpl<DICompositeType> {
   unsigned Tag;
   MDString *Name;
   Metadata *File;
   unsigned Line;
   Metadata *Scope;
   Metadata *BaseType;
   uint64_t SizeInBits;
-  uint64_t AlignInBits;
+  DIAlignment AlignInBits;
   uint64_t OffsetInBits;
   unsigned Flags;
   Metadata *Elements;
   unsigned RuntimeLang;
   Metadata *VTableHolder;
   Metadata *TemplateParams;
   MDString *Identifier;
 
   MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
                 Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
-                uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
+                DIAlignment AlignInBits, uint64_t OffsetInBits, unsigned Flags,
                 Metadata *Elements, unsigned RuntimeLang,
                 Metadata *VTableHolder, Metadata *TemplateParams,
                 MDString *Identifier)
       : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
         BaseType(BaseType), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
         OffsetInBits(OffsetInBits), Flags(Flags), Elements(Elements),
         RuntimeLang(RuntimeLang), VTableHolder(VTableHolder),
         TemplateParams(TemplateParams), Identifier(Identifier) {}

test/Assembler/ditype-large-values.ll

 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
 ; RUN: verify-uselistorder %s
 
 ; CHECK: !named = !{!0, !1, !2}
 !named = !{!0, !1, !2}
 
-; CHECK:      !0 = !DIBasicType(name: "name", size: 18446744073709551615, align: 18446744073709551614, encoding: DW_ATE_unsigned_char)
-; CHECK-NEXT: !1 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !0, size: 18446744073709551615, align: 18446744073709551614, offset: 18446744073709551613)
-; CHECK-NEXT: !2 = !DICompositeType(tag: DW_TAG_array_type, baseType: !0, size: 18446744073709551615, align: 18446744073709551614, offset: 18446744073709551613)
-!0 = !DIBasicType(tag: DW_TAG_base_type, name: "name", size: 18446744073709551615, align: 18446744073709551614, encoding: DW_ATE_unsigned_char)
-!1 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !0, size: 18446744073709551615, align: 18446744073709551614, offset: 18446744073709551613)
-!2 = !DICompositeType(tag: DW_TAG_array_type, baseType: !0, size: 18446744073709551615, align: 18446744073709551614, offset: 18446744073709551613)
+; CHECK:      !0 = !DIBasicType(name: "name", size: 18446744073709551615, align: 4294967294, encoding: DW_ATE_unsigned_char)
+; CHECK-NEXT: !1 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !0, size: 18446744073709551615, align: 4294967294, offset: 18446744073709551613)
+; CHECK-NEXT: !2 = !DICompositeType(tag: DW_TAG_array_type, baseType: !0, size: 18446744073709551615, align: 4294967294, offset: 18446744073709551613)
+!0 = !DIBasicType(tag: DW_TAG_base_type, name: "name", size: 18446744073709551615, align: 4294967294, encoding: DW_ATE_unsigned_char)
+!1 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !0, size: 18446744073709551615, align: 4294967294, offset: 18446744073709551613)
+!2 = !DICompositeType(tag: DW_TAG_array_type, baseType: !0, size: 18446744073709551615, align: 4294967294, offset: 18446744073709551613)

unittests/IR/MetadataTest.cpp

EXPECT_NE(N, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33,
                                 26, 6));
 
   TempDIBasicType Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 TEST_F(DIBasicTypeTest, getWithLargeValues) {
   auto *N = DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special",
-                             UINT64_MAX, UINT64_MAX - 1, 7);
+                             UINT64_MAX, UINT32_MAX - 1, 7);
   EXPECT_EQ(UINT64_MAX, N->getSizeInBits());
-  EXPECT_EQ(UINT64_MAX - 1, N->getAlignInBits());
+  EXPECT_EQ(UINT32_MAX - 1, N->getAlignInBits());
 }
 
 TEST_F(DIBasicTypeTest, getUnspecified) {
   auto *N =
       DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type, "unspecified");
   EXPECT_EQ(dwarf::DW_TAG_unspecified_type, N->getTag());
   EXPECT_EQ("unspecified", N->getName());
   EXPECT_EQ(0u, N->getSizeInBits());
TEST_F(DIDerivedTypeTest, getWithLargeValues) {
   DIFile *File = getFile();
   DIScope *Scope = getSubprogram();
   DIType *BaseType = getBasicType("basic");
   MDTuple *ExtraData = getTuple();
   DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
 
   auto *N = DIDerivedType::get(
       Context, dwarf::DW_TAG_pointer_type, "something", File, 1, Scope,
-      BaseType, UINT64_MAX, UINT64_MAX - 1, UINT64_MAX - 2, Flags, ExtraData);
+      BaseType, UINT64_MAX, UINT32_MAX - 1, UINT64_MAX - 2, Flags, ExtraData);
   EXPECT_EQ(UINT64_MAX, N->getSizeInBits());
-  EXPECT_EQ(UINT64_MAX - 1, N->getAlignInBits());
+  EXPECT_EQ(UINT32_MAX - 1, N->getAlignInBits());
   EXPECT_EQ(UINT64_MAX - 2, N->getOffsetInBits());
 }
 
 typedef MetadataTest DICompositeTypeTest;
 
 TEST_F(DICompositeTypeTest, get) {
   unsigned Tag = dwarf::DW_TAG_structure_type;
   StringRef Name = "some name";
   DIFile *File = getFile();
   unsigned Line = 1;
   DIScope *Scope = getSubprogram();
   DIType *BaseType = getCompositeType();
   uint64_t SizeInBits = 2;
-  uint64_t AlignInBits = 3;
+  DIAlignment AlignInBits = 3;
   uint64_t OffsetInBits = 4;
   DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
   MDTuple *Elements = getTuple();
   unsigned RuntimeLang = 6;
   DIType *VTableHolder = getCompositeType();
   MDTuple *TemplateParams = getTuple();
   StringRef Identifier = "some id";
 

 TEST_F(DICompositeTypeTest, getWithLargeValues) {
   unsigned Tag = dwarf::DW_TAG_structure_type;
   StringRef Name = "some name";
   DIFile *File = getFile();
   unsigned Line = 1;
   DIScope *Scope = getSubprogram();
   DIType *BaseType = getCompositeType();
   uint64_t SizeInBits = UINT64_MAX;
-  uint64_t AlignInBits = UINT64_MAX - 1;
+  DIAlignment AlignInBits = UINT32_MAX - 1;
   uint64_t OffsetInBits = UINT64_MAX - 2;
   DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
   MDTuple *Elements = getTuple();
   unsigned RuntimeLang = 6;
   DIType *VTableHolder = getCompositeType();
   MDTuple *TemplateParams = getTuple();
   StringRef Identifier = "some id";
 

 TEST_F(DICompositeTypeTest, replaceOperands) {
   unsigned Tag = dwarf::DW_TAG_structure_type;
   StringRef Name = "some name";
   DIFile *File = getFile();
   unsigned Line = 1;
   DIScope *Scope = getSubprogram();
   DIType *BaseType = getCompositeType();
   uint64_t SizeInBits = 2;
-  uint64_t AlignInBits = 3;
+  DIAlignment AlignInBits = 3;
   uint64_t OffsetInBits = 4;
   DINode::DIFlags Flags = static_cast<DINode::DIFlags>(5);
   unsigned RuntimeLang = 6;
   StringRef Identifier = "some id";
 
   auto *N = DICompositeType::get(
       Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, AlignInBits,
       OffsetInBits, Flags, nullptr, RuntimeLang, nullptr, nullptr, Identifier);