[llgo] Fix `debug` to use latest `DIBuilder` bindings

[meadori]

Summary

Two recent commits to the LLVM Go bindings caused breaking changes
to llgo:

1. r284707 - Moving the AlignInBits field from DIBasicType to DIAutoVariable.
2. r284482 - The AlignInBits fields going from uint64 to uint32.

This commit updates llgo accordingly.

[pcc]

LGTM

[meadori]

Fixed in rL288768.

debug/debug.go

case types.String:
     return d.typeDebugDescriptor(types.NewStruct([]*types.Var{
       types.NewVar(0, nil, "ptr", types.NewPointer(types.Typ[types.Uint8])),
       types.NewVar(0, nil, "len", types.Typ[types.Int]),
     }, nil), name)
   case types.UnsafePointer:
     return d.builder.CreateBasicType(llvm.DIBasicType{
       Name:        name,
       SizeInBits:  uint64(d.sizes.Sizeof(t) * 8),
-      AlignInBits: uint64(d.sizes.Alignof(t) * 8),
       Encoding:    llvm.DW_ATE_unsigned,
     })
   default:
     bt := llvm.DIBasicType{
       Name:        t.String(),
       SizeInBits:  uint64(d.sizes.Sizeof(t) * 8),
-      AlignInBits: uint64(d.sizes.Alignof(t) * 8),
     }
     switch bi := t.Info(); {
     case bi&types.IsBoolean != 0:
       bt.Encoding = llvm.DW_ATE_boolean
     case bi&types.IsUnsigned != 0:
       bt.Encoding = llvm.DW_ATE_unsigned
     case bi&types.IsInteger != 0:
       bt.Encoding = llvm.DW_ATE_signed
default:
     return d.builder.CreateBasicType(bt)
   }
 }
 
 func (d *DIBuilder) descriptorPointer(t *types.Pointer) llvm.Metadata {
   return d.builder.CreatePointerType(llvm.DIPointerType{
     Pointee:     d.DIType(t.Elem()),
     SizeInBits:  uint64(d.sizes.Sizeof(t) * 8),
-    AlignInBits: uint64(d.sizes.Alignof(t) * 8),
+    AlignInBits: uint32(d.sizes.Alignof(t) * 8),
   })
 }
 
 func (d *DIBuilder) descriptorStruct(t *types.Struct, name string) llvm.Metadata {
   fields := make([]*types.Var, t.NumFields())
   for i := range fields {
     fields[i] = t.Field(i)
   }
   offsets := d.sizes.Offsetsof(fields)
   members := make([]llvm.Metadata, len(fields))
   for i, f := range fields {
     // TODO(axw) file/line where member is defined.
     t := f.Type()
     members[i] = d.builder.CreateMemberType(d.cu, llvm.DIMemberType{
       Name:         f.Name(),
       Type:         d.DIType(t),
       SizeInBits:   uint64(d.sizes.Sizeof(t) * 8),
-      AlignInBits:  uint64(d.sizes.Alignof(t) * 8),
+      AlignInBits:  uint32(d.sizes.Alignof(t) * 8),
       OffsetInBits: uint64(offsets[i] * 8),
     })
   }
   // TODO(axw) file/line where struct is defined.
   return d.builder.CreateStructType(d.cu, llvm.DIStructType{
     Name:        name,
     SizeInBits:  uint64(d.sizes.Sizeof(t) * 8),
-    AlignInBits: uint64(d.sizes.Alignof(t) * 8),
+    AlignInBits: uint32(d.sizes.Alignof(t) * 8),
     Elements:    members,
   })
 }
 
 func (d *DIBuilder) descriptorNamed(t *types.Named) llvm.Metadata {
   var diFile llvm.Metadata
   var line int
   if file := d.fset.File(t.Obj().Pos()); file != nil {
func (d *DIBuilder) descriptorNamed(t *types.Named) llvm.Metadata {
   })
   placeholder.ReplaceAllUsesWith(typedef)
   return typedef
 }
 
 func (d *DIBuilder) descriptorArray(t *types.Array, name string) llvm.Metadata {
   return d.builder.CreateArrayType(llvm.DIArrayType{
     SizeInBits:  uint64(d.sizes.Sizeof(t) * 8),
-    AlignInBits: uint64(d.sizes.Alignof(t) * 8),
+    AlignInBits: uint32(d.sizes.Alignof(t) * 8),
     ElementType: d.DIType(t.Elem()),
     Subscripts:  []llvm.DISubrange{{Count: t.Len()}},
   })
 }
 
 func (d *DIBuilder) descriptorSlice(t *types.Slice, name string) llvm.Metadata {
   sliceStruct := types.NewStruct([]*types.Var{
     types.NewVar(0, nil, "ptr", types.NewPointer(t.Elem())),