[llgo] Roll gofrontend to 07baa07598ea; roll libffi to r219477.

[pcc]

Summary

Incorporates https://codereview.appspot.com/198770044, which causes us to start
using the static chain register for closures instead of __go_{get,set}_closure.

[axw]

Nice! LGTM.

irgen/cabi.go

 }
 
 type functionTypeInfo struct {
   functionType llvm.Type
   argAttrs     []llvm.Attribute
   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)
   for i, a := range fi.argAttrs {
     if a != 0 {
       fn.Param(i).AddAttribute(a)
     }
   }
   return fn
 }
 
-func (fi *functionTypeInfo) call(ctx llvm.Context, allocaBuilder llvm.Builder, builder llvm.Builder, callee llvm.Value, args []llvm.Value) []llvm.Value {
+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)
   for i, a := range fi.argAttrs {
     call.AddInstrAttribute(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, args []llvm.Value, cont, lpad llvm.BasicBlock) []llvm.Value {
+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)
   for i, a := range fi.argAttrs {
if len(results) == 0 {
     case AIK_Indirect:
       returnType = llvm.VoidType()
       argTypes = []llvm.Type{llvm.PointerType(resultsType, 0)}
       fi.argAttrs = []llvm.Attribute{llvm.StructRetAttribute}
       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)
+
   // Keep track of the number of INTEGER/SSE class registers remaining.
   remainingInt := 6
   remainingSSE := 8
 
   for _, arg := range args {
     aik := tm.classify(arg)
 
     isDirect := aik == AIK_Direct

irgen/call.go

 
 import (
   "llvm.org/llgo/third_party/gotools/go/types"
   "llvm.org/llvm/bindings/go/llvm"
 )
 
 // createCall emits the code for a function call,
 // taking into account receivers, and panic/defer.
-func (fr *frame) createCall(fn *govalue, argValues []*govalue) []*govalue {
+func (fr *frame) createCall(fn *govalue, chain llvm.Value, argValues []*govalue) []*govalue {
   fntyp := fn.Type().Underlying().(*types.Signature)
   typinfo := fr.types.getSignatureInfo(fntyp)
 
   args := make([]llvm.Value, len(argValues))
   for i, arg := range argValues {
     args[i] = arg.value
   }
   var results []llvm.Value
   if fr.unwindBlock.IsNil() {
-    results = typinfo.call(fr.types.ctx, fr.allocaBuilder, fr.builder, fn.value, args)
+    results = typinfo.call(fr.types.ctx, fr.allocaBuilder, fr.builder, fn.value, chain, args)
   } else {
     contbb := llvm.AddBasicBlock(fr.function, "")
-    results = typinfo.invoke(fr.types.ctx, fr.allocaBuilder, fr.builder, fn.value, args, contbb, fr.unwindBlock)
+    results = typinfo.invoke(fr.types.ctx, fr.allocaBuilder, fr.builder, fn.value, chain, args, contbb, fr.unwindBlock)
   }
 
   resultValues := make([]*govalue, len(results))
   for i, res := range results {
     resultValues[i] = newValue(res, fntyp.Results().At(i).Type())
   }
   return resultValues
 }

irgen/compiler.go

if imp := mainPkg.Func("init"); imp != nil {
     impname := c.types.mc.mangleFunctionName(imp)
     uniqinits = append(uniqinits, gccgoimporter.PackageInit{mainPkg.Object.Name(), impname, ourprio})
   }
 
   return gccgoimporter.InitData{ourprio, uniqinits}
 }
 
 func (c *compiler) createInitMainFunction(mainPkg *ssa.Package) {
-  ftyp := llvm.FunctionType(llvm.VoidType(), nil, false)
+  int8ptr := llvm.PointerType(c.types.ctx.Int8Type(), 0)
+  ftyp := llvm.FunctionType(llvm.VoidType(), []llvm.Type{int8ptr}, false)
   initMain := llvm.AddFunction(c.module.Module, "__go_init_main", ftyp)
   c.addCommonFunctionAttrs(initMain)
   entry := llvm.AddBasicBlock(initMain, "entry")
 
   builder := llvm.GlobalContext().NewBuilder()
   defer builder.Dispose()
   builder.SetInsertPointAtEnd(entry)
 
+  initargs := []llvm.Value{llvm.Undef(int8ptr)}
+
   if !c.GccgoABI {
     initfn := c.module.Module.NamedFunction("main..import")
     if !initfn.IsNil() {
-      builder.CreateCall(initfn, nil, "")
+      builder.CreateCall(initfn, initargs, "")
     }
     builder.CreateRetVoid()
     return
   }
 
   initdata := c.buildPackageInitData(mainPkg)
 
   for _, init := range initdata.Inits {
     initfn := c.module.Module.NamedFunction(init.InitFunc)
     if initfn.IsNil() {
       initfn = llvm.AddFunction(c.module.Module, init.InitFunc, ftyp)
     }
-    builder.CreateCall(initfn, nil, "")
+    builder.CreateCall(initfn, initargs, "")
   }
 
   builder.CreateRetVoid()
 }
 
 func (c *compiler) buildExportData(mainPkg *ssa.Package) []byte {
   exportData := importer.ExportData(mainPkg.Object)
   b := bytes.NewBuffer(exportData)

irgen/runtime.go

func (rfi *runtimeFnInfo) call(f *frame, args ...llvm.Value) []llvm.Value {
   if f.unwindBlock.IsNil() {
     return rfi.callOnly(f, args...)
   } else {
     return rfi.invoke(f, f.unwindBlock, args...)
   }
 }
 
 func (rfi *runtimeFnInfo) callOnly(f *frame, args ...llvm.Value) []llvm.Value {
-  return rfi.fi.call(f.llvmtypes.ctx, f.allocaBuilder, f.builder, rfi.fn, args)
+  return rfi.fi.call(f.llvmtypes.ctx, f.allocaBuilder, f.builder, rfi.fn, llvm.Value{nil}, args)
 }
 
 func (rfi *runtimeFnInfo) invoke(f *frame, lpad llvm.BasicBlock, args ...llvm.Value) []llvm.Value {
   contbb := llvm.AddBasicBlock(f.function, "")
-  return rfi.fi.invoke(f.llvmtypes.ctx, f.allocaBuilder, f.builder, rfi.fn, args, contbb, lpad)
+  return rfi.fi.invoke(f.llvmtypes.ctx, f.allocaBuilder, f.builder, rfi.fn, llvm.Value{nil}, args, contbb, lpad)
 }
 
 // runtimeInterface is a struct containing references to
 // runtime types and intrinsic function declarations.
 type runtimeInterface struct {
   // LLVM intrinsics
   memcpy,
   memset,
type runtimeInterface struct {
   checkDefer,
   checkInterfaceType,
   builtinClose,
   convertInterface,
   copy,
   Defer,
   deferredRecover,
   emptyInterfaceCompare,
-  getClosure,
   Go,
   ifaceE2I2,
   ifaceI2I2,
   intArrayToString,
   interfaceCompare,
   intToString,
   makeSlice,
   mapdelete,
type runtimeInterface struct {
   recover,
   registerGcRoots,
   runtimeError,
   selectdefault,
   selectrecv2,
   selectsend,
   selectgo,
   sendBig,
-  setClosure,
   setDeferRetaddr,
   strcmp,
   stringiter2,
   stringPlus,
   stringSlice,
   stringToIntArray,
   typeDescriptorsEqual,
   undefer runtimeFnInfo
for _, rt := range [...]struct {
     },
     {
       name: "__go_empty_interface_compare",
       rfi:  &ri.emptyInterfaceCompare,
       args: []types.Type{EmptyInterface, EmptyInterface},
       res:  []types.Type{Int},
     },
     {
-      name: "__go_get_closure",
-      rfi:  &ri.getClosure,
-      res:  []types.Type{UnsafePointer},
-    },
-    {
       name: "__go_go",
       rfi:  &ri.Go,
       args: []types.Type{UnsafePointer, UnsafePointer},
     },
     {
       name: "runtime.ifaceE2I2",
       rfi:  &ri.ifaceE2I2,
       args: []types.Type{UnsafePointer, EmptyInterface},
attrs     []llvm.Attribute
       args: []types.Type{UnsafePointer, UnsafePointer, UnsafePointer, Int32},
     },
     {
       name: "__go_send_big",
       rfi:  &ri.sendBig,
       args: []types.Type{UnsafePointer, UnsafePointer, UnsafePointer},
     },
     {
-      name: "__go_set_closure",
-      rfi:  &ri.setClosure,
-      args: []types.Type{UnsafePointer},
-    },
-    {
       name: "__go_set_defer_retaddr",
       rfi:  &ri.setDeferRetaddr,
       args: []types.Type{UnsafePointer},
       res:  []types.Type{Bool},
     },
     {
       name: "__go_strcmp",
       rfi:  &ri.strcmp,

irgen/ssa.go

for _, fv := range f.FreeVars {
       fr.env[fv] = newValue(llvm.ConstNull(u.llvmtypes.ToLLVM(fv.Type())), fv.Type())
     }
     elemTypes := make([]llvm.Type, len(f.FreeVars)+1)
     elemTypes[0] = llvm.PointerType(llvm.Int8Type(), 0) // function pointer
     for i, fv := range f.FreeVars {
       elemTypes[i+1] = u.llvmtypes.ToLLVM(fv.Type())
     }
     structType := llvm.StructType(elemTypes, false)
-    closure := fr.runtime.getClosure.call(fr)[0]
+    closure := fr.function.Param(fti.chainIndex)
     closure = fr.builder.CreateBitCast(closure, llvm.PointerType(structType, 0), "")
     for i, fv := range f.FreeVars {
       ptr := fr.builder.CreateStructGEP(closure, i+1, "")
       ptr = fr.builder.CreateLoad(ptr, "")
       fr.env[fv] = newValue(ptr, fv.Type())
     }
   }
 
func (fr *frame) emitInitPrologue() llvm.BasicBlock {
   initGuardVal := fr.builder.CreateLoad(initGuard, "")
   fr.builder.CreateCondBr(initGuardVal, returnBlock, initBlock)
 
   fr.builder.SetInsertPointAtEnd(returnBlock)
   fr.builder.CreateRetVoid()
 
   fr.builder.SetInsertPointAtEnd(initBlock)
   fr.builder.CreateStore(llvm.ConstInt(llvm.Int1Type(), 1, false), initGuard)
-  ftyp := llvm.FunctionType(llvm.VoidType(), nil, false)
+  int8ptr := llvm.PointerType(fr.types.ctx.Int8Type(), 0)
+  ftyp := llvm.FunctionType(llvm.VoidType(), []llvm.Type{int8ptr}, false)
+  initargs := []llvm.Value{llvm.Undef(int8ptr)}
   for _, pkg := range fr.pkg.Object.Imports() {
     initname := ManglePackagePath(pkg.Path()) + "..import"
     initfn := fr.module.Module.NamedFunction(initname)
     if initfn.IsNil() {
       initfn = llvm.AddFunction(fr.module.Module, initname, ftyp)
     }
-    fr.builder.CreateCall(initfn, nil, "")
+    fr.builder.CreateCall(initfn, initargs, "")
   }
 
   return initBlock
 }
 
 // bridgeRecoverFunc creates a function that may call recover(), and creates
 // a call to it from the current frame. The created function will be called
 // with a boolean parameter that indicates whether it may call recover().
func (fr *frame) callInstruction(instr ssa.CallInstruction) []*govalue {
   }
 
   args := make([]*govalue, len(call.Args))
   for i, arg := range call.Args {
     args[i] = fr.value(arg)
   }
 
   var fn *govalue
+  var chain llvm.Value
   if call.IsInvoke() {
     var recv *govalue
     fn, recv = fr.interfaceMethod(fr.llvmvalue(call.Value), call.Value.Type(), call.Method)
     args = append([]*govalue{recv}, args...)
   } else {
     if ssafn, ok := call.Value.(*ssa.Function); ok {
       llfn := fr.resolveFunctionGlobal(ssafn)
       llfn = llvm.ConstBitCast(llfn, llvm.PointerType(llvm.Int8Type(), 0))
       fn = newValue(llfn, ssafn.Type())
     } else {
       // First-class function values are stored as *{*fnptr}, so
       // we must extract the function pointer. We must also
-      // call __go_set_closure, in case the function is a closure.
+      // set the chain, in case the function is a closure.
       fn = fr.value(call.Value)
-      fr.runtime.setClosure.call(fr, fn.value)
+      chain = fn.value
       fnptr := fr.builder.CreateBitCast(fn.value, llvm.PointerType(fn.value.Type(), 0), "")
       fnptr = fr.builder.CreateLoad(fnptr, "")
       fn = newValue(fnptr, fn.Type())
     }
     if recv := call.Signature().Recv(); recv != nil {
       if _, ok := recv.Type().Underlying().(*types.Pointer); !ok {
         recvalloca := fr.allocaBuilder.CreateAlloca(args[0].value.Type(), "")
         fr.builder.CreateStore(args[0].value, recvalloca)
         args[0] = newValue(recvalloca, types.NewPointer(args[0].Type()))
       }
     }
   }
-  return fr.createCall(fn, args)
+  return fr.createCall(fn, chain, args)
 }
 
 func hasDefer(f *ssa.Function) bool {
   for _, b := range f.Blocks {
     for _, instr := range b.Instrs {
       if _, ok := instr.(*ssa.Defer); ok {
         return true
       }

libgo-noext.diff

-diff -r a6e10414311a libgo/runtime/chan.goc
---- a/libgo/runtime/chan.goc  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/chan.goc  Fri Feb 13 16:36:07 2015 -0800
+diff -r bb70e852004f libgo/runtime/chan.goc
+--- a/libgo/runtime/chan.goc  Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/chan.goc  Fri Apr 03 17:31:02 2015 -0700
 @@ -111,7 +111,7 @@
     mysg.releasetime = -1;
   }
  
 - runtime_lock(c);
 + runtime_lock(&c->lock);
   if(c->closed)
     goto closed;
@@ -1048,7 +1048,7 @@
     runtime_ready(gp);
   }
  
 - runtime_unlock(c);
 + runtime_unlock(&c->lock);
  }
  
  void
-diff -r a6e10414311a libgo/runtime/chan.h
---- a/libgo/runtime/chan.h  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/chan.h  Fri Feb 13 16:36:07 2015 -0800
+diff -r bb70e852004f libgo/runtime/chan.h
+--- a/libgo/runtime/chan.h  Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/chan.h  Fri Apr 03 17:31:02 2015 -0700
 @@ -39,7 +39,7 @@
   uintgo  recvx;      // receive index
   WaitQ recvq;      // list of recv waiters
   WaitQ sendq;      // list of send waiters
 - Lock;
 + Lock  lock;
  };
  
  // Buffer follows Hchan immediately in memory.
-diff -r a6e10414311a libgo/runtime/heapdump.c
---- a/libgo/runtime/heapdump.c  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/heapdump.c  Fri Feb 13 16:36:07 2015 -0800
+diff -r bb70e852004f libgo/runtime/heapdump.c
+--- a/libgo/runtime/heapdump.c  Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/heapdump.c  Fri Apr 03 17:31:02 2015 -0700
 @@ -387,7 +387,7 @@
         if(sp->kind != KindSpecialFinalizer)
           continue;
         spf = (SpecialFinalizer*)sp;
 -       p = (byte*)((s->start << PageShift) + spf->offset);
 +       p = (byte*)((s->start << PageShift) + spf->special.offset);
         dumpfinalizer(p, spf->fn, spf->ft, spf->ot);
       }
     }
 @@ -566,7 +566,7 @@
       if(sp->kind != KindSpecialProfile)
         continue;
       spp = (SpecialProfile*)sp;
 -     p = (byte*)((s->start << PageShift) + spp->offset);
 +     p = (byte*)((s->start << PageShift) + spp->special.offset);
       dumpint(TagAllocSample);
       dumpint((uintptr)p);
       dumpint((uintptr)spp->b);
-diff -r a6e10414311a libgo/runtime/malloc.goc
---- a/libgo/runtime/malloc.goc  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/malloc.goc  Fri Feb 13 16:36:07 2015 -0800
-@@ -437,9 +437,9 @@
+diff -r bb70e852004f libgo/runtime/malloc.goc
+--- a/libgo/runtime/malloc.goc  Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/malloc.goc  Fri Apr 03 17:31:02 2015 -0700
+@@ -429,9 +429,9 @@
   m->mcache->local_nlookup++;
   if (sizeof(void*) == 4 && m->mcache->local_nlookup >= (1<<30)) {
     // purge cache stats to prevent overflow
 -   runtime_lock(&runtime_mheap);
 +   runtime_lock(&runtime_mheap.lock);
     runtime_purgecachedstats(m->mcache);
 -   runtime_unlock(&runtime_mheap);
 +   runtime_unlock(&runtime_mheap.lock);
   }
  
   s = runtime_MHeap_LookupMaybe(&runtime_mheap, v);
-@@ -736,7 +736,7 @@
+@@ -728,7 +728,7 @@
  
  static struct
  {
 - Lock;
 + Lock  lock;
   byte* pos;
   byte* end;
  } persistent;
-@@ -765,19 +765,19 @@
+@@ -757,19 +757,19 @@
     align = 8;
   if(size >= PersistentAllocMaxBlock)
     return runtime_SysAlloc(size, stat);
 - runtime_lock(&persistent);
 + runtime_lock(&persistent.lock);
   persistent.pos = (byte*)ROUND((uintptr)persistent.pos, align);
   if(persistent.pos + size > persistent.end) {
     persistent.pos = runtime_SysAlloc(PersistentAllocChunk, &mstats.other_sys);
     if(persistent.pos == nil) {
 -     runtime_unlock(&persistent);
 +     runtime_unlock(&persistent.lock);
       runtime_throw("runtime: cannot allocate memory");
     }
     persistent.end = persistent.pos + PersistentAllocChunk;
   }
   p = persistent.pos;
   persistent.pos += size;
 - runtime_unlock(&persistent);
 + runtime_unlock(&persistent.lock);
   if(stat != &mstats.other_sys) {
     // reaccount the allocation against provided stat
     runtime_xadd64(stat, size);
-diff -r a6e10414311a libgo/runtime/malloc.h
---- a/libgo/runtime/malloc.h  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/malloc.h  Fri Feb 13 16:36:07 2015 -0800
+diff -r bb70e852004f libgo/runtime/malloc.h
+--- a/libgo/runtime/malloc.h  Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/malloc.h  Fri Apr 03 17:31:02 2015 -0700
 @@ -390,7 +390,7 @@
  typedef struct SpecialFinalizer SpecialFinalizer;
  struct SpecialFinalizer
  {
 - Special;
 + Special   special;
   FuncVal*  fn;
   const FuncType* ft;
@@ -505,7 +505,7 @@
   // spaced CacheLineSize bytes apart, so that each MCentral.Lock
   // gets its own cache line.
   struct {
 -   MCentral;
 +   MCentral mcentral;
     byte pad[64];
   } central[NumSizeClasses];
  
-diff -r a6e10414311a libgo/runtime/mcache.c
---- a/libgo/runtime/mcache.c  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/mcache.c  Fri Feb 13 16:36:07 2015 -0800
+diff -r bb70e852004f libgo/runtime/mcache.c
+--- a/libgo/runtime/mcache.c  Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/mcache.c  Fri Apr 03 17:31:02 2015 -0700
 @@ -23,9 +23,9 @@
   MCache *c;
   int32 i;
  
 - runtime_lock(&runtime_mheap);
 + runtime_lock(&runtime_mheap.lock);
   c = runtime_FixAlloc_Alloc(&runtime_mheap.cachealloc);
 - runtime_unlock(&runtime_mheap);
+     runtime_MCentral_UncacheSpan(&runtime_mheap.central[i].mcentral, s);
     }
     l = &c->free[i];
     if(l->nlist > 0) {
 -     runtime_MCentral_FreeList(&runtime_mheap.central[i], l->list);
 +     runtime_MCentral_FreeList(&runtime_mheap.central[i].mcentral, l->list);
       l->list = nil;
       l->nlist = 0;
     }
-diff -r a6e10414311a libgo/runtime/mcentral.c
---- a/libgo/runtime/mcentral.c  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/mcentral.c  Fri Feb 13 16:36:07 2015 -0800
+diff -r bb70e852004f libgo/runtime/mcentral.c
+--- a/libgo/runtime/mcentral.c  Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/mcentral.c  Fri Apr 03 17:31:02 2015 -0700
 @@ -39,14 +39,14 @@
   int32 cap, n;
   uint32 sg;
  
 - runtime_lock(c);
 + runtime_lock(&c->lock);
   sg = runtime_mheap.sweepgen;
  retry:
@@ -301,7 +301,7 @@
   if(s->ref != 0)
     runtime_throw("ref wrong");
   c->nfree -= (s->npages << PageShift) / size;
 - runtime_unlock(c);
 + runtime_unlock(&c->lock);
   runtime_unmarkspan((byte*)(s->start<<PageShift), s->npages<<PageShift);
   runtime_MHeap_Free(&runtime_mheap, s, 0);
  }
-diff -r a6e10414311a libgo/runtime/mgc0.c
---- a/libgo/runtime/mgc0.c  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/mgc0.c  Fri Feb 13 16:36:07 2015 -0800
+diff -r bb70e852004f libgo/runtime/mgc0.c
+--- a/libgo/runtime/mgc0.c  Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/mgc0.c  Fri Apr 03 17:31:02 2015 -0700
 @@ -225,7 +225,7 @@
   Note  alldone;
   ParFor  *markfor;
  
 - Lock;
 + Lock  lock;
   byte  *chunk;
   uintptr nchunk;
+ runtime_lock(&runtime_mheap.lock);
   if(in < 0)
     in = -1;
   gcpercent = in;
 - runtime_unlock(&runtime_mheap);
 + runtime_unlock(&runtime_mheap.lock);
   return out;
  }
  
-diff -r a6e10414311a libgo/runtime/mheap.c
---- a/libgo/runtime/mheap.c Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/mheap.c Fri Feb 13 16:36:07 2015 -0800
+diff -r bb70e852004f libgo/runtime/mheap.c
+--- a/libgo/runtime/mheap.c Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/mheap.c Fri Apr 03 17:31:02 2015 -0700
 @@ -70,7 +70,7 @@
   runtime_MSpanList_Init(&h->freelarge);
   runtime_MSpanList_Init(&h->busylarge);
   for(i=0; i<nelem(h->central); i++)
 -   runtime_MCentral_Init(&h->central[i], i);
 +   runtime_MCentral_Init(&h->central[i].mcentral, i);
  }
  
+   runtime_unlock(&c->lock);
     if(s->npages < nelem(h->free))
       runtime_MSpanList_InsertBack(&h->busy[s->npages], s);
     else
       runtime_MSpanList_InsertBack(&h->busylarge, s);
 -   runtime_unlock(h);
 +   runtime_unlock(&h->lock);
   }
  }
-diff -r a6e10414311a libgo/runtime/netpoll.goc
---- a/libgo/runtime/netpoll.goc Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/netpoll.goc Fri Feb 13 16:36:07 2015 -0800
+diff -r bb70e852004f libgo/runtime/netpoll.goc
+--- a/libgo/runtime/netpoll.goc Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/netpoll.goc Fri Apr 03 17:31:02 2015 -0700
 @@ -53,7 +53,7 @@
   // pollReset, pollWait, pollWaitCanceled and runtime_netpollready (IO rediness notification)
   // proceed w/o taking the lock. So closing, rg, rd, wg and wd are manipulated
   // in a lock-free way by all operations.
 - Lock;   // protectes the following fields
 + Lock  lock; // protectes the following fields
   uintptr fd;
   bool  closing;

 @@ -467,6 +467,6 @@
   }
   pd = pollcache.first;
   pollcache.first = pd->link;
 - runtime_unlock(&pollcache);
 + runtime_unlock(&pollcache.lock);
   return pd;
  }
-diff -r a6e10414311a libgo/runtime/proc.c
---- a/libgo/runtime/proc.c  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/proc.c  Fri Feb 13 16:36:07 2015 -0800
+diff -r bb70e852004f libgo/runtime/proc.c
+--- a/libgo/runtime/proc.c  Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/proc.c  Fri Apr 03 17:31:02 2015 -0700
 @@ -302,7 +302,7 @@
  
  typedef struct Sched Sched;
  struct Sched {
 - Lock;
 + Lock  lock;
  
   uint64  goidgen;
+ runtime_lock(&runtime_sched.lock);
   out = runtime_sched.maxmcount;
   runtime_sched.maxmcount = in;
   checkmcount();
 - runtime_unlock(&runtime_sched);
 + runtime_unlock(&runtime_sched.lock);
   return out;
  }
  
-diff -r a6e10414311a libgo/runtime/runtime.h
---- a/libgo/runtime/runtime.h Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/runtime.h Fri Feb 13 16:36:07 2015 -0800
-@@ -286,7 +286,7 @@
+diff -r bb70e852004f libgo/runtime/runtime.h
+--- a/libgo/runtime/runtime.h Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/runtime.h Fri Apr 03 17:31:02 2015 -0700
+@@ -285,7 +285,7 @@
  
  struct P
  {
 - Lock;
 + Lock  lock;
  
   int32 id;
   uint32  status;   // one of Pidle/Prunning/...
-@@ -384,7 +384,7 @@
+@@ -383,7 +383,7 @@
  
  struct Timers
  {
 - Lock;
 + Lock  lock;
   G *timerproc;
   bool    sleeping;
   bool    rescheduling;
-diff -r a6e10414311a libgo/runtime/sema.goc
---- a/libgo/runtime/sema.goc  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/sema.goc  Fri Feb 13 16:36:07 2015 -0800
+diff -r bb70e852004f libgo/runtime/sema.goc
+--- a/libgo/runtime/sema.goc  Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/sema.goc  Fri Apr 03 17:31:02 2015 -0700
 @@ -35,7 +35,7 @@
  typedef struct SemaRoot SemaRoot;
  struct SemaRoot
  {
 - Lock;
 + Lock    lock;
   SemaWaiter* head;
   SemaWaiter* tail;
else
       s->tail->next = &w;
     s->tail = &w;
 -   runtime_parkunlock(s, "semarelease");
 +   runtime_parkunlock(&s->lock, "semarelease");
   } else
 -   runtime_unlock(s);
 +   runtime_unlock(&s->lock);
  }
-diff -r a6e10414311a libgo/runtime/sigqueue.goc
---- a/libgo/runtime/sigqueue.goc  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/sigqueue.goc  Fri Feb 13 16:36:07 2015 -0800
+diff -r bb70e852004f libgo/runtime/sigqueue.goc
+--- a/libgo/runtime/sigqueue.goc  Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/sigqueue.goc  Fri Apr 03 17:31:02 2015 -0700
 @@ -32,7 +32,7 @@
  #include "defs.h"
  
  static struct {
 - Note;
 + Note note;
   uint32 mask[(NSIG+31)/32];
   uint32 wanted[(NSIG+31)/32];
@@ -138,7 +138,7 @@
     // to use for initialization.  It does not pass
     // signal information in m.
     sig.inuse = true; // enable reception of signals; cannot disable
 -   runtime_noteclear(&sig);
 +   runtime_noteclear(&sig.note);
     return;
   }
   
-diff -r a6e10414311a libgo/runtime/time.goc
---- a/libgo/runtime/time.goc  Fri Jan 16 07:57:02 2015 -0800
-+++ b/libgo/runtime/time.goc  Fri Feb 13 16:36:07 2015 -0800
+diff -r bb70e852004f libgo/runtime/time.goc
+--- a/libgo/runtime/time.goc  Fri Jan 16 13:28:21 2015 -0800
++++ b/libgo/runtime/time.goc  Fri Apr 03 17:31:02 2015 -0700
 @@ -92,17 +92,17 @@
   t.fv = &readyv;
   t.arg.__object = g;
   t.seq = 0;
 - runtime_lock(&timers);
 + runtime_lock(&timers.lock);
   addtimer(&t);
 - runtime_parkunlock(&timers, reason);
+   runtime_lock(&timers.lock);
     now = runtime_nanotime();
     for(;;) {
 @@ -236,7 +236,7 @@
       f = (void*)t->fv->fn;
       arg = t->arg;
       seq = t->seq;
 -     runtime_unlock(&timers);
 +     runtime_unlock(&timers.lock);
-      __go_set_closure(fv);
-      f(arg, seq);
+      __builtin_call_with_static_chain(f(arg, seq), fv);
  
-@@ -247,20 +247,20 @@
+      // clear f and arg to avoid leak while sleeping for next timer
+@@ -246,20 +246,20 @@
       arg.__object = nil;
       USED(&arg);
  
 -     runtime_lock(&timers);
 +     runtime_lock(&timers.lock);
     }
     if(delta < 0) {
       // No timers left - put goroutine to sleep.

test/irgen/cabi.go

 // RUN: llgo -S -emit-llvm -o - %s | FileCheck %s
 
 package foo
 
-// CHECK: define void @foo.Test01_SI8(i8 signext)
+// CHECK: define void @foo.Test01_SI8(i8* nest, i8 signext)
 func Test01_SI8(x int8) {}
-// CHECK: define void @foo.Test02_UI8(i8 zeroext)
+// CHECK: define void @foo.Test02_UI8(i8* nest, i8 zeroext)
 func Test02_UI8(x uint8) {}
 
-// CHECK: define void @foo.Test03_SI16(i16 signext)
+// CHECK: define void @foo.Test03_SI16(i8* nest, i16 signext)
 func Test03_SI16(x int16) {}
-// CHECK: define void @foo.Test04_UI16(i16 zeroext)
+// CHECK: define void @foo.Test04_UI16(i8* nest, i16 zeroext)
 func Test04_UI16(x uint16) {}
 
-// CHECK: define void @foo.Test05_SI32(i32)
+// CHECK: define void @foo.Test05_SI32(i8* nest, i32)
 func Test05_SI32(x int32) {}
-// CHECK: define void @foo.Test06_UI32(i32)
+// CHECK: define void @foo.Test06_UI32(i8* nest, i32)
 func Test06_UI32(x uint32) {}
 
-// CHECK: define void @foo.Test07_SI64(i64)
+// CHECK: define void @foo.Test07_SI64(i8* nest, i64)
 func Test07_SI64(x int64) {}
-// CHECK: define void @foo.Test08_UI64(i64)
+// CHECK: define void @foo.Test08_UI64(i8* nest, i64)
 func Test08_UI64(x uint64) {}

test/irgen/imports.go

 // RUN: llgo -S -emit-llvm -o - %s | FileCheck %s
 
 package foo
 
 import _ "fmt"
 
 var X interface{}
 
 // CHECK: @"init$guard" = internal global i1 false
 
-// CHECK: define void @foo..import()
+// CHECK: define void @foo..import(i8* nest)
 // CHECK-NEXT: :
 // CHECK-NEXT: %[[N:.*]] = load i1, i1* @"init$guard"
 // CHECK-NEXT: br i1 %[[N]], label %{{.*}}, label %[[L:.*]]
 
 // CHECK: ; <label>:[[L]]
 // CHECK-NEXT: call void @__go_register_gc_roots
 // CHECK-NEXT: store i1 true, i1* @"init$guard"
-// CHECK-NEXT: call void @fmt..import()
+// CHECK-NEXT: call void @fmt..import(i8* undef)
 // CHECK-NEXT: br label

test/irgen/mangling-synthetic.go

 // RUN: llgo -fgo-pkgpath=p -c -o %T/p.o %S/Inputs/mangling-synthetic-p.go
 // RUN: llgo -fgo-pkgpath=q -I %T -S -emit-llvm -o - %s | FileCheck %s
 
 package q
 
 import "p"
 
-// CHECK-DAG: define linkonce_odr void @p.f.N3_q.T(i8*)
-// CHECK-DAG: define linkonce_odr void @p.f.pN3_q.T(i8*)
+// CHECK-DAG: define linkonce_odr void @p.f.N3_q.T(i8* nest, i8*)
+// CHECK-DAG: define linkonce_odr void @p.f.pN3_q.T(i8* nest, i8*)
 type T struct { p.U }
 
-// CHECK-DAG: declare void @q.f.N3_q.T(i8*)
-// CHECK-DAG: define linkonce_odr void @q.f.pN3_q.T(i8*)
+// CHECK-DAG: declare void @q.f.N3_q.T(i8* nest, i8*)
+// CHECK-DAG: define linkonce_odr void @q.f.pN3_q.T(i8* nest, i8*)
 func (T) f()

update_third_party.sh

 #!/bin/sh -e
 
 gofrontendrepo=https://code.google.com/p/gofrontend
-gofrontendrev=a6e10414311a
+gofrontendrev=07baa07598ea
 
 gccrepo=svn://gcc.gnu.org/svn/gcc/trunk
-gccrev=216268
+gccrev=219477
 
 gotoolsrepo=https://go.googlesource.com/tools
 gotoolsrev=d4e70101500b43ffe705d4c45e50dd4f1c8e3b2e
 
 tempdir=$(mktemp -d /tmp/update_third_party.XXXXXX)
 gofrontenddir=$tempdir/gofrontend
 gotoolsdir=$tempdir/go.tools
 
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 \
   third_party/gofrontend/libffi/doc/libffi.texi \
   third_party/gofrontend/libffi/msvcc.sh \
-  third_party/gofrontend/libffi/testsuite/lib/libffi.exp \
+  third_party/gofrontend/libffi/testsuite/config/default.exp \
   third_party/gofrontend/libffi/testsuite/libffi.call/call.exp \
+  third_party/gofrontend/libffi/testsuite/libffi.complex/complex.exp \
+  third_party/gofrontend/libffi/testsuite/libffi.go/go.exp \
   third_party/gofrontend/libffi/testsuite/libffi.special/special.exp \
-  third_party/gofrontend/libffi/testsuite/config/default.exp
+  third_party/gofrontend/libffi/testsuite/lib/libffi.exp \
+  third_party/gofrontend/libffi/testsuite/lib/target-libpath.exp \
+  third_party/gofrontend/libffi/testsuite/lib/wrapper.exp
 
 # The build requires these files to exist.
 touch \
   third_party/gofrontend/include/dwarf2.def \
   third_party/gofrontend/libffi/doc/libffi.texi
 
 # --------------------- go.tools ---------------------