cl: _testpy/gcd

ssa/decl.go

@@ -33,15 +33,19 @@ const (
 )
 
 func VArg() *types.Var {
-	return types.NewParam(0, nil, NameValist, types.Typ[types.Invalid])
+	return types.NewParam(0, nil, NameValist, types.NewSlice(tyAny))
 }
 
 func IsVArg(arg *types.Var) bool {
 	return arg.Name() == NameValist
 }
 
-func HasVArg(t *types.Tuple, n int) bool {
-	return n > 0 && IsVArg(t.At(n-1))
+func HasVArg(t *types.Tuple, n int, sig *types.Signature) bool {
+	has := n > 0 && IsVArg(t.At(n-1))
+	if has && !sig.Variadic() { // TODO(xsw): remove this check
+		panic("HasVArg: varg must mark as variadic in signature")
+	}
+	return has
 }
 
 // -----------------------------------------------------------------------------
@@ -196,7 +200,7 @@ func newParams(fn Type, prog Program) (params []Type, hasVArg bool) {
 	sig := fn.raw.Type.(*types.Signature)
 	in := sig.Params()
 	if n := in.Len(); n > 0 {
-		if hasVArg = HasVArg(in, n); hasVArg {
+		if hasVArg = HasVArg(in, n, sig); hasVArg {
 			n--
 		}
 		params = make([]Type, n)

ssa/package.go

@@ -532,7 +532,7 @@ func (p Program) tyCallFunctionObjArgs() *types.Signature {
 		paramObjPtr := p.paramObjPtr()
 		params := types.NewTuple(paramObjPtr, VArg())
 		results := types.NewTuple(paramObjPtr)
-		p.callFOArgs = types.NewSignatureType(nil, nil, nil, params, results, false)
+		p.callFOArgs = types.NewSignatureType(nil, nil, nil, params, results, true)
 	}
 	return p.callFOArgs
 }
@@ -576,7 +576,7 @@ func (p Program) tyLoadPyModSyms() *types.Signature {
 		objPtr := p.PyObjectPtr().raw.Type
 		paramObjPtr := types.NewParam(token.NoPos, nil, "mod", objPtr)
 		params := types.NewTuple(paramObjPtr, VArg())
-		p.loadPyModS = types.NewSignatureType(nil, nil, nil, params, nil, false)
+		p.loadPyModS = types.NewSignatureType(nil, nil, nil, params, nil, true)
 	}
 	return p.loadPyModS
 }
@@ -647,8 +647,11 @@ func (b Builder) pyCall(fn Expr, args []Expr) (ret Expr) {
 		call := pkg.pyFunc("PyObject_CallNoArgs", prog.tyCallNoArgs())
 		ret = b.Call(call, fn)
 	case 1:
-		call := pkg.pyFunc("PyObject_CallOneArg", prog.tyCallOneArg())
-		ret = b.Call(call, fn, args[0])
+		if !sig.Variadic() {
+			call := pkg.pyFunc("PyObject_CallOneArg", prog.tyCallOneArg())
+			return b.Call(call, fn, args[0])
+		}
+		fallthrough
 	default:
 		call := pkg.pyFunc("PyObject_CallFunctionObjArgs", prog.tyCallFunctionObjArgs())
 		n = len(args)

ssa/ssa_test.go

@@ -399,7 +399,7 @@ func TestPrintf(t *testing.T) {
 	pchar := types.NewPointer(types.Typ[types.Int8])
 	params := types.NewTuple(types.NewVar(0, nil, "format", pchar), VArg())
 	rets := types.NewTuple(types.NewVar(0, nil, "", types.Typ[types.Int32]))
-	sig := types.NewSignatureType(nil, nil, nil, params, rets, false)
+	sig := types.NewSignatureType(nil, nil, nil, params, rets, true)
 	pkg.NewFunc("printf", sig, InGo)
 	assertPkg(t, pkg, `; ModuleID = 'foo/bar'
 source_filename = "foo/bar"

ssa/type.go

@@ -313,7 +313,7 @@ func (p Program) toLLVMTypes(t *types.Tuple, n int) (ret []llvm.Type) {
 func (p Program) toLLVMFunc(sig *types.Signature) llvm.Type {
 	tParams := sig.Params()
 	n := tParams.Len()
-	hasVArg := HasVArg(tParams, n)
+	hasVArg := HasVArg(tParams, n, sig)
 	if hasVArg {
 		n--
 	}

ssa/type_cvt.go

@@ -66,6 +66,27 @@ func (p Program) FuncDecl(sig *types.Signature, bg Background) Type {
 	return &aType{p.toLLVMFunc(sig), rawType{sig}, vkFuncDecl}
 }
 
+/*
+// cvtCxFunc converts a C extended function type into raw type.
+func cvtCxFunc(sig *types.Signature, recv *types.Var) *types.Signature {
+	if sig.Variadic() {
+			// convert printf-like function type
+			tParams := sig.Params()
+			n := tParams.Len()
+			params := make([]*types.Var, n)
+			n--
+			for i := 0; i < n; i++ {
+				params[i] = tParams.At(i)
+			}
+			params[n] = VArg()
+			sig = types.NewSignatureType(nil, nil, nil, types.NewTuple(params...), sig.Results(), true)
+		panic("todo")
+	}
+	sig = FuncAddCtx(recv, sig)
+	return sig
+}
+*/
+
 // Closure creates a closture type for a function.
 func (p Program) Closure(fn Type) Type {
 	sig := fn.raw.Type.(*types.Signature)
@@ -152,7 +173,7 @@ func (p goTypes) cvtFunc(sig *types.Signature, recv *types.Var) (raw *types.Sign
 	params, cvt1 := p.cvtTuple(sig.Params())
 	results, cvt2 := p.cvtTuple(sig.Results())
 	if cvt1 || cvt2 {
-		return types.NewSignatureType(nil, nil, nil, params, results, sig.Variadic())
+		return types.NewSignatureType(nil, nil, nil, params, results, false)
 	}
 	return sig
 }