[llgo] Update to use the latest IR attribute bindings

[meadori]

Summary

A recent commit (r286087) to the LLVM Go bindings that
changed things over to use the new attribute API broke
llgo. This commit updates llgo accordingly.

[pcc]

irgen/attribute.go

157

We probably don't want to allow arbitrary attributes here. (In fact, I would be happy to see this feature removed entirely; it is untested and exposes too many LLVM specifics.)

[meadori]

irgen/attribute.go

157

Agreed. Okay if I constrain the attribute application for now and remove the feature in a follow-on commit?

[pcc]

irgen/attribute.go

157

SGTM

[meadori]

Address review feedback about constraining LLVM attribute application.

[pcc]

LGTM

[meadori]

Fixed in rL288769.

cmd/gllgo/gllgo.go

func (san *sanitizerOptions) addLibs(triple string, flags []string) []string {
   case san.dataflow:
     flags = san.addLibsForSanitizer(flags, triple, "dfsan")
   }
 
   return flags
 }
 
 func (san *sanitizerOptions) getAttribute() llvm.Attribute {
+  var attrKind uint
+
   switch {
   case san.address:
-    return llvm.SanitizeAddressAttribute
+    attrKind = llvm.AttributeKindID("sanitize_address")
   case san.thread:
-    return llvm.SanitizeThreadAttribute
+    attrKind = llvm.AttributeKindID("sanitize_thread")
   case san.memory:
-    return llvm.SanitizeMemoryAttribute
+    attrKind = llvm.AttributeKindID("sanitize_memory")
   default:
-    return 0
+    attrKind = 0
   }
+
+  ctx := llvm.GlobalContext()
+  return ctx.CreateEnumAttribute(attrKind, 0)
 }
 
 type driverOptions struct {
   actions []action
   output  string
 
   bprefix         string
   debugPrefixMaps []debug.PrefixMap

irgen/attribute.go

 }
 
 func parseLLVMAttribute(value string) llvmAttribute {
   var result llvmAttribute
   value = strings.Replace(value, ",", " ", -1)
   for _, field := range strings.Fields(value) {
     switch strings.ToLower(field) {
     case "noreturn":
-      result |= llvmAttribute(llvm.NoReturnAttribute)
     case "nounwind":
-      result |= llvmAttribute(llvm.NoUnwindAttribute)
     case "noinline":
-      result |= llvmAttribute(llvm.NoInlineAttribute)
     case "alwaysinline":
-      result |= llvmAttribute(llvm.AlwaysInlineAttribute)
+      kind := llvm.AttributeKindID(strings.ToLower(field))
+      result.AttrKinds = append(result.AttrKinds, kind)
     }
   }
   return result
 }
 
-type llvmAttribute llvm.Attribute
+type llvmAttribute struct {
+  AttrKinds []uint
+}
 
 func (a llvmAttribute) Apply(v llvm.Value) {
+  ctx := v.GlobalParent().Context()
   if !v.IsAFunction().IsNil() {
-    v.AddFunctionAttr(llvm.Attribute(a))
-  } else {
-    v.AddAttribute(llvm.Attribute(a))
+    for _, kind := range a.AttrKinds {
+      attr := ctx.CreateEnumAttribute(kind, 0)
+      v.AddFunctionAttr(attr)
+    }
   }
 }
 
 type tlsAttribute struct{}
 
 func (tlsAttribute) Apply(v llvm.Value) {
   v.SetThreadLocal(true)
 }

irgen/cabi.go

 }
 
 func (tm *llvmTypeMap) expandType(argTypes []llvm.Type, argAttrs []llvm.Attribute, bt backendType) ([]llvm.Type, []llvm.Attribute, int, int) {
   var numInt, numSSE int
   var argAttr llvm.Attribute
 
   switch bt := bt.(type) {
   case *structBType, *arrayBType:
+    noneAttr := tm.ctx.CreateEnumAttribute(0, 0)
     bo := tm.getBackendOffsets(bt)
     sp := 0
     for sp != len(bo) && bo[sp].offset < 8 {
       sp++
     }
     eb1 := bo[0:sp]
     eb2 := bo[sp:]
     if len(eb2) > 0 {
       argTypes = append(argTypes, tm.classifyEightbyte(eb1, &numInt, &numSSE), tm.classifyEightbyte(eb2, &numInt, &numSSE))
-      argAttrs = append(argAttrs, 0, 0)
+      argAttrs = append(argAttrs, noneAttr, noneAttr)
     } else {
       argTypes = append(argTypes, tm.classifyEightbyte(eb1, &numInt, &numSSE))
-      argAttrs = append(argAttrs, 0)
+      argAttrs = append(argAttrs, noneAttr)
     }
 
     return argTypes, argAttrs, numInt, numSSE
 
   case *intBType:
     if bt.width < 4 {
+      var argAttrKind uint
       if bt.signed {
-        argAttr = llvm.SExtAttribute
+        argAttrKind = llvm.AttributeKindID("signext")
       } else {
-        argAttr = llvm.ZExtAttribute
+        argAttrKind = llvm.AttributeKindID("zeroext")
       }
+      argAttr = tm.ctx.CreateEnumAttribute(argAttrKind, 0)
     }
   }
 
   argTypes = append(argTypes, tm.classifyEightbyte([]offsetedType{{bt, 0}}, &numInt, &numSSE))
   argAttrs = append(argAttrs, argAttr)
 
   return argTypes, argAttrs, numInt, numSSE
 }
type functionTypeInfo struct {
   retAttr      llvm.Attribute
   argInfos     []argInfo
   retInf       retInfo
   chainIndex   int
 }
 
 func (fi *functionTypeInfo) declare(m llvm.Module, name string) llvm.Value {
   fn := llvm.AddFunction(m, name, fi.functionType)
-  fn.AddFunctionAttr(fi.retAttr)
+  if fi.retAttr.GetEnumKind() != 0 {
+    fn.AddAttributeAtIndex(0, fi.retAttr)
+  }
   for i, a := range fi.argAttrs {
-    if a != 0 {
-      fn.Param(i).AddAttribute(a)
+    if a.GetEnumKind() != 0 {
+      fn.AddAttributeAtIndex(i + 1, a)
     }
   }
   return fn
 }
 
 func (fi *functionTypeInfo) call(ctx llvm.Context, allocaBuilder llvm.Builder, builder llvm.Builder, callee llvm.Value, chain llvm.Value, args []llvm.Value) []llvm.Value {
   callArgs := make([]llvm.Value, len(fi.argAttrs))
   if chain.C == nil {
     chain = llvm.Undef(llvm.PointerType(ctx.Int8Type(), 0))
   }
   callArgs[fi.chainIndex] = chain
   for i, a := range args {
     fi.argInfos[i].encode(ctx, allocaBuilder, builder, callArgs, a)
   }
   fi.retInf.prepare(ctx, allocaBuilder, callArgs)
   typedCallee := builder.CreateBitCast(callee, llvm.PointerType(fi.functionType, 0), "")
   call := builder.CreateCall(typedCallee, callArgs, "")
-  call.AddInstrAttribute(0, fi.retAttr)
+  if fi.retAttr.GetEnumKind() != 0 {
+    call.AddCallSiteAttribute(0, fi.retAttr)
+  }
   for i, a := range fi.argAttrs {
-    call.AddInstrAttribute(i+1, a)
+    if a.GetEnumKind() != 0 {
+      call.AddCallSiteAttribute(i + 1, a)
+    }
   }
   return fi.retInf.decode(ctx, allocaBuilder, builder, call)
 }
 
 func (fi *functionTypeInfo) invoke(ctx llvm.Context, allocaBuilder llvm.Builder, builder llvm.Builder, callee llvm.Value, chain llvm.Value, args []llvm.Value, cont, lpad llvm.BasicBlock) []llvm.Value {
   callArgs := make([]llvm.Value, len(fi.argAttrs))
   if chain.C == nil {
     chain = llvm.Undef(llvm.PointerType(ctx.Int8Type(), 0))
   }
   callArgs[fi.chainIndex] = chain
   for i, a := range args {
     fi.argInfos[i].encode(ctx, allocaBuilder, builder, callArgs, a)
   }
   fi.retInf.prepare(ctx, allocaBuilder, callArgs)
   typedCallee := builder.CreateBitCast(callee, llvm.PointerType(fi.functionType, 0), "")
   call := builder.CreateInvoke(typedCallee, callArgs, cont, lpad, "")
-  call.AddInstrAttribute(0, fi.retAttr)
+  if fi.retAttr.GetEnumKind() != 0 {
+    call.AddCallSiteAttribute(0, fi.retAttr)
+  }
   for i, a := range fi.argAttrs {
-    call.AddInstrAttribute(i+1, a)
+    if a.GetEnumKind() != 0 {
+      call.AddCallSiteAttribute(i + 1, a)
+    }
   }
   builder.SetInsertPointAtEnd(cont)
   return fi.retInf.decode(ctx, allocaBuilder, builder, call)
 }
 
 func (tm *llvmTypeMap) getFunctionTypeInfo(args []types.Type, results []types.Type) (fi functionTypeInfo) {
   var returnType llvm.Type
   var argTypes []llvm.Type
+  var argAttrKind uint
   if len(results) == 0 {
     returnType = llvm.VoidType()
     fi.retInf = &directRetInfo{}
   } else {
     aik := tm.classify(results...)
 
     var resultsType llvm.Type
     if len(results) == 1 {
case AIK_Direct:
       default:
         panic("unexpected expandType result")
       }
       fi.retInf = &directRetInfo{numResults: len(results), retTypes: retTypes, resultsType: resultsType}
 
     case AIK_Indirect:
       returnType = llvm.VoidType()
       argTypes = []llvm.Type{llvm.PointerType(resultsType, 0)}
-      fi.argAttrs = []llvm.Attribute{llvm.StructRetAttribute}
+      argAttrKind = llvm.AttributeKindID("sret")
+      fi.argAttrs = []llvm.Attribute{tm.ctx.CreateEnumAttribute(argAttrKind, 0)}
       fi.retInf = &indirectRetInfo{numResults: len(results), resultsType: resultsType}
     }
   }
 
   // Allocate an argument for the call chain.
   fi.chainIndex = len(argTypes)
   argTypes = append(argTypes, llvm.PointerType(tm.ctx.Int8Type(), 0))
-  fi.argAttrs = append(fi.argAttrs, llvm.NestAttribute)
+  argAttrKind = llvm.AttributeKindID("nest")
+  fi.argAttrs = append(fi.argAttrs, tm.ctx.CreateEnumAttribute(argAttrKind, 0))
 
   // Keep track of the number of INTEGER/SSE class registers remaining.
   remainingInt := 6
   remainingSSE := 8
 
   for _, arg := range args {
     aik := tm.classify(arg)
 
if isDirect {
         // No remaining registers; pass on the stack.
         isDirect = false
       }
     }
 
     if !isDirect {
       fi.argInfos = append(fi.argInfos, &indirectArgInfo{len(argTypes)})
       argTypes = append(argTypes, llvm.PointerType(tm.ToLLVM(arg), 0))
-      fi.argAttrs = append(fi.argAttrs, llvm.ByValAttribute)
+      argAttrKind = llvm.AttributeKindID("byval")
+      fi.argAttrs = append(fi.argAttrs, tm.ctx.CreateEnumAttribute(argAttrKind, 0))
     }
   }
 
   fi.functionType = llvm.FunctionType(returnType, argTypes, false)
   return
 }
 
 func (tm *llvmTypeMap) getSignatureInfo(sig *types.Signature) functionTypeInfo {

irgen/compiler.go

func (c *compiler) logf(format string, v ...interface{}) {
   if c.Logger != nil {
     c.Logger.Printf(format, v...)
   }
 }
 
 func (c *compiler) addCommonFunctionAttrs(fn llvm.Value) {
   fn.AddTargetDependentFunctionAttr("disable-tail-calls", "true")
   fn.AddTargetDependentFunctionAttr("split-stack", "")
-  if attr := c.SanitizerAttribute; attr != 0 {
-    fn.AddFunctionAttr(attr)
+  if c.SanitizerAttribute.GetEnumKind() != 0 {
+    fn.AddFunctionAttr(c.SanitizerAttribute)
   }
 }
 
 // MakeImporter sets CompilerOptions.Importer to an appropriate importer
 // for the search paths given in CompilerOptions.ImportPaths, and sets
 // CompilerOptions.InitMap to an init map belonging to that importer.
 // If CompilerOptions.GccgoPath is non-empty, the importer will also use
 // the search paths for that gccgo installation.

irgen/maps.go

 }
 
 // mapLookup implements v[, ok] = m[k]
 func (fr *frame) mapLookup(m, k *govalue) (v *govalue, ok *govalue) {
   llk := k.value
   pk := fr.allocaBuilder.CreateAlloca(llk.Type(), "")
   fr.builder.CreateStore(llk, pk)
   valptr := fr.runtime.mapIndex.call(fr, m.value, pk, boolLLVMValue(false))[0]
-  valptr.AddInstrAttribute(2, llvm.NoCaptureAttribute)
-  valptr.AddInstrAttribute(2, llvm.ReadOnlyAttribute)
+  attrkind := llvm.AttributeKindID("nocapture")
+  valptr.AddCallSiteAttribute(2, fr.types.ctx.CreateEnumAttribute(attrkind, 0))
+  attrkind = llvm.AttributeKindID("readonly")
+  valptr.AddCallSiteAttribute(2, fr.types.ctx.CreateEnumAttribute(attrkind, 0))
   okbit := fr.builder.CreateIsNotNull(valptr, "")
 
   elemtyp := m.Type().Underlying().(*types.Map).Elem()
   ok = newValue(fr.builder.CreateZExt(okbit, llvm.Int8Type(), ""), types.Typ[types.Bool])
   v = fr.loadOrNull(okbit, valptr, elemtyp)
   return
 }
 
 // mapUpdate implements m[k] = v
 func (fr *frame) mapUpdate(m, k, v *govalue) {
   llk := k.value
   pk := fr.allocaBuilder.CreateAlloca(llk.Type(), "")
   fr.builder.CreateStore(llk, pk)
   valptr := fr.runtime.mapIndex.call(fr, m.value, pk, boolLLVMValue(true))[0]
-  valptr.AddInstrAttribute(2, llvm.NoCaptureAttribute)
-  valptr.AddInstrAttribute(2, llvm.ReadOnlyAttribute)
+  attrkind := llvm.AttributeKindID("nocapture")
+  valptr.AddCallSiteAttribute(2, fr.types.ctx.CreateEnumAttribute(attrkind, 0))
+  attrkind = llvm.AttributeKindID("readonly")
+  valptr.AddCallSiteAttribute(2, fr.types.ctx.CreateEnumAttribute(attrkind, 0))
 
   elemtyp := m.Type().Underlying().(*types.Map).Elem()
   llelemtyp := fr.types.ToLLVM(elemtyp)
   typedvalptr := fr.builder.CreateBitCast(valptr, llvm.PointerType(llelemtyp, 0), "")
   fr.builder.CreateStore(v.value, typedvalptr)
 }
 
 // mapDelete implements delete(m, k)

irgen/runtime.go

func newRuntimeInterface(module llvm.Module, tm *llvmTypeMap) (*runtimeInterface, error) {
   String := types.Typ[types.String]
   Uintptr := types.Typ[types.Uintptr]
   UnsafePointer := types.Typ[types.UnsafePointer]
 
   EmptyInterface := types.NewInterface(nil, nil)
   ByteSlice := types.NewSlice(types.Typ[types.Byte])
   IntSlice := types.NewSlice(types.Typ[types.Int])
 
+  AttrKind := llvm.AttributeKindID("nounwind")
+  NoUnwindAttr := module.Context().CreateEnumAttribute(AttrKind, 0)
+  AttrKind = llvm.AttributeKindID("noreturn")
+  NoReturnAttr := module.Context().CreateEnumAttribute(AttrKind, 0)
+
   for _, rt := range [...]struct {
     name      string
     rfi       *runtimeFnInfo
     args, res []types.Type
     attrs     []llvm.Attribute
   }{
     {
       name: "__go_append",
       rfi:  &ri.append,
       args: []types.Type{IntSlice, UnsafePointer, Uintptr, Uintptr},
       res:  []types.Type{IntSlice},
     },
     {
       name: "__go_assert_interface",
       rfi:  &ri.assertInterface,
       args: []types.Type{UnsafePointer, UnsafePointer},
       res:  []types.Type{UnsafePointer},
     },
     {
       name:  "__go_byte_array_to_string",
       rfi:   &ri.byteArrayToString,
       args:  []types.Type{UnsafePointer, Int},
       res:   []types.Type{String},
-      attrs: []llvm.Attribute{llvm.NoUnwindAttribute},
+      attrs: []llvm.Attribute{NoUnwindAttr},
     },
     {
       name: "__go_can_recover",
       rfi:  &ri.canRecover,
       args: []types.Type{UnsafePointer},
       res:  []types.Type{Bool},
     },
     {
attrs     []llvm.Attribute
       args: []types.Type{UnsafePointer},
       res:  []types.Type{Int},
     },
     {
       name:  "__go_new",
       rfi:   &ri.New,
       args:  []types.Type{UnsafePointer, Uintptr},
       res:   []types.Type{UnsafePointer},
-      attrs: []llvm.Attribute{llvm.NoUnwindAttribute},
+      attrs: []llvm.Attribute{NoUnwindAttr},
     },
     {
       name: "__go_new_channel",
       rfi:  &ri.newChannel,
       args: []types.Type{UnsafePointer, Uintptr},
       res:  []types.Type{UnsafePointer},
     },
     {
       name: "__go_new_map",
       rfi:  &ri.newMap,
       args: []types.Type{UnsafePointer, Uintptr},
       res:  []types.Type{UnsafePointer},
     },
     {
       name: "runtime.newselect",
       rfi:  &ri.newSelect,
       args: []types.Type{Int32},
       res:  []types.Type{UnsafePointer},
     },
     {
       name:  "__go_panic",
       rfi:   &ri.panic,
       args:  []types.Type{EmptyInterface},
-      attrs: []llvm.Attribute{llvm.NoReturnAttribute},
+      attrs: []llvm.Attribute{NoReturnAttr},
     },
     {
       name: "__go_print_bool",
       rfi:  &ri.printBool,
       args: []types.Type{Bool},
     },
     {
       name: "__go_print_complex",
attrs     []llvm.Attribute
       name: "__go_register_gc_roots",
       rfi:  &ri.registerGcRoots,
       args: []types.Type{UnsafePointer},
     },
     {
       name:  "__go_runtime_error",
       rfi:   &ri.runtimeError,
       args:  []types.Type{Int32},
-      attrs: []llvm.Attribute{llvm.NoReturnAttribute},
+      attrs: []llvm.Attribute{NoReturnAttr},
     },
     {
       name: "runtime.selectdefault",
       rfi:  &ri.selectdefault,
       args: []types.Type{UnsafePointer, Int32},
     },
     {
       name: "runtime.selectgo",
attrs     []llvm.Attribute
       args: []types.Type{String, Int, Int},
       res:  []types.Type{String},
     },
     {
       name:  "__go_string_to_byte_array",
       rfi:   &ri.stringToByteArray,
       args:  []types.Type{String},
       res:   []types.Type{ByteSlice},
-      attrs: []llvm.Attribute{llvm.NoUnwindAttribute},
+      attrs: []llvm.Attribute{NoUnwindAttr},
     },
     {
       name: "__go_string_to_int_array",
       rfi:  &ri.stringToIntArray,
       args: []types.Type{String},
       res:  []types.Type{IntSlice},
     },
     {

irgen/ssa.go

 // The created function will have the same name as the current frame's function
 // with "$recover" appended, having the same return types and parameters with
 // an additional boolean parameter appended.
 //
 // A new frame will be returned for the newly created function.
 func (fr *frame) bridgeRecoverFunc(llfn llvm.Value, fti functionTypeInfo) *frame {
   // The bridging function must not be inlined, or the return address
   // may not correspond to the source function.
-  llfn.AddFunctionAttr(llvm.NoInlineAttribute)
+  attrKind := llvm.AttributeKindID("noinline")
+  noInlineAttr := fr.module.Context().CreateEnumAttribute(attrKind, 0)
+  llfn.AddFunctionAttr(noInlineAttr)
 
   // Call __go_can_recover, passing in the function's return address.
   entry := llvm.AddBasicBlock(llfn, "entry")
   fr.builder.SetInsertPointAtEnd(entry)
   canRecover := fr.runtime.canRecover.call(fr, fr.returnAddress(0))[0]
   returnType := fti.functionType.ReturnType()
   argTypes := fti.functionType.ParamTypes()
   argTypes = append(argTypes, canRecover.Type())