Merge commit 'd06146ed970f52d564521ff0be7d56839c85e497' into async-functions

* commit 'd06146ed970f52d564521ff0be7d56839c85e497': (152 commits) perf(lib/sync): avoid using `defer` refactor(c-libuv): Added TODO(uid) comment & adjusted the position of Handle, Stream, Req, Write, Connect README: io/ioutil library: io/ioutil c/openssl: bio, pem, rsa refactor(c/libuv): Adapt libuv.Fs struct Revert "fix(c/libuv): Add libuv fs struct new func" fix(c/libuv): Fix async_fs demo return 255 error & pointer not allocated error fix(c/libuv): Add libuv fs struct new func doc/c:refine symbol visibility description README: math/big library: math/big.Int (mini-impl for _cmptest/bigintdemo) doc/c:update implicit destructors description c/openssl: bignum, rsa library: crypto library: crypto/{sha1, sha256, sha512} doc/c:fix incorrect usage in construtors doc/c:update destructor usage delete sum fix test error ... # Conflicts: # ssa/eh.go
2024-08-04 10:26:27 +08:00
parent efa771f3ff d06146ed97
commit e470bc2069
165 changed files with 11563 additions and 606 deletions
--- a/ssa/datastruct.go
+++ b/ssa/datastruct.go
@@ -579,8 +579,8 @@ func (b Builder) Next(typ Type, iter Expr, isString bool) Expr {
 		return b.InlineCall(b.Pkg.rtFunc("StringIterNext"), iter)
 	}
 	prog := b.Prog
-	ktyp := prog.Type(typ.raw.Type.(*types.Map).Key(), InGo)
-	vtyp := prog.Type(typ.raw.Type.(*types.Map).Elem(), InGo)
+	ktyp := prog.Type(typ.raw.Type.Underlying().(*types.Map).Key(), InGo)
+	vtyp := prog.Type(typ.raw.Type.Underlying().(*types.Map).Elem(), InGo)
 	rets := b.InlineCall(b.Pkg.rtFunc("MapIterNext"), iter)
 	ok := b.impl.CreateExtractValue(rets.impl, 0, "")
 	t := prog.Struct(prog.Bool(), ktyp, vtyp)
--- a/ssa/eh.go
+++ b/ssa/eh.go
@@ -63,7 +63,11 @@ func (b Builder) AllocaSigjmpBuf() Expr {
 }

 func (b Builder) Sigsetjmp(jb, savemask Expr) Expr {
-	fn := b.Pkg.cFunc("sigsetjmp", b.Prog.tySigsetjmp())
+	fname := "sigsetjmp"
+	if b.Prog.target.GOOS == "linux" {
+		fname = "__sigsetjmp"
+	}
+	fn := b.Pkg.cFunc(fname, b.Prog.tySigsetjmp())
 	return b.Call(fn, jb, savemask)
 }

@@ -86,14 +90,16 @@ func (p Function) deferInitBuilder() (b Builder, next BasicBlock) {
 }

 type aDefer struct {
-	nextBit  int          // next defer bit
-	key      Expr         // pthread TLS key
-	data     Expr         // pointer to runtime.Defer
-	bitsPtr  Expr         // pointer to defer bits
-	rundPtr  Expr         // pointer to RunDefers index
-	procBlk  BasicBlock   // deferProc block
-	runsNext []BasicBlock // next blocks of RunDefers
-	stmts    []func(bits Expr)
+	nextBit   int          // next defer bit
+	key       Expr         // pthread TLS key
+	data      Expr         // pointer to runtime.Defer
+	bitsPtr   Expr         // pointer to defer bits
+	rethPtr   Expr         // next block of Rethrow
+	rundPtr   Expr         // next block of RunDefers
+	procBlk   BasicBlock   // deferProc block
+	panicBlk  BasicBlock   // panic block (runDefers and rethrow)
+	rundsNext []BasicBlock // next blocks of RunDefers
+	stmts     []func(bits Expr)
 }

 func (p Package) keyInit(name string) {
@@ -124,53 +130,59 @@ const (
 	// 0: addr sigjmpbuf
 	// 1: bits uintptr
 	// 2: link *Defer
-	// 3: rund voidptr
+	// 3: reth voidptr: block address after Rethrow
+	// 4: rund voidptr: block address after RunDefers
 	deferSigjmpbuf = iota
 	deferBits
 	deferLink
-	deferRund
+	deferRethrow
+	deferRunDefers
 )

 func (b Builder) getDefer(kind DoAction) *aDefer {
 	self := b.Func
 	if self.defer_ == nil {
 		// TODO(xsw): check if in pkg.init
-		var next, rundBlk BasicBlock
+		var next, panicBlk BasicBlock
 		if kind != DeferAlways {
 			b, next = self.deferInitBuilder()
 		}
+
 		prog := b.Prog
+		blks := self.MakeBlocks(2)
+		procBlk, rethrowBlk := blks[0], blks[1]
+
 		key := b.deferKey()
 		zero := prog.Val(uintptr(0))
 		link := Expr{b.pthreadGetspecific(key).impl, prog.DeferPtr()}
 		jb := b.AllocaSigjmpBuf()
-		ptr := b.aggregateAlloca(prog.Defer(), jb.impl, zero.impl, link.impl)
+		ptr := b.aggregateAlloca(prog.Defer(), jb.impl, zero.impl, link.impl, procBlk.Addr().impl)
 		deferData := Expr{ptr, prog.DeferPtr()}
 		b.pthreadSetspecific(key, deferData)
-		blks := self.MakeBlocks(2)
-		procBlk, rethrowBlk := blks[0], blks[1]
 		bitsPtr := b.FieldAddr(deferData, deferBits)
-		rundPtr := b.FieldAddr(deferData, deferRund)
-		self.defer_ = &aDefer{
-			key:      key,
-			data:     deferData,
-			bitsPtr:  bitsPtr,
-			rundPtr:  rundPtr,
-			procBlk:  procBlk,
-			runsNext: []BasicBlock{rethrowBlk},
-		}
+		rethPtr := b.FieldAddr(deferData, deferRethrow)
+		rundPtr := b.FieldAddr(deferData, deferRunDefers)
+
 		czero := prog.IntVal(0, prog.CInt())
 		retval := b.Sigsetjmp(jb, czero)
 		if kind != DeferAlways {
-			rundBlk = self.MakeBlock("")
+			panicBlk = self.MakeBlock("")
 		} else {
 			blks = self.MakeBlocks(2)
-			next, rundBlk = blks[0], blks[1]
+			next, panicBlk = blks[0], blks[1]
+		}
+		b.If(b.BinOp(token.EQL, retval, czero), next, panicBlk)
+
+		self.defer_ = &aDefer{
+			key:       key,
+			data:      deferData,
+			bitsPtr:   bitsPtr,
+			rethPtr:   rethPtr,
+			rundPtr:   rundPtr,
+			procBlk:   procBlk,
+			panicBlk:  panicBlk,
+			rundsNext: []BasicBlock{rethrowBlk},
 		}
-		b.If(b.BinOp(token.EQL, retval, czero), next, rundBlk)
-		b.SetBlockEx(rundBlk, AtEnd, false) // exec runDefers and rethrow
-		b.Store(rundPtr, rethrowBlk.Addr())
-		b.Jump(procBlk)

 		b.SetBlockEx(rethrowBlk, AtEnd, false) // rethrow
 		b.Call(b.Pkg.rtFunc("Rethrow"), link)
@@ -209,7 +221,7 @@ func (b Builder) Defer(kind DoAction, fn Expr, args ...Expr) {
 	case DeferAlways:
 		// nothing to do
 	default:
-		panic("todo: DeferInLoop is not supported")
+		panic("todo: DeferInLoop is not supported - " + b.Func.Name())
 	}
 	self.stmts = append(self.stmts, func(bits Expr) {
 		switch kind {
@@ -229,7 +241,7 @@ func (b Builder) Defer(kind DoAction, fn Expr, args ...Expr) {
 func (b Builder) RunDefers() {
 	self := b.getDefer(DeferInCond)
 	blk := b.Func.MakeBlock("")
-	self.runsNext = append(self.runsNext, blk)
+	self.rundsNext = append(self.rundsNext, blk)

 	b.Store(self.rundPtr, blk.Addr())
 	b.Jump(self.procBlk)
@@ -243,20 +255,42 @@ func (p Function) endDefer(b Builder) {
 	if self == nil {
 		return
 	}
-	nexts := self.runsNext
+	nexts := self.rundsNext
 	if len(nexts) == 0 {
 		return
 	}
-	b.SetBlockEx(self.procBlk, AtEnd, true)
-	bits := b.Load(self.bitsPtr)
-	stmts := self.stmts
-	for i := len(stmts) - 1; i >= 0; i-- {
-		stmts[i](bits)
-	}

+	rethrowBlk := nexts[0]
+	procBlk := self.procBlk
+	panicBlk := self.panicBlk
+	rethPtr := self.rethPtr
+	rundPtr := self.rundPtr
+	bitsPtr := self.bitsPtr
+
+	stmts := self.stmts
+	n := len(stmts)
+	rethsNext := make([]BasicBlock, n+1)
+	blks := p.MakeBlocks(n - 1)
+	copy(rethsNext[1:], blks)
+	rethsNext[0] = rethrowBlk
+	rethsNext[n] = procBlk
+
+	for i := n - 1; i >= 0; i-- {
+		rethNext := rethsNext[i]
+		b.SetBlockEx(rethsNext[i+1], AtEnd, true)
+		b.Store(rethPtr, rethNext.Addr())
+		stmts[i](b.Load(bitsPtr))
+		if i != 0 {
+			b.Jump(rethNext)
+		}
+	}
 	link := b.getField(b.Load(self.data), deferLink)
 	b.pthreadSetspecific(self.key, link)
-	b.IndirectJump(b.Load(self.rundPtr), nexts)
+	b.IndirectJump(b.Load(rundPtr), nexts)
+
+	b.SetBlockEx(panicBlk, AtEnd, false) // panicBlk: exec runDefers and rethrow
+	b.Store(rundPtr, rethrowBlk.Addr())
+	b.IndirectJump(b.Load(rethPtr), rethsNext)
 }

 // -----------------------------------------------------------------------------
--- a/ssa/expr.go
+++ b/ssa/expr.go
@@ -388,7 +388,7 @@ var boolPredOpToLLVM = []llvm.IntPredicate{
 	token.NEQ - predOpBase: llvm.IntNE,
 }

-// EQL NEQ LSS LEQ GTR GEQ      == != < <= < >=
+// EQL NEQ LSS LEQ GTR GEQ      == != < <= > >=
 func isPredOp(op token.Token) bool {
 	return op >= predOpBase && op <= predOpLast
 }
@@ -397,7 +397,7 @@ func isPredOp(op token.Token) bool {
 // op can be:
 // ADD SUB MUL QUO REM          + - * / %
 // AND OR XOR SHL SHR AND_NOT   & | ^ << >> &^
-// EQL NEQ LSS LEQ GTR GEQ      == != < <= < >=
+// EQL NEQ LSS LEQ GTR GEQ      == != < <= > >=
 func (b Builder) BinOp(op token.Token, x, y Expr) Expr {
 	if debugInstr {
 		log.Printf("BinOp %d, %v, %v\n", op, x.impl, y.impl)
@@ -495,7 +495,7 @@ func (b Builder) BinOp(op token.Token, x, y Expr) Expr {
 			llop := logicOpToLLVM[op-logicOpBase]
 			return Expr{llvm.CreateBinOp(b.impl, llop, x.impl, y.impl), x.Type}
 		}
-	case isPredOp(op): // op: == != < <= < >=
+	case isPredOp(op): // op: == != < <= > >=
 		prog := b.Prog
 		tret := prog.Bool()
 		kind := x.kind
@@ -567,7 +567,7 @@ func (b Builder) BinOp(op token.Token, x, y Expr) Expr {
 				return Expr{llvm.CreateICmp(b.impl, pred, x.impl, y.impl), tret}
 			}
 		case vkArray:
-			typ := x.raw.Type.(*types.Array)
+			typ := x.raw.Type.Underlying().(*types.Array)
 			elem := b.Prog.Elem(x.Type)
 			ret := prog.BoolVal(true)
 			for i, n := 0, int(typ.Len()); i < n; i++ {
@@ -699,8 +699,31 @@ func (b Builder) ChangeType(t Type, x Expr) (ret Expr) {
 	if debugInstr {
 		log.Printf("ChangeType %v, %v\n", t.RawType(), x.impl)
 	}
-	if t.kind == vkClosure && x.kind == vkFuncDecl {
-		ret.impl = checkExpr(x, t.raw.Type.Underlying(), b).impl
+	if t.kind == vkClosure {
+		switch x.kind {
+		case vkFuncDecl:
+			ret.impl = checkExpr(x, t.raw.Type, b).impl
+		case vkClosure:
+			// TODO(xsw): change type should be a noop instruction
+			convType := func() Expr {
+				r := Expr{llvm.CreateAlloca(b.impl, t.ll), b.Prog.Pointer(t)}
+				b.Store(r, x)
+				return b.Load(r)
+			}
+			switch t.RawType().(type) {
+			case *types.Named:
+				if _, ok := x.RawType().(*types.Struct); ok {
+					return convType()
+				}
+			case *types.Struct:
+				if _, ok := x.RawType().(*types.Named); ok {
+					return convType()
+				}
+			}
+			fallthrough
+		default:
+			ret.impl = x.impl
+		}
 	} else {
 		ret.impl = x.impl
 	}
@@ -996,6 +1019,22 @@ func (b Builder) Do(da DoAction, fn Expr, args ...Expr) (ret Expr) {
 	return
 }

+// compareSelect performs a series of comparisons and selections based on the
+// given comparison op. It's used to implement operations like min and max.
+//
+// The function iterates through the provided expressions, comparing each with
+// the current result using the specified comparison op. It selects the
+// appropriate value based on the comparison.
+func (b Builder) compareSelect(op token.Token, x Expr, y ...Expr) Expr {
+	ret := x
+	for _, v := range y {
+		cond := b.BinOp(op, ret, v)
+		sel := llvm.CreateSelect(b.impl, cond.impl, ret.impl, v.impl)
+		ret = Expr{sel, ret.Type}
+	}
+	return ret
+}
+
 // A Builtin represents a specific use of a built-in function, e.g. len.
 //
 // Builtins are immutable values.  Builtins do not have addresses.
@@ -1106,6 +1145,14 @@ func (b Builder) BuiltinCall(fn string, args ...Expr) (ret Expr) {
 			b.Call(b.Pkg.rtFunc("MapClear"), t, m)
 			return
 		}
+	case "min":
+		if len(args) > 0 {
+			return b.compareSelect(token.LSS, args[0], args[1:]...)
+		}
+	case "max":
+		if len(args) > 0 {
+			return b.compareSelect(token.GTR, args[0], args[1:]...)
+		}
 	}
 	panic("todo: " + fn)
 }
@@ -1177,7 +1224,7 @@ func (b Builder) PrintEx(ln bool, args ...Expr) (ret Expr) {
 // -----------------------------------------------------------------------------

 func checkExpr(v Expr, t types.Type, b Builder) Expr {
-	if t, ok := t.(*types.Struct); ok && isClosure(t) {
+	if st, ok := t.Underlying().(*types.Struct); ok && isClosure(st) {
 		if v.kind != vkClosure {
 			return b.Pkg.closureStub(b, t, v)
 		}
--- a/ssa/package.go
+++ b/ssa/package.go
@@ -19,6 +19,7 @@ package ssa
 import (
 	"go/token"
 	"go/types"
+	"runtime"
 	"strconv"
 	"unsafe"

@@ -240,7 +241,10 @@ type Program = *aProgram
 // NewProgram creates a new program.
 func NewProgram(target *Target) Program {
 	if target == nil {
-		target = &Target{}
+		target = &Target{
+			GOOS:   runtime.GOOS,
+			GOARCH: runtime.GOARCH,
+		}
 	}
 	ctx := llvm.NewContext()
 	td := target.targetData() // TODO(xsw): target config
@@ -653,7 +657,7 @@ const (
 	closureStub = "__llgo_stub."
 )

-func (p Package) closureStub(b Builder, t *types.Struct, v Expr) Expr {
+func (p Package) closureStub(b Builder, t types.Type, v Expr) Expr {
 	name := v.impl.Name()
 	prog := b.Prog
 	nilVal := prog.Nil(prog.VoidPtr()).impl
--- a/ssa/ssa_test.go
+++ b/ssa/ssa_test.go
@@ -521,3 +521,34 @@ func TestBasicType(t *testing.T) {
 		}
 	}
 }
+
+func TestCompareSelect(t *testing.T) {
+	prog := NewProgram(nil)
+	pkg := prog.NewPackage("bar", "foo/bar")
+
+	params := types.NewTuple(
+		types.NewVar(0, nil, "a", types.Typ[types.Int]),
+		types.NewVar(0, nil, "b", types.Typ[types.Int]),
+		types.NewVar(0, nil, "c", types.Typ[types.Int]),
+	)
+	rets := types.NewTuple(types.NewVar(0, nil, "", types.Typ[types.Int]))
+	sig := types.NewSignatureType(nil, nil, nil, params, rets, false)
+	fn := pkg.NewFunc("fn", sig, InGo)
+
+	b := fn.MakeBody(1)
+	result := b.compareSelect(token.GTR, fn.Param(0), fn.Param(1), fn.Param(2))
+	b.Return(result)
+
+	assertPkg(t, pkg, `; ModuleID = 'foo/bar'
+source_filename = "foo/bar"
+
+define i64 @fn(i64 %0, i64 %1, i64 %2) {
+_llgo_0:
+  %3 = icmp sgt i64 %0, %1
+  %4 = select i1 %3, i64 %0, i64 %1
+  %5 = icmp sgt i64 %4, %2
+  %6 = select i1 %5, i64 %4, i64 %2
+  ret i64 %6
+}
+`)
+}