func (p *exporter) signature(sig *types.Signature) {
// We need the receiver information (T vs *T)
// for methods associated with named types.
// We do not record interface receiver types in the
// export data because 1) the importer can derive them
// from the interface type and 2) they create cycles
// in the type graph.
if recv := sig.Recv(); recv != nil {
if _, ok := recv.Type().Underlying().(*types.Interface); !ok {
// 1-element tuple
p.int(1)
p.param(recv)
} else {
// 0-element tuple
p.int(0)
}
} else {
// 0-element tuple
p.int(0)
}
p.tuple(sig.Params())
p.tuple(sig.Results())
if sig.Variadic() {
p.int(1)
} else {
p.int(0)
}
}
func (tm *LLVMTypeMap) funcLLVMType(tstr string, f *types.Signature) llvm.Type {
typ, ok := tm.types[tstr]
if !ok {
// If there's a receiver change the receiver to an
// additional (first) parameter, and take the value of
// the resulting signature instead.
var param_types []llvm.Type
if recv := f.Recv(); recv != nil {
params := f.Params()
paramvars := make([]*types.Var, int(params.Len()+1))
paramvars[0] = recv
for i := 0; i < int(params.Len()); i++ {
paramvars[i+1] = params.At(i)
}
params = types.NewTuple(paramvars...)
f := types.NewSignature(nil, params, f.Results(), f.IsVariadic())
return tm.ToLLVM(f)
}
typ = llvm.GlobalContext().StructCreateNamed("")
tm.types[tstr] = typ
params := f.Params()
nparams := int(params.Len())
for i := 0; i < nparams; i++ {
typ := params.At(i).Type()
if f.IsVariadic() && i == nparams-1 {
typ = types.NewSlice(typ)
}
llvmtyp := tm.ToLLVM(typ)
param_types = append(param_types, llvmtyp)
}
var return_type llvm.Type
results := f.Results()
switch nresults := int(results.Len()); nresults {
case 0:
return_type = llvm.VoidType()
case 1:
return_type = tm.ToLLVM(results.At(0).Type())
default:
elements := make([]llvm.Type, nresults)
for i := range elements {
result := results.At(i)
elements[i] = tm.ToLLVM(result.Type())
}
return_type = llvm.StructType(elements, false)
}
fntyp := llvm.FunctionType(return_type, param_types, false)
fnptrtyp := llvm.PointerType(fntyp, 0)
i8ptr := llvm.PointerType(llvm.Int8Type(), 0)
elements := []llvm.Type{fnptrtyp, i8ptr} // func, closure
typ.StructSetBody(elements, false)
}
return typ
}
// changeRecv returns sig with Recv prepended to Params().
func changeRecv(sig *types.Signature) *types.Signature {
params := sig.Params()
n := params.Len()
p2 := make([]*types.Var, n+1)
p2[0] = sig.Recv()
for i := 0; i < n; i++ {
p2[i+1] = params.At(i)
}
return types.NewSignature(nil, nil, types.NewTuple(p2...), sig.Results(), sig.IsVariadic())
}
func (c *compiler) makeFunc(ident *ast.Ident, ftyp *types.Signature) *LLVMValue {
fname := ident.String()
if ftyp.Recv() == nil && fname == "init" {
// Make "init" functions anonymous.
fname = ""
} else {
var pkgname string
if recv := ftyp.Recv(); recv != nil {
var recvname string
switch recvtyp := recv.Type().(type) {
case *types.Pointer:
if named, ok := recvtyp.Elem().(*types.Named); ok {
obj := named.Obj()
recvname = "*" + obj.Name()
pkgname = obj.Pkg().Path()
}
case *types.Named:
named := recvtyp
obj := named.Obj()
recvname = obj.Name()
pkgname = obj.Pkg().Path()
}
if recvname != "" {
fname = fmt.Sprintf("%s.%s", recvname, fname)
} else {
// If the receiver is an unnamed struct, we're
// synthesising a method for an unnamed struct
// type. There's no meaningful name to give the
// function, so leave it up to LLVM.
fname = ""
}
} else {
obj := c.typeinfo.Objects[ident]
pkgname = obj.Pkg().Path()
}
if fname != "" {
fname = pkgname + "." + fname
}
}
// gcimporter may produce multiple AST objects for the same function.
llvmftyp := c.types.ToLLVM(ftyp)
var fn llvm.Value
if fname != "" {
fn = c.module.Module.NamedFunction(fname)
}
if fn.IsNil() {
llvmfptrtyp := llvmftyp.StructElementTypes()[0].ElementType()
fn = llvm.AddFunction(c.module.Module, fname, llvmfptrtyp)
}
fn = llvm.ConstInsertValue(llvm.ConstNull(llvmftyp), fn, []uint32{0})
return c.NewValue(fn, ftyp)
}
func (tm *llvmTypeMap) funcLLVMType(f *types.Signature, name string) llvm.Type {
// If there's a receiver change the receiver to an
// additional (first) parameter, and take the value of
// the resulting signature instead.
if recv := f.Recv(); recv != nil {
params := f.Params()
paramvars := make([]*types.Var, int(params.Len()+1))
paramvars[0] = recv
for i := 0; i < int(params.Len()); i++ {
paramvars[i+1] = params.At(i)
}
params = types.NewTuple(paramvars...)
f := types.NewSignature(nil, nil, params, f.Results(), f.Variadic())
return tm.toLLVM(f, name)
}
if typ, ok := tm.types.At(f).(llvm.Type); ok {
return typ
}
typ := llvm.GlobalContext().StructCreateNamed(name)
tm.types.Set(f, typ)
params := f.Params()
param_types := make([]llvm.Type, params.Len())
for i := range param_types {
llvmtyp := tm.ToLLVM(params.At(i).Type())
param_types[i] = llvmtyp
}
var return_type llvm.Type
results := f.Results()
switch nresults := int(results.Len()); nresults {
case 0:
return_type = llvm.VoidType()
case 1:
return_type = tm.ToLLVM(results.At(0).Type())
default:
elements := make([]llvm.Type, nresults)
for i := range elements {
result := results.At(i)
elements[i] = tm.ToLLVM(result.Type())
}
return_type = llvm.StructType(elements, false)
}
fntyp := llvm.FunctionType(return_type, param_types, false)
fnptrtyp := llvm.PointerType(fntyp, 0)
i8ptr := llvm.PointerType(llvm.Int8Type(), 0)
elements := []llvm.Type{fnptrtyp, i8ptr} // func, closure
typ.StructSetBody(elements, false)
return typ
}
// writeSignature writes to buf the signature sig in declaration syntax.
func writeSignature(buf *bytes.Buffer, pkg *types.Package, name string, sig *types.Signature, params []*Parameter) {
buf.WriteString("func ")
if recv := sig.Recv(); recv != nil {
buf.WriteString("(")
if n := params[0].Name(); n != "" {
buf.WriteString(n)
buf.WriteString(" ")
}
buf.WriteString(relType(params[0].Type(), pkg))
buf.WriteString(") ")
}
buf.WriteString(name)
types.WriteSignature(buf, pkg, sig)
}
func (cdd *CDD) signature(sig *types.Signature, recv bool, pnames int) (res results, params string) {
params = "("
res = cdd.results(sig.Results())
if r := sig.Recv(); r != nil && recv {
typ, dim, acds := cdd.TypeStr(r.Type())
res.acds = append(res.acds, acds...)
var pname string
switch pnames {
case numNames:
pname = "_0"
case orgNames:
pname = cdd.NameStr(r, true)
}
if pname == "" {
params += typ + dimFuncPtr("", dim)
} else {
params += typ + " " + dimFuncPtr(pname, dim)
}
if sig.Params() != nil {
params += ", "
}
}
if p := sig.Params(); p != nil {
for i, n := 0, p.Len(); i < n; i++ {
if i != 0 {
params += ", "
}
v := p.At(i)
typ, dim, acds := cdd.TypeStr(v.Type())
res.acds = append(res.acds, acds...)
var pname string
switch pnames {
case numNames:
pname = "_" + strconv.Itoa(i+1)
case orgNames:
pname = cdd.NameStr(v, true)
if pname == "_$" {
pname = "unused" + cdd.gtc.uniqueId()
}
}
if pname == "" {
params += typ + dimFuncPtr("", dim)
} else {
params += typ + " " + dimFuncPtr(pname, dim)
}
}
}
params += ")"
return
}
func (m *TypeMap) descriptorSignature(t *types.Signature, name string) TypeDebugDescriptor {
// If there's a receiver change the receiver to an
// additional (first) parameter, and take the value of
// the resulting signature instead.
if recv := t.Recv(); recv != nil {
params := t.Params()
paramvars := make([]*types.Var, int(params.Len()+1))
paramvars[0] = recv
for i := 0; i < int(params.Len()); i++ {
paramvars[i+1] = params.At(i)
}
params = types.NewTuple(paramvars...)
t := types.NewSignature(nil, nil, params, t.Results(), t.Variadic())
return m.typeDebugDescriptor(t, name)
}
if dt, ok := m.m.At(t).(TypeDebugDescriptor); ok {
return dt
}
var returnType DebugDescriptor
var paramTypes []DebugDescriptor
if results := t.Results(); results.Len() == 1 {
returnType = m.TypeDebugDescriptor(results.At(0).Type())
} else if results != nil {
fields := make([]DebugDescriptor, results.Len())
for i := range fields {
fields[i] = m.TypeDebugDescriptor(results.At(i).Type())
}
returnType = NewStructCompositeType(fields)
}
if params := t.Params(); params != nil && params.Len() > 0 {
paramTypes = make([]DebugDescriptor, params.Len())
for i := range paramTypes {
paramTypes[i] = m.TypeDebugDescriptor(params.At(i).Type())
}
}
ct := NewStructCompositeType([]DebugDescriptor{
NewSubroutineCompositeType(returnType, paramTypes),
m.TypeDebugDescriptor(types.NewPointer(types.Typ[types.Uint8])),
})
ct.Name = name
m.m.Set(t, ct)
return ct
}
func (v funcTypeVisitor) Visit(node ast.Node) ast.Visitor {
var sig *types.Signature
var noderecv *ast.FieldList
var astfunc *ast.FuncType
switch node := node.(type) {
case *ast.FuncDecl:
sig = v.objects[node.Name].Type().(*types.Signature)
astfunc = node.Type
noderecv = node.Recv
case *ast.FuncLit:
sig = v.exprtypes[node].Type.(*types.Signature)
astfunc = node.Type
default:
return v
}
// go/types creates a separate types.Var for
// internal and external usage. We need to
// associate them at the object data level.
paramIdents := fieldlistIdents(astfunc.Params)
resultIdents := fieldlistIdents(astfunc.Results)
if recv := sig.Recv(); recv != nil {
id := fieldlistIdents(noderecv)[0]
if obj, ok := v.objects[id]; ok {
v.objectdata[recv] = v.objectdata[obj]
}
}
for i, id := range paramIdents {
if obj, ok := v.objects[id]; ok {
v.objectdata[sig.Params().At(i)] = v.objectdata[obj]
}
}
for i, id := range resultIdents {
if obj, ok := v.objects[id]; ok {
v.objectdata[sig.Results().At(i)] = v.objectdata[obj]
}
}
return v
}
func (ts *TypeStringer) writeSignature(buf *bytes.Buffer, sig *types.Signature) {
if recv := sig.Recv(); recv != nil {
ts.writeType(buf, recv.Type())
buf.WriteByte(' ')
}
ts.writeParams(buf, sig.Params(), sig.IsVariadic())
if sig.Results().Len() == 0 {
// no result
return
}
buf.WriteByte(' ')
if sig.Results().Len() == 1 {
// single unnamed result
ts.writeType(buf, sig.Results().At(0).Type())
return
}
// multiple or named result(s)
ts.writeParams(buf, sig.Results(), false)
}
// writeSignature writes to w the signature sig in declaration syntax.
// Derived from types.Signature.String().
//
func writeSignature(w io.Writer, name string, sig *types.Signature, params []*Parameter) {
io.WriteString(w, "func ")
if recv := sig.Recv(); recv != nil {
io.WriteString(w, "(")
if n := params[0].Name(); n != "" {
io.WriteString(w, n)
io.WriteString(w, " ")
}
io.WriteString(w, params[0].Type().String())
io.WriteString(w, ") ")
params = params[1:]
}
io.WriteString(w, name)
io.WriteString(w, "(")
for i, v := range params {
if i > 0 {
io.WriteString(w, ", ")
}
io.WriteString(w, v.Name())
io.WriteString(w, " ")
if sig.IsVariadic() && i == len(params)-1 {
io.WriteString(w, "...")
io.WriteString(w, v.Type().Underlying().(*types.Slice).Elem().String())
} else {
io.WriteString(w, v.Type().String())
}
}
io.WriteString(w, ")")
if n := sig.Results().Len(); n > 0 {
io.WriteString(w, " ")
r := sig.Results()
if n == 1 && r.At(0).Name() == "" {
io.WriteString(w, r.At(0).Type().String())
} else {
io.WriteString(w, r.String())
}
}
}
func (p *exporter) signature(sig *types.Signature) {
// TODO(gri) We only need to record the receiver type
// for interface methods if we flatten them
// out. If we track embedded types instead,
// the information is already present.
// We do need the receiver information (T vs *T)
// for methods associated with named types.
if recv := sig.Recv(); recv != nil {
// 1-element tuple
p.int(1)
p.param(recv)
} else {
// 0-element tuple
p.int(0)
}
p.tuple(sig.Params())
p.tuple(sig.Results())
if sig.Variadic() {
p.int(1)
} else {
p.int(0)
}
}
func (ts *TypeStringer) writeSignature(buf *bytes.Buffer, sig *types.Signature, unique bool) {
if recv := sig.Recv(); recv != nil {
if _, ok := recv.Type().Underlying().(*types.Interface); !ok {
ts.writeType(buf, recv.Type(), unique)
buf.WriteByte(' ')
}
}
ts.writeParams(buf, sig.Params(), sig.IsVariadic(), unique)
if sig.Results().Len() == 0 {
// no result
return
}
buf.WriteByte(' ')
if sig.Results().Len() == 1 {
// single unnamed result
ts.writeType(buf, sig.Results().At(0).Type(), unique)
return
}
// multiple or named result(s)
ts.writeParams(buf, sig.Results(), false, unique)
}