[llgo] drop use of __go_new_nopointers

[axw]

Summary

__go_new_nopointers has been removed from
libgo, so we need to migrate away from it
before we can update. It was only used in
two places (via fr.createMalloc), for
converting between []byte and string. libgo
has functions for both of these, so we now
use them instead.

[axw]

Fix ordering of __go_byte_array_to_string

[pcc]

LGTM, but I have a slight preference for making this change at the same time as the libgo roll, as it looks like this may regress the allocator strategy for small objects (grep for FlagNoScan).

[axw]

Superceded by D15188

irgen/runtime.go

type runtimeInterface struct {
 
   // Exception handling support
   gccgoPersonality   llvm.Value
   gccgoExceptionType llvm.Type
 
   // Runtime intrinsics
   append,
   assertInterface,
+  byteArrayToString,
   canRecover,
   chanCap,
   chanLen,
   chanrecv2,
   checkDefer,
   checkInterfaceType,
   builtinClose,
   convertInterface,
type runtimeInterface struct {
   mapiter2,
   mapiterinit,
   mapiternext,
   mapIndex,
   mapLen,
   New,
   newChannel,
   newMap,
-  NewNopointers,
   newSelect,
   panic,
   printBool,
   printComplex,
   printDouble,
   printEmptyInterface,
   printInterface,
   printInt64,
type runtimeInterface struct {
   selectsend,
   selectgo,
   sendBig,
   setDeferRetaddr,
   strcmp,
   stringiter2,
   stringPlus,
   stringSlice,
+  stringToByteArray,
   stringToIntArray,
   typeDescriptorsEqual,
   undefer runtimeFnInfo
 }
 
 func newRuntimeInterface(module llvm.Module, tm *llvmTypeMap) (*runtimeInterface, error) {
   var ri runtimeInterface
 
   Bool := types.Typ[types.Bool]
   Complex128 := types.Typ[types.Complex128]
   Float64 := types.Typ[types.Float64]
   Int32 := types.Typ[types.Int32]
   Int64 := types.Typ[types.Int64]
   Int := types.Typ[types.Int]
   Rune := types.Typ[types.Rune]
   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])
 
   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},
+    },
+    {
       name: "__go_can_recover",
       rfi:  &ri.canRecover,
       args: []types.Type{UnsafePointer},
       res:  []types.Type{Bool},
     },
     {
       name: "__go_chan_cap",
       rfi:  &ri.chanCap,
for _, rt := range [...]struct {
     },
     {
       name: "__go_new_map",
       rfi:  &ri.newMap,
       args: []types.Type{UnsafePointer, Uintptr},
       res:  []types.Type{UnsafePointer},
     },
     {
-      name: "__go_new_nopointers",
-      rfi:  &ri.NewNopointers,
-      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,
for _, rt := range [...]struct {
     },
     {
       name: "__go_string_slice",
       rfi:  &ri.stringSlice,
       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},
+    },
+    {
       name: "__go_string_to_int_array",
       rfi:  &ri.stringToIntArray,
       args: []types.Type{String},
       res:  []types.Type{IntSlice},
     },
     {
       name: "runtime.stringiter2",
       rfi:  &ri.stringiter2,
func (fr *frame) createZExtOrTrunc(v llvm.Value, t llvm.Type, name string) llvm.Value {
   case n < 0:
     v = fr.builder.CreateZExt(v, fr.target.IntPtrType(), name)
   case n > 0:
     v = fr.builder.CreateTrunc(v, fr.target.IntPtrType(), name)
   }
   return v
 }
 
-func (fr *frame) createMalloc(size llvm.Value) llvm.Value {
-  return fr.runtime.NewNopointers.callOnly(fr,
-    llvm.ConstNull(llvm.PointerType(llvm.Int8Type(), 0)),
-    fr.createZExtOrTrunc(size, fr.target.IntPtrType(), ""))[0]
-}
-
 func (fr *frame) createTypeMalloc(t types.Type) llvm.Value {
   size := llvm.ConstInt(fr.target.IntPtrType(), uint64(fr.llvmtypes.Sizeof(t)), false)
   malloc := fr.runtime.New.callOnly(fr, fr.types.ToRuntime(t), size)[0]
   return fr.builder.CreateBitCast(malloc, llvm.PointerType(fr.types.ToLLVM(t), 0), "")
 }
 
 func (fr *frame) memsetZero(ptr llvm.Value, size llvm.Value) {
   memset := fr.runtime.memset

irgen/value.go

 //
 //===----------------------------------------------------------------------===//
 
 package irgen
 
 import (
   "fmt"
   "go/token"
+
   "llvm.org/llgo/third_party/gotools/go/exact"
   "llvm.org/llgo/third_party/gotools/go/types"
   "llvm.org/llvm/bindings/go/llvm"
 )
 
 // govalue contains an LLVM value and a Go type,
 // representing the result of a Go expression.
 type govalue struct {
if isString(srctyp) {
     // (untyped) string -> string
     // XXX should untyped strings be able to escape go/types?
     if isString(dsttyp) {
       return newValue(v.value, origdsttyp)
     }
 
     // string -> []byte
     if isSlice(dsttyp, types.Byte) {
-      value := v.value
-      strdata := fr.builder.CreateExtractValue(value, 0, "")
-      strlen := fr.builder.CreateExtractValue(value, 1, "")
-
-      // Data must be copied, to prevent changes in
-      // the byte slice from mutating the string.
-      newdata := fr.createMalloc(strlen)
-      fr.memcpy(newdata, strdata, strlen)
-
-      struct_ := llvm.Undef(fr.types.ToLLVM(dsttyp))
-      struct_ = fr.builder.CreateInsertValue(struct_, newdata, 0, "")
-      struct_ = fr.builder.CreateInsertValue(struct_, strlen, 1, "")
-      struct_ = fr.builder.CreateInsertValue(struct_, strlen, 2, "")
-      return newValue(struct_, origdsttyp)
+      sliceValue := fr.runtime.stringToByteArray.callOnly(fr, v.value)[0]
+      return newValue(sliceValue, origdsttyp)
     }
 
     // string -> []rune
     if isSlice(dsttyp, types.Rune) {
       return fr.stringToRuneSlice(v)
     }
   }
 
   // []byte -> string
   if isSlice(srctyp, types.Byte) && isString(dsttyp) {
-    value := v.value
-    data := fr.builder.CreateExtractValue(value, 0, "")
-    len := fr.builder.CreateExtractValue(value, 1, "")
-
-    // Data must be copied, to prevent changes in
-    // the byte slice from mutating the string.
-    newdata := fr.createMalloc(len)
-    fr.memcpy(newdata, data, len)
-
-    struct_ := llvm.Undef(fr.types.ToLLVM(types.Typ[types.String]))
-    struct_ = fr.builder.CreateInsertValue(struct_, newdata, 0, "")
-    struct_ = fr.builder.CreateInsertValue(struct_, len, 1, "")
-    return newValue(struct_, types.Typ[types.String])
+    data := fr.builder.CreateExtractValue(v.value, 0, "")
+    len := fr.builder.CreateExtractValue(v.value, 1, "")
+    stringValue := fr.runtime.byteArrayToString.callOnly(fr, data, len)[0]
+    return newValue(stringValue, dsttyp)
   }
 
   // []rune -> string
   if isSlice(srctyp, types.Rune) && isString(dsttyp) {
     return fr.runeSliceToString(v)
   }
 
   // rune -> string