[llgo] Roll gofrontend forward

[axw]

Summary

Switch gofrontend to using go.googlesource.com, and
update to 81eb6a3f425b2158c67ee32c0cc973a72ce9d6be.

There are various changes required to update to the
go 1.5 runtime:

• typemap.go is changed to accommodate the change in representation for equal/hash algorithms, and the removal of the zero value/type.
• CMakeLists.txt is updated to add the build tree to the package search path, so internal packages, which are not installed, are found.
• various files changes due to removal of __go_new_nopointers; the same change as in D11863, but with NoUnwindAttribute added to the added runtime functions which are called with "callOnly".
• minor cleanups in ssa.go while investigating issues with unwinding/panic handling.

[axw]

I've just come back to this and found that it's broken. Unsure of what's changed in the interim, but I get "panic: panic during panic" caused by type descriptor comparisons. Will come back to this when I have time.

[axw]

Revert removal of __go_runtime_error

No longer causing errors. Have not bisected
to find out what the issue is yet.

[axw]

In D15188#331740, @axw wrote:

Revert removal of __go_runtime_error

No longer causing errors. Have not bisected
to find out what the issue is yet.

The failures stopped in r256202.

[axw]

@pcc Ping. This is ready for review now.

[pcc]

irgen/typemap.go

1492–1506

I don't think you need to be able to call arbitrary closures in the algorithm implementations. Since the identity of the element type is statically known, you can just call the function directly. The only place where you should need to deal with closure descriptors is when building the type descriptor struct.

update_third_party.sh

74–76

Will this work now that autoconf support is removed from LLVM? We might need to make our own copies of the files in the llgo repo.

[axw]

• Fix autoconf file copying
• Call hash/equal functions directly, not through descriptors.

[axw]

@pcc Thanks, PTAL.

irgen/typemap.go

1492–1506

Yep, thanks, I'm storing functions and descriptors, so reverted the hash/equal calls.

update_third_party.sh

74–76

config.guess was relocated to cmake/config.guess, so I'll change it to copy from there.
config.sub was removed, so adding it as llgo/autoconf/config.sub.

[axw]

Ping. Once this is in, I'll look at updating to 1.6.

[cierniak]

In D15188#355493, @axw wrote:

Ping. Once this is in, I'll look at updating to 1.6.

I'm also keen to see this submitted and then seeing the update to 1.6.

[pcc]

Sorry for the delay. LGTM, thanks!

[axw]

TargetMachine.TargetData -> TargetMachine.CreateTargetData

[pcc]

cmd/gllgo/gllgo.go

490–492 ↗

(On Diff #47306)

Was this change intended?

[pcc]

Ah, I see that LLVMAddTargetData is no more. LGTM then.

[axw]

cmd/gllgo/gllgo.go

489–490 ↗

(On Diff #50694)

Yes, sorry, should have commented. LLVMAddTargetData has been removed. AFAICT, PM now uses the data layout from the module.

[axw]

Closed by rL263536

CMakeLists.txt

set(LLGO_GO_SOURCES
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/fmt.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/generate.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/get.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/go11.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/help.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/http.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/list.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/main.go
+  ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/note.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/pkg.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/run.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/signal.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/signal_unix.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/testflag.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/test.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/tool.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/vcs.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/version.go
   ${CMAKE_CURRENT_SOURCE_DIR}/third_party/gofrontend/libgo/go/cmd/go/vet.go
   ${CMAKE_CURRENT_BINARY_DIR}/cmd/go/zdefaultcc.go
 )
 
 add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/bin/llgo-go${CMAKE_EXECUTABLE_SUFFIX}
   COMMAND ${CMAKE_BINARY_DIR}/bin/llgo -static-libgo
+          -I ${CMAKE_CURRENT_BINARY_DIR}/libgo
           -o ${CMAKE_BINARY_DIR}/bin/llgo-go${CMAKE_EXECUTABLE_SUFFIX}
           ${LLGO_GO_SOURCES}
           ${CMAKE_CURRENT_BINARY_DIR}/libgo/zstdpkglist.go
   DEPENDS llgo libgo ${LLGO_GO_SOURCES}
   COMMENT "Building Go executable llgo-go"
   VERBATIM)
 add_custom_target(llgo-go ALL DEPENDS ${CMAKE_BINARY_DIR}/bin/llgo-go${CMAKE_EXECUTABLE_SUFFIX})
 

irgen/errors.go

func (fr *frame) setBranchWeightMetadata(br llvm.Value, trueweight, falseweight uint64) {
   br.SetMetadata(mdprof, mdnode)
 }
 
 func (fr *frame) condBrRuntimeError(cond llvm.Value, errcode uint64) {
   if cond.IsNull() {
     return
   }
 
-  errorbb := fr.runtimeErrorBlocks[errcode]
-  newbb := errorbb.C == nil
-  if newbb {
-    errorbb = llvm.AddBasicBlock(fr.function, "")
-    fr.runtimeErrorBlocks[errcode] = errorbb
-  }
-
+  errorbb := llvm.AddBasicBlock(fr.function, "")
   contbb := llvm.AddBasicBlock(fr.function, "")
 
   br := fr.builder.CreateCondBr(cond, errorbb, contbb)
   fr.setBranchWeightMetadata(br, 1, 1000)
 
-  if newbb {
-    fr.builder.SetInsertPointAtEnd(errorbb)
-    fr.runtime.runtimeError.call(fr, llvm.ConstInt(llvm.Int32Type(), errcode, false))
-    fr.builder.CreateUnreachable()
-  }
 
   fr.builder.SetInsertPointAtEnd(contbb)
 }

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},
+      attrs: []llvm.Attribute{llvm.NoUnwindAttribute},
+    },
+    {
       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_map_len",
       rfi:  &ri.mapLen,
       args: []types.Type{UnsafePointer},
       res:  []types.Type{Int},
     },
     {
-      name: "__go_new",
-      rfi:  &ri.New,
-      args: []types.Type{UnsafePointer, Uintptr},
-      res:  []types.Type{UnsafePointer},
+      name:  "__go_new",
+      rfi:   &ri.New,
+      args:  []types.Type{UnsafePointer, Uintptr},
+      res:   []types.Type{UnsafePointer},
+      attrs: []llvm.Attribute{llvm.NoUnwindAttribute},
     },
     {
       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: "__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},
+      attrs: []llvm.Attribute{llvm.NoUnwindAttribute},
+    },
+    {
       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/ssa.go

for _, local := range f.Locals {
     value := newValue(bcalloca, local.Type())
     fr.env[local] = value
   }
 
   // If the function contains any defers, we must first create
   // an unwind block. We can short-circuit the check for defers with
   // f.Recover != nil.
   if f.Recover != nil || hasDefer(f) {
-    fr.unwindBlock = llvm.AddBasicBlock(fr.function, "")
+    fr.unwindBlock = llvm.AddBasicBlock(fr.function, "unwind")
     fr.frameptr = fr.builder.CreateAlloca(llvm.Int8Type(), "")
   }
 
   // Keep track of the block into which we need to insert the call
   // to __go_register_gc_roots. This needs to be inserted after the
   // init guard check under the llgo ABI.
   var registerGcBlock llvm.BasicBlock
 
if llblock.IsNil() {
       continue
     }
     fr.translateBlock(block, llblock)
   }
 
   fr.fixupPhis()
 
   if !fr.unwindBlock.IsNil() {
-    fr.setupUnwindBlock(f.Recover, f.Signature.Results())
+    fr.setupUnwindBlock(f.Recover)
   }
 
   // The init function needs to register the GC roots first. We do this
   // after generating code for it because allocations may have caused
   // additional GC roots to be created.
   if fr.isInit {
     fr.builder.SetInsertPointBefore(registerGcBlock.FirstInstruction())
     fr.registerGcRoots()
   }
 }
 
 type pendingPhi struct {
   ssa  *ssa.Phi
   llvm llvm.Value
 }
 
 type frame struct {
   *unit
   function               llvm.Value
   builder, allocaBuilder llvm.Builder
   retInf                 retInfo
   blocks                 []llvm.BasicBlock
   lastBlocks             []llvm.BasicBlock
-  runtimeErrorBlocks     [gccgoRuntimeErrorCount]llvm.BasicBlock
   unwindBlock            llvm.BasicBlock
   frameptr               llvm.Value
   env                    map[ssa.Value]*govalue
   ptr                    map[ssa.Value]llvm.Value
   tuples                 map[ssa.Value][]*govalue
   phis                   []pendingPhi
   canRecover             llvm.Value
   isInit                 bool
func (fr *frame) runDefers() {
   fr.createLandingPad(false)
   fr.runtime.checkDefer.callOnly(fr, fr.frameptr)
   fr.builder.CreateBr(loopbb)
 
   fr.builder.SetInsertPointAtEnd(loopbb)
   fr.runtime.undefer.invoke(fr, retrylpad, fr.frameptr)
 }
 
-func (fr *frame) setupUnwindBlock(rec *ssa.BasicBlock, results *types.Tuple) {
-  recoverbb := llvm.AddBasicBlock(fr.function, "")
+func (fr *frame) setupUnwindBlock(rec *ssa.BasicBlock) {
+  var recoverbb llvm.BasicBlock
   if rec != nil {
-    fr.translateBlock(rec, recoverbb)
-  } else if results.Len() == 0 || results.At(0).Anonymous() {
-    // TODO(pcc): Remove this code after https://codereview.appspot.com/87210044/ lands
-    fr.builder.SetInsertPointAtEnd(recoverbb)
-    values := make([]llvm.Value, results.Len())
-    for i := range values {
-      values[i] = llvm.ConstNull(fr.llvmtypes.ToLLVM(results.At(i).Type()))
-    }
-    fr.retInf.encode(llvm.GlobalContext(), fr.allocaBuilder, fr.builder, values)
+    recoverbb = fr.blocks[rec.Index]
   } else {
+    recoverbb = llvm.AddBasicBlock(fr.function, "recover")
     fr.builder.SetInsertPointAtEnd(recoverbb)
     fr.builder.CreateUnreachable()
   }
 
   checkunwindbb := llvm.AddBasicBlock(fr.function, "")
   fr.builder.SetInsertPointAtEnd(checkunwindbb)
   exc := fr.createLandingPad(true)
   fr.runDefers()

irgen/typemap.go

type TypeMap struct {
 
   commonTypeType, uncommonTypeType, ptrTypeType, funcTypeType, arrayTypeType, sliceTypeType, mapTypeType, chanTypeType, interfaceTypeType, structTypeType llvm.Type
   mapDescType                                                                                                                                             llvm.Type
 
   methodType, imethodType, structFieldType llvm.Type
 
   typeSliceType, methodSliceType, imethodSliceType, structFieldSliceType llvm.Type
 
-  hashFnType, equalFnType llvm.Type
+  funcValType                           llvm.Type
+  hashFnType, equalFnType               llvm.Type
+  ptrHashFnNestType, ptrEqualFnNestType llvm.Type // with *funcValType as first arg
 
-  hashFnEmptyInterface, hashFnInterface, hashFnFloat, hashFnComplex, hashFnString, hashFnIdentity, hashFnError        llvm.Value
-  equalFnEmptyInterface, equalFnInterface, equalFnFloat, equalFnComplex, equalFnString, equalFnIdentity, equalFnError llvm.Value
-
-  zeroType  llvm.Type
-  zeroValue llvm.Value
+  hashFnEmptyInterfaceDescriptor,
+  hashFnInterfaceDescriptor,
+  hashFnFloatDescriptor,
+  hashFnComplexDescriptor,
+  hashFnStringDescriptor,
+  hashFnIdentityDescriptor,
+  hashFnErrorDescriptor llvm.Value
+
+  equalFnEmptyInterfaceDescriptor,
+  equalFnInterfaceDescriptor,
+  equalFnFloatDescriptor,
+  equalFnComplexDescriptor,
+  equalFnStringDescriptor,
+  equalFnIdentityDescriptor,
+  equalFnErrorDescriptor llvm.Value
 }
 
 func NewLLVMTypeMap(ctx llvm.Context, target llvm.TargetData) *llvmTypeMap {
   // spec says int is either 32-bit or 64-bit.
   // ABI currently requires sizeof(int) == sizeof(uint) == sizeof(uintptr).
   inttype := ctx.IntType(8 * target.PointerSize())
 
   i8ptr := llvm.PointerType(llvm.Int8Type(), 0)
func NewTypeMap(pkg *ssa.Package, llvmtm *llvmTypeMap, module llvm.Module, r *runtimeInterface, mr MethodResolver) *TypeMap {
 
   tm.mc.init(pkg.Prog, &tm.MethodSetCache)
 
   uintptrType := tm.inttype
   voidPtrType := llvm.PointerType(tm.ctx.Int8Type(), 0)
   boolType := llvm.Int8Type()
   stringPtrType := llvm.PointerType(tm.stringType, 0)
 
-  // Create runtime algorithm function types.
+  tm.funcValType = tm.ctx.StructCreateNamed("funcVal")
+  tm.funcValType.StructSetBody([]llvm.Type{
+    llvm.PointerType(llvm.FunctionType(llvm.VoidType(), []llvm.Type{}, false), 0),
+  }, false)
+  ptrFuncValType := llvm.PointerType(tm.funcValType, 0)
+
   params := []llvm.Type{voidPtrType, uintptrType}
   tm.hashFnType = llvm.FunctionType(uintptrType, params, false)
+  params = []llvm.Type{ptrFuncValType, voidPtrType, uintptrType}
+  tm.ptrHashFnNestType = llvm.PointerType(llvm.FunctionType(uintptrType, params, false), 0)
   params = []llvm.Type{voidPtrType, voidPtrType, uintptrType}
   tm.equalFnType = llvm.FunctionType(boolType, params, false)
+  params = []llvm.Type{ptrFuncValType, voidPtrType, voidPtrType, uintptrType}
+  tm.ptrEqualFnNestType = llvm.PointerType(llvm.FunctionType(boolType, params, false), 0)
 
-  tm.hashFnEmptyInterface = llvm.AddFunction(tm.module, "__go_type_hash_empty_interface", tm.hashFnType)
-  tm.hashFnInterface = llvm.AddFunction(tm.module, "__go_type_hash_interface", tm.hashFnType)
-  tm.hashFnFloat = llvm.AddFunction(tm.module, "__go_type_hash_float", tm.hashFnType)
-  tm.hashFnComplex = llvm.AddFunction(tm.module, "__go_type_hash_complex", tm.hashFnType)
-  tm.hashFnString = llvm.AddFunction(tm.module, "__go_type_hash_string", tm.hashFnType)
-  tm.hashFnIdentity = llvm.AddFunction(tm.module, "__go_type_hash_identity", tm.hashFnType)
-  tm.hashFnError = llvm.AddFunction(tm.module, "__go_type_hash_error", tm.hashFnType)
-
-  tm.equalFnEmptyInterface = llvm.AddFunction(tm.module, "__go_type_equal_empty_interface", tm.equalFnType)
-  tm.equalFnInterface = llvm.AddFunction(tm.module, "__go_type_equal_interface", tm.equalFnType)
-  tm.equalFnFloat = llvm.AddFunction(tm.module, "__go_type_equal_float", tm.equalFnType)
-  tm.equalFnComplex = llvm.AddFunction(tm.module, "__go_type_equal_complex", tm.equalFnType)
-  tm.equalFnString = llvm.AddFunction(tm.module, "__go_type_equal_string", tm.equalFnType)
-  tm.equalFnIdentity = llvm.AddFunction(tm.module, "__go_type_equal_identity", tm.equalFnType)
-  tm.equalFnError = llvm.AddFunction(tm.module, "__go_type_equal_error", tm.equalFnType)
-
-  // The body of this type is set in emitTypeDescInitializers once we have scanned
-  // every type, as it needs to be as large and well aligned as the
-  // largest/most aligned type.
-  tm.zeroType = tm.ctx.StructCreateNamed("zero")
-  tm.zeroValue = llvm.AddGlobal(tm.module, tm.zeroType, "go$zerovalue")
-  tm.zeroValue.SetLinkage(llvm.CommonLinkage)
-  tm.zeroValue.SetInitializer(llvm.ConstNull(tm.zeroType))
+  algorithmDescriptors := [...]struct {
+    Name  string
+    Hash  *llvm.Value
+    Equal *llvm.Value
+  }{{
+    "empty_interface",
+    &tm.hashFnEmptyInterfaceDescriptor,
+    &tm.equalFnEmptyInterfaceDescriptor,
+  }, {
+    "interface",
+    &tm.hashFnInterfaceDescriptor,
+    &tm.equalFnInterfaceDescriptor,
+  }, {
+    "float",
+    &tm.hashFnFloatDescriptor,
+    &tm.equalFnFloatDescriptor,
+  }, {
+    "complex",
+    &tm.hashFnComplexDescriptor,
+    &tm.equalFnComplexDescriptor,
+  }, {
+    "string",
+    &tm.hashFnStringDescriptor,
+    &tm.equalFnStringDescriptor,
+  }, {
+    "identity",
+    &tm.hashFnIdentityDescriptor,
+    &tm.equalFnIdentityDescriptor,
+  }, {
+    "error",
+    &tm.hashFnErrorDescriptor,
+    &tm.equalFnErrorDescriptor,
+  }}
+  for _, alg := range algorithmDescriptors {
+    hashDescriptorName := "__go_type_hash_" + alg.Name + "_descriptor"
+    equalDescriptorName := "__go_type_equal_" + alg.Name + "_descriptor"
+    *alg.Hash = llvm.AddGlobal(tm.module, tm.funcValType, hashDescriptorName)
+    *alg.Equal = llvm.AddGlobal(tm.module, tm.funcValType, equalDescriptorName)
+  }
 
   tm.commonTypeType = tm.ctx.StructCreateNamed("commonType")
   commonTypeTypePtr := llvm.PointerType(tm.commonTypeType, 0)
 
   tm.methodType = tm.ctx.StructCreateNamed("method")
   tm.methodType.StructSetBody([]llvm.Type{
     stringPtrType,     // name
     stringPtrType,     // pkgPath
func NewTypeMap(pkg *ssa.Package, llvmtm *llvmTypeMap, module llvm.Module, r *runtimeInterface, mr MethodResolver) *TypeMap {
   }, false)
 
   tm.commonTypeType.StructSetBody([]llvm.Type{
     tm.ctx.Int8Type(),                        // Kind
     tm.ctx.Int8Type(),                        // align
     tm.ctx.Int8Type(),                        // fieldAlign
     uintptrType,                              // size
     tm.ctx.Int32Type(),                       // hash
-    llvm.PointerType(tm.hashFnType, 0),       // hashfn
-    llvm.PointerType(tm.equalFnType, 0),      // equalfn
+    llvm.PointerType(tm.funcValType, 0),      // hashfn
+    llvm.PointerType(tm.funcValType, 0),      // equalfn
     voidPtrType,                              // gc
     stringPtrType,                            // string
     llvm.PointerType(tm.uncommonTypeType, 0), // uncommonType
     commonTypeTypePtr,                        // ptrToThis
-    llvm.PointerType(tm.zeroType, 0),         // zero
   }, false)
 
   tm.typeSliceType = tm.makeNamedSliceType("typeSlice", commonTypeTypePtr)
 
   tm.ptrTypeType = tm.ctx.StructCreateNamed("ptrType")
   tm.ptrTypeType.StructSetBody([]llvm.Type{
     tm.commonTypeType,
     commonTypeTypePtr,
if changed {
           maxSize = size
         }
         if align := tm.Alignof(t.typ); align > maxAlign {
           maxAlign = align
         }
       }
     }
   }
-
-  tm.zeroType.StructSetBody([]llvm.Type{llvm.ArrayType(tm.ctx.Int8Type(), int(maxSize))}, false)
-  tm.zeroValue.SetAlignment(int(maxAlign))
 }
 
 const (
   // From libgo/runtime/mgc0.h
   gcOpcodeEND = iota
   gcOpcodePTR
   gcOpcodeAPTR
   gcOpcodeARRAY_START
func (tm *TypeMap) getStructAlgorithmFunctions(st *types.Struct) (hash, equal llvm.Value) {
   if algs, ok := tm.algs.At(st).(algorithmFns); ok {
     return algs.hash, algs.equal
   }
 
   hashes := make([]llvm.Value, st.NumFields())
   equals := make([]llvm.Value, st.NumFields())
 
   for i := range hashes {
-    fhash, fequal := tm.getAlgorithmFunctions(st.Field(i).Type())
-    if fhash == tm.hashFnError {
+    fhash, fequal := tm.getAlgorithmDescriptors(st.Field(i).Type())
+    if fhash == tm.hashFnErrorDescriptor {
       return fhash, fequal
     }
     hashes[i], equals[i] = fhash, fequal
   }
 
   i8ptr := llvm.PointerType(tm.ctx.Int8Type(), 0)
   llsptrty := llvm.PointerType(tm.ToLLVM(st), 0)
 
   builder := tm.ctx.NewBuilder()
   defer builder.Dispose()
 
-  hash = llvm.AddFunction(tm.module, tm.mc.mangleHashFunctionName(st), tm.hashFnType)
-  hash.SetLinkage(llvm.LinkOnceODRLinkage)
-  builder.SetInsertPointAtEnd(llvm.AddBasicBlock(hash, "entry"))
-  sptr := builder.CreateBitCast(hash.Param(0), llsptrty, "")
+  hashFunctionName := tm.mc.mangleHashFunctionName(st)
+  hashFn := llvm.AddFunction(tm.module, hashFunctionName, tm.hashFnType)
+  hashFn.SetLinkage(llvm.LinkOnceODRLinkage)
+  hash = tm.createAlgorithmDescriptor(hashFunctionName+"_descriptor", hashFn)
+
+  builder.SetInsertPointAtEnd(llvm.AddBasicBlock(hashFn, "entry"))
+  sptr := builder.CreateBitCast(hashFn.Param(0), llsptrty, "")
 
   hashval := llvm.ConstNull(tm.inttype)
   i33 := llvm.ConstInt(tm.inttype, 33, false)
 
-  for i, fhash := range hashes {
+  for i, hashDescriptor := range hashes {
     fptr := builder.CreateStructGEP(sptr, i, "")
     fptr = builder.CreateBitCast(fptr, i8ptr, "")
-
     fsize := llvm.ConstInt(tm.inttype, uint64(tm.sizes.Sizeof(st.Field(i).Type())), false)
-
-    hashcall := builder.CreateCall(fhash, []llvm.Value{fptr, fsize}, "")
+    fhash := tm.callHashDescriptor(builder, hashDescriptor, fptr, fsize)
     hashval = builder.CreateMul(hashval, i33, "")
-    hashval = builder.CreateAdd(hashval, hashcall, "")
+    hashval = builder.CreateAdd(hashval, fhash, "")
   }
 
   builder.CreateRet(hashval)
 
-  equal = llvm.AddFunction(tm.module, tm.mc.mangleEqualFunctionName(st), tm.equalFnType)
-  equal.SetLinkage(llvm.LinkOnceODRLinkage)
-  eqentrybb := llvm.AddBasicBlock(equal, "entry")
-  eqretzerobb := llvm.AddBasicBlock(equal, "retzero")
+  equalFunctionName := tm.mc.mangleEqualFunctionName(st)
+  equalFn := llvm.AddFunction(tm.module, equalFunctionName, tm.equalFnType)
+  equalFn.SetLinkage(llvm.LinkOnceODRLinkage)
+  equal = tm.createAlgorithmDescriptor(equalFunctionName+"_descriptor", equalFn)
 
+  eqentrybb := llvm.AddBasicBlock(equalFn, "entry")
+  eqretzerobb := llvm.AddBasicBlock(equalFn, "retzero")
   builder.SetInsertPointAtEnd(eqentrybb)
-  s1ptr := builder.CreateBitCast(equal.Param(0), llsptrty, "")
-  s2ptr := builder.CreateBitCast(equal.Param(1), llsptrty, "")
+  s1ptr := builder.CreateBitCast(equalFn.Param(0), llsptrty, "")
+  s2ptr := builder.CreateBitCast(equalFn.Param(1), llsptrty, "")
 
   zerobool := llvm.ConstNull(tm.ctx.Int8Type())
   onebool := llvm.ConstInt(tm.ctx.Int8Type(), 1, false)
 
-  for i, fequal := range equals {
+  for i, equalDescriptor := range equals {
     f1ptr := builder.CreateStructGEP(s1ptr, i, "")
     f1ptr = builder.CreateBitCast(f1ptr, i8ptr, "")
     f2ptr := builder.CreateStructGEP(s2ptr, i, "")
     f2ptr = builder.CreateBitCast(f2ptr, i8ptr, "")
-
     fsize := llvm.ConstInt(tm.inttype, uint64(tm.sizes.Sizeof(st.Field(i).Type())), false)
-
-    equalcall := builder.CreateCall(fequal, []llvm.Value{f1ptr, f2ptr, fsize}, "")
-    equaleqzero := builder.CreateICmp(llvm.IntEQ, equalcall, zerobool, "")
-
-    contbb := llvm.AddBasicBlock(equal, "cont")
+    fequal := tm.callEqualDescriptor(builder, equalDescriptor, f1ptr, f2ptr, fsize)
+    equaleqzero := builder.CreateICmp(llvm.IntEQ, fequal, zerobool, "")
+    contbb := llvm.AddBasicBlock(equalFn, "cont")
     builder.CreateCondBr(equaleqzero, eqretzerobb, contbb)
-
     builder.SetInsertPointAtEnd(contbb)
   }
 
   builder.CreateRet(onebool)
 
   builder.SetInsertPointAtEnd(eqretzerobb)
   builder.CreateRet(zerobool)
 
   tm.algs.Set(st, algorithmFns{hash, equal})
   return
 }
 
 func (tm *TypeMap) getArrayAlgorithmFunctions(at *types.Array) (hash, equal llvm.Value) {
   if algs, ok := tm.algs.At(at).(algorithmFns); ok {
     return algs.hash, algs.equal
   }
 
-  ehash, eequal := tm.getAlgorithmFunctions(at.Elem())
-  if ehash == tm.hashFnError {
+  ehash, eequal := tm.getAlgorithmDescriptors(at.Elem())
+  if ehash == tm.hashFnErrorDescriptor {
     return ehash, eequal
   }
 
   i8ptr := llvm.PointerType(tm.ctx.Int8Type(), 0)
   llelemty := llvm.PointerType(tm.ToLLVM(at.Elem()), 0)
 
   i1 := llvm.ConstInt(tm.inttype, 1, false)
   alen := llvm.ConstInt(tm.inttype, uint64(at.Len()), false)
   esize := llvm.ConstInt(tm.inttype, uint64(tm.sizes.Sizeof(at.Elem())), false)
 
   builder := tm.ctx.NewBuilder()
   defer builder.Dispose()
 
-  hash = llvm.AddFunction(tm.module, tm.mc.mangleHashFunctionName(at), tm.hashFnType)
-  hash.SetLinkage(llvm.LinkOnceODRLinkage)
-  hashentrybb := llvm.AddBasicBlock(hash, "entry")
+  hashFunctionName := tm.mc.mangleHashFunctionName(at)
+  hashFn := llvm.AddFunction(tm.module, hashFunctionName, tm.hashFnType)
+  hashFn.SetLinkage(llvm.LinkOnceODRLinkage)
+  hash = tm.createAlgorithmDescriptor(hashFunctionName+"_descriptor", hashFn)
+  equalFunctionName := tm.mc.mangleHashFunctionName(at)
+  equalFn := llvm.AddFunction(tm.module, equalFunctionName, tm.equalFnType)
+  equalFn.SetLinkage(llvm.LinkOnceODRLinkage)
+  equal = tm.createAlgorithmDescriptor(equalFunctionName+"_descriptor", equalFn)
+  tm.algs.Set(at, algorithmFns{hash, equal})
+
+  hashentrybb := llvm.AddBasicBlock(hashFn, "entry")
   builder.SetInsertPointAtEnd(hashentrybb)
   if at.Len() == 0 {
     builder.CreateRet(llvm.ConstNull(tm.inttype))
   } else {
     i33 := llvm.ConstInt(tm.inttype, 33, false)
 
-    aptr := builder.CreateBitCast(hash.Param(0), llelemty, "")
-    loopbb := llvm.AddBasicBlock(hash, "loop")
+    aptr := builder.CreateBitCast(hashFn.Param(0), llelemty, "")
+    loopbb := llvm.AddBasicBlock(hashFn, "loop")
     builder.CreateBr(loopbb)
 
-    exitbb := llvm.AddBasicBlock(hash, "exit")
+    exitbb := llvm.AddBasicBlock(hashFn, "exit")
 
     builder.SetInsertPointAtEnd(loopbb)
     indexphi := builder.CreatePHI(tm.inttype, "")
     index := indexphi
     hashvalphi := builder.CreatePHI(tm.inttype, "")
     hashval := hashvalphi
 
     eptr := builder.CreateGEP(aptr, []llvm.Value{index}, "")
     eptr = builder.CreateBitCast(eptr, i8ptr, "")
 
-    hashcall := builder.CreateCall(ehash, []llvm.Value{eptr, esize}, "")
+    hashcall := tm.callHashDescriptor(builder, ehash, eptr, esize)
     hashval = builder.CreateMul(hashval, i33, "")
     hashval = builder.CreateAdd(hashval, hashcall, "")
 
     index = builder.CreateAdd(index, i1, "")
 
     indexphi.AddIncoming(
       []llvm.Value{llvm.ConstNull(tm.inttype), index},
       []llvm.BasicBlock{hashentrybb, loopbb},
     )
     hashvalphi.AddIncoming(
       []llvm.Value{llvm.ConstNull(tm.inttype), hashval},
       []llvm.BasicBlock{hashentrybb, loopbb},
     )
 
     exit := builder.CreateICmp(llvm.IntEQ, index, alen, "")
     builder.CreateCondBr(exit, exitbb, loopbb)
 
     builder.SetInsertPointAtEnd(exitbb)
     builder.CreateRet(hashval)
   }
 
   zerobool := llvm.ConstNull(tm.ctx.Int8Type())
   onebool := llvm.ConstInt(tm.ctx.Int8Type(), 1, false)
 
-  equal = llvm.AddFunction(tm.module, tm.mc.mangleEqualFunctionName(at), tm.equalFnType)
-  equal.SetLinkage(llvm.LinkOnceODRLinkage)
-  eqentrybb := llvm.AddBasicBlock(equal, "entry")
+  eqentrybb := llvm.AddBasicBlock(equalFn, "entry")
   builder.SetInsertPointAtEnd(eqentrybb)
   if at.Len() == 0 {
     builder.CreateRet(onebool)
   } else {
-    a1ptr := builder.CreateBitCast(equal.Param(0), llelemty, "")
-    a2ptr := builder.CreateBitCast(equal.Param(1), llelemty, "")
-    loopbb := llvm.AddBasicBlock(equal, "loop")
+    a1ptr := builder.CreateBitCast(equalFn.Param(0), llelemty, "")
+    a2ptr := builder.CreateBitCast(equalFn.Param(1), llelemty, "")
+    loopbb := llvm.AddBasicBlock(equalFn, "loop")
     builder.CreateBr(loopbb)
 
-    exitbb := llvm.AddBasicBlock(equal, "exit")
-    retzerobb := llvm.AddBasicBlock(equal, "retzero")
+    exitbb := llvm.AddBasicBlock(equalFn, "exit")
+    retzerobb := llvm.AddBasicBlock(equalFn, "retzero")
 
     builder.SetInsertPointAtEnd(loopbb)
     indexphi := builder.CreatePHI(tm.inttype, "")
     index := indexphi
 
     e1ptr := builder.CreateGEP(a1ptr, []llvm.Value{index}, "")
     e1ptr = builder.CreateBitCast(e1ptr, i8ptr, "")
     e2ptr := builder.CreateGEP(a2ptr, []llvm.Value{index}, "")
     e2ptr = builder.CreateBitCast(e2ptr, i8ptr, "")
 
-    equalcall := builder.CreateCall(eequal, []llvm.Value{e1ptr, e2ptr, esize}, "")
+    equalcall := tm.callEqualDescriptor(builder, eequal, e1ptr, e2ptr, esize)
     equaleqzero := builder.CreateICmp(llvm.IntEQ, equalcall, zerobool, "")
 
-    contbb := llvm.AddBasicBlock(equal, "cont")
+    contbb := llvm.AddBasicBlock(equalFn, "cont")
     builder.CreateCondBr(equaleqzero, retzerobb, contbb)
 
     builder.SetInsertPointAtEnd(contbb)
 
     index = builder.CreateAdd(index, i1, "")
 
     indexphi.AddIncoming(
       []llvm.Value{llvm.ConstNull(tm.inttype), index},
       []llvm.BasicBlock{eqentrybb, contbb},
     )
 
     exit := builder.CreateICmp(llvm.IntEQ, index, alen, "")
     builder.CreateCondBr(exit, exitbb, loopbb)
 
     builder.SetInsertPointAtEnd(exitbb)
     builder.CreateRet(onebool)
 
     builder.SetInsertPointAtEnd(retzerobb)
     builder.CreateRet(zerobool)
   }
 
-  tm.algs.Set(at, algorithmFns{hash, equal})
   return
 }
 
-func (tm *TypeMap) getAlgorithmFunctions(t types.Type) (hash, equal llvm.Value) {
+func (tm *TypeMap) createAlgorithmDescriptor(name string, fn llvm.Value) llvm.Value {
+  d := llvm.AddGlobal(tm.module, tm.funcValType, name)
+  d.SetLinkage(llvm.LinkOnceODRLinkage)
+  d.SetGlobalConstant(true)
+  fn = llvm.ConstBitCast(fn, tm.funcValType.StructElementTypes()[0])
+  init := llvm.ConstNull(tm.funcValType)
+  init = llvm.ConstInsertValue(init, fn, []uint32{0})
+  d.SetInitializer(init)
+  return d
+}
+
+func (tm *TypeMap) callHashDescriptor(builder llvm.Builder, descriptor, ptr, size llvm.Value) llvm.Value {
+  hashFn := builder.CreateLoad(builder.CreateStructGEP(descriptor, 0, ""), "")
+  hashFn = builder.CreateBitCast(hashFn, tm.ptrHashFnNestType, "")
+  hashcall := builder.CreateCall(hashFn, []llvm.Value{descriptor, ptr, size}, "")
+  hashcall.AddInstrAttribute(1, llvm.NestAttribute)
+  return hashcall
+}
+
+func (tm *TypeMap) callEqualDescriptor(builder llvm.Builder, descriptor, ptr1, ptr2, size llvm.Value) llvm.Value {
+  equalFn := builder.CreateLoad(builder.CreateStructGEP(descriptor, 0, ""), "")
+  equalFn = builder.CreateBitCast(equalFn, tm.ptrEqualFnNestType, "")
+  equalcall := builder.CreateCall(equalFn, []llvm.Value{descriptor, ptr1, ptr2, size}, "")
+  equalcall.AddInstrAttribute(1, llvm.NestAttribute)
+  return equalcall
+}
+
+func (tm *TypeMap) getAlgorithmDescriptors(t types.Type) (hash, equal llvm.Value) {
   switch t := t.Underlying().(type) {
   case *types.Interface:
     if t.NumMethods() == 0 {
-      hash = tm.hashFnEmptyInterface
-      equal = tm.equalFnEmptyInterface
+      hash = tm.hashFnEmptyInterfaceDescriptor
+      equal = tm.equalFnEmptyInterfaceDescriptor
     } else {
-      hash = tm.hashFnInterface
-      equal = tm.equalFnInterface
+      hash = tm.hashFnInterfaceDescriptor
+      equal = tm.equalFnInterfaceDescriptor
     }
   case *types.Basic:
     switch t.Kind() {
     case types.Float32, types.Float64:
-      hash = tm.hashFnFloat
-      equal = tm.equalFnFloat
+      hash = tm.hashFnFloatDescriptor
+      equal = tm.equalFnFloatDescriptor
     case types.Complex64, types.Complex128:
-      hash = tm.hashFnComplex
-      equal = tm.equalFnComplex
+      hash = tm.hashFnComplexDescriptor
+      equal = tm.equalFnComplexDescriptor
     case types.String:
-      hash = tm.hashFnString
-      equal = tm.equalFnString
+      hash = tm.hashFnStringDescriptor
+      equal = tm.equalFnStringDescriptor
     default:
-      hash = tm.hashFnIdentity
-      equal = tm.equalFnIdentity
+      hash = tm.hashFnIdentityDescriptor
+      equal = tm.equalFnIdentityDescriptor
     }
   case *types.Signature, *types.Map, *types.Slice:
-    hash = tm.hashFnError
-    equal = tm.equalFnError
+    hash = tm.hashFnErrorDescriptor
+    equal = tm.equalFnErrorDescriptor
   case *types.Struct:
     hash, equal = tm.getStructAlgorithmFunctions(t)
   case *types.Array:
     hash, equal = tm.getArrayAlgorithmFunctions(t)
   default:
-    hash = tm.hashFnIdentity
-    equal = tm.equalFnIdentity
+    hash = tm.hashFnIdentityDescriptor
+    equal = tm.equalFnIdentityDescriptor
   }
 
   return
 }
 
 func (tm *TypeMap) getTypeDescInfo(t types.Type) *typeDescInfo {
   if tdi, ok := tm.types.At(t).(*typeDescInfo); ok {
     return tdi
func runtimeTypeKind(t types.Type) (k uint8) {
   if !hasPointers(t) {
     k |= gccgoRuntimeTypeKindNO_POINTERS
   }
 
   return
 }
 
 func (tm *TypeMap) makeCommonType(t types.Type) llvm.Value {
-  var vals [12]llvm.Value
+  var vals [11]llvm.Value
   vals[0] = llvm.ConstInt(tm.ctx.Int8Type(), uint64(runtimeTypeKind(t)), false)
   vals[1] = llvm.ConstInt(tm.ctx.Int8Type(), uint64(tm.Alignof(t)), false)
   vals[2] = vals[1]
   vals[3] = llvm.ConstInt(tm.inttype, uint64(tm.Sizeof(t)), false)
   vals[4] = llvm.ConstInt(tm.ctx.Int32Type(), uint64(tm.getTypeHash(t)), false)
-  hash, equal := tm.getAlgorithmFunctions(t)
+  hash, equal := tm.getAlgorithmDescriptors(t)
   vals[5] = hash
   vals[6] = equal
   vals[7] = tm.getGcPointer(t)
   var b bytes.Buffer
   tm.writeType(t, &b)
   vals[8] = tm.globalStringPtr(b.String())
   vals[9] = tm.makeUncommonTypePtr(t)
-  if _, ok := t.(*types.Named); ok {
+  switch t.(type) {
+  case *types.Named, *types.Struct:
     vals[10] = tm.getTypeDescriptorPointer(types.NewPointer(t))
-  } else {
+  default:
     vals[10] = llvm.ConstPointerNull(llvm.PointerType(tm.commonTypeType, 0))
   }
-  vals[11] = tm.zeroValue
-
   return llvm.ConstNamedStruct(tm.commonTypeType, vals[:])
 }
 
 func (tm *TypeMap) makeBasicType(t types.Type, u *types.Basic) llvm.Value {
   return tm.makeCommonType(t)
 }
 
 func (tm *TypeMap) makeArrayType(t types.Type, a *types.Array) llvm.Value {

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

libgo-check-failures.diff

 @@ -62,6 +62,7 @@
     }()
     <-done
     runtime.GC()
 +   runtime.GC()
     select {
     case <-ch:
     case <-time.After(time.Second * 4):
-diff -r a6e10414311a libgo/go/runtime/runtime_test.go
---- a/libgo/go/runtime/runtime_test.go  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/go/runtime/runtime_test.go  Fri Apr 03 15:07:47 2015 -0700
-@@ -176,6 +176,8 @@
- }
- 
- func TestSetPanicOnFault(t *testing.T) {
-+ t.Skip("skipping for llgo due to lack of non-call exception support")
-+
-  // This currently results in a fault in the signal trampoline on
-  // dragonfly/386 - see issue 7421.
-  if GOOS == "dragonfly" && GOARCH == "386" {

update_third_party.sh

 #!/bin/sh -e
 
 scriptpath=$(readlink -f "$0")
 llgosrcdir=$(dirname "$scriptpath")
 cd $llgosrcdir
 
-gofrontendrepo=https://code.google.com/p/gofrontend
-gofrontendrev=15a24202fa42
+gofrontendrepo=https://go.googlesource.com/gofrontend
+gofrontendrev=81eb6a3f425b2158c67ee32c0cc973a72ce9d6be
 
 gccrepo=svn://gcc.gnu.org/svn/gcc/trunk
 gccrev=219477
 
 gotoolsrepo=https://go.googlesource.com/tools
 gotoolsrev=d4e70101500b43ffe705d4c45e50dd4f1c8e3b2e
 
 linerrepo=https://github.com/peterh/liner.git
-linerrev=1bb0d1c1a25ed393d8feb09bab039b2b1b1fbced
+linerrev=4d47685ab2fd2dbb46c66b831344d558bc4be5b9
 
 tempdir=$(mktemp -d /tmp/update_third_party.XXXXXX)
 gofrontenddir=$tempdir/gofrontend
 gotoolsdir=$tempdir/go.tools
 linerdir=third_party/liner
 
 rm -rf third_party
 mkdir -p third_party/gofrontend third_party/gotools
 
+git_clone() {
+    repo=$1
+    dir=$2
+    rev=$3
+    git clone $repo $dir
+    (
+        cd $dir
+        git checkout $rev
+        rm -fr .git
+    )
+}
+
 # --------------------- gofrontend ---------------------
 
-hg clone -r $gofrontendrev $gofrontendrepo $gofrontenddir
+git_clone $gofrontendrepo $gofrontenddir $gofrontendrev
 
 cp -r $gofrontenddir/LICENSE $gofrontenddir/libgo third_party/gofrontend
 
 # Apply a diff that eliminates use of the unnamed struct extension beyond what
 # -fms-extensions supports.
 (cd third_party/gofrontend && patch -p1) < libgo-noext.diff
 # Apply a diff that disables testing of packages known to fail.
 (cd third_party/gofrontend && patch -p1) < libgo-check-failures.diff

 
 mkdir -p third_party/gofrontend/include third_party/gofrontend/libgcc
 
 # Copy in our versions of GCC files.
 cp include/dwarf2.h third_party/gofrontend/include/
 cp include/filenames.h third_party/gofrontend/include/
 cp include/unwind-pe.h third_party/gofrontend/libgcc/
 
 # Note: this expects the llgo source tree to be located at llvm/tools/llgo.
 cp ../../autoconf/config.guess third_party/gofrontend/
 cp ../../autoconf/config.sub third_party/gofrontend/
 
 for d in libbacktrace libffi ; do
   svn export -r $gccrev $gccrepo/$d third_party/gofrontend/$d
 done
 
 # Remove GPL licensed files, and files that confuse our license check.
 rm \
   third_party/gofrontend/libffi/ChangeLog \

 
 # The build requires these files to exist.
 touch \
   third_party/gofrontend/include/dwarf2.def \
   third_party/gofrontend/libffi/doc/libffi.texi
 
 # --------------------- go.tools ---------------------
 
-git clone $gotoolsrepo $gotoolsdir
-(cd $gotoolsdir && git checkout $gotoolsrev)
+git_clone $gotoolsrepo $gotoolsdir $gotoolsrev
 
 cp -r $gotoolsdir/LICENSE $gotoolsdir/go third_party/gotools
 
 # Vendor the go.tools repository.
 find third_party/gotools -name '*.go' | xargs sed -i -e \
   's,"golang.org/x/tools/,"llvm.org/llgo/third_party/gotools/,g'
 
 # --------------------- peterh/liner -----------------
 
-git clone $linerrepo $linerdir
-(cd $linerdir && git checkout $linerrev && rm -rf .git)
+git_clone $linerrepo $linerdir $linerrev
 
 # --------------------- license check ---------------------
 
 # We don't want any GPL licensed code without an autoconf/libtool
 # exception, or any GPLv3 licensed code.
 
 for i in `grep -lr 'General Public License' third_party` ; do
   if grep -q 'configuration script generated by Autoconf, you may include it under' $i || \