Merge pull request #666 from cpunion/async-functions

Async functions

README.md

@@ -312,9 +312,7 @@ Here are the Go packages that can be imported correctly:
 * [crypto/sha1](https://pkg.go.dev/crypto/sha1)
 * [crypto/sha256](https://pkg.go.dev/crypto/sha256)
 * [crypto/sha512](https://pkg.go.dev/crypto/sha512) (partially)
-* [crypto/hmac](https://pkg.go.dev/crypto/hmac) (partially)
 * [crypto/rand](https://pkg.go.dev/crypto/rand) (partially)
-* [crypto/subtle](https://pkg.go.dev/crypto/subtle) (partially)
 * [regexp](https://pkg.go.dev/regexp)
 * [regexp/syntax](https://pkg.go.dev/regexp/syntax)
 * [go/token](https://pkg.go.dev/go/token)

_cmptest/bigintdemo/fib.go

@@ -5,7 +5,7 @@ import (
 	"math/big"
 )
 
-func fib() {
+func main() {
 	// Initialize two big ints with the first two numbers in the sequence.
 	a := big.NewInt(0)
 	b := big.NewInt(1)
@@ -23,41 +23,3 @@ func fib() {
 	}
 	fmt.Println(a) // 100-digit Fibonacci number
 }
-
-func abs() {
-	a := big.NewInt(64)
-	b := big.NewInt(-52)
-	a.Set(b)
-	a.Abs(a)
-	a.Set(big.NewInt(-164))
-	a.Abs(a)
-	fmt.Println("value: ", a.String())
-}
-
-func neg() {
-	fmt.Println("value: ", big.NewInt(-64).Neg(big.NewInt(-64)))
-	fmt.Println("value: ", big.NewInt(64).Neg(big.NewInt(64)))
-	fmt.Println("value: ", big.NewInt(0).Neg(big.NewInt(0)))
-}
-
-func calc() {
-	a := big.NewInt(64)
-	b := big.NewInt(-52)
-	c := big.NewInt(54)
-	fmt.Println("value:", a.Add(a, b))
-	fmt.Println("value:", a.Sub(b, c))
-	d := big.NewInt(10)
-	e := big.NewInt(4)
-	fmt.Println("value:", d.Mul(d, e))
-}
-
-func bitop() {
-	a := big.NewInt(4)
-	fmt.Println("value:", a.Lsh(a, 1))
-	b := big.NewInt(16)
-	fmt.Println("value:", b.Rsh(b, 2))
-}
-
-func main() {
-	bitop()
-}

_cmptest/hmacdemo/hmac.go

@@ -1,15 +0,0 @@
-package main
-
-import (
-	"crypto/hmac"
-	"crypto/sha1"
-	"fmt"
-	"io"
-)
-
-func main() {
-	h := hmac.New(sha1.New, []byte("<key>"))
-	io.WriteString(h, "The fog is getting thicker!")
-	io.WriteString(h, "And Leon's getting laaarger!")
-	fmt.Printf("%x", h.Sum(nil))
-}

c/c.go

@@ -79,9 +79,6 @@ func AllocaNew[T any]() *T { return nil }
 //go:linkname Malloc C.malloc
 func Malloc(size uintptr) Pointer
 
-//go:linkname Calloc C.calloc
-func Calloc(num uintptr, size uintptr) Pointer
-
 //go:linkname Free C.free
 func Free(ptr Pointer)
 

c/clang/_demo/castdump/astdump.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/clang"
+)
+
+func visit(cursor, parent clang.Cursor, clientData c.Pointer) clang.ChildVisitResult {
+	depth := *(*c.Uint)(clientData)
+	printAST(cursor, depth+1)
+	return clang.ChildVisit_Continue
+}
+
+func printAST(cursor clang.Cursor, depth c.Uint) {
+	cursorKind := cursor.Kind.String()
+
+	cursorSpelling := cursor.String()
+
+	for i := c.Uint(0); i < depth; i++ {
+		c.Fputs(c.Str("  "), c.Stdout)
+	}
+
+	c.Printf(c.Str("%s: %s\n"), cursorKind.CStr(), cursorSpelling.CStr())
+
+	cursorKind.Dispose()
+	cursorSpelling.Dispose()
+
+	clang.VisitChildren(cursor, visit, c.Pointer(&depth))
+}
+
+func main() {
+	if c.Argc != 2 {
+		fmt.Fprintln(os.Stderr, "Usage: castdump <headerFile>")
+		return
+	}
+	sourceFile := *c.Advance(c.Argv, 1)
+
+	index := clang.CreateIndex(0, 0)
+
+	unit := index.ParseTranslationUnit(
+		sourceFile,
+		nil, 0,
+		nil, 0,
+		clang.TranslationUnit_None,
+	)
+
+	if unit == nil {
+		println("Unable to parse translation unit. Quitting.")
+		c.Exit(1)
+	}
+
+	cursor := unit.Cursor()
+
+	printAST(cursor, 0)
+
+	unit.Dispose()
+	index.Dispose()
+}

c/clang/_demo/symboldump/symboldump.go

@@ -80,7 +80,7 @@ func printFuncInfo(cursor clang.Cursor) {
 	}
 	c.Printf(c.Str("%s\n"), cursorStr.CStr())
 
-	if cursor.Kind == clang.CursorCXXMethod || cursor.Kind == clang.CursorFunctionDecl {
+	if cursor.Kind == clang.CXXMethod || cursor.Kind == clang.FunctionDecl {
 		c.Printf(c.Str("symbol:%s\n"), symbol.CStr())
 
 		typeStr := cursor.ResultType().String()
@@ -107,19 +107,19 @@ func printFuncInfo(cursor clang.Cursor) {
 }
 
 func visit(cursor, parent clang.Cursor, clientData c.Pointer) clang.ChildVisitResult {
-	if cursor.Kind == clang.CursorMacroDefinition {
+	if cursor.Kind == clang.MacroDefinition {
 		printMarcoInfo(cursor)
-	} else if cursor.Kind == clang.CursorNamespace {
+	} else if cursor.Kind == clang.Namespace {
 		nameStr := cursor.String()
 		context.setNamespaceName(c.GoString(nameStr.CStr()))
 		clang.VisitChildren(cursor, visit, nil)
 		context.setNamespaceName("")
-	} else if cursor.Kind == clang.CursorClassDecl {
+	} else if cursor.Kind == clang.ClassDecl {
 		nameStr := cursor.String()
 		context.setClassName(c.GoString(nameStr.CStr()))
 		clang.VisitChildren(cursor, visit, nil)
 		context.setClassName("")
-	} else if cursor.Kind == clang.CursorCXXMethod || cursor.Kind == clang.CursorFunctionDecl {
+	} else if cursor.Kind == clang.CXXMethod || cursor.Kind == clang.FunctionDecl {
 		printFuncInfo(cursor)
 	}
 

c/clang/_wrap/cursor.cpp

@@ -33,24 +33,6 @@ void wrap_clang_getCursorType(CXCursor *cur, CXType *typ) { *typ = clang_getCurs
 
 void wrap_clang_getCursorResultType(CXCursor *cur, CXType *typ) { *typ = clang_getCursorResultType(*cur); }
 
-void wrap_clang_getResultType(CXType *typ, CXType *resultTyp) { *resultTyp = clang_getResultType(*typ); }
-
-int wrap_clang_getNumArgTypes(CXType *typ) { return clang_getNumArgTypes(*typ); }
-
-void wrap_clang_getArgType(CXType *typ, unsigned i, CXType *argTyp) { *argTyp = clang_getArgType(*typ, i); }
-
-long long wrap_clang_getEnumConstantDeclValue(CXCursor *cur) { return clang_getEnumConstantDeclValue(*cur); }
-
-void wrap_clang_getPointeeType(CXType *pointerTyp, CXType *pointeeTyp) {
-    *pointeeTyp = clang_getPointeeType(*pointerTyp);
-}
-
-void wrap_clang_getArrayElementType(CXType *arrayTyp, CXType *elemTyp) {
-    *elemTyp = clang_getArrayElementType(*arrayTyp);
-}
-
-void wrap_clang_getCanonicalType(CXType *typ, CXType *canonicalType) { *canonicalType = clang_getCanonicalType(*typ); }
-
 CXString wrap_clang_getTypeSpelling(CXType *typ) { return clang_getTypeSpelling(*typ); }
 
 CXString wrap_clang_getTokenSpelling(CXTranslationUnit unit, CXToken *token) {
@@ -64,10 +46,6 @@ void wrap_clang_getSpellingLocation(CXSourceLocation *loc, CXFile *file, unsigne
     clang_getSpellingLocation(*loc, file, line, column, offset);
 }
 
-enum CX_CXXAccessSpecifier wrap_clang_getCXXAccessSpecifier(CXCursor *cursor) {
-    return clang_getCXXAccessSpecifier(*cursor);
-}
-
 void wrap_clang_getCursorExtent(CXCursor *cur, CXSourceRange *range) { *range = clang_getCursorExtent(*cur); }
 
 void wrap_clang_tokenize(CXTranslationUnit unit, CXSourceRange *Range, CXToken **Tokens, unsigned *NumTokens) {

c/libuv/_demo/async/async.go

@@ -1,41 +0,0 @@
-package main
-
-import (
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/libuv"
-)
-
-func ensure(b bool, msg string) {
-	if !b {
-		panic(msg)
-	}
-}
-
-func main() {
-	loop := libuv.LoopNew()
-	defer loop.Close()
-
-	a := &libuv.Async{}
-	r := loop.Async(a, func(a *libuv.Async) {
-		println("async callback")
-		a.Close(nil) // or loop.Stop()
-	})
-	ensure(r == 0, "Async failed")
-
-	go func() {
-		println("begin async task")
-		c.Usleep(100 * 1000)
-		println("send async event")
-		ensure(a.Send() == 0, "Send failed")
-	}()
-
-	loop.Run(libuv.RUN_DEFAULT)
-	println("done")
-}
-
-/*Expected Output:
-begin async task
-send async event
-async callback
-done
-*/

c/libuv/_demo/async_fs/async_fs.go

@@ -31,7 +31,7 @@ func main() {
 	libuv.FsOpen(loop, &openReq, c.Str("example.txt"), os.O_RDONLY, 0, onOpen)
 
 	// Run the loop
-	result := loop.Run(libuv.RUN_DEFAULT)
+	result := libuv.Run(loop, libuv.RUN_DEFAULT)
 
 	if result != 0 {
 		c.Fprintf(c.Stderr, c.Str("Error in Run: %s\n"), libuv.Strerror(libuv.Errno(result)))
@@ -43,14 +43,14 @@ func main() {
 
 func onOpen(req *libuv.Fs) {
 	// Check for errors
-	if req.GetResult() < 0 {
-		c.Fprintf(c.Stderr, c.Str("Error opening file: %s\n"), libuv.Strerror(libuv.Errno(req.GetResult())))
-		loop.Close()
+	if libuv.FsGetResult(req) < 0 {
+		c.Fprintf(c.Stderr, c.Str("Error opening file: %s\n"), libuv.Strerror(libuv.Errno(libuv.FsGetResult(req))))
+		libuv.LoopClose(loop)
 		return
 	}
 
 	// Store the file descriptor
-	file = libuv.File(req.GetResult())
+	file = libuv.File(libuv.FsGetResult(req))
 
 	// Init buffer
 	iov = libuv.InitBuf((*c.Char)(unsafe.Pointer(&buffer[0])), c.Uint(unsafe.Sizeof(buffer)))
@@ -68,28 +68,28 @@ func readFile() {
 	readRes := libuv.FsRead(loop, &readReq, file, &iov, 1, -1, onRead)
 	if readRes != 0 {
 		c.Printf(c.Str("Error in FsRead: %s (code: %d)\n"), libuv.Strerror(libuv.Errno(readRes)), readRes)
-		readReq.ReqCleanup()
-		loop.Close()
+		libuv.FsReqCleanup(&readReq)
+		libuv.LoopClose(loop)
 	}
 }
 
 func onRead(req *libuv.Fs) {
 	// Cleanup the request
-	defer req.ReqCleanup()
+	defer libuv.FsReqCleanup(req)
 	// Check for errors
-	if req.GetResult() < 0 {
-		c.Fprintf(c.Stderr, c.Str("Read error: %s\n"), libuv.Strerror(libuv.Errno(req.GetResult())))
-	} else if req.GetResult() == 0 {
+	if libuv.FsGetResult(req) < 0 {
+		c.Fprintf(c.Stderr, c.Str("Read error: %s\n"), libuv.Strerror(libuv.Errno(libuv.FsGetResult(req))))
+	} else if libuv.FsGetResult(req) == 0 {
 		// Close the file
-		closeRes := libuv.FsClose(loop, &closeReq, libuv.File(openReq.GetResult()), onClose)
+		closeRes := libuv.FsClose(loop, &closeReq, libuv.File(libuv.FsGetResult(&openReq)), onClose)
 		if closeRes != 0 {
 			c.Printf(c.Str("Error in FsClose: %s (code: %d)\n"), libuv.Strerror(libuv.Errno(closeRes)), closeRes)
-			loop.Close()
+			libuv.LoopClose(loop)
 			return
 		}
 	} else {
-		c.Printf(c.Str("Read %d bytes\n"), req.GetResult())
-		c.Printf(c.Str("Read content: %.*s\n"), req.GetResult(), (*c.Char)(unsafe.Pointer(&buffer[0])))
+		c.Printf(c.Str("Read %d bytes\n"), libuv.FsGetResult(req))
+		c.Printf(c.Str("Read content: %.*s\n"), libuv.FsGetResult(req), (*c.Char)(unsafe.Pointer(&buffer[0])))
 		// Read the file again
 		readFile()
 	}
@@ -97,8 +97,8 @@ func onRead(req *libuv.Fs) {
 
 func onClose(req *libuv.Fs) {
 	// Check for errors
-	if req.GetResult() < 0 {
-		c.Fprintf(c.Stderr, c.Str("Error closing file: %s\n"), libuv.Strerror(libuv.Errno(req.GetResult())))
+	if libuv.FsGetResult(req) < 0 {
+		c.Fprintf(c.Stderr, c.Str("Error closing file: %s\n"), libuv.Strerror(libuv.Errno(libuv.FsGetResult(req))))
 	} else {
 		c.Printf(c.Str("\nFile closed successfully.\n"))
 	}
@@ -106,10 +106,10 @@ func onClose(req *libuv.Fs) {
 
 func cleanup() {
 	// Cleanup the requests
-	openReq.ReqCleanup()
-	closeReq.ReqCleanup()
+	libuv.FsReqCleanup(&openReq)
+	libuv.FsReqCleanup(&closeReq)
 	// Close the loop
-	result := loop.Close()
+	result := libuv.LoopClose(loop)
 	if result != 0 {
 		c.Fprintf(c.Stderr, c.Str("Error in LoopClose: %s\n"), libuv.Strerror(libuv.Errno(result)))
 	}

c/libuv/_demo/echo_server/echo_server.go

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"unsafe"
+
 	"github.com/goplus/llgo/c"
 	"github.com/goplus/llgo/c/libuv"
 	"github.com/goplus/llgo/c/net"
@@ -9,18 +11,18 @@ import (
 var DEFAULT_PORT c.Int = 8080
 var DEFAULT_BACKLOG c.Int = 128
 
-var (
-	Req *libuv.Write
+type WriteReq struct {
+	Req libuv.Write
 	Buf libuv.Buf
-)
+}
 
 func main() {
 	// Initialize the default event loop
 	var loop = libuv.DefaultLoop()
 
 	// Initialize a TCP server
-	server := &libuv.Tcp{}
-	libuv.InitTcp(loop, server)
+	var server libuv.Tcp
+	libuv.InitTcp(loop, &server)
 
 	// Set up the address to bind the server to
 	var addr net.SockaddrIn
@@ -28,20 +30,22 @@ func main() {
 	c.Printf(c.Str("Listening on %s:%d\n"), c.Str("0.0.0.0"), DEFAULT_PORT)
 
 	// Bind the server to the specified address and port
-	server.Bind((*net.SockAddr)(c.Pointer(&addr)), 0)
-	res := (*libuv.Stream)(server).Listen(DEFAULT_BACKLOG, OnNewConnection)
+	(&server).Bind((*net.SockAddr)(c.Pointer(&addr)), 0)
+	res := (*libuv.Stream)(&server).Listen(DEFAULT_BACKLOG, OnNewConnection)
 	if res != 0 {
-		c.Fprintf(c.Stderr, c.Str("Listen error: %s\n"), libuv.Strerror(libuv.Errno(res)))
+		c.Fprintf(c.Stderr, c.Str("Listen error: %s\n"), libuv.Strerror((libuv.Errno(res))))
 		return
 	}
 
 	// Start listening for incoming connections
-	loop.Run(libuv.RUN_DEFAULT)
+	libuv.Run(loop, libuv.RUN_DEFAULT)
 }
 
-func FreeWriteReq() {
-	// Free the buffer base.
-	c.Free(c.Pointer(Buf.Base))
+func FreeWriteReq(req *libuv.Write) {
+	wr := (*WriteReq)(c.Pointer(req))
+	// Free the buffer base and the WriteReq itself.
+	c.Free(c.Pointer(wr.Buf.Base))
+	c.Free(c.Pointer(wr))
 }
 
 func AllocBuffer(handle *libuv.Handle, suggestedSize uintptr, buf *libuv.Buf) {
@@ -52,24 +56,29 @@ func AllocBuffer(handle *libuv.Handle, suggestedSize uintptr, buf *libuv.Buf) {
 
 func EchoWrite(req *libuv.Write, status c.Int) {
 	if status != 0 {
-		c.Fprintf(c.Stderr, c.Str("Write error: %s\n"), libuv.Strerror(libuv.Errno(status)))
+		c.Fprintf(c.Stderr, c.Str("Write error: %s\n"), libuv.Strerror((libuv.Errno(status))))
 	}
-	FreeWriteReq()
+	FreeWriteReq(req)
 }
 
 func EchoRead(client *libuv.Stream, nread c.Long, buf *libuv.Buf) {
 	if nread > 0 {
+		req := (*WriteReq)(c.Malloc(unsafe.Sizeof(WriteReq{})))
+		if req == nil {
+			c.Fprintf(c.Stderr, c.Str("Failed to allocate memory for write request\n"))
+			c.Free(c.Pointer(buf.Base))
+			return
+		}
 		// Initialize the buffer with the data read.
-		Buf = libuv.InitBuf(buf.Base, c.Uint(nread))
+		req.Buf = libuv.InitBuf(buf.Base, c.Uint(nread))
 		// Write the data back to the client.
-		Req = &libuv.Write{}
-		Req.Write(client, &Buf, 1, EchoWrite)
+		(&req.Req).Write(client, &req.Buf, 1, EchoWrite)
 		return
 	}
 	if nread < 0 {
 		// Handle read errors and EOF.
 		if (libuv.Errno)(nread) != libuv.EOF {
-			c.Fprintf(c.Stderr, c.Str("Read error: %s\n"), libuv.Strerror(libuv.Errno(nread)))
+			c.Fprintf(c.Stderr, c.Str("Read error: %s\n"), libuv.Strerror((libuv.Errno)(nread)))
 		}
 		(*libuv.Handle)(c.Pointer(client)).Close(nil)
 	}
@@ -86,7 +95,7 @@ func OnNewConnection(server *libuv.Stream, status c.Int) {
 	}
 
 	// Allocate memory for a new client.
-	client := &libuv.Tcp{}
+	client := (*libuv.Tcp)(c.Malloc(unsafe.Sizeof(libuv.Tcp{})))
 
 	if client == nil {
 		c.Fprintf(c.Stderr, c.Str("Failed to allocate memory for client\n"))

c/libuv/_wrap/libuv.c

@@ -1,5 +0,0 @@
-#include <uv.h>
-
-int uv_tcp_get_io_watcher_fd (uv_tcp_t* handle) {
-  return handle->io_watcher.fd;
-}

c/libuv/async.go

@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package libuv
-
-import (
-	_ "unsafe"
-
-	"github.com/goplus/llgo/c"
-)
-
-// struct uv_async_t
-type Async struct {
-	Handle
-	// On macOS arm64, sizeof uv_async_t is 128 bytes.
-	// Handle is 92 bytes, so we need 36 bytes to fill the gap.
-	// Maybe reserve more for future use.
-	Unused [36]byte
-}
-
-// typedef void (*uv_async_cb)(uv_async_t* handle);
-// llgo:type C
-type AsyncCb func(*Async)
-
-// int uv_async_init(uv_loop_t*, uv_async_t* async, uv_async_cb async_cb);
-//
-// llgo:link (*Loop).Async C.uv_async_init
-func (loop *Loop) Async(a *Async, cb AsyncCb) c.Int {
-	return 0
-}
-
-// int uv_async_send(uv_async_t* async);
-//
-// llgo:link (*Async).Send C.uv_async_send
-func (a *Async) Send() c.Int {
-	return 0
-}

c/libuv/fs.go

@@ -106,40 +106,29 @@ type FsPollCb func(handle *FsPoll, status c.Int, events c.Int)
 
 /* Fs related function and method */
 
-// llgo:link (*Fs).GetType C.uv_fs_get_type
-func (req *Fs) GetType() FsType {
-	return 0
-}
+//go:linkname FsGetType C.uv_fs_get_type
+func FsGetType(req *Fs) FsType
 
-// llgo:link (*Fs).GetPath C.uv_fs_get_path
-func (req *Fs) GetPath() *c.Char {
-	return nil
-}
+//go:linkname FsGetPath C.uv_fs_get_path
+func FsGetPath(req *Fs) *c.Char
 
-// llgo:link (*Fs).GetResult C.uv_fs_get_result
-func (req *Fs) GetResult() c.Int {
-	return 0
-}
+//go:linkname FsGetResult C.uv_fs_get_result
+func FsGetResult(req *Fs) c.Int
 
-// llgo:link (*Fs).GetPtr C.uv_fs_get_ptr
-func (req *Fs) GetPtr() c.Pointer {
-	return nil
-}
+//go:linkname FsGetPtr C.uv_fs_get_ptr
+func FsGetPtr(req *Fs) c.Pointer
 
-// llgo:link (*Fs).GetSystemError C.uv_fs_get_system_error
-func (req *Fs) GetSystemError() c.Int {
-	return 0
-}
+//go:linkname FsGetSystemError C.uv_fs_get_system_error
+func FsGetSystemError(req *Fs) c.Int
 
-// llgo:link (*Fs).GetStatBuf C.uv_fs_get_statbuf
-func (req *Fs) GetStatBuf() *Stat {
-	return nil
-}
+//go:linkname FsGetStatBuf C.uv_fs_get_statbuf
+func FsGetStatBuf(req *Fs) *Stat
 
-// llgo:link (*Fs).ReqCleanup C.uv_fs_req_cleanup
-func (req *Fs) ReqCleanup() {
-	// No return value needed for this method
-}
+//go:linkname FsReqCleanup C.uv_fs_req_cleanup
+func FsReqCleanup(req *Fs)
+
+//go:linkname DefaultLoop C.uv_default_loop
+func DefaultLoop() *Loop
 
 //go:linkname FsOpen C.uv_fs_open
 func FsOpen(loop *Loop, req *Fs, path *c.Char, flags c.Int, mode c.Int, cb FsCb) c.Int
@@ -252,56 +241,32 @@ func FsLchown(loop *Loop, req *Fs, path *c.Char, uid c.Int, gid c.Int, cb FsCb)
 //go:linkname FsLstat C.uv_fs_lstat
 func FsLstat(loop *Loop, req *Fs, path *c.Char, cb FsCb) c.Int
 
-// ----------------------------------------------
-
-/* FsEvent related function and method */
-
 //go:linkname FsEventInit C.uv_fs_event_init
 func FsEventInit(loop *Loop, handle *FsEvent) c.Int
 
-// llgo:link (*FsEvent).Start C.uv_fs_event_start
-func (handle *FsEvent) Start(cb FsEventCb, path *c.Char, flags c.Int) c.Int {
-	return 0
-}
+//go:linkname FsEventStart C.uv_fs_event_start
+func FsEventStart(handle *FsEvent, cb FsEventCb, path *c.Char, flags c.Int) c.Int
 
-// llgo:link (*FsEvent).Stop C.uv_fs_event_stop
-func (handle *FsEvent) Stop() c.Int {
-	return 0
-}
+//go:linkname FsEventStop C.uv_fs_event_stop
+func FsEventStop(handle *FsEvent) c.Int
 
-// llgo:link (*FsEvent).Close C.uv_fs_event_close
-func (handle *FsEvent) Close() c.Int {
-	return 0
-}
+//go:linkname FsEventClose C.uv_fs_event_close
+func FsEventClose(handle *FsEvent) c.Int
 
-// llgo:link (*FsEvent).Getpath C.uv_fs_event_getpath
-func (handle *FsEvent) Getpath() *c.Char {
-	return nil
-}
-
-// ----------------------------------------------
-
-/* FsPoll related function and method */
+//go:linkname FsEventGetpath C.uv_fs_event_getpath
+func FsEventGetpath(handle *FsEvent) *c.Char
 
 //go:linkname FsPollInit C.uv_fs_poll_init
 func FsPollInit(loop *Loop, handle *FsPoll) c.Int
 
-// llgo:link (*FsPoll).Start C.uv_fs_poll_start
-func (handle *FsPoll) Start(cb FsPollCb, path *c.Char, interval uint) c.Int {
-	return 0
-}
+//go:linkname FsPollStart C.uv_fs_poll_start
+func FsPollStart(handle *FsPoll, cb FsPollCb, path *c.Char, interval uint) c.Int
 
-// llgo:link (*FsPoll).Stop C.uv_fs_poll_stop
-func (handle *FsPoll) Stop() c.Int {
-	return 0
-}
+//go:linkname FsPollStop C.uv_fs_poll_stop
+func FsPollStop(handle *FsPoll) c.Int
 
-// llgo:link (*FsPoll).Close C.uv_fs_poll_close
-func (handle *FsPoll) Close() c.Int {
-	return 0
-}
+//go:linkname FsPollClose C.uv_fs_poll_close
+func FsPollClose(handle *FsPoll) c.Int
 
-// llgo:link (*FsPoll).GetPath C.uv_fs_poll_getpath
-func (handle *FsPoll) GetPath() *c.Char {
-	return nil
-}
+//go:linkname FsPollGetPath C.uv_fs_poll_getpath
+func FsPollGetPath(handle *FsPoll) *c.Char

c/libuv/libuv.go

@@ -9,7 +9,6 @@ import (
 
 const (
 	LLGoPackage = "link: $(pkg-config --libs libuv); -luv"
-	LLGoFiles   = "$(pkg-config --cflags libuv): _wrap/libuv.c"
 )
 
 // ----------------------------------------------
@@ -104,6 +103,10 @@ type Poll struct {
 
 /* Request types. */
 
+type Shutdown struct {
+	Unused [0]byte
+}
+
 type Buf struct {
 	Base *c.Char
 	Len  uintptr
@@ -132,6 +135,9 @@ type GetaddrinfoCb func(req *GetAddrInfo, status c.Int, res *net.AddrInfo)
 // llgo:type C
 type GetnameinfoCb func(req *GetNameInfo, status c.Int, hostname *c.Char, service *c.Char)
 
+// llgo:type C
+type ShutdownCb func(req *Shutdown, status c.Int)
+
 // llgo:type C
 type WalkCb func(handle *Handle, arg c.Pointer)
 
@@ -154,88 +160,59 @@ func ReplaceAllocator(mallocFunc MallocFunc, reallocFunc ReallocFunc, callocFunc
 
 // ----------------------------------------------
 
-/* Loop related functions and method. */
+// llgo:link (*Shutdown).Shutdown C.uv_shutdown
+func (shutdown *Shutdown) Shutdown(stream *Stream, shutdownCb ShutdownCb) c.Int {
+	return 0
+}
 
-//go:linkname DefaultLoop C.uv_default_loop
-func DefaultLoop() *Loop
+// ----------------------------------------------
+
+/* Loop related functions and method. */
 
 //go:linkname LoopSize C.uv_loop_size
 func LoopSize() uintptr
 
-// llgo:link (*Loop).Run C.uv_run
-func (loop *Loop) Run(mode RunMode) c.Int {
-	return 0
-}
+//go:linkname Run C.uv_run
+func Run(loop *Loop, mode RunMode) c.Int
 
-// llgo:link (*Loop).Alive C.uv_loop_alive
-func (loop *Loop) Alive() c.Int {
-	return 0
-}
+//go:linkname LoopAlive C.uv_loop_alive
+func LoopAlive(loop *Loop) c.Int
 
-// void uv_stop(uv_loop_t *loop)
-//
-// llgo:link (*Loop).Stop C.uv_stop
-func (loop *Loop) Stop() {}
+//go:linkname LoopClose C.uv_loop_close
+func LoopClose(loop *Loop) c.Int
 
-// llgo:link (*Loop).Close C.uv_loop_close
-func (loop *Loop) Close() c.Int {
-	return 0
-}
+//go:linkname LoopConfigure C.uv_loop_configure
+func LoopConfigure(loop *Loop, option LoopOption, arg c.Int) c.Int
 
-// llgo:link (*Loop).Configure C.uv_loop_configure
-func (loop *Loop) Configure(option LoopOption, arg c.Int) c.Int {
-	return 0
-}
+//go:linkname LoopDefault C.uv_default_loop
+func LoopDefault() *Loop
 
-// llgo:link LoopDefault C.uv_default_loop
-func LoopDefault() *Loop {
-	return nil
-}
+//go:linkname LoopDelete C.uv_loop_delete
+func LoopDelete(loop *Loop) c.Int
 
-// llgo:link (*Loop).Delete C.uv_loop_delete
-func (loop *Loop) Delete() c.Int {
-	return 0
-}
+//go:linkname LoopFork C.uv_loop_fork
+func LoopFork(loop *Loop) c.Int
 
-// llgo:link (*Loop).Fork C.uv_loop_fork
-func (loop *Loop) Fork() c.Int {
-	return 0
-}
+//go:linkname LoopInit C.uv_loop_init
+func LoopInit(loop *Loop) c.Int
 
-// llgo:link (*Loop).Init C.uv_loop_init
-func (loop *Loop) Init() c.Int {
-	return 0
-}
+//go:linkname LoopNew C.uv_loop_new
+func LoopNew() *Loop
 
-// llgo:link LoopNew C.uv_loop_new
-func LoopNew() *Loop {
-	return nil
-}
+//go:linkname LoopNow C.uv_now
+func LoopNow(loop *Loop) c.UlongLong
 
-// llgo:link (*Loop).Now C.uv_now
-func (loop *Loop) Now() c.UlongLong {
-	return 0
-}
+//go:linkname LoopUpdateTime C.uv_update_time
+func LoopUpdateTime(loop *Loop)
 
-// llgo:link (*Loop).UpdateTime C.uv_update_time
-func (loop *Loop) UpdateTime() {
-	// No return value needed for this method
-}
+//go:linkname LoopBackendFd C.uv_backend_fd
+func LoopBackendFd(loop *Loop) c.Int
 
-// llgo:link (*Loop).BackendFd C.uv_backend_fd
-func (loop *Loop) BackendFd() c.Int {
-	return 0
-}
+//go:linkname LoopBackendTimeout C.uv_backend_timeout
+func LoopBackendTimeout(loop *Loop) c.Int
 
-// llgo:link (*Loop).BackendTimeout C.uv_backend_timeout
-func (loop *Loop) BackendTimeout() c.Int {
-	return 0
-}
-
-// llgo:link (*Loop).Walk C.uv_walk
-func (loop *Loop) Walk(walkCb WalkCb, arg c.Pointer) {
-	// No return value needed for this method
-}
+//go:linkname LoopWalk C.uv_walk
+func LoopWalk(loop *Loop, walkCb WalkCb, arg c.Pointer)
 
 // ----------------------------------------------
 
@@ -251,15 +228,11 @@ func InitBuf(base *c.Char, len c.Uint) Buf
 //go:linkname PollInit C.uv_poll_init
 func PollInit(loop *Loop, handle *Poll, fd OsFd) c.Int
 
+//go:linkname PollStart C.uv_poll_start
+func PollStart(handle *Poll, events c.Int, cb PollCb) c.Int
+
+//go:linkname PollStop C.uv_poll_stop
+func PollStop(handle *Poll) c.Int
+
 //go:linkname PollInitSocket C.uv_poll_init_socket
 func PollInitSocket(loop *Loop, handle *Poll, socket c.Int) c.Int
-
-// llgo:link (*Poll).Start C.uv_poll_start
-func (handle *Poll) Start(events c.Int, cb PollCb) c.Int {
-	return 0
-}
-
-// llgo:link (*Poll).Stop C.uv_poll_stop
-func (handle *Poll) Stop() c.Int {
-	return 0
-}

c/libuv/net.go

@@ -117,10 +117,6 @@ type GetNameInfo struct {
 	Unused [0]byte
 }
 
-type Shutdown struct {
-	Unused [0]byte
-}
-
 // ----------------------------------------------
 
 /* Function type */
@@ -146,19 +142,10 @@ type WriteCb func(req *Write, status c.Int)
 // llgo:type C
 type ConnectionCb func(server *Stream, status c.Int)
 
-// llgo:type C
-type ShutdownCb func(req *Shutdown, status c.Int)
-
 // ----------------------------------------------
 
 /* Handle related function and method */
 
-//go:linkname HandleSize C.uv_handle_size
-func HandleSize(handleType HandleType) uintptr
-
-//go:linkname HandleTypeName C.uv_handle_type_name
-func HandleTypeName(handleType HandleType) *c.Char
-
 // llgo:link (*Handle).Ref C.uv_ref
 func (handle *Handle) Ref() {}
 
@@ -170,11 +157,17 @@ func (handle *Handle) HasRef() c.Int {
 	return 0
 }
 
+//go:linkname HandleSize C.uv_handle_size
+func HandleSize(handleType HandleType) uintptr
+
 // llgo:link (*Handle).GetType C.uv_handle_get_type
 func (handle *Handle) GetType() HandleType {
 	return 0
 }
 
+//go:linkname HandleTypeName C.uv_handle_type_name
+func HandleTypeName(handleType HandleType) *c.Char
+
 // llgo:link (*Handle).GetData C.uv_handle_get_data
 func (handle *Handle) GetData() c.Pointer {
 	return nil
@@ -211,21 +204,6 @@ func (handle *Handle) Fileno(fd *OsFd) c.Int {
 	return 0
 }
 
-// llgo:link (*Handle).IsClosing C.uv_is_closing
-func (handle *Handle) IsClosing() c.Int {
-	return 0
-}
-
-// llgo:link (*Handle).IsReadable C.uv_is_readable
-func (handle *Handle) IsReadable() c.Int {
-	return 0
-}
-
-// llgo:link (*Handle).IsWritable C.uv_is_writable
-func (handle *Handle) IsWritable() c.Int {
-	return 0
-}
-
 //go:linkname Pipe C.uv_pipe
 func Pipe(fds [2]File, readFlags c.Int, writeFlags c.Int) c.Int {
 	return 0
@@ -236,6 +214,11 @@ func Socketpair(_type c.Int, protocol c.Int, socketVector [2]OsSock, flag0 c.Int
 	return 0
 }
 
+// llgo:link (*Handle).IsClosing C.uv_is_closing
+func (handle *Handle) IsClosing() c.Int {
+	return 0
+}
+
 // ----------------------------------------------
 
 /* Req related function and method */
@@ -243,15 +226,12 @@ func Socketpair(_type c.Int, protocol c.Int, socketVector [2]OsSock, flag0 c.Int
 //go:linkname ReqSize C.uv_req_size
 func ReqSize(reqType ReqType) uintptr
 
-//go:linkname TypeName C.uv_req_type_name
-func TypeName(reqType ReqType) *c.Char
-
 // llgo:link (*Req).GetData C.uv_req_get_data
 func (req *Req) GetData() c.Pointer {
 	return nil
 }
 
-// llgo:link (*Req).SetData C.uv_req_set_data
+// llgo:link (*Req).SetData C.uv_handle_set_data
 func (req *Req) SetData(data c.Pointer) {}
 
 // llgo:link (*Req).GetType C.uv_req_get_type
@@ -259,6 +239,9 @@ func (req *Req) GetType() ReqType {
 	return 0
 }
 
+//go:linkname TypeName C.uv_req_type_name
+func TypeName(reqType ReqType) *c.Char
+
 // ----------------------------------------------
 
 /* Stream related function and method */
@@ -323,11 +306,6 @@ func (stream *Stream) SetBlocking(blocking c.Int) c.Int {
 	return 0
 }
 
-//go:linkname StreamShutdown C.uv_shutdown
-func StreamShutdown(shutdown *Shutdown, stream *Stream, shutdownCb ShutdownCb) c.Int {
-	return 0
-}
-
 // ----------------------------------------------
 
 /* Tcp related function and method */
@@ -378,11 +356,6 @@ func (tcp *Tcp) CloseReset(closeCb CloseCb) c.Int {
 	return 0
 }
 
-// llgo:link (*Tcp).GetIoWatcherFd C.uv_tcp_get_io_watcher_fd
-func (tcp *Tcp) GetIoWatcherFd() c.Int {
-	return 0
-}
-
 //go:linkname TcpConnect C.uv_tcp_connect
 func TcpConnect(req *Connect, tcp *Tcp, addr *net.SockAddr, connectCb ConnectCb) c.Int
 
@@ -456,6 +429,9 @@ func (udp *Udp) SetTTL(ttl c.Int) c.Int {
 	return 0
 }
 
+//go:linkname Send C.uv_udp_send
+func Send(req *UdpSend, udp *Udp, bufs *Buf, nbufs c.Uint, addr *net.SockAddr, sendCb UdpSendCb) c.Int
+
 // llgo:link (*Udp).TrySend C.uv_udp_try_send
 func (udp *Udp) TrySend(bufs *Buf, nbufs c.Uint, addr *net.SockAddr) c.Int {
 	return 0
@@ -486,13 +462,8 @@ func (udp *Udp) GetSendQueueCount() uintptr {
 	return 0
 }
 
-//go:linkname Send C.uv_udp_send
-func Send(req *UdpSend, udp *Udp, bufs *Buf, nbufs c.Uint, addr *net.SockAddr, sendCb UdpSendCb) c.Int
-
 // ----------------------------------------------
 
-/* DNS related function and method */
-
 //go:linkname Ip4Addr C.uv_ip4_addr
 func Ip4Addr(ip *c.Char, port c.Int, addr *net.SockaddrIn) c.Int
 

c/libuv/signal.go

@@ -26,17 +26,8 @@ type SignalCb func(handle *Signal, sigNum c.Int)
 //go:linkname SignalInit C.uv_signal_init
 func SignalInit(loop *Loop, handle *Signal) c.Int
 
-// llgo:link (*Signal).Start C.uv_signal_start
-func (handle *Signal) Start(cb SignalCb, signum c.Int) c.Int {
-	return 0
-}
+//go:linkname SignalStart C.uv_signal_start
+func SignalStart(handle *Signal, cb SignalCb, signum c.Int) c.Int
 
-// llgo:link (*Signal).StartOneshot C.uv_signal_start_oneshot
-func (handle *Signal) StartOneshot(cb SignalCb, signum c.Int) c.Int {
-	return 0
-}
-
-// llgo:link (*Signal).Stop C.uv_signal_stop
-func (handle *Signal) Stop() c.Int {
-	return 0
-}
+//go:linkname SignalStartOneshot C.uv_signal_start_oneshot
+func SignalStartOneshot(handle *Signal, cb SignalCb, signum c.Int) c.Int

c/net/net.go

@@ -17,7 +17,7 @@
 package net
 
 import (
-	"unsafe"
+	_ "unsafe"
 
 	"github.com/goplus/llgo/c"
 )
@@ -97,13 +97,6 @@ const (
 	EAI_OVERFLOW              /* argument buffer overflow */
 )
 
-const (
-	ALIGNSIZE = unsafe.Sizeof(c.LongLong(0))
-	MAXSIZE   = 128
-	PAD1_SIZE = ALIGNSIZE - unsafe.Sizeof(byte(0)) - unsafe.Sizeof(byte(0))
-	PAD2_SIZE = MAXSIZE - unsafe.Sizeof(byte(0)) - unsafe.Sizeof(byte(0)) - PAD1_SIZE - ALIGNSIZE
-)
-
 // (TODO) merge to inet
 const INET_ADDRSTRLEN = 16
 
@@ -124,14 +117,6 @@ type SockaddrIn6 struct {
 	ScopeId  c.Uint
 }
 
-type SockaddrStorage struct {
-	Len    uint8
-	Family uint8
-	pad1   [PAD1_SIZE]c.Char
-	align  c.LongLong
-	pad2   [PAD2_SIZE]c.Char
-}
-
 type InAddr struct {
 	Addr c.Uint
 }
@@ -186,9 +171,6 @@ func Send(c.Int, c.Pointer, uintptr, c.Int) c.Long
 //go:linkname Recv C.recv
 func Recv(c.Int, c.Pointer, uintptr, c.Int) c.Long
 
-//go:linkname SetSockOpt C.setsockopt
-func SetSockOpt(socket c.Int, level c.Int, optionName c.Int, optionValue c.Pointer, sockLen c.Uint) c.Int
-
 // -----------------------------------------------------------------------------
 
 type AddrInfo struct {
@@ -214,27 +196,8 @@ func swapInt16(data uint16) uint16 {
 	return (data << 8) | (data >> 8)
 }
 
-func swapInt32(data c.Uint) c.Uint {
-	return ((data & 0xff) << 24) |
-		((data & 0xff00) << 8) |
-		((data & 0xff0000) >> 8) |
-		((data & 0xff000000) >> 24)
-}
-
 func Htons(x uint16) uint16 {
 	return swapInt16(x)
 }
 
-func Ntohs(x uint16) uint16 {
-	return swapInt16(x)
-}
-
-func Htonl(x c.Uint) c.Uint {
-	return swapInt32(x)
-}
-
-func Ntohl(x c.Uint) c.Uint {
-	return swapInt32(x)
-}
-
 // -----------------------------------------------------------------------------

c/openssl/_demo/chmacdemo/hmac.go

@@ -21,6 +21,7 @@ func main() {
 		return
 	}
 	defer ctx.Free()
+
 	var ret c.Int = ctx.InitEx(unsafe.Pointer(unsafe.StringData(key)), c.Int(lenKey), openssl.EVP_sha256(), nil)
 	if ret == 0 {
 		c.Fprintf(c.Stderr, c.Str("%s\n"), c.Str("Error initializing HMAC_CTX"))
@@ -36,5 +37,9 @@ func main() {
 		c.Fprintf(c.Stderr, c.Str("%s\n"), c.Str("Error finalizing HMAC_CTX"))
 		return
 	}
-	fmt.Printf("HMAC:%x\n", digest[:digestLen])
+	fmt.Print("HMAC: ")
+	for i := 0; i < int(digestLen); i++ {
+		fmt.Printf("%02x", digest[i])
+	}
+	fmt.Print("\n")
 }

c/openssl/bn.go

@@ -49,19 +49,8 @@ func BN_CTXSecureNew() *BN_CTX
 func (*BN_CTX) Free() {}
 
 // void BN_CTX_start(BN_CTX *ctx);
-//
-// llgo:link (*BN_CTX).Start C.BN_CTX_start
-func (*BN_CTX) Start() {}
-
 // BIGNUM *BN_CTX_get(BN_CTX *ctx);
-//
-// llgo:link (*BN_CTX).Get C.BN_CTX_get
-func (*BN_CTX) Get() *BIGNUM { return nil }
-
 // void BN_CTX_end(BN_CTX *ctx);
-//
-// llgo:link (*BN_CTX).End C.BN_CTX_end
-func (*BN_CTX) End() {}
 
 // -----------------------------------------------------------------------------
 
@@ -202,80 +191,23 @@ func BNDec2bn(a **BIGNUM, str *c.Char) c.Int
 //go:linkname BNAsc2bn C.BN_asc2bn
 func BNAsc2bn(a **BIGNUM, str *c.Char) c.Int
 
-// BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
-//
-//go:linkname BNBin2bn C.BN_bin2bn
-func BNBin2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
-
-// BIGNUM *BN_signed_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
-//
-//go:linkname BNSignedBin2bn C.BN_signed_bin2bn
-func BNSignedBin2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
-
-// int BN_bn2bin(const BIGNUM *a, unsigned char *to);
-//
-// llgo:link (*BIGNUM).Bn2bin C.BN_bn2bin
-func (bn *BIGNUM) Bn2bin(to *byte) c.Int { return 0 }
-
-// int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen);
-//
-// llgo:link (*BIGNUM).Bn2binpad C.BN_bn2binpad
-func (bn *BIGNUM) Bn2binpad(to *byte, tolen c.Int) c.Int { return 0 }
-
-// int BN_signed_bn2bin(const BIGNUM *a, unsigned char *to, int tolen);
-//
-// llgo:link (*BIGNUM).SignedBn2bin C.BN_signed_bn2bin
-func (bn *BIGNUM) SignedBn2bin(to *byte, tolen c.Int) c.Int { return 0 }
-
-// BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
-//
-//go:linkname BNLebin2bn C.BN_lebin2bn
-func BNLebin2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
-
-// BIGNUM *BN_signed_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
-//
-//go:linkname BNSignedLebin2bn C.BN_signed_lebin2bn
-func BNSignedLebin2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
-
-// int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen);
-//
-// llgo:link (*BIGNUM).Bn2lebinpad C.BN_bn2lebinpad
-func (bn *BIGNUM) Bn2lebinpad(to *byte, tolen c.Int) c.Int { return 0 }
-
-// int BN_signed_bn2lebin(const BIGNUM *a, unsigned char *to, int tolen);
-//
-// llgo:link (*BIGNUM).SignedBn2lebin C.BN_signed_bn2lebin
-func (bn *BIGNUM) SignedBn2lebin(to *byte, tolen c.Int) c.Int { return 0 }
-
-// BIGNUM *BN_native2bn(const unsigned char *s, int len, BIGNUM *ret);
-//
-//go:linkname BNNative2bn C.BN_native2bn
-func BNNative2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
-
-// BIGNUM *BN_signed_native2bn(const unsigned char *s, int len, BIGNUM *ret);
-//
-//go:linkname BNSignedNative2bn C.BN_signed_native2bn
-func BNSignedNative2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
-
-// int BN_bn2nativepad(const BIGNUM *a, unsigned char *to, int tolen);
-//
-// llgo:link (*BIGNUM).Bn2nativepad C.BN_bn2nativepad
-func (bn *BIGNUM) Bn2nativepad(to *byte, tolen c.Int) c.Int { return 0 }
-
-// int BN_signed_bn2native(const BIGNUM *a, unsigned char *to, int tolen);
-//
-// llgo:link (*BIGNUM).SignedBn2native C.BN_signed_bn2native
-func (bn *BIGNUM) SignedBn2native(to *byte, tolen c.Int) c.Int { return 0 }
-
-// BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret);
-//
-//go:linkname BNMpi2bn C.BN_mpi2bn
-func BNMpi2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
-
-// int BN_bn2mpi(const BIGNUM *a, unsigned char *to);
-//
-// llgo:link (*BIGNUM).Bn2mpi C.BN_bn2mpi
-func (bn *BIGNUM) Bn2mpi(to *byte) c.Int { return 0 }
+/*
+BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
+BIGNUM *BN_signed_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2bin(const BIGNUM *a, unsigned char *to);
+int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen);
+int BN_signed_bn2bin(const BIGNUM *a, unsigned char *to, int tolen);
+BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
+BIGNUM *BN_signed_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen);
+int BN_signed_bn2lebin(const BIGNUM *a, unsigned char *to, int tolen);
+BIGNUM *BN_native2bn(const unsigned char *s, int len, BIGNUM *ret);
+BIGNUM *BN_signed_native2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2nativepad(const BIGNUM *a, unsigned char *to, int tolen);
+int BN_signed_bn2native(const BIGNUM *a, unsigned char *to, int tolen);
+BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2mpi(const BIGNUM *a, unsigned char *to);
+*/
 
 // int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
 //

c/openssl/hmac.go

@@ -6,15 +6,7 @@ import (
 	"github.com/goplus/llgo/c"
 )
 
-const (
-	EVP_MAX_MD_SIZE = 64 /* longest known is SHA512 */
-)
-
-// -----------------------------------------------------------------------------
-
-type EVP_MD struct {
-	Unused [0]byte
-}
+const EVP_MAX_MD_SIZE = 64 /* longest known is SHA512 */
 
 // const EVP_MD *EVP_sha1(void)
 //
@@ -51,7 +43,13 @@ func EVP_sha384() *EVP_MD
 //go:linkname EVP_sha512 C.EVP_sha512
 func EVP_sha512() *EVP_MD
 
-// -----------------------------------------------------------------------------
+type EVP_MD struct {
+	Unused [0]byte
+}
+
+type EVP_MD_CTX struct {
+	Unused [0]byte
+}
 
 type HMAC_CTX struct {
 	Unused [0]byte
@@ -65,38 +63,30 @@ func NewHMAC_CTX() *HMAC_CTX
 // OSSL_DEPRECATEDIN_3_0 void HMAC_CTX_free(HMAC_CTX *ctx);
 //
 // llgo:link (*HMAC_CTX).Free C.HMAC_CTX_free
-func (ctx *HMAC_CTX) Free() {}
+func (c *HMAC_CTX) Free() {}
 
 // OSSL_DEPRECATEDIN_3_0 size_t HMAC_size(const HMAC_CTX *e);
 //
 // llgo:link (*HMAC_CTX).Size C.HMAC_size
-func (ctx *HMAC_CTX) Size() uintptr { return 0 }
+func (c *HMAC_CTX) Size() uintptr { return 0 }
 
 // OSSL_DEPRECATEDIN_3_0 int HMAC_CTX_reset(HMAC_CTX *ctx);
 //
 // llgo:link (*HMAC_CTX).Reset C.HMAC_CTX_reset
-func (ctx *HMAC_CTX) Reset() c.Int { return 0 }
+func (c *HMAC_CTX) Reset() c.Int { return 0 }
 
 // OSSL_DEPRECATEDIN_1_1_0 __owur int HMAC_Init(HMAC_CTX *ctx,
 // const void *key, int len,
 // const EVP_MD *md);
 //
 // llgo:link (*HMAC_CTX).Init C.HMAC_Init
-func (ctx *HMAC_CTX) Init(key unsafe.Pointer, len c.Int, md *EVP_MD) c.Int { return 0 }
-
-func (ctx *HMAC_CTX) InitBytes(key []byte, md *EVP_MD) c.Int {
-	return ctx.Init(unsafe.Pointer(unsafe.SliceData(key)), c.Int(len(key)), md)
-}
-
-func (ctx *HMAC_CTX) InitString(key string, md *EVP_MD) c.Int {
-	return ctx.Init(unsafe.Pointer(unsafe.StringData(key)), c.Int(len(key)), md)
-}
+func (c *HMAC_CTX) Init(key unsafe.Pointer, len c.Int, md *EVP_MD) c.Int { return 0 }
 
 // OSSL_DEPRECATEDIN_3_0 int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
 // const EVP_MD *md, ENGINE *impl);
 //
 // llgo:link (*HMAC_CTX).InitEx C.HMAC_Init_ex
-func (ctx *HMAC_CTX) InitEx(key unsafe.Pointer, len c.Int, md *EVP_MD, impl unsafe.Pointer) c.Int {
+func (c *HMAC_CTX) InitEx(key unsafe.Pointer, len c.Int, md *EVP_MD, impl unsafe.Pointer) c.Int {
 	return 0
 }
 
@@ -104,30 +94,28 @@ func (ctx *HMAC_CTX) InitEx(key unsafe.Pointer, len c.Int, md *EVP_MD, impl unsa
 // size_t len);
 //
 // llgo:link (*HMAC_CTX).Update C.HMAC_Update
-func (ctx *HMAC_CTX) Update(data unsafe.Pointer, len uintptr) c.Int { return 0 }
+func (c *HMAC_CTX) Update(data unsafe.Pointer, len uintptr) c.Int { return 0 }
 
-func (ctx *HMAC_CTX) UpdateBytes(data []byte) c.Int {
-	return ctx.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+func (c *HMAC_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
 }
 
-func (ctx *HMAC_CTX) UpdateString(data string) c.Int {
-	return ctx.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+func (c *HMAC_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
 }
 
 // OSSL_DEPRECATEDIN_3_0 int HMAC_Final(HMAC_CTX *ctx, unsigned char *md,
 // unsigned int *len);
 //
 // llgo:link (*HMAC_CTX).Final C.HMAC_Final
-func (ctx *HMAC_CTX) Final(md *byte, len *c.Uint) c.Int { return 0 }
+func (c *HMAC_CTX) Final(md *byte, len *c.Uint) c.Int { return 0 }
 
 // OSSL_DEPRECATEDIN_3_0 __owur int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx);
 //
 // llgo:link (*HMAC_CTX).Copy C.HMAC_CTX_copy
-func (ctx *HMAC_CTX) Copy(sctx *HMAC_CTX) c.Int { return 0 }
+func (c *HMAC_CTX) Copy(sctx *HMAC_CTX) c.Int { return 0 }
 
 // OSSL_DEPRECATEDIN_3_0 void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags);
 //
 // llgo:link (*HMAC_CTX).SetFlags C.HMAC_CTX_set_flags
-func (ctx *HMAC_CTX) SetFlags(flags c.Ulong) {}
-
-// -----------------------------------------------------------------------------
+func (c *HMAC_CTX) SetFlags(flags c.Ulong) {}

chore/_xtool/castdump/castdump.go

@@ -1,217 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"strings"
-	"unsafe"
-
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/clang"
-)
-
-type Data struct {
-	Depth c.Uint
-	Unit  *clang.TranslationUnit
-}
-
-var accessMap = map[clang.CXXAccessSpecifier]string{
-	clang.CXXInvalidAccessSpecifier: "invalid",
-	clang.CXXPublic:                 "public",
-	clang.CXXProtected:              "protected",
-	clang.CXXPrivate:                "private",
-}
-
-func printIndent(depth c.Uint) {
-	fmt.Print(strings.Repeat("   ", int(depth)))
-}
-
-func accessToString(spec clang.CXXAccessSpecifier) string {
-	if str, ok := accessMap[spec]; ok {
-		return str
-	}
-	return "unknown"
-}
-
-func visit(cursor, parent clang.Cursor, ClientData c.Pointer) clang.ChildVisitResult {
-	data := (*Data)(ClientData)
-	printAST(cursor, data)
-	return clang.ChildVisit_Continue
-}
-
-func printType(t clang.Type, data *Data) {
-	printIndent(data.Depth)
-
-	typeSpell := t.String()
-	typeKind := t.Kind.String()
-
-	if t.Kind == clang.TypeInvalid {
-	} else if t.Kind == clang.TypeUnexposed {
-		c.Printf(c.Str("<UnexposedType|%s>: %s\n"), typeKind.CStr(), typeSpell.CStr())
-	} else if t.Kind >= clang.TypeFirstBuiltin && t.Kind <= clang.TypeLastBuiltin {
-		c.Printf(c.Str("<BuiltinType|%s>: %s\n"), typeKind.CStr(), typeSpell.CStr())
-	} else if t.Kind > clang.TypeComplex {
-		c.Printf(c.Str("<ComplexType|%s>: %s\n"), typeKind.CStr(), typeSpell.CStr())
-	}
-
-	data.Depth++
-	switch t.Kind {
-	case clang.TypePointer:
-		printType(t.PointeeType(), data)
-	case clang.TypeIncompleteArray, clang.TypeVariableArray, clang.TypeDependentSizedArray, clang.TypeConstantArray:
-		printType(t.ArrayElementType(), data)
-	case clang.TypeTypedef:
-		printType(t.CanonicalType(), data)
-	case clang.TypeFunctionProto:
-		printType(t.ResultType(), data)
-		for i := 0; i < int(t.NumArgTypes()); i++ {
-			printType(t.ArgType(c.Uint(i)), data)
-		}
-	}
-	data.Depth--
-
-	typeKind.Dispose()
-	typeSpell.Dispose()
-}
-
-func printLocation(cursor clang.Cursor) {
-	loc := cursor.Location()
-	var file clang.File
-	var line, column c.Uint
-
-	loc.SpellingLocation(&file, &line, &column, nil)
-	filename := file.FileName()
-	defer filename.Dispose()
-
-	c.Printf(c.Str("(Loc:%s:%d:%d)\n"), filename.CStr(), line, column)
-}
-
-func printAccess(cursor clang.Cursor) {
-	kind := cursor.Kind.String()
-	spell := cursor.String()
-	defer kind.Dispose()
-	defer spell.Dispose()
-
-	c.Printf(c.Str("%s: %s %s"), kind.CStr(), spell.CStr(), c.AllocaCStr(accessToString(cursor.CXXAccessSpecifier())))
-	printLocation(cursor)
-}
-
-func printMacro(cursor clang.Cursor, unit *clang.TranslationUnit) {
-	kind := cursor.Kind.String()
-	defer kind.Dispose()
-
-	c.Printf(c.Str("%s: "), kind.CStr())
-	ran := cursor.Extent()
-	var numTokens c.Uint
-	var tokens *clang.Token
-	unit.Tokenize(ran, &tokens, &numTokens)
-	tokensSlice := unsafe.Slice(tokens, int(numTokens))
-	for _, tok := range tokensSlice {
-		tokStr := unit.Token(tok)
-		c.Printf(c.Str("%s "), tokStr.CStr())
-		tokStr.Dispose()
-	}
-	printLocation(cursor)
-}
-
-func printFunc(cursor clang.Cursor, data *Data) {
-	kind := cursor.Kind.String()
-	spell := cursor.String()
-	symbol := cursor.Mangling()
-	defer symbol.Dispose()
-	defer kind.Dispose()
-	defer spell.Dispose()
-
-	c.Printf(c.Str("%s: %s (Symbol: %s)"), kind.CStr(), spell.CStr(), symbol.CStr())
-	printLocation(cursor)
-	printType(cursor.Type(), data)
-}
-
-func printEnumConstant(cursor clang.Cursor) {
-	kind := cursor.Kind.String()
-	spell := cursor.String()
-	defer kind.Dispose()
-	defer spell.Dispose()
-
-	c.Printf(c.Str("%s: %s:%lld"), kind.CStr(), spell.CStr(), cursor.EnumConstantDeclValue())
-	printLocation(cursor)
-}
-
-func printDefault(cursor clang.Cursor, data *Data) {
-	kind := cursor.Kind.String()
-	spell := cursor.String()
-	defer kind.Dispose()
-	defer spell.Dispose()
-
-	// node which has type
-	if cursor.Type().Kind != clang.TypeInvalid {
-		c.Printf(c.Str("%s: %s"), kind.CStr(), spell.CStr())
-		printLocation(cursor)
-		printType(cursor.Type(), data)
-	} else {
-		c.Printf(c.Str("%s: %s\n"), kind.CStr(), spell.CStr())
-	}
-}
-
-func printAST(cursor clang.Cursor, data *Data) {
-	kind := cursor.Kind.String()
-	spell := cursor.String()
-
-	printIndent(data.Depth)
-
-	switch cursor.Kind {
-	case clang.CursorCXXAccessSpecifier:
-		printAccess(cursor)
-	case clang.CursorMacroDefinition:
-		printMacro(cursor, data.Unit)
-	case clang.CursorFunctionDecl, clang.CursorCXXMethod, clang.CursorConstructor, clang.CursorDestructor:
-		printFunc(cursor, data)
-	case clang.CursorEnumConstantDecl:
-		printEnumConstant(cursor)
-	default:
-		printDefault(cursor, data)
-	}
-
-	data.Depth++
-	clang.VisitChildren(cursor, visit, c.Pointer(data))
-	data.Depth--
-
-	kind.Dispose()
-	spell.Dispose()
-}
-
-func main() {
-	if c.Argc != 2 {
-		fmt.Fprintln(os.Stderr, "Usage: castdump <headerFile>")
-		return
-	}
-
-	args := make([]*c.Char, 3)
-	args[0] = c.Str("-x")
-	args[1] = c.Str("c++")
-	args[2] = c.Str("-std=c++11")
-
-	sourceFile := *c.Advance(c.Argv, 1)
-	index := clang.CreateIndex(0, 0)
-	unit := index.ParseTranslationUnit(
-		sourceFile,
-		unsafe.SliceData(args), 3,
-		nil, 0,
-		clang.DetailedPreprocessingRecord,
-	)
-	defer index.Dispose()
-	defer unit.Dispose()
-
-	if unit == nil {
-		println("Unable to parse translation unit. Quitting.")
-		c.Exit(1)
-	}
-
-	cursor := unit.Cursor()
-
-	Data := &Data{
-		Depth: 0,
-		Unit:  unit,
-	}
-	printAST(cursor, Data)
-}

chore/_xtool/llcppsymg/llcppsymg.go

@@ -22,6 +22,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"unsafe"
 
@@ -60,11 +61,11 @@ func main() {
 
 	check(err)
 
-	filepaths := genHeaderFilePath(conf.CFlags, conf.Include)
-	headerInfos, err := parse.ParseHeaderFile(filepaths, conf.TrimPrefixes)
+	filepaths := generateHeaderFilePath(conf.CFlags, conf.Include)
+	astInfos, err := parse.ParseHeaderFile(filepaths)
 	check(err)
 
-	symbolInfo := getCommonSymbols(symbols, headerInfos, conf.TrimPrefixes)
+	symbolInfo := getCommonSymbols(symbols, astInfos, conf.TrimPrefixes)
 
 	err = genSymbolTableFile(symbolInfo)
 	check(err)
@@ -76,8 +77,8 @@ func check(err error) {
 	}
 }
 
-func parseDylibSymbols(lib string) ([]*nm.Symbol, error) {
-	dylibPath, err := genDylibPath(lib)
+func parseDylibSymbols(lib string) ([]types.CPPSymbol, error) {
+	dylibPath, err := generateDylibPath(lib)
 	if err != nil {
 		return nil, errors.New("failed to generate dylib path")
 	}
@@ -87,15 +88,22 @@ func parseDylibSymbols(lib string) ([]*nm.Symbol, error) {
 		return nil, errors.New("failed to list symbols in dylib")
 	}
 
-	var symbols []*nm.Symbol
+	var symbols []types.CPPSymbol
+
 	for _, file := range files {
-		symbols = append(symbols, file.Symbols...)
+		for _, sym := range file.Symbols {
+			demangleName := decodeSymbolName(sym.Name)
+			symbols = append(symbols, types.CPPSymbol{
+				Symbol:       sym,
+				DemangleName: demangleName,
+			})
+		}
 	}
 
 	return symbols, nil
 }
 
-func genDylibPath(lib string) (string, error) {
+func generateDylibPath(lib string) (string, error) {
 	output := lib
 	libPath := ""
 	libName := ""
@@ -115,20 +123,31 @@ func genDylibPath(lib string) (string, error) {
 	return dylibPath, nil
 }
 
-func decodeSymbol(symbolName string) string {
+func decodeSymbolName(symbolName string) string {
 	if symbolName == "" {
 		return ""
 	}
+
 	demangled := llvm.ItaniumDemangle(symbolName, true)
 	if demangled == nil {
 		return symbolName
 	}
 	defer c.Free(unsafe.Pointer(demangled))
+
 	demangleName := c.GoString(demangled)
-	return strings.TrimSpace(demangleName)
+	if demangleName == "" {
+		return symbolName
+	}
+
+	decodedName := strings.TrimSpace(demangleName)
+	decodedName = strings.ReplaceAll(decodedName,
+		"std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const",
+		"std::string")
+
+	return decodedName
 }
 
-func genHeaderFilePath(cflags string, files []string) []string {
+func generateHeaderFilePath(cflags string, files []string) []string {
 	prefixPath := cflags
 	prefixPath = strings.TrimPrefix(prefixPath, "-I")
 	var includePaths []string
@@ -138,23 +157,77 @@ func genHeaderFilePath(cflags string, files []string) []string {
 	return includePaths
 }
 
-func getCommonSymbols(dylibSymbols []*nm.Symbol, symbolMap map[string]string, prefix []string) []*types.SymbolInfo {
-	var commonSymbols []*types.SymbolInfo
-	for _, dylibSym := range dylibSymbols {
-		symName := strings.TrimPrefix(dylibSym.Name, "_")
-		if goName, ok := symbolMap[symName]; ok {
-			symbolInfo := &types.SymbolInfo{
-				Mangle: symName,
-				CPP:    decodeSymbol(dylibSym.Name),
-				Go:     goName,
+func getCommonSymbols(dylibSymbols []types.CPPSymbol, astInfoList []types.ASTInformation, prefix []string) []types.SymbolInfo {
+	var commonSymbols []types.SymbolInfo
+	functionNameMap := make(map[string]int)
+
+	for _, astInfo := range astInfoList {
+		for _, dylibSym := range dylibSymbols {
+			if strings.TrimPrefix(dylibSym.Name, "_") == astInfo.Symbol {
+				cppName := generateCPPName(astInfo)
+				functionNameMap[cppName]++
+				symbolInfo := types.SymbolInfo{
+					Mangle: strings.TrimPrefix(dylibSym.Name, "_"),
+					CPP:    cppName,
+					Go:     generateMangle(astInfo, functionNameMap[cppName], prefix),
+				}
+				commonSymbols = append(commonSymbols, symbolInfo)
+				break
 			}
-			commonSymbols = append(commonSymbols, symbolInfo)
 		}
 	}
+
 	return commonSymbols
 }
 
-func genSymbolTableFile(symbolInfos []*types.SymbolInfo) error {
+func generateCPPName(astInfo types.ASTInformation) string {
+	cppName := astInfo.Name
+	if astInfo.Class != "" {
+		cppName = astInfo.Class + "::" + astInfo.Name
+	}
+	return cppName
+}
+
+func generateMangle(astInfo types.ASTInformation, count int, prefixes []string) string {
+	astInfo.Class = removePrefix(astInfo.Class, prefixes)
+	astInfo.Name = removePrefix(astInfo.Name, prefixes)
+	res := ""
+	if astInfo.Class != "" {
+		if astInfo.Class == astInfo.Name {
+			res = "(*" + astInfo.Class + ")." + "Init"
+			if count > 1 {
+				res += "__" + strconv.Itoa(count-1)
+			}
+		} else if astInfo.Name == "~"+astInfo.Class {
+			res = "(*" + astInfo.Class + ")." + "Dispose"
+			if count > 1 {
+				res += "__" + strconv.Itoa(count-1)
+			}
+		} else {
+			res = "(*" + astInfo.Class + ")." + astInfo.Name
+			if count > 1 {
+				res += "__" + strconv.Itoa(count-1)
+			}
+		}
+	} else {
+		res = astInfo.Name
+		if count > 1 {
+			res += "__" + strconv.Itoa(count-1)
+		}
+	}
+	return res
+}
+
+func removePrefix(str string, prefixes []string) string {
+	for _, prefix := range prefixes {
+		if strings.HasPrefix(str, prefix) {
+			return strings.TrimPrefix(str, prefix)
+		}
+	}
+	return str
+}
+
+func genSymbolTableFile(symbolInfos []types.SymbolInfo) error {
 	// keep open follow code block can run successfully
 	for i := range symbolInfos {
 		println("symbol", symbolInfos[i].Go)
@@ -196,7 +269,6 @@ func genSymbolTableFile(symbolInfos []*types.SymbolInfo) error {
 	}
 	return nil
 }
-
 func readExistingSymbolTable(fileName string) (map[string]types.SymbolInfo, error) {
 	existingSymbols := make(map[string]types.SymbolInfo)
 

chore/_xtool/llcppsymg/parse/parse.go

@@ -3,27 +3,23 @@ package parse
 import (
 	"errors"
 	"strconv"
-	"strings"
 	"unsafe"
 
 	"github.com/goplus/llgo/c"
 	"github.com/goplus/llgo/c/clang"
+	"github.com/goplus/llgo/chore/llcppg/types"
 )
 
 type Context struct {
 	namespaceName string
 	className     string
-	prefixes      []string
-	symbolMap     map[string]string
+	astInfo       []types.ASTInformation
 	currentFile   string
-	nameCounts    map[string]int
 }
 
-func newContext(prefixes []string) *Context {
+func newContext() *Context {
 	return &Context{
-		prefixes:   prefixes,
-		symbolMap:  make(map[string]string),
-		nameCounts: make(map[string]int),
+		astInfo: make([]types.ASTInformation, 0),
 	}
 }
 
@@ -39,83 +35,70 @@ func (c *Context) setCurrentFile(filename string) {
 	c.currentFile = filename
 }
 
-func (c *Context) removePrefix(str string) string {
-	for _, prefix := range c.prefixes {
-		if strings.HasPrefix(str, prefix) {
-			return strings.TrimPrefix(str, prefix)
-		}
-	}
-	return str
-}
+var context = newContext()
 
-func (c *Context) genGoName(name string) string {
-	class := c.removePrefix(c.className)
-	name = c.removePrefix(name)
+func collectFuncInfo(cursor clang.Cursor) types.ASTInformation {
 
-	var baseName string
-	if class == "" {
-		baseName = name
-	} else {
-		baseName = c.genMethodName(class, name)
+	info := types.ASTInformation{
+		Namespace: context.namespaceName,
+		Class:     context.className,
 	}
 
-	return c.addSuffix(baseName)
-}
-
-func (c *Context) genMethodName(class, name string) string {
-	prefix := "(*" + class + ")."
-	if class == name {
-		return prefix + "Init"
-	}
-	if name == "~"+class {
-		return prefix + "Dispose"
-	}
-	return prefix + name
-}
-
-func (c *Context) addSuffix(name string) string {
-	c.nameCounts[name]++
-	count := c.nameCounts[name]
-	if count > 1 {
-		return name + "__" + strconv.Itoa(count-1)
-	}
-	return name
-}
-
-var context = newContext([]string{})
-
-func collectFuncInfo(cursor clang.Cursor) {
 	cursorStr := cursor.String()
 	symbol := cursor.Mangling()
 
-	name := c.GoString(cursorStr.CStr())
-	symbolName := c.GoString(symbol.CStr())
-	if len(symbolName) >= 1 && symbolName[0] == '_' {
-		symbolName = symbolName[1:]
+	info.Name = c.GoString(cursorStr.CStr())
+
+	info.Symbol = c.GoString(symbol.CStr())
+	if len(info.Symbol) >= 1 {
+		if info.Symbol[0] == '_' {
+			info.Symbol = info.Symbol[1:]
+		}
 	}
+
 	defer symbol.Dispose()
 	defer cursorStr.Dispose()
 
-	goName := context.genGoName(name)
-	context.symbolMap[symbolName] = goName
+	if context.namespaceName != "" {
+		info.Namespace = context.namespaceName
+	}
+	if context.className != "" {
+		info.Class = context.className
+	}
+
+	typeStr := cursor.ResultType().String()
+	defer typeStr.Dispose()
+	info.ReturnType = c.GoString(typeStr.CStr())
+
+	info.Parameters = make([]types.Parameter, cursor.NumArguments())
+	for i := 0; i < int(cursor.NumArguments()); i++ {
+		argCurSor := cursor.Argument(c.Uint(i))
+		argType := argCurSor.Type().String()
+		argName := argCurSor.String()
+		info.Parameters[i] = types.Parameter{
+			Name: c.GoString(argName.CStr()),
+			Type: c.GoString(argType.CStr()),
+		}
+
+		argType.Dispose()
+		argName.Dispose()
+	}
+
+	return info
 }
 
 func visit(cursor, parent clang.Cursor, clientData c.Pointer) clang.ChildVisitResult {
-	if cursor.Kind == clang.CursorNamespace {
+	if cursor.Kind == clang.Namespace {
 		nameStr := cursor.String()
-		defer nameStr.Dispose()
-
 		context.setNamespaceName(c.GoString(nameStr.CStr()))
 		clang.VisitChildren(cursor, visit, nil)
 		context.setNamespaceName("")
-	} else if cursor.Kind == clang.CursorClassDecl {
+	} else if cursor.Kind == clang.ClassDecl {
 		nameStr := cursor.String()
-		defer nameStr.Dispose()
-
 		context.setClassName(c.GoString(nameStr.CStr()))
 		clang.VisitChildren(cursor, visit, nil)
 		context.setClassName("")
-	} else if cursor.Kind == clang.CursorCXXMethod || cursor.Kind == clang.CursorFunctionDecl || cursor.Kind == clang.CursorConstructor || cursor.Kind == clang.CursorDestructor {
+	} else if cursor.Kind == clang.CXXMethod || cursor.Kind == clang.FunctionDecl || cursor.Kind == clang.Constructor || cursor.Kind == clang.Destructor {
 		loc := cursor.Location()
 		var file clang.File
 		var line, column c.Uint
@@ -124,7 +107,9 @@ func visit(cursor, parent clang.Cursor, clientData c.Pointer) clang.ChildVisitRe
 		filename := file.FileName()
 
 		if c.Strcmp(filename.CStr(), c.AllocaCStr(context.currentFile)) == 0 {
-			collectFuncInfo(cursor)
+			info := collectFuncInfo(cursor)
+			info.Location = c.GoString(filename.CStr()) + ":" + strconv.Itoa(int(line)) + ":" + strconv.Itoa(int(column))
+			context.astInfo = append(context.astInfo, info)
 		}
 
 		defer filename.Dispose()
@@ -133,13 +118,14 @@ func visit(cursor, parent clang.Cursor, clientData c.Pointer) clang.ChildVisitRe
 	return clang.ChildVisit_Continue
 }
 
-func ParseHeaderFile(filepaths []string, prefixes []string) (map[string]string, error) {
+func ParseHeaderFile(filepaths []string) ([]types.ASTInformation, error) {
+
 	index := clang.CreateIndex(0, 0)
 	args := make([]*c.Char, 3)
 	args[0] = c.Str("-x")
 	args[1] = c.Str("c++")
 	args[2] = c.Str("-std=c++11")
-	context = newContext(prefixes)
+	context = newContext()
 
 	for _, filename := range filepaths {
 		unit := index.ParseTranslationUnit(
@@ -163,5 +149,5 @@ func ParseHeaderFile(filepaths []string, prefixes []string) (map[string]string,
 
 	index.Dispose()
 
-	return context.symbolMap, nil
+	return context.astInfo, nil
 }

chore/llcppg/ast/ast.go

@@ -36,11 +36,6 @@ type Stmt interface {
 	stmtNode()
 }
 
-type PPD interface { // preprocessing directive
-	Node
-	ppdNode()
-}
-
 // =============================================================================
 // Expressions (Types are also expressions)
 
@@ -231,8 +226,6 @@ type EnumItem struct {
 	Value Expr // optional
 }
 
-func (*EnumItem) exprNode() {}
-
 // enum Name { Item1, Item2, ... };
 type EnumTypeDecl struct {
 	DeclBase
@@ -268,25 +261,8 @@ func (*TypeDecl) declNode() {}
 // =============================================================================
 // AST File
 
-type Include struct {
-	Path string `json:"path"`
-}
-
-func (*Include) ppdNode() {}
-
-// ------------------------------------------------
-
-type Macro struct {
-}
-
-func (*Macro) ppdNode() {}
-
-// ------------------------------------------------
-
 type File struct {
-	Decls    []Decl     `json:"decls"`
-	Includes []*Include `json:"includes,omitempty"`
-	Macros   []*Macro   `json:"macros,omitempty"`
+	Decls []Decl
 }
 
 // =============================================================================

chore/llcppg/design.md

@@ -59,21 +59,8 @@ llcppsigfetch -  # read config from stdin
 
 It fetches information of C/C++ symbols and print to stdout. Its format is as follows:
 
-```json
-[
-  {
-    "path": "/path/to/file.h",
-    "doc": {
-      "decls": [],
-      "macros": [],
-      "includes": [
-        {
-          "path": "incfile.h"
-        }
-      ]
-    }
-  }
-]
+```
+TODO: see llgo/xtool/clang/ast
 ```
 
 ### gogensig
@@ -82,3 +69,252 @@ It fetches information of C/C++ symbols and print to stdout. Its format is as fo
 gogensig ast-file
 gogensig -  # read AST from stdin
 ```
+
+## Overall
+
+### Process
+
+1. The Parsing Module reads `llcppg.cfg` to obtain dynamic libraries, header files, and the package name. After parsing, it writes the generated `llcppg.symb.json` path into `llcppg.cfg`.
+2. The Function Declaration Generation Module reads `llcppg.cfg` to get the package name, header files, and the previously generated `llcppg.symb.json`. After parsing, it generates the function prototype `llcppg.function.json`.
+3. Reads the previously generated `llcppg.information.json`, stores it as a structure, and uses gogen to generate code based on the structure.
+
+## Parsing Module
+
+### Input
+
+Obtains the paths to header files and dynamic library files by reading the JSON file `llcppg.cfg`.
+
+```json
+{
+  "name": "inih",
+  "cflags": "$(pkg-config --cflags INIReader)",
+  "include": [
+    "INIReader.h",
+    "AnotherHeaderFile.h"
+  ],
+  "libs": "$(pkg-config --libs INIReader)",
+  "trimPrefixes": ["Ini", "INI"]
+}
+```
+
+```bash
+llcppsymg config-file
+```
+
+### Implementation Steps
+
+1. Parse dylib and store:
+
+```go
+// types.go
+type CPPSymbol struct {
+    Symbol string `json:"symbol"`
+    Type   string `json:"type"`
+    Name   string `json:"name"`
+}
+
+// parser_dylib.go
+func parseDylibSymbols(lib string) ([]common.CPPSymbol, error) 
+```
+
+2. Parse header files and store:
+
+```go
+// common.go
+type ASTInformation struct {
+    Namespace   string      `json:"namespace"`
+    Class       string      `json:"class"`
+    Name        string      `json:"name"`
+    BaseClasses []string    `json:"baseClasses"`
+    ReturnType  string      `json:"returnType"`
+    Location    string      `json:"location"`
+    Parameters  []Parameter `json:"parameters"`
+    Symbol      string      `json:"symbol"`
+}
+
+type Parameter struct {
+    Name string `json:"name"`
+    Type string `json:"type"`
+}
+
+// parser_ast.go
+func parseHeaderFile(config types.Config) ([]common.ASTInformation, error)
+```
+
+3. Cross-reference data from the first two steps to get the final output
+
+```go
+// common.go
+type SymbolInfo struct {
+    Mangle string `json:"mangle"` // C++ Symbol
+    CPP    string `json:"c++"`    // C++ function name
+    Go     string `json:"go"`     // Go function name
+}
+
+// common_symbols.go
+func getCommonSymbols(dylibSymbols []common.CPPSymbol, astInfoList []common.ASTInformation) []common.SymbolInfo {
+```
+
+4. Generate `llcppg.symb.json` file and store the JSON file path into `llcppg.cfg`
+
+```go
+func generateJSON([]CommonSymbolInfo)
+```
+
+5. Example `llcppg.symb.json` file
+
+```json
+{
+    "FunctionName": "A::B::C",
+    "Symbol": "_ZN9INIReaderC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE",
+    "Location": "a.h",
+    "UserFunctionName": "CFromA"
+}
+```
+
+## Function Declaration Generation Module
+
+### Input
+
+No input required, directly reads the `llcppg.cfg` file
+
+### Implementation Steps
+
+1. Execute the executable
+
+```bash
+llcppsigfetch config-file
+```
+
+2. Parse header files
+
+```go
+// common.go
+type ASTInformation struct {
+    Namespace   string      `json:"namespace"`
+    Class       string      `json:"class"`
+    Name        string      `json:"name"`
+    BaseClasses []string    `json:"baseClasses"`
+    ReturnType  string      `json:"returnType"`
+    Location    string      `json:"location"`
+    Parameters  []Parameter `json:"parameters"`
+    Symbol      string      `json:"symbol"`
+}
+
+type Parameter struct {
+    Name string `json:"name"`
+    Type string `json:"type"`
+}
+
+// parser_ast.go
+func ParseHeaderFile(filePath string) ([]common.ASTInformation, error)
+```
+
+3. Generate the final JSON mapping file `llcppg.information.json`
+
+```go
+ func GenerateJSONFile(info []common.ASTInformation)
+```
+
+```json
+{
+    "functionName": "A::B::C",
+    "symbol": "_ZN9INIReaderC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE",
+    "location": "a.h",
+    "returnType": "int",
+    "userFunctionName": "CFromA",
+    "parameters": [
+        {
+          "arg1": "int"
+        },
+        {
+          "arg2": "*char"
+        }
+  ]
+}
+```
+
+## Code Generation Module
+
+### Input
+
+No input required, directly reads `llcppg.information.json` file
+
+### Implementation Steps
+
+1. Execute the executable
+
+```bash
+gogensig ast-file
+```
+
+2. Parse JSON file
+
+```go
+// common.go
+type HeaderFileInfo struct {
+    FunctionName     string            `json:"functionName"`
+    Symbol           string            `json:"symbol"`
+    Location         string            `json:"location"`
+    UserFunctionName string            `json:"userFunctionName"`
+    Parameters       map[string]string `json:"parameters"`
+}
+
+// parse_json.go
+func ParseJSON(jsonFilePath string) ([]common.HeaderFileInfo, error)
+```
+
+3. Generate code using the parsed structure with gogen
+
+```go
+// generator.go
+func GenerateCode(info []common.HeaderFileInfo) {
+    pkg := gogen.NewPackage("", PackageName, nil)
+    cm := comment(fmt.Sprintf("llgo:link %s %s", funcName1, symbol1))
+    pkg.NewFunc(recv, funcName, params, results, variadic).SetComments(pkg, cm).BodyStart(pkg).End()
+}
+```
+
+### Output
+
+1. Directory structure
+
+```bash
+package_name/
+├── _demo
+    ├── demo1.go
+└── llgo_link.go
+└── a.go
+└── b.go
+└── c.go
+```
+
+Note that `demo1.go` file needs to be written by the user
+
+2. `llgo_link.go` is responsible for linking configuration
+
+```go
+package inih
+const (
+        LLGoFiles   = "$(pkg-config --cflags INIReader): _wrap/reader.cpp"
+        LLGoPackage = "link: $(pkg-config --libs inih INIReader); -linih -lINIReader"
+)
+```
+
+3. Example content for `a.go`
+
+```go
+package inih
+import (
+        _ "unsafe"
+        "github.com/goplus/llgo/c"
+)
+//go:linkname Parse C.ini_parse
+func Parse(filename *c.Char, handler func(user c.Pointer, section *c.Char, name *c.Char, value *c.Char) c.Int, user c.Pointer) c.Int
+
+//go:linkname ParseFile C.ini_parse_file
+func ParseFile(file c.FilePtr, handler func(user c.Pointer, section *c.Char, name *c.Char, value *c.Char) c.Int, user c.Pointer) c.Int
+
+//go:linkname ParseString C.ini_parse_string
+func ParseString(str *c.Char, handler func(user c.Pointer, section *c.Char, name *c.Char, value *c.Char) c.Int, user c.Pointer) c.Int
+```

chore/llcppg/types/types.go

@@ -16,6 +16,10 @@
 
 package types
 
+import (
+	"github.com/goplus/llgo/xtool/nm"
+)
+
 // Config represents a configuration for the llcppg tool.
 type Config struct {
 	Name         string   `json:"name"`
@@ -25,6 +29,27 @@ type Config struct {
 	TrimPrefixes []string `json:"trimPrefixes"`
 }
 
+type CPPSymbol struct {
+	DemangleName string
+	*nm.Symbol
+}
+
+type ASTInformation struct {
+	Namespace   string      `json:"namespace"`
+	Class       string      `json:"class"`
+	Name        string      `json:"name"`
+	BaseClasses []string    `json:"baseClasses"`
+	ReturnType  string      `json:"returnType"`
+	Location    string      `json:"location"`
+	Parameters  []Parameter `json:"parameters"`
+	Symbol      string      `json:"symbol"`
+}
+
+type Parameter struct {
+	Name string `json:"name"`
+	Type string `json:"type"`
+}
+
 type SymbolInfo struct {
 	Mangle string `json:"mangle"` // C++ Symbol
 	CPP    string `json:"c++"`    // C++ function name

cl/_testdata/async/in.go

@@ -0,0 +1,27 @@
+package async
+
+import (
+	"github.com/goplus/llgo/x/async"
+)
+
+func GenInts() (co *async.Promise[int]) {
+	co.Yield(1)
+	co.Yield(2)
+	co.Yield(3)
+	return
+}
+
+func WrapGenInts() *async.Promise[int] {
+	return GenInts()
+}
+
+func UseGenInts() int {
+	co := WrapGenInts()
+	r := 0
+	for !co.Done() {
+		v := co.Value()
+		r += v
+		co.Next()
+	}
+	return r
+}

cl/_testdata/async/out.ll

@@ -0,0 +1,201 @@
+; ModuleID = 'async'
+source_filename = "async"
+
+%"github.com/goplus/llgo/x/async.Promise[int]" = type { ptr, i64 }
+
+@"async.init$guard" = global i1 false, align 1
+
+define ptr @async.GenInts() presplitcoroutine {
+entry:
+  %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
+  %frame.size = call i64 @llvm.coro.size.i64()
+  %alloc.size = add i64 16, %frame.size
+  %promise = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 %alloc.size)
+  %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
+  br i1 %need.dyn.alloc, label %alloc, label %_llgo_5
+
+alloc:                                            ; preds = %entry
+  %0 = getelementptr ptr, ptr %promise, i64 16
+  br label %_llgo_5
+
+clean:                                            ; preds = %_llgo_8, %_llgo_7, %_llgo_6, %_llgo_5
+  %1 = call ptr @llvm.coro.free(token %id, ptr %hdl)
+  br label %suspend
+
+suspend:                                          ; preds = %_llgo_8, %_llgo_7, %_llgo_6, %_llgo_5, %clean
+  %2 = call i1 @llvm.coro.end(ptr %hdl, i1 false, token none)
+  ret ptr %promise
+
+trap:                                             ; preds = %_llgo_8
+  call void @llvm.trap()
+  unreachable
+
+_llgo_5:                                          ; preds = %alloc, %entry
+  %frame = phi ptr [ null, %entry ], [ %0, %alloc ]
+  %hdl = call ptr @llvm.coro.begin(token %id, ptr %frame)
+  store ptr %hdl, ptr %promise, align 8
+  call void @"github.com/goplus/llgo/x/async.(*Promise).setValue[int]"(ptr %promise, i64 1)
+  %3 = call i8 @llvm.coro.suspend(token %id, i1 false)
+  switch i8 %3, label %suspend [
+    i8 0, label %_llgo_6
+    i8 1, label %clean
+  ]
+
+_llgo_6:                                          ; preds = %_llgo_5
+  call void @"github.com/goplus/llgo/x/async.(*Promise).setValue[int]"(ptr %promise, i64 2)
+  %4 = call i8 @llvm.coro.suspend(token %id, i1 false)
+  switch i8 %4, label %suspend [
+    i8 0, label %_llgo_7
+    i8 1, label %clean
+  ]
+
+_llgo_7:                                          ; preds = %_llgo_6
+  call void @"github.com/goplus/llgo/x/async.(*Promise).setValue[int]"(ptr %promise, i64 3)
+  %5 = call i8 @llvm.coro.suspend(token %id, i1 false)
+  switch i8 %5, label %suspend [
+    i8 0, label %_llgo_8
+    i8 1, label %clean
+  ]
+
+_llgo_8:                                          ; preds = %_llgo_7
+  %6 = call i8 @llvm.coro.suspend(token %id, i1 true)
+  switch i8 %6, label %suspend [
+    i8 0, label %trap
+    i8 1, label %clean
+  ]
+}
+
+define i64 @async.UseGenInts() {
+_llgo_0:
+  %0 = call ptr @async.WrapGenInts()
+  br label %_llgo_3
+
+_llgo_1:                                          ; preds = %_llgo_3
+  %1 = call i64 @"github.com/goplus/llgo/x/async.(*Promise).Value[int]"(ptr %0)
+  %2 = add i64 %3, %1
+  call void @"github.com/goplus/llgo/x/async.(*Promise).Next[int]"(ptr %0)
+  br label %_llgo_3
+
+_llgo_2:                                          ; preds = %_llgo_3
+  ret i64 %3
+
+_llgo_3:                                          ; preds = %_llgo_1, %_llgo_0
+  %3 = phi i64 [ 0, %_llgo_0 ], [ %2, %_llgo_1 ]
+  %4 = call i1 @"github.com/goplus/llgo/x/async.(*Promise).Done[int]"(ptr %0)
+  br i1 %4, label %_llgo_2, label %_llgo_1
+}
+
+define ptr @async.WrapGenInts() presplitcoroutine {
+entry:
+  %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
+  %frame.size = call i64 @llvm.coro.size.i64()
+  %alloc.size = add i64 16, %frame.size
+  %promise = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 %alloc.size)
+  %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
+  br i1 %need.dyn.alloc, label %alloc, label %_llgo_5
+
+alloc:                                            ; preds = %entry
+  %0 = getelementptr ptr, ptr %promise, i64 16
+  br label %_llgo_5
+
+clean:                                            ; preds = %_llgo_5
+  %1 = call ptr @llvm.coro.free(token %id, ptr %hdl)
+  br label %suspend
+
+suspend:                                          ; preds = %_llgo_5, %clean
+  %2 = call i1 @llvm.coro.end(ptr %hdl, i1 false, token none)
+  ret ptr %promise
+
+trap:                                             ; preds = %_llgo_5
+  call void @llvm.trap()
+  unreachable
+
+_llgo_5:                                          ; preds = %alloc, %entry
+  %frame = phi ptr [ null, %entry ], [ %0, %alloc ]
+  %hdl = call ptr @llvm.coro.begin(token %id, ptr %frame)
+  store ptr %hdl, ptr %promise, align 8
+  %3 = call ptr @async.GenInts()
+  %4 = call i8 @llvm.coro.suspend(token %id, i1 true)
+  switch i8 %4, label %suspend [
+    i8 0, label %trap
+    i8 1, label %clean
+  ]
+}
+
+define void @async.init() {
+_llgo_0:
+  %0 = load i1, ptr @"async.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"async.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
+
+; Function Attrs: nounwind memory(none)
+declare i64 @llvm.coro.size.i64()
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64)
+
+; Function Attrs: nounwind
+declare i1 @llvm.coro.alloc(token)
+
+; Function Attrs: nounwind
+declare ptr @llvm.coro.begin(token, ptr writeonly)
+
+; Function Attrs: nounwind memory(argmem: read)
+declare ptr @llvm.coro.free(token, ptr nocapture readonly)
+
+; Function Attrs: nounwind
+declare i1 @llvm.coro.end(ptr, i1, token)
+
+; Function Attrs: cold noreturn nounwind memory(inaccessiblemem: write)
+declare void @llvm.trap()
+
+define void @"github.com/goplus/llgo/x/async.(*Promise).setValue[int]"(ptr %0, i64 %1) {
+_llgo_0:
+  %2 = getelementptr inbounds %"github.com/goplus/llgo/x/async.Promise[int]", ptr %0, i32 0, i32 1
+  store i64 %1, ptr %2, align 4
+  ret void
+}
+
+; Function Attrs: nounwind
+declare i8 @llvm.coro.suspend(token, i1)
+
+define i1 @"github.com/goplus/llgo/x/async.(*Promise).Done[int]"(ptr %0) {
+_llgo_0:
+  %1 = getelementptr inbounds %"github.com/goplus/llgo/x/async.Promise[int]", ptr %0, i32 0, i32 0
+  %2 = load ptr, ptr %1, align 8
+  %3 = call i1 @llvm.coro.done(ptr %2)
+  %4 = zext i1 %3 to i64
+  %5 = trunc i64 %4 to i8
+  %6 = icmp ne i8 %5, 0
+  ret i1 %6
+}
+
+define i64 @"github.com/goplus/llgo/x/async.(*Promise).Value[int]"(ptr %0) {
+_llgo_0:
+  %1 = getelementptr inbounds %"github.com/goplus/llgo/x/async.Promise[int]", ptr %0, i32 0, i32 1
+  %2 = load i64, ptr %1, align 4
+  ret i64 %2
+}
+
+define void @"github.com/goplus/llgo/x/async.(*Promise).Next[int]"(ptr %0) {
+_llgo_0:
+  %1 = getelementptr inbounds %"github.com/goplus/llgo/x/async.Promise[int]", ptr %0, i32 0, i32 0
+  %2 = load ptr, ptr %1, align 8
+  call void @llvm.coro.resume(ptr %2)
+  ret void
+}
+
+; Function Attrs: nounwind memory(argmem: readwrite)
+declare i1 @llvm.coro.done(ptr nocapture readonly)
+
+declare void @llvm.coro.resume(ptr)
+

cl/_testgo/equal/out.ll

@@ -543,12 +543,10 @@ _llgo_0:
 
 define void @"main.init#7"() {
 _llgo_0:
-  %0 = load ptr, ptr @_llgo_int, align 8
-  %1 = load ptr, ptr @_llgo_string, align 8
-  %2 = load ptr, ptr @"map[_llgo_int]_llgo_string", align 8
-  %3 = call ptr @"github.com/goplus/llgo/internal/runtime.MakeMap"(ptr %2, i64 0)
-  %4 = icmp ne ptr %3, null
-  call void @main.assert(i1 %4)
+  %0 = load ptr, ptr @"map[_llgo_int]_llgo_string", align 8
+  %1 = call ptr @"github.com/goplus/llgo/internal/runtime.MakeMap"(ptr %0, i64 0)
+  %2 = icmp ne ptr %1, null
+  call void @main.assert(i1 %2)
   call void @main.assert(i1 true)
   ret void
 }

cl/_testrt/makemap/in.go

@@ -7,7 +7,6 @@ func main() {
 	make4()
 	make5()
 	make6()
-	make7()
 }
 
 func make1() {
@@ -114,15 +113,3 @@ func make6() {
 		println(k, v)
 	}
 }
-
-func make7() {
-	type N int
-	m := map[N]string{
-		1: "hello",
-		2: "world",
-	}
-	for k, v := range m {
-		println(k, v)
-	}
-	println(m[1])
-}

cl/_testrt/map/out.ll

@@ -8,7 +8,6 @@ source_filename = "main"
 @"main.init$guard" = global i1 false, align 1
 @__llgo_argc = global i32 0, align 4
 @__llgo_argv = global ptr null, align 8
-@_llgo_int = linkonce global ptr null, align 8
 @"map[_llgo_int]_llgo_int" = linkonce global ptr null, align 8
 @0 = private unnamed_addr constant [7 x i8] c"topbits", align 1
 @1 = private unnamed_addr constant [4 x i8] c"keys", align 1
@@ -37,32 +36,24 @@ _llgo_0:
   store ptr %1, ptr @__llgo_argv, align 8
   call void @"github.com/goplus/llgo/internal/runtime.init"()
   call void @main.init()
-  %2 = load ptr, ptr @_llgo_int, align 8
-  %3 = load ptr, ptr @_llgo_int, align 8
+  %2 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
+  %3 = call ptr @"github.com/goplus/llgo/internal/runtime.MakeMap"(ptr %2, i64 2)
   %4 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
-  %5 = call ptr @"github.com/goplus/llgo/internal/runtime.MakeMap"(ptr %4, i64 2)
-  %6 = load ptr, ptr @_llgo_int, align 8
-  %7 = load ptr, ptr @_llgo_int, align 8
-  %8 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
-  %9 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
-  store i64 23, ptr %9, align 4
-  %10 = call ptr @"github.com/goplus/llgo/internal/runtime.MapAssign"(ptr %8, ptr %5, ptr %9)
-  store i64 100, ptr %10, align 4
-  %11 = load ptr, ptr @_llgo_int, align 8
-  %12 = load ptr, ptr @_llgo_int, align 8
-  %13 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
-  %14 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
-  store i64 7, ptr %14, align 4
-  %15 = call ptr @"github.com/goplus/llgo/internal/runtime.MapAssign"(ptr %13, ptr %5, ptr %14)
-  store i64 29, ptr %15, align 4
-  %16 = load ptr, ptr @_llgo_int, align 8
-  %17 = load ptr, ptr @_llgo_int, align 8
-  %18 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
-  %19 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
-  store i64 23, ptr %19, align 4
-  %20 = call ptr @"github.com/goplus/llgo/internal/runtime.MapAccess1"(ptr %18, ptr %5, ptr %19)
-  %21 = load i64, ptr %20, align 4
-  %22 = call i32 (ptr, ...) @printf(ptr @5, i64 %21)
+  %5 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
+  store i64 23, ptr %5, align 4
+  %6 = call ptr @"github.com/goplus/llgo/internal/runtime.MapAssign"(ptr %4, ptr %3, ptr %5)
+  store i64 100, ptr %6, align 4
+  %7 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
+  %8 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
+  store i64 7, ptr %8, align 4
+  %9 = call ptr @"github.com/goplus/llgo/internal/runtime.MapAssign"(ptr %7, ptr %3, ptr %8)
+  store i64 29, ptr %9, align 4
+  %10 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
+  %11 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
+  store i64 23, ptr %11, align 4
+  %12 = call ptr @"github.com/goplus/llgo/internal/runtime.MapAccess1"(ptr %10, ptr %3, ptr %11)
+  %13 = load i64, ptr %12, align 4
+  %14 = call i32 (ptr, ...) @printf(ptr @5, i64 %13)
   ret i32 0
 }
 
@@ -70,119 +61,109 @@ declare void @"github.com/goplus/llgo/internal/runtime.init"()
 
 define void @"main.init$after"() {
 _llgo_0:
-  %0 = load ptr, ptr @_llgo_int, align 8
+  %0 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
   %1 = icmp eq ptr %0, null
   br i1 %1, label %_llgo_1, label %_llgo_2
 
 _llgo_1:                                          ; preds = %_llgo_0
   %2 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 34)
-  store ptr %2, ptr @_llgo_int, align 8
+  %3 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 34)
+  %4 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
+  %5 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %4, i32 0, i32 0
+  store ptr @0, ptr %5, align 8
+  %6 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %4, i32 0, i32 1
+  store i64 7, ptr %6, align 4
+  %7 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %4, align 8
+  %8 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
+  %9 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %8, i32 0, i32 0
+  store ptr null, ptr %9, align 8
+  %10 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %8, i32 0, i32 1
+  store i64 0, ptr %10, align 4
+  %11 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %8, align 8
+  %12 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 40)
+  %13 = call ptr @"github.com/goplus/llgo/internal/runtime.ArrayOf"(i64 8, ptr %12)
+  %14 = call %"github.com/goplus/llgo/internal/abi.StructField" @"github.com/goplus/llgo/internal/runtime.StructField"(%"github.com/goplus/llgo/internal/runtime.String" %7, ptr %13, i64 0, %"github.com/goplus/llgo/internal/runtime.String" %11, i1 false)
+  %15 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
+  %16 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %15, i32 0, i32 0
+  store ptr @1, ptr %16, align 8
+  %17 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %15, i32 0, i32 1
+  store i64 4, ptr %17, align 4
+  %18 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %15, align 8
+  %19 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
+  %20 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %19, i32 0, i32 0
+  store ptr null, ptr %20, align 8
+  %21 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %19, i32 0, i32 1
+  store i64 0, ptr %21, align 4
+  %22 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %19, align 8
+  %23 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 34)
+  %24 = call ptr @"github.com/goplus/llgo/internal/runtime.ArrayOf"(i64 8, ptr %23)
+  %25 = call %"github.com/goplus/llgo/internal/abi.StructField" @"github.com/goplus/llgo/internal/runtime.StructField"(%"github.com/goplus/llgo/internal/runtime.String" %18, ptr %24, i64 8, %"github.com/goplus/llgo/internal/runtime.String" %22, i1 false)
+  %26 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
+  %27 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %26, i32 0, i32 0
+  store ptr @2, ptr %27, align 8
+  %28 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %26, i32 0, i32 1
+  store i64 5, ptr %28, align 4
+  %29 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %26, align 8
+  %30 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
+  %31 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %30, i32 0, i32 0
+  store ptr null, ptr %31, align 8
+  %32 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %30, i32 0, i32 1
+  store i64 0, ptr %32, align 4
+  %33 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %30, align 8
+  %34 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 34)
+  %35 = call ptr @"github.com/goplus/llgo/internal/runtime.ArrayOf"(i64 8, ptr %34)
+  %36 = call %"github.com/goplus/llgo/internal/abi.StructField" @"github.com/goplus/llgo/internal/runtime.StructField"(%"github.com/goplus/llgo/internal/runtime.String" %29, ptr %35, i64 72, %"github.com/goplus/llgo/internal/runtime.String" %33, i1 false)
+  %37 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
+  %38 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %37, i32 0, i32 0
+  store ptr @3, ptr %38, align 8
+  %39 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %37, i32 0, i32 1
+  store i64 8, ptr %39, align 4
+  %40 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %37, align 8
+  %41 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
+  %42 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %41, i32 0, i32 0
+  store ptr null, ptr %42, align 8
+  %43 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %41, i32 0, i32 1
+  store i64 0, ptr %43, align 4
+  %44 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %41, align 8
+  %45 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 44)
+  %46 = call %"github.com/goplus/llgo/internal/abi.StructField" @"github.com/goplus/llgo/internal/runtime.StructField"(%"github.com/goplus/llgo/internal/runtime.String" %40, ptr %45, i64 136, %"github.com/goplus/llgo/internal/runtime.String" %44, i1 false)
+  %47 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
+  %48 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %47, i32 0, i32 0
+  store ptr @4, ptr %48, align 8
+  %49 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %47, i32 0, i32 1
+  store i64 4, ptr %49, align 4
+  %50 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %47, align 8
+  %51 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 224)
+  %52 = getelementptr %"github.com/goplus/llgo/internal/abi.StructField", ptr %51, i64 0
+  store %"github.com/goplus/llgo/internal/abi.StructField" %14, ptr %52, align 8
+  %53 = getelementptr %"github.com/goplus/llgo/internal/abi.StructField", ptr %51, i64 1
+  store %"github.com/goplus/llgo/internal/abi.StructField" %25, ptr %53, align 8
+  %54 = getelementptr %"github.com/goplus/llgo/internal/abi.StructField", ptr %51, i64 2
+  store %"github.com/goplus/llgo/internal/abi.StructField" %36, ptr %54, align 8
+  %55 = getelementptr %"github.com/goplus/llgo/internal/abi.StructField", ptr %51, i64 3
+  store %"github.com/goplus/llgo/internal/abi.StructField" %46, ptr %55, align 8
+  %56 = alloca %"github.com/goplus/llgo/internal/runtime.Slice", align 8
+  %57 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.Slice", ptr %56, i32 0, i32 0
+  store ptr %51, ptr %57, align 8
+  %58 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.Slice", ptr %56, i32 0, i32 1
+  store i64 4, ptr %58, align 4
+  %59 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.Slice", ptr %56, i32 0, i32 2
+  store i64 4, ptr %59, align 4
+  %60 = load %"github.com/goplus/llgo/internal/runtime.Slice", ptr %56, align 8
+  %61 = call ptr @"github.com/goplus/llgo/internal/runtime.Struct"(%"github.com/goplus/llgo/internal/runtime.String" %50, i64 144, %"github.com/goplus/llgo/internal/runtime.Slice" %60)
+  %62 = call ptr @"github.com/goplus/llgo/internal/runtime.MapOf"(ptr %2, ptr %3, ptr %61, i64 4)
+  call void @"github.com/goplus/llgo/internal/runtime.SetDirectIface"(ptr %62)
+  store ptr %62, ptr @"map[_llgo_int]_llgo_int", align 8
   br label %_llgo_2
 
 _llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
-  %3 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
-  %4 = icmp eq ptr %3, null
-  br i1 %4, label %_llgo_3, label %_llgo_4
-
-_llgo_3:                                          ; preds = %_llgo_2
-  %5 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 34)
-  %6 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 34)
-  %7 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
-  %8 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %7, i32 0, i32 0
-  store ptr @0, ptr %8, align 8
-  %9 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %7, i32 0, i32 1
-  store i64 7, ptr %9, align 4
-  %10 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %7, align 8
-  %11 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
-  %12 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %11, i32 0, i32 0
-  store ptr null, ptr %12, align 8
-  %13 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %11, i32 0, i32 1
-  store i64 0, ptr %13, align 4
-  %14 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %11, align 8
-  %15 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 40)
-  %16 = call ptr @"github.com/goplus/llgo/internal/runtime.ArrayOf"(i64 8, ptr %15)
-  %17 = call %"github.com/goplus/llgo/internal/abi.StructField" @"github.com/goplus/llgo/internal/runtime.StructField"(%"github.com/goplus/llgo/internal/runtime.String" %10, ptr %16, i64 0, %"github.com/goplus/llgo/internal/runtime.String" %14, i1 false)
-  %18 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
-  %19 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %18, i32 0, i32 0
-  store ptr @1, ptr %19, align 8
-  %20 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %18, i32 0, i32 1
-  store i64 4, ptr %20, align 4
-  %21 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %18, align 8
-  %22 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
-  %23 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %22, i32 0, i32 0
-  store ptr null, ptr %23, align 8
-  %24 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %22, i32 0, i32 1
-  store i64 0, ptr %24, align 4
-  %25 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %22, align 8
-  %26 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 34)
-  %27 = call ptr @"github.com/goplus/llgo/internal/runtime.ArrayOf"(i64 8, ptr %26)
-  %28 = call %"github.com/goplus/llgo/internal/abi.StructField" @"github.com/goplus/llgo/internal/runtime.StructField"(%"github.com/goplus/llgo/internal/runtime.String" %21, ptr %27, i64 8, %"github.com/goplus/llgo/internal/runtime.String" %25, i1 false)
-  %29 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
-  %30 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %29, i32 0, i32 0
-  store ptr @2, ptr %30, align 8
-  %31 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %29, i32 0, i32 1
-  store i64 5, ptr %31, align 4
-  %32 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %29, align 8
-  %33 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
-  %34 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %33, i32 0, i32 0
-  store ptr null, ptr %34, align 8
-  %35 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %33, i32 0, i32 1
-  store i64 0, ptr %35, align 4
-  %36 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %33, align 8
-  %37 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 34)
-  %38 = call ptr @"github.com/goplus/llgo/internal/runtime.ArrayOf"(i64 8, ptr %37)
-  %39 = call %"github.com/goplus/llgo/internal/abi.StructField" @"github.com/goplus/llgo/internal/runtime.StructField"(%"github.com/goplus/llgo/internal/runtime.String" %32, ptr %38, i64 72, %"github.com/goplus/llgo/internal/runtime.String" %36, i1 false)
-  %40 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
-  %41 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %40, i32 0, i32 0
-  store ptr @3, ptr %41, align 8
-  %42 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %40, i32 0, i32 1
-  store i64 8, ptr %42, align 4
-  %43 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %40, align 8
-  %44 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
-  %45 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %44, i32 0, i32 0
-  store ptr null, ptr %45, align 8
-  %46 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %44, i32 0, i32 1
-  store i64 0, ptr %46, align 4
-  %47 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %44, align 8
-  %48 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 44)
-  %49 = call %"github.com/goplus/llgo/internal/abi.StructField" @"github.com/goplus/llgo/internal/runtime.StructField"(%"github.com/goplus/llgo/internal/runtime.String" %43, ptr %48, i64 136, %"github.com/goplus/llgo/internal/runtime.String" %47, i1 false)
-  %50 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
-  %51 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %50, i32 0, i32 0
-  store ptr @4, ptr %51, align 8
-  %52 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %50, i32 0, i32 1
-  store i64 4, ptr %52, align 4
-  %53 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %50, align 8
-  %54 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 224)
-  %55 = getelementptr %"github.com/goplus/llgo/internal/abi.StructField", ptr %54, i64 0
-  store %"github.com/goplus/llgo/internal/abi.StructField" %17, ptr %55, align 8
-  %56 = getelementptr %"github.com/goplus/llgo/internal/abi.StructField", ptr %54, i64 1
-  store %"github.com/goplus/llgo/internal/abi.StructField" %28, ptr %56, align 8
-  %57 = getelementptr %"github.com/goplus/llgo/internal/abi.StructField", ptr %54, i64 2
-  store %"github.com/goplus/llgo/internal/abi.StructField" %39, ptr %57, align 8
-  %58 = getelementptr %"github.com/goplus/llgo/internal/abi.StructField", ptr %54, i64 3
-  store %"github.com/goplus/llgo/internal/abi.StructField" %49, ptr %58, align 8
-  %59 = alloca %"github.com/goplus/llgo/internal/runtime.Slice", align 8
-  %60 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.Slice", ptr %59, i32 0, i32 0
-  store ptr %54, ptr %60, align 8
-  %61 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.Slice", ptr %59, i32 0, i32 1
-  store i64 4, ptr %61, align 4
-  %62 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.Slice", ptr %59, i32 0, i32 2
-  store i64 4, ptr %62, align 4
-  %63 = load %"github.com/goplus/llgo/internal/runtime.Slice", ptr %59, align 8
-  %64 = call ptr @"github.com/goplus/llgo/internal/runtime.Struct"(%"github.com/goplus/llgo/internal/runtime.String" %53, i64 144, %"github.com/goplus/llgo/internal/runtime.Slice" %63)
-  %65 = call ptr @"github.com/goplus/llgo/internal/runtime.MapOf"(ptr %5, ptr %6, ptr %64, i64 4)
-  call void @"github.com/goplus/llgo/internal/runtime.SetDirectIface"(ptr %65)
-  store ptr %65, ptr @"map[_llgo_int]_llgo_int", align 8
-  br label %_llgo_4
-
-_llgo_4:                                          ; preds = %_llgo_3, %_llgo_2
   ret void
 }
 
-declare ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64)
-
 declare ptr @"github.com/goplus/llgo/internal/runtime.MapOf"(ptr, ptr, ptr, i64)
 
+declare ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64)
+
 declare ptr @"github.com/goplus/llgo/internal/runtime.Struct"(%"github.com/goplus/llgo/internal/runtime.String", i64, %"github.com/goplus/llgo/internal/runtime.Slice")
 
 declare %"github.com/goplus/llgo/internal/abi.StructField" @"github.com/goplus/llgo/internal/runtime.StructField"(%"github.com/goplus/llgo/internal/runtime.String", ptr, i64, %"github.com/goplus/llgo/internal/runtime.String", i1)

cl/async.go

@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cl
+
+import (
+	"go/constant"
+	"go/types"
+	"strings"
+
+	llssa "github.com/goplus/llgo/ssa"
+	"golang.org/x/tools/go/ssa"
+)
+
+// TODO(lijie): need more generics, shouldn't limit to async.Promise
+func promiseType(ty types.Type) (types.Type, bool) {
+	// ty is a generic type, so we need to check the package path and type name
+	if ptrTy, ok := ty.(*types.Pointer); ok {
+		ty = ptrTy.Elem()
+		if ty, ok := ty.(*types.Named); ok {
+			if ty.Obj().Pkg() == nil {
+				return nil, false
+			}
+			if ty.Obj().Pkg().Path() == "github.com/goplus/llgo/x/async" && ty.Obj().Name() == "Promise" {
+				return ty, true
+			}
+		}
+	}
+	return nil, false
+}
+
+// check function return async.Promise[T]
+// TODO(lijie): make it generic
+func isAsyncFunc(sig *types.Signature) bool {
+	r := sig.Results()
+	if r.Len() != 1 {
+		return false
+	}
+	ty := r.At(0).Type()
+	_, ok := promiseType(ty)
+	return ok
+}
+
+func (p *context) coAwait(b llssa.Builder, args []ssa.Value) llssa.Expr {
+	if !isAsyncFunc(b.Func.RawType().(*types.Signature)) {
+		panic("coAwait(promise *T) T: invalid context")
+	}
+	if len(args) == 1 {
+		// promise := p.compileValue(b, args[0])
+		b.Unreachable()
+		// return b.CoroutineAwait(promise)
+	}
+	panic("coAwait(promise *T) T: invalid arguments")
+}
+
+func (p *context) coSuspend(b llssa.Builder, final llssa.Expr) {
+	b.CoSuspend(b.AsyncToken(), final, nil)
+}
+
+func (p *context) coDone(b llssa.Builder, args []ssa.Value) llssa.Expr {
+	if len(args) != 1 {
+		panic("coDone(promise *T): invalid arguments")
+	}
+	hdl := p.compileValue(b, args[0])
+	return b.CoDone(hdl)
+}
+
+func (p *context) coResume(b llssa.Builder, args []ssa.Value) {
+	if len(args) == 1 {
+		hdl := p.compileValue(b, args[0])
+		b.CoResume(hdl)
+	}
+}
+
+func (p *context) getSetValueFunc(fn *ssa.Function) llssa.Function {
+	typ := fn.Signature.Recv().Type()
+	mthds := p.goProg.MethodSets.MethodSet(typ)
+	for i := 0; i < mthds.Len(); i++ {
+		m := mthds.At(i)
+		if ssaMthd := p.goProg.MethodValue(m); ssaMthd != nil {
+			if ssaMthd.Name() == "setValue" || strings.HasPrefix(ssaMthd.Name(), "setValue[") {
+				setValueFn, _, _ := p.compileFunction(ssaMthd)
+				return setValueFn
+			}
+		}
+	}
+	panic("method setValue not found on type " + typ.String())
+}
+
+func (p *context) coReturn(b llssa.Builder, fn *ssa.Function, args []ssa.Value) {
+	setValueFn := p.getSetValueFunc(fn)
+	value := p.compileValue(b, args[1])
+	b.CoReturn(setValueFn, value)
+}
+
+func (p *context) coYield(b llssa.Builder, fn *ssa.Function, args []ssa.Value) {
+	setValueFn := p.getSetValueFunc(fn)
+	value := p.compileValue(b, args[1])
+	// TODO(lijie): find whether the co.Yield/co.Return is the last instruction
+	final := b.Const(constant.MakeBool(false), b.Prog.Bool())
+	b.CoYield(setValueFn, value, final)
+}
+
+func (p *context) coRun(b llssa.Builder, args []ssa.Value) {
+	panic("coRun(): not implemented")
+}

cl/compile.go

@@ -98,9 +98,8 @@ type context struct {
 	patches  Patches
 	blkInfos []blocks.Info
 
-	inits     []func()
-	phis      []func()
-	initAfter func()
+	inits []func()
+	phis  []func()
 
 	state   pkgState
 	inCFunc bool
@@ -219,6 +218,7 @@ func (p *context) compileFuncDecl(pkg llssa.Package, f *ssa.Function) (llssa.Fun
 			log.Println("==> NewFunc", name, "type:", sig.Recv(), sig, "ftype:", ftype)
 		}
 	}
+	async := isAsyncFunc(f.Signature)
 	if fn == nil {
 		if name == "main" {
 			argc := types.NewParam(token.NoPos, pkgTypes, "", types.Typ[types.Int32])
@@ -228,13 +228,24 @@ func (p *context) compileFuncDecl(pkg llssa.Package, f *ssa.Function) (llssa.Fun
 			results := types.NewTuple(ret)
 			sig = types.NewSignatureType(nil, nil, nil, params, results, false)
 		}
-		fn = pkg.NewFuncEx(name, sig, llssa.Background(ftype), hasCtx)
+		fn = pkg.NewFuncEx(name, sig, llssa.Background(ftype), hasCtx, async)
 	}
-
+	nBlkOff := 0
 	if nblk := len(f.Blocks); nblk > 0 {
-		fn.MakeBlocks(nblk)   // to set fn.HasBody() = true
+		var entryBlk, allocBlk, cleanBlk, suspdBlk, trapBlk, beginBlk llssa.BasicBlock
+		if async {
+			nBlkOff = 5
+			entryBlk = fn.MakeBlock("entry")
+			allocBlk = fn.MakeBlock("alloc")
+			cleanBlk = fn.MakeBlock("clean")
+			suspdBlk = fn.MakeBlock("suspend")
+			trapBlk = fn.MakeBlock("trap")
+		}
+		fn.MakeBlocks(nblk) // to set fn.HasBody() = true
+		beginBlk = fn.Block(nBlkOff)
 		if f.Recover != nil { // set recover block
-			fn.SetRecover(fn.Block(f.Recover.Index))
+			// TODO(lijie): fix this for async function because of the block offset increase
+			fn.SetRecover(fn.Block(f.Recover.Index + nBlkOff))
 		}
 		p.inits = append(p.inits, func() {
 			p.fn = fn
@@ -250,6 +261,10 @@ func (p *context) compileFuncDecl(pkg llssa.Package, f *ssa.Function) (llssa.Fun
 				log.Println("==> FuncBody", name)
 			}
 			b := fn.NewBuilder()
+			b.SetBlockOffset(nBlkOff)
+			if async {
+				b.BeginAsync(fn, entryBlk, allocBlk, cleanBlk, suspdBlk, trapBlk, beginBlk)
+			}
 			p.bvals = make(map[ssa.Value]llssa.Expr)
 			off := make([]int, len(f.Blocks))
 			for i, block := range f.Blocks {
@@ -285,7 +300,7 @@ func (p *context) compileBlock(b llssa.Builder, block *ssa.BasicBlock, n int, do
 	var pkg = p.pkg
 	var fn = p.fn
 	var instrs = block.Instrs[n:]
-	var ret = fn.Block(block.Index)
+	var ret = fn.Block(block.Index + b.BlockOffset())
 	b.SetBlock(ret)
 	if doModInit {
 		if pyModInit = p.pyMod != ""; pyModInit {
@@ -293,9 +308,9 @@ func (p *context) compileBlock(b llssa.Builder, block *ssa.BasicBlock, n int, do
 			instrs = instrs[:last]
 		} else if p.state != pkgHasPatch {
 			// TODO(xsw): confirm pyMod don't need to call AfterInit
-			p.initAfter = func() {
+			p.inits = append(p.inits, func() {
 				pkg.AfterInit(b, ret)
-			}
+			})
 		}
 	} else if doMainInit {
 		argc := pkg.NewVar("__llgo_argc", types.NewPointer(types.Typ[types.Int32]), llssa.InC)
@@ -323,7 +338,7 @@ func (p *context) compileBlock(b llssa.Builder, block *ssa.BasicBlock, n int, do
 		modPtr := pkg.PyNewModVar(modName, true).Expr
 		mod := b.Load(modPtr)
 		cond := b.BinOp(token.NEQ, mod, prog.Nil(mod.Type))
-		newBlk := fn.MakeBlock()
+		newBlk := fn.MakeBlock("")
 		b.If(cond, jumpTo, newBlk)
 		b.SetBlockEx(newBlk, llssa.AtEnd, false)
 		b.Store(modPtr, b.PyImportMod(modPath))
@@ -655,7 +670,11 @@ func (p *context) compileInstr(b llssa.Builder, instr ssa.Instruction) {
 			results = make([]llssa.Expr, 1)
 			results[0] = p.prog.IntVal(0, p.prog.CInt())
 		}
-		b.Return(results...)
+		if b.Async() {
+			b.EndAsync()
+		} else {
+			b.Return(results...)
+		}
 	case *ssa.If:
 		fn := p.fn
 		cond := p.compileValue(b, v.Cond)
@@ -838,10 +857,6 @@ func NewPackageEx(prog llssa.Program, patches Patches, pkg *ssa.Package, files [
 			ini()
 		}
 	}
-	if fn := ctx.initAfter; fn != nil {
-		ctx.initAfter = nil
-		fn()
-	}
 	return
 }
 

cl/compile_test.go

@@ -53,7 +53,7 @@ func TestFromTestrt(t *testing.T) {
 }
 
 func TestFromTestdata(t *testing.T) {
-	cltest.FromDir(t, "", "./_testdata", false)
+	cltest.FromDir(t, "", "./_testdata", true)
 }
 
 func TestFromTestpymath(t *testing.T) {
@@ -124,3 +124,114 @@ _llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
 }
 `)
 }
+
+func TestAsyncFunc(t *testing.T) {
+	testCompile(t, `package foo
+
+import "github.com/goplus/llgo/x/async"
+
+func GenInts() (co *async.Promise[int]) {
+  co.Yield(1)
+  co.Yield(2)
+  return
+}
+`, `; ModuleID = 'foo'
+source_filename = "foo"
+
+@"foo.init$guard" = global i1 false, align 1
+
+define ptr @foo.GenInts() presplitcoroutine {
+entry:
+  %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
+  %frame.size = call i64 @llvm.coro.size.i64()
+  %alloc.size = add i64 16, %frame.size
+  %promise = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 %alloc.size)
+  %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
+  br i1 %need.dyn.alloc, label %alloc, label %_llgo_5
+
+alloc:                                            ; preds = %entry
+  %0 = getelementptr ptr, ptr %promise, i64 16
+  br label %_llgo_5
+
+clean:                                            ; preds = %_llgo_7, %_llgo_6, %_llgo_5
+  %1 = call ptr @llvm.coro.free(token %id, ptr %hdl)
+  br label %suspend
+
+suspend:                                          ; preds = %_llgo_7, %_llgo_6, %_llgo_5, %clean
+  %2 = call i1 @llvm.coro.end(ptr %hdl, i1 false, token none)
+  ret ptr %promise
+
+trap:                                             ; preds = %_llgo_7
+  call void @llvm.trap()
+  unreachable
+
+_llgo_5:                                          ; preds = %alloc, %entry
+  %frame = phi ptr [ null, %entry ], [ %0, %alloc ]
+  %hdl = call ptr @llvm.coro.begin(token %id, ptr %frame)
+  store ptr %hdl, ptr %promise, align 8
+  call void @"github.com/goplus/llgo/x/async.(*Promise).setValue[int]"(ptr %promise, i64 1)
+  %3 = call i8 @llvm.coro.suspend(token %id, i1 false)
+  switch i8 %3, label %suspend [
+    i8 0, label %_llgo_6
+    i8 1, label %clean
+  ]
+
+_llgo_6:                                          ; preds = %_llgo_5
+  call void @"github.com/goplus/llgo/x/async.(*Promise).setValue[int]"(ptr %promise, i64 2)
+  %4 = call i8 @llvm.coro.suspend(token %id, i1 false)
+  switch i8 %4, label %suspend [
+    i8 0, label %_llgo_7
+    i8 1, label %clean
+  ]
+
+_llgo_7:                                          ; preds = %_llgo_6
+  %5 = call i8 @llvm.coro.suspend(token %id, i1 true)
+  switch i8 %5, label %suspend [
+    i8 0, label %trap
+    i8 1, label %clean
+  ]
+}
+
+define void @foo.init() {
+_llgo_0:
+  %0 = load i1, ptr @"foo.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"foo.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
+
+; Function Attrs: nounwind memory(none)
+declare i64 @llvm.coro.size.i64()
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64)
+
+; Function Attrs: nounwind
+declare i1 @llvm.coro.alloc(token)
+
+; Function Attrs: nounwind
+declare ptr @llvm.coro.begin(token, ptr writeonly)
+
+; Function Attrs: nounwind memory(argmem: read)
+declare ptr @llvm.coro.free(token, ptr nocapture readonly)
+
+; Function Attrs: nounwind
+declare i1 @llvm.coro.end(ptr, i1, token)
+
+; Function Attrs: cold noreturn nounwind memory(inaccessiblemem: write)
+declare void @llvm.trap()
+
+declare void @"github.com/goplus/llgo/x/async.(*Promise).setValue[int]"(ptr, i64)
+
+; Function Attrs: nounwind
+declare i8 @llvm.coro.suspend(token, i1)
+
+`)
+}

cl/import.go

@@ -412,7 +412,16 @@ const (
 	llgoAtomicUMax = llgoAtomicOpBase + llssa.OpUMax
 	llgoAtomicUMin = llgoAtomicOpBase + llssa.OpUMin
 
-	llgoAtomicOpLast = llgoAtomicOpBase + int(llssa.OpUMin)
+	llgoCoBase    = llgoInstrBase + 0x30
+	llgoCoAwait   = llgoCoBase + 0
+	llgoCoSuspend = llgoCoBase + 1
+	llgoCoDone    = llgoCoBase + 2
+	llgoCoResume  = llgoCoBase + 3
+	llgoCoReturn  = llgoCoBase + 4
+	llgoCoYield   = llgoCoBase + 5
+	llgoCoRun     = llgoCoBase + 6
+
+	llgoAtomicOpLast = llgoCoRun
 )
 
 func (p *context) funcName(fn *ssa.Function, ignore bool) (*types.Package, string, int) {

cl/instr.go

@@ -133,7 +133,7 @@ func (p *context) stringData(b llssa.Builder, args []ssa.Value) (ret llssa.Expr)
 }
 
 // func funcAddr(fn any) unsafe.Pointer
-func (p *context) funcAddr(_ llssa.Builder, args []ssa.Value) llssa.Expr {
+func (p *context) funcAddr(b llssa.Builder, args []ssa.Value) llssa.Expr {
 	if len(args) == 1 {
 		if fn, ok := args[0].(*ssa.MakeInterface); ok {
 			if fnDecl, ok := fn.X.(*ssa.Function); ok {
@@ -237,6 +237,14 @@ var llgoInstrs = map[string]int{
 	"atomicMin":  int(llgoAtomicMin),
 	"atomicUMax": int(llgoAtomicUMax),
 	"atomicUMin": int(llgoAtomicUMin),
+
+	"coAwait":   int(llgoCoAwait),
+	"coResume":  int(llgoCoResume),
+	"coSuspend": int(llgoCoSuspend),
+	"coDone":    int(llgoCoDone),
+	"coReturn":  int(llgoCoReturn),
+	"coYield":   int(llgoCoYield),
+	"coRun":     int(llgoCoRun),
 }
 
 // funcOf returns a function by name and set ftype = goFunc, cFunc, etc.
@@ -265,7 +273,8 @@ func (p *context) funcOf(fn *ssa.Function) (aFn llssa.Function, pyFn llssa.PyObj
 				return nil, nil, ignoredFunc
 			}
 			sig := fn.Signature
-			aFn = pkg.NewFuncEx(name, sig, llssa.Background(ftype), false)
+			async := isAsyncFunc(sig)
+			aFn = pkg.NewFuncEx(name, sig, llssa.Background(ftype), false, async)
 		}
 	}
 	return
@@ -390,6 +399,20 @@ func (p *context) call(b llssa.Builder, act llssa.DoAction, call *ssa.CallCommon
 			ret = p.funcAddr(b, args)
 		case llgoUnreachable: // func unreachable()
 			b.Unreachable()
+		case llgoCoAwait:
+			ret = p.coAwait(b, args)
+		case llgoCoSuspend:
+			p.coSuspend(b, p.prog.BoolVal(false))
+		case llgoCoDone:
+			return p.coDone(b, args)
+		case llgoCoResume:
+			p.coResume(b, args)
+		case llgoCoReturn:
+			p.coReturn(b, cv, args)
+		case llgoCoYield:
+			p.coYield(b, cv, args)
+		case llgoCoRun:
+			p.coRun(b, args)
 		default:
 			if ftype >= llgoAtomicOpBase && ftype <= llgoAtomicOpLast {
 				ret = p.atomic(b, llssa.AtomicOp(ftype-llgoAtomicOpBase), args)

go.mod

@@ -7,7 +7,7 @@ require (
 	github.com/goplus/llvm v0.8.0
 	github.com/goplus/mod v0.13.12
 	github.com/qiniu/x v1.13.10
-	golang.org/x/tools v0.19.0
+	golang.org/x/tools v0.22.0
 )
 
 require (

go.sum

@@ -10,5 +10,5 @@ golang.org/x/mod v0.19.0 h1:fEdghXQSo20giMthA7cd28ZC+jts4amQ3YMXiP5oMQ8=
 golang.org/x/mod v0.19.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/tools v0.19.0 h1:tfGCXNR1OsFG+sVdLAitlpjAvD/I6dHDKnYrpEZUHkw=
-golang.org/x/tools v0.19.0/go.mod h1:qoJWxmGSIBmAeriMx19ogtrEPrGtDbPK634QFIcLAhc=
+golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
+golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=

internal/build/build.go

@@ -757,13 +757,11 @@ func findDylibDep(exe, lib string) string {
 type none struct{}
 
 var hasAltPkg = map[string]none{
-	"crypto/hmac":              {},
 	"crypto/md5":               {},
-	"crypto/rand":              {},
 	"crypto/sha1":              {},
 	"crypto/sha256":            {},
 	"crypto/sha512":            {},
-	"crypto/subtle":            {},
+	"crypto/rand":              {},
 	"fmt":                      {},
 	"hash/crc32":               {},
 	"internal/abi":             {},

internal/lib/crypto/hmac/hmac.go

@@ -1,72 +0,0 @@
-package hmac
-
-// llgo:skipall
-import (
-	"crypto/sha256"
-	"crypto/subtle"
-	"hash"
-	"unsafe"
-
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/openssl"
-)
-
-type eface struct {
-	_type   unsafe.Pointer
-	funcPtr *unsafe.Pointer
-}
-
-func funcOf(a any) unsafe.Pointer {
-	e := (*eface)(unsafe.Pointer(&a))
-	return *e.funcPtr
-}
-
-type digest openssl.HMAC_CTX
-
-func (d *digest) Size() int { panic("todo: hmac.(*digest).Size") }
-
-func (d *digest) BlockSize() int { panic("todo: hmac.(*digest).BlockSize") }
-
-func (d *digest) Reset() {
-	(*openssl.HMAC_CTX)(d).Reset()
-}
-
-func (d *digest) Write(p []byte) (nn int, err error) {
-	(*openssl.HMAC_CTX)(d).UpdateBytes(p)
-	return len(p), nil
-}
-
-func (d *digest) Sum(in []byte) []byte {
-	const Size = openssl.EVP_MAX_MD_SIZE
-	var digestLen c.Uint
-	hash := (*[Size]byte)(c.Alloca(Size))
-	(*openssl.HMAC_CTX)(d).Final(&hash[0], &digestLen)
-	return append(in, hash[:digestLen]...)
-}
-
-// New returns a new HMAC hash using the given [hash.Hash] type and key.
-// New functions like sha256.New from [crypto/sha256] can be used as h.
-// h must return a new Hash every time it is called.
-// Note that unlike other hash implementations in the standard library,
-// the returned Hash does not implement [encoding.BinaryMarshaler]
-// or [encoding.BinaryUnmarshaler].
-func New(h func() hash.Hash, key []byte) hash.Hash {
-	var md *openssl.EVP_MD
-	switch funcOf(h) {
-	case c.Func(sha256.New):
-		md = openssl.EVP_sha256()
-	default:
-		panic("todo: hmac.New: unsupported hash function")
-	}
-	ctx := openssl.NewHMAC_CTX()
-	ctx.InitBytes(key, md)
-	return (*digest)(ctx)
-}
-
-// Equal compares two MACs for equality without leaking timing information.
-func Equal(mac1, mac2 []byte) bool {
-	// We don't have to be constant time if the lengths of the MACs are
-	// different as that suggests that a completely different hash function
-	// was used.
-	return subtle.ConstantTimeCompare(mac1, mac2) == 1
-}

internal/lib/crypto/sha1/sha1.go

@@ -1,19 +1,3 @@
-/*
- * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package sha1
 
 // llgo:skipall

internal/lib/crypto/sha256/sha224.go

@@ -1,19 +1,3 @@
-/*
- * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package sha256
 
 import (

internal/lib/crypto/sha256/sha256.go

@@ -1,19 +1,3 @@
-/*
- * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package sha256
 
 // llgo:skipall

internal/lib/crypto/sha512/sha384.go

@@ -1,19 +1,3 @@
-/*
- * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package sha512
 
 import (

internal/lib/crypto/sha512/sha512.go

@@ -1,19 +1,3 @@
-/*
- * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package sha512
 
 // llgo:skipall

internal/lib/internal/fmtsort/sort.go

@@ -1,220 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package fmtsort provides a general stable ordering mechanism
-// for maps, on behalf of the fmt and text/template packages.
-// It is not guaranteed to be efficient and works only for types
-// that are valid map keys.
-package fmtsort
-
-// llgo:skipall
-import (
-	"reflect"
-	"sort"
-)
-
-// Note: Throughout this package we avoid calling reflect.Value.Interface as
-// it is not always legal to do so and it's easier to avoid the issue than to face it.
-
-// SortedMap represents a map's keys and values. The keys and values are
-// aligned in index order: Value[i] is the value in the map corresponding to Key[i].
-type SortedMap struct {
-	Key   []reflect.Value
-	Value []reflect.Value
-}
-
-func (o *SortedMap) Len() int           { return len(o.Key) }
-func (o *SortedMap) Less(i, j int) bool { return compare(o.Key[i], o.Key[j]) < 0 }
-func (o *SortedMap) Swap(i, j int) {
-	o.Key[i], o.Key[j] = o.Key[j], o.Key[i]
-	o.Value[i], o.Value[j] = o.Value[j], o.Value[i]
-}
-
-// Sort accepts a map and returns a SortedMap that has the same keys and
-// values but in a stable sorted order according to the keys, modulo issues
-// raised by unorderable key values such as NaNs.
-//
-// The ordering rules are more general than with Go's < operator:
-//
-//   - when applicable, nil compares low
-//   - ints, floats, and strings order by <
-//   - NaN compares less than non-NaN floats
-//   - bool compares false before true
-//   - complex compares real, then imag
-//   - pointers compare by machine address
-//   - channel values compare by machine address
-//   - structs compare each field in turn
-//   - arrays compare each element in turn.
-//     Otherwise identical arrays compare by length.
-//   - interface values compare first by reflect.Type describing the concrete type
-//     and then by concrete value as described in the previous rules.
-func Sort(mapValue reflect.Value) *SortedMap {
-	if mapValue.Type().Kind() != reflect.Map {
-		return nil
-	}
-	// Note: this code is arranged to not panic even in the presence
-	// of a concurrent map update. The runtime is responsible for
-	// yelling loudly if that happens. See issue 33275.
-	n := mapValue.Len()
-	key := make([]reflect.Value, 0, n)
-	value := make([]reflect.Value, 0, n)
-	iter := mapValue.MapRange()
-	for iter.Next() {
-		key = append(key, iter.Key())
-		value = append(value, iter.Value())
-	}
-	sorted := &SortedMap{
-		Key:   key,
-		Value: value,
-	}
-	sort.Stable(sorted)
-	return sorted
-}
-
-// compare compares two values of the same type. It returns -1, 0, 1
-// according to whether a > b (1), a == b (0), or a < b (-1).
-// If the types differ, it returns -1.
-// See the comment on Sort for the comparison rules.
-func compare(aVal, bVal reflect.Value) int {
-	aType, bType := aVal.Type(), bVal.Type()
-	if aType != bType {
-		return -1 // No good answer possible, but don't return 0: they're not equal.
-	}
-	switch aVal.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		a, b := aVal.Int(), bVal.Int()
-		switch {
-		case a < b:
-			return -1
-		case a > b:
-			return 1
-		default:
-			return 0
-		}
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		a, b := aVal.Uint(), bVal.Uint()
-		switch {
-		case a < b:
-			return -1
-		case a > b:
-			return 1
-		default:
-			return 0
-		}
-	case reflect.String:
-		a, b := aVal.String(), bVal.String()
-		switch {
-		case a < b:
-			return -1
-		case a > b:
-			return 1
-		default:
-			return 0
-		}
-	case reflect.Float32, reflect.Float64:
-		return floatCompare(aVal.Float(), bVal.Float())
-	case reflect.Complex64, reflect.Complex128:
-		a, b := aVal.Complex(), bVal.Complex()
-		if c := floatCompare(real(a), real(b)); c != 0 {
-			return c
-		}
-		return floatCompare(imag(a), imag(b))
-	case reflect.Bool:
-		a, b := aVal.Bool(), bVal.Bool()
-		switch {
-		case a == b:
-			return 0
-		case a:
-			return 1
-		default:
-			return -1
-		}
-	case reflect.Pointer, reflect.UnsafePointer:
-		a, b := aVal.Pointer(), bVal.Pointer()
-		switch {
-		case a < b:
-			return -1
-		case a > b:
-			return 1
-		default:
-			return 0
-		}
-	case reflect.Chan:
-		if c, ok := nilCompare(aVal, bVal); ok {
-			return c
-		}
-		ap, bp := aVal.Pointer(), bVal.Pointer()
-		switch {
-		case ap < bp:
-			return -1
-		case ap > bp:
-			return 1
-		default:
-			return 0
-		}
-	case reflect.Struct:
-		for i := 0; i < aVal.NumField(); i++ {
-			if c := compare(aVal.Field(i), bVal.Field(i)); c != 0 {
-				return c
-			}
-		}
-		return 0
-	case reflect.Array:
-		for i := 0; i < aVal.Len(); i++ {
-			if c := compare(aVal.Index(i), bVal.Index(i)); c != 0 {
-				return c
-			}
-		}
-		return 0
-	case reflect.Interface:
-		if c, ok := nilCompare(aVal, bVal); ok {
-			return c
-		}
-		c := compare(reflect.ValueOf(aVal.Elem().Type()), reflect.ValueOf(bVal.Elem().Type()))
-		if c != 0 {
-			return c
-		}
-		return compare(aVal.Elem(), bVal.Elem())
-	default:
-		// Certain types cannot appear as keys (maps, funcs, slices), but be explicit.
-		panic("bad type in compare: " + aType.String())
-	}
-}
-
-// nilCompare checks whether either value is nil. If not, the boolean is false.
-// If either value is nil, the boolean is true and the integer is the comparison
-// value. The comparison is defined to be 0 if both are nil, otherwise the one
-// nil value compares low. Both arguments must represent a chan, func,
-// interface, map, pointer, or slice.
-func nilCompare(aVal, bVal reflect.Value) (int, bool) {
-	if aVal.IsNil() {
-		if bVal.IsNil() {
-			return 0, true
-		}
-		return -1, true
-	}
-	if bVal.IsNil() {
-		return 1, true
-	}
-	return 0, false
-}
-
-// floatCompare compares two floating-point values. NaNs compare low.
-func floatCompare(a, b float64) int {
-	switch {
-	case isNaN(a):
-		return -1 // No good answer if b is a NaN so don't bother checking.
-	case isNaN(b):
-		return 1
-	case a < b:
-		return -1
-	case a > b:
-		return 1
-	}
-	return 0
-}
-
-func isNaN(a float64) bool {
-	return a != a
-}

internal/lib/math/big/int.go

@@ -18,9 +18,6 @@ package big
 
 // llgo:skipall
 import (
-	"math/rand"
-
-	"github.com/goplus/llgo/c"
 	"github.com/goplus/llgo/c/openssl"
 )
 
@@ -84,34 +81,9 @@ func NewInt(x int64) *Int {
 	return z.SetInt64(x)
 }
 
+/*
 // Set sets z to x and returns z.
 func (z *Int) Set(x *Int) *Int {
-	if z != x {
-		a := (*openssl.BIGNUM)(z)
-		b := (*openssl.BIGNUM)(x)
-		a.Copy(b)
-	}
-	return z
-}
-
-// Abs sets z to |x| (the absolute value of x) and returns z.
-func (z *Int) Abs(x *Int) *Int {
-	z.Set(x)
-	a := (*openssl.BIGNUM)(z)
-	a.SetNegative(0)
-	return z
-}
-
-// Neg sets z to -x and returns z.
-func (z *Int) Neg(x *Int) *Int {
-	z.Set(x)
-	a := (*openssl.BIGNUM)(z)
-	if a.IsNegative() != 0 {
-		a.SetNegative(0)
-	} else {
-		a.SetNegative(1)
-	}
-	return z
 }
 
 // Bits provides raw (unchecked but fast) access to x by returning its
@@ -120,7 +92,6 @@ func (z *Int) Neg(x *Int) *Int {
 // Bits is intended to support implementation of missing low-level Int
 // functionality outside this package; it should be avoided otherwise.
 func (x *Int) Bits() []Word {
-	panic("todo big.Bits")
 }
 
 // SetBits provides raw (unchecked but fast) access to z by setting its
@@ -129,9 +100,17 @@ func (x *Int) Bits() []Word {
 // SetBits is intended to support implementation of missing low-level Int
 // functionality outside this package; it should be avoided otherwise.
 func (z *Int) SetBits(abs []Word) *Int {
-	panic("todo big.SetBits")
 }
 
+// Abs sets z to |x| (the absolute value of x) and returns z.
+func (z *Int) Abs(x *Int) *Int {
+}
+
+// Neg sets z to -x and returns z.
+func (z *Int) Neg(x *Int) *Int {
+}
+*/
+
 // Add sets z to the sum x+y and returns z.
 func (z *Int) Add(x, y *Int) *Int {
 	(*openssl.BIGNUM)(z).Add((*openssl.BIGNUM)(x), (*openssl.BIGNUM)(y))
@@ -144,35 +123,31 @@ func (z *Int) Sub(x, y *Int) *Int {
 	return z
 }
 
+/*
 // Mul sets z to the product x*y and returns z.
 func (z *Int) Mul(x, y *Int) *Int {
-	panic("todo big.Mul")
 }
 
 // MulRange sets z to the product of all integers
 // in the range [a, b] inclusively and returns z.
 // If a > b (empty range), the result is 1.
 func (z *Int) MulRange(a, b int64) *Int {
-	panic("todo big.MulRange")
 }
 
 // Binomial sets z to the binomial coefficient C(n, k) and returns z.
 func (z *Int) Binomial(n, k int64) *Int {
-	panic("todo big.Binomial")
 }
 
 // Quo sets z to the quotient x/y for y != 0 and returns z.
 // If y == 0, a division-by-zero run-time panic occurs.
 // Quo implements truncated division (like Go); see QuoRem for more details.
 func (z *Int) Quo(x, y *Int) *Int {
-	panic("todo big.Quo")
 }
 
 // Rem sets z to the remainder x%y for y != 0 and returns z.
 // If y == 0, a division-by-zero run-time panic occurs.
 // Rem implements truncated modulus (like Go); see QuoRem for more details.
 func (z *Int) Rem(x, y *Int) *Int {
-	panic("todo big.Rem")
 }
 
 // QuoRem sets z to the quotient x/y and r to the remainder x%y
@@ -187,21 +162,18 @@ func (z *Int) Rem(x, y *Int) *Int {
 // (See Daan Leijen, “Division and Modulus for Computer Scientists”.)
 // See DivMod for Euclidean division and modulus (unlike Go).
 func (z *Int) QuoRem(x, y, r *Int) (*Int, *Int) {
-	panic("todo big.QuoRem")
 }
 
 // Div sets z to the quotient x/y for y != 0 and returns z.
 // If y == 0, a division-by-zero run-time panic occurs.
 // Div implements Euclidean division (unlike Go); see DivMod for more details.
 func (z *Int) Div(x, y *Int) *Int {
-	panic("todo big.Div")
 }
 
 // Mod sets z to the modulus x%y for y != 0 and returns z.
 // If y == 0, a division-by-zero run-time panic occurs.
 // Mod implements Euclidean modulus (unlike Go); see DivMod for more details.
 func (z *Int) Mod(x, y *Int) *Int {
-	panic("todo big.Mod")
 }
 
 // DivMod sets z to the quotient x div y and m to the modulus x mod y
@@ -219,8 +191,8 @@ func (z *Int) Mod(x, y *Int) *Int {
 // ACM press.)
 // See QuoRem for T-division and modulus (like Go).
 func (z *Int) DivMod(x, y, m *Int) (*Int, *Int) {
-	panic("big.DivMod")
 }
+*/
 
 // Cmp compares x and y and returns:
 //
@@ -240,35 +212,29 @@ func (x *Int) CmpAbs(y *Int) int {
 	return int((*openssl.BIGNUM)(x).Ucmp((*openssl.BIGNUM)(y)))
 }
 
+/*
 // Int64 returns the int64 representation of x.
 // If x cannot be represented in an int64, the result is undefined.
 func (x *Int) Int64() int64 {
-	panic("todo big.Int64")
 }
 
 // Uint64 returns the uint64 representation of x.
 // If x cannot be represented in a uint64, the result is undefined.
 func (x *Int) Uint64() uint64 {
-	panic("todo big.Uint64")
 }
 
 // IsInt64 reports whether x can be represented as an int64.
 func (x *Int) IsInt64() bool {
-	panic("todo big.IsInt64")
 }
 
 // IsUint64 reports whether x can be represented as a uint64.
 func (x *Int) IsUint64() bool {
-	panic("todo big.IsUint64")
 }
 
 // Float64 returns the float64 value nearest x,
 // and an indication of any rounding that occurred.
 // TODO(xsw):
-/*
-func (x *Int) Float64() (float64, Accuracy) {
-	panic("todo big.Float64")
-}*/
+// func (x *Int) Float64() (float64, Accuracy)
 
 // SetString sets z to the value of s, interpreted in the given base,
 // and returns z and a boolean indicating success. The entire string
@@ -293,20 +259,17 @@ func (x *Int) Float64() (float64, Accuracy) {
 // are no other errors. If base != 0, underscores are not recognized
 // and act like any other character that is not a valid digit.
 func (z *Int) SetString(s string, base int) (*Int, bool) {
-	panic("todo big.SetString")
 }
 
 // SetBytes interprets buf as the bytes of a big-endian unsigned
 // integer, sets z to that value, and returns z.
 func (z *Int) SetBytes(buf []byte) *Int {
-	panic("todo big.SetBytes")
 }
 
 // Bytes returns the absolute value of x as a big-endian byte slice.
 //
 // To use a fixed length slice, or a preallocated one, use FillBytes.
 func (x *Int) Bytes() []byte {
-	panic("todo big.Bytes")
 }
 
 // FillBytes sets buf to the absolute value of x, storing it as a zero-extended
@@ -314,20 +277,18 @@ func (x *Int) Bytes() []byte {
 //
 // If the absolute value of x doesn't fit in buf, FillBytes will panic.
 func (x *Int) FillBytes(buf []byte) []byte {
-	panic("todo big.FillBytes")
 }
 
 // BitLen returns the length of the absolute value of x in bits.
 // The bit length of 0 is 0.
 func (x *Int) BitLen() int {
-	panic("todo big.BitLen")
 }
 
 // TrailingZeroBits returns the number of consecutive least significant zero
 // bits of |x|.
 func (x *Int) TrailingZeroBits() uint {
-	panic("todo big.TrailingZeroBits")
 }
+*/
 
 // Exp sets z = x**y mod |m| (i.e. the sign of m is ignored), and returns z.
 // If m == nil or m == 0, z = x**y unless y <= 0 then z = 1. If m != 0, y < 0,
@@ -347,6 +308,7 @@ func (z *Int) Exp(x, y, m *Int) *Int {
 	return z
 }
 
+/*
 // GCD sets z to the greatest common divisor of a and b and returns z.
 // If x or y are not nil, GCD sets their value such that z = a*x + b*y.
 //
@@ -359,7 +321,6 @@ func (z *Int) Exp(x, y, m *Int) *Int {
 //
 // If a != 0 and b == 0, GCD sets z = |a|, x = sign(a) * 1, y = 0.
 func (z *Int) GCD(x, y, a, b *Int) *Int {
-	panic("todo big.GCD")
 }
 
 // Rand sets z to a pseudo-random number in [0, n) and returns z.
@@ -367,7 +328,6 @@ func (z *Int) GCD(x, y, a, b *Int) *Int {
 // As this uses the math/rand package, it must not be used for
 // security-sensitive work. Use crypto/rand.Int instead.
 func (z *Int) Rand(rnd *rand.Rand, n *Int) *Int {
-	panic("todo big.Rand")
 }
 
 // ModInverse sets z to the multiplicative inverse of g in the ring ℤ/nℤ
@@ -375,13 +335,11 @@ func (z *Int) Rand(rnd *rand.Rand, n *Int) *Int {
 // inverse in the ring ℤ/nℤ.  In this case, z is unchanged and the return value
 // is nil. If n == 0, a division-by-zero run-time panic occurs.
 func (z *Int) ModInverse(g, n *Int) *Int {
-	panic("todo big.ModInverse")
 }
 
 // Jacobi returns the Jacobi symbol (x/y), either +1, -1, or 0.
 // The y argument must be an odd integer.
 func Jacobi(x, y *Int) int {
-	panic("todo big.Jacobi")
 }
 
 // ModSqrt sets z to a square root of x mod p if such a square root exists, and
@@ -389,29 +347,19 @@ func Jacobi(x, y *Int) int {
 // ModSqrt leaves z unchanged and returns nil. This function panics if p is
 // not an odd integer, its behavior is undefined if p is odd but not prime.
 func (z *Int) ModSqrt(x, p *Int) *Int {
-	panic("todo big.ModSqrt")
 }
 
 // Lsh sets z = x << n and returns z.
 func (z *Int) Lsh(x *Int, n uint) *Int {
-	a := (*openssl.BIGNUM)(z)
-	b := (*openssl.BIGNUM)(x)
-	a.Lshift(b, c.Int(n))
-	return z
 }
 
 // Rsh sets z = x >> n and returns z.
 func (z *Int) Rsh(x *Int, n uint) *Int {
-	a := (*openssl.BIGNUM)(z)
-	b := (*openssl.BIGNUM)(x)
-	a.Rshift(b, c.Int(n))
-	return z
 }
 
 // Bit returns the value of the i'th bit of x. That is, it
 // returns (x>>i)&1. The bit index i must be >= 0.
 func (x *Int) Bit(i int) uint {
-	panic("todo big.Bit")
 }
 
 // SetBit sets z to x, with x's i'th bit set to b (0 or 1).
@@ -419,38 +367,32 @@ func (x *Int) Bit(i int) uint {
 // if b is 0 SetBit sets z = x &^ (1 << i). If b is not 0 or 1,
 // SetBit will panic.
 func (z *Int) SetBit(x *Int, i int, b uint) *Int {
-	panic("todo big.SetBit")
 }
 
 // And sets z = x & y and returns z.
 func (z *Int) And(x, y *Int) *Int {
-	panic("todo big.And")
 }
 
 // AndNot sets z = x &^ y and returns z.
 func (z *Int) AndNot(x, y *Int) *Int {
-	panic("todo big.AndNot")
 }
 
 // Or sets z = x | y and returns z.
 func (z *Int) Or(x, y *Int) *Int {
-	panic("todo big.Or")
 }
 
 // Xor sets z = x ^ y and returns z.
 func (z *Int) Xor(x, y *Int) *Int {
-	panic("todo big.Xor")
 }
 
 // Not sets z = ^x and returns z.
 func (z *Int) Not(x *Int) *Int {
-	panic("todo big.Not")
 }
 
 // Sqrt sets z to ⌊√x⌋, the largest integer such that z² ≤ x, and returns z.
 // It panics if x is negative.
 func (z *Int) Sqrt(x *Int) *Int {
-	panic("todo big.Sqrt")
 }
+*/
 
 // -----------------------------------------------------------------------------

internal/lib/syscall/syscall_linux.go

@@ -70,16 +70,14 @@ func (w WaitStatus) StopSignal() Signal {
 	return Signal(w>>shift) & 0xFF
 }
 
+/* TODO(xsw):
 func (w WaitStatus) TrapCause() int {
-	/*
-		if w.StopSignal() != SIGTRAP {
-			return -1
-		}
-
-		return int(w>>shift) >> 8
-	*/
-	panic("todo: syscall.WaitStatus.TrapCause")
+	if w.StopSignal() != SIGTRAP {
+		return -1
+	}
+	return int(w>>shift) >> 8
 }
+*/
 
 func Wait4(pid int, wstatus *WaitStatus, options int, rusage *syscall.Rusage) (wpid int, err error) {
 	var status c.Int

ssa/abitype.go

@@ -414,9 +414,6 @@ func (b Builder) abiType(t types.Type) Expr {
 		b.loadType(t.Elem())
 	case *types.Array:
 		b.abiType(t.Elem())
-	case *types.Map:
-		b.abiType(t.Key())
-		b.abiType(t.Elem())
 	}
 	g := b.loadType(t)
 	return b.Load(g.Expr)

ssa/cl_test.go

@@ -50,7 +50,7 @@ func TestFromTestrt(t *testing.T) {
 }
 
 func TestFromTestdata(t *testing.T) {
-	cltest.FromDir(t, "", "../cl/_testdata", false)
+	cltest.FromDir(t, "", "../cl/_testdata", true)
 }
 
 func TestMakeInterface(t *testing.T) {

ssa/coro.go

@@ -0,0 +1,690 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ssa
+
+import (
+	"fmt"
+	"go/constant"
+	"go/token"
+	"go/types"
+)
+
+// declare void @llvm.coro.destroy(ptr <handle>)
+// declare void @llvm.coro.resume(ptr <handle>)
+// declare i1 @llvm.coro.done(ptr <handle>)
+// declare ptr @llvm.coro.promise(ptr <ptr>, i32 <alignment>, i1 <from>)
+// declare i32 @llvm.coro.size.i32()
+// declare i64 @llvm.coro.size.i64()
+// declare i32 @llvm.coro.align.i32()
+// declare i64 @llvm.coro.align.i64()
+// declare ptr @llvm.coro.begin(token <id>, ptr <mem>)
+// declare ptr @llvm.coro.free(token %id, ptr <frame>)
+// declare i1 @llvm.coro.alloc(token <id>)
+// declare ptr @llvm.coro.noop()
+// declare ptr @llvm.coro.frame()
+// declare token @llvm.coro.id(i32 <align>, ptr <promise>, ptr <coroaddr>, ptr <fnaddrs>)
+// declare token @llvm.coro.id.async(i32 <context size>, i32 <align>, ptr <context arg>, ptr <async function pointer>)
+// declare token @llvm.coro.id.retcon(i32 <size>, i32 <align>, ptr <buffer>, ptr <continuation prototype>, ptr <alloc>, ptr <dealloc>)
+// declare token @llvm.coro.id.retcon.once(i32 <size>, i32 <align>, ptr <buffer>, ptr <prototype>, ptr <alloc>, ptr <dealloc>)
+// declare i1 @llvm.coro.end(ptr <handle>, i1 <unwind>, token <result.token>)
+// declare token @llvm.coro.end.results(...)
+// declare i1 @llvm.coro.end.async(ptr <handle>, i1 <unwind>, ...)
+// declare i8 @llvm.coro.suspend(token <save>, i1 <final>)
+// declare token @llvm.coro.save(ptr <handle>)
+// declare {ptr, ptr, ptr} @llvm.coro.suspend.async(ptr <resume function>, ptr <context projection function>, ... <function to call> ... <arguments to function>)
+// declare ptr @llvm.coro.prepare.async(ptr <coroutine function>)
+// declare i1 @llvm.coro.suspend.retcon(...)
+// declare void @await_suspend_function(ptr %awaiter, ptr %hdl)
+// declare void @llvm.coro.await.suspend.void(ptr <awaiter>, ptr <handle>, ptr <await_suspend_function>)
+// declare i1 @llvm.coro.await.suspend.bool(ptr <awaiter>, ptr <handle>, ptr <await_suspend_function>)
+// declare void @llvm.coro.await.suspend.handle(ptr <awaiter>, ptr <handle>, ptr <await_suspend_function>)
+
+// -----------------------------------------------------------------------------
+
+// declare void @llvm.coro.destroy(ptr <handle>)
+func (p Program) tyCoDestroy() *types.Signature {
+	if p.coDestroyTy == nil {
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(i8Ptr)
+		p.coDestroyTy = types.NewSignatureType(nil, nil, nil, params, nil, false)
+	}
+	return p.coDestroyTy
+}
+
+// declare void @llvm.coro.resume(ptr <handle>)
+func (p Program) tyCoResume() *types.Signature {
+	if p.coResumeTy == nil {
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(i8Ptr)
+		p.coResumeTy = types.NewSignatureType(nil, nil, nil, params, nil, false)
+	}
+	return p.coResumeTy
+}
+
+// declare i1 @llvm.coro.done(ptr <handle>)
+func (p Program) tyCoDone() *types.Signature {
+	if p.coDoneTy == nil {
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(i8Ptr)
+		results := types.NewTuple(types.NewParam(token.NoPos, nil, "", p.Bool().raw.Type))
+		p.coDoneTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coDoneTy
+}
+
+// declare ptr @llvm.coro.promise(ptr <ptr>, i32 <alignment>, i1 <from>)
+func (p Program) tyCoPromise() *types.Signature {
+	if p.coPromiseTy == nil {
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		i32 := types.NewParam(token.NoPos, nil, "", p.Int32().raw.Type)
+		boolParam := types.NewParam(token.NoPos, nil, "", p.Bool().raw.Type)
+		params := types.NewTuple(i8Ptr, i32, boolParam)
+		results := types.NewTuple(i8Ptr)
+		p.coPromiseTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coPromiseTy
+}
+
+// declare i32 @llvm.coro.size.i32()
+func (p Program) tyCoSizeI32() *types.Signature {
+	if p.coSizeI32Ty == nil {
+		results := types.NewTuple(types.NewParam(token.NoPos, nil, "", p.Int32().raw.Type))
+		p.coSizeI32Ty = types.NewSignatureType(nil, nil, nil, nil, results, false)
+	}
+	return p.coSizeI32Ty
+}
+
+// declare i64 @llvm.coro.size.i64()
+func (p Program) tyCoSizeI64() *types.Signature {
+	if p.coSizeI64Ty == nil {
+		results := types.NewTuple(types.NewParam(token.NoPos, nil, "", p.Int64().raw.Type))
+		p.coSizeI64Ty = types.NewSignatureType(nil, nil, nil, nil, results, false)
+	}
+	return p.coSizeI64Ty
+}
+
+// declare i32 @llvm.coro.align.i32()
+func (p Program) tyCoAlignI32() *types.Signature {
+	if p.coAlignI32Ty == nil {
+		results := types.NewTuple(types.NewParam(token.NoPos, nil, "", p.Int32().raw.Type))
+		p.coAlignI32Ty = types.NewSignatureType(nil, nil, nil, nil, results, false)
+	}
+	return p.coAlignI32Ty
+}
+
+// declare i64 @llvm.coro.align.i64()
+func (p Program) tyCoAlignI64() *types.Signature {
+	if p.coAlignI64Ty == nil {
+		results := types.NewTuple(types.NewParam(token.NoPos, nil, "", p.Int64().raw.Type))
+		p.coAlignI64Ty = types.NewSignatureType(nil, nil, nil, nil, results, false)
+	}
+	return p.coAlignI64Ty
+}
+
+// declare ptr @llvm.coro.begin(token <id>, ptr <mem>)
+func (p Program) tyCoBegin() *types.Signature {
+	if p.coBeginTy == nil {
+		tokenParam := types.NewParam(token.NoPos, nil, "", p.Token().raw.Type)
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(tokenParam, i8Ptr)
+		results := types.NewTuple(i8Ptr)
+		p.coBeginTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coBeginTy
+}
+
+// declare ptr @llvm.coro.free(token %id, ptr <frame>)
+func (p Program) tyCoFree() *types.Signature {
+	if p.coFreeTy == nil {
+		tokenParam := types.NewParam(token.NoPos, nil, "", p.Token().raw.Type)
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(tokenParam, i8Ptr)
+		results := types.NewTuple(i8Ptr)
+		p.coFreeTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coFreeTy
+}
+
+// declare i1 @llvm.coro.alloc(token <id>)
+func (p Program) tyCoAlloc() *types.Signature {
+	if p.coAllocTy == nil {
+		tokenParam := types.NewParam(token.NoPos, nil, "", p.Token().raw.Type)
+		params := types.NewTuple(tokenParam)
+		boolParam := types.NewParam(token.NoPos, nil, "", p.Bool().raw.Type)
+		results := types.NewTuple(boolParam)
+		p.coAllocTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coAllocTy
+}
+
+// declare ptr @llvm.coro.noop()
+func (p Program) tyCoNoop() *types.Signature {
+	if p.coNoopTy == nil {
+		results := types.NewTuple(types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type))
+		p.coNoopTy = types.NewSignatureType(nil, nil, nil, nil, results, false)
+	}
+	return p.coNoopTy
+}
+
+// declare ptr @llvm.coro.frame()
+func (p Program) tyCoFrame() *types.Signature {
+	if p.coFrameTy == nil {
+		results := types.NewTuple(types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type))
+		p.coFrameTy = types.NewSignatureType(nil, nil, nil, nil, results, false)
+	}
+	return p.coFrameTy
+}
+
+// declare token @llvm.coro.id(i32 <align>, ptr <promise>, ptr <coroaddr>, ptr <fnaddrs>)
+func (p Program) tyCoID() *types.Signature {
+	if p.coIDTy == nil {
+		i32 := types.NewParam(token.NoPos, nil, "", p.Int32().raw.Type)
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(i32, i8Ptr, i8Ptr, i8Ptr)
+		tokenParam := types.NewParam(token.NoPos, nil, "", p.Token().raw.Type)
+		results := types.NewTuple(tokenParam)
+		p.coIDTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coIDTy
+}
+
+/*
+// declare token @llvm.coro.id.async(i32 <context size>, i32 <align>, ptr <context arg>, ptr <async function pointer>)
+func (p Program) tyCoIDAsync() *types.Signature {
+	if p.coIDAsyncTy == nil {
+		i32 := types.NewParam(token.NoPos, nil, "", p.Int32().raw.Type)
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(i32, i32, i8Ptr, i8Ptr)
+		tokenParam := types.NewParam(token.NoPos, nil, "", p.Token().raw.Type)
+		results := types.NewTuple(tokenParam)
+		p.coIDAsyncTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coIDAsyncTy
+}
+
+// declare token @llvm.coro.id.retcon(i32 <size>, i32 <align>, ptr <buffer>, ptr <continuation prototype>, ptr <alloc>, ptr <dealloc>)
+func (p Program) tyCoIDRetcon() *types.Signature {
+	if p.coIDRetconTy == nil {
+		i32 := types.NewParam(token.NoPos, nil, "", p.Int32().raw.Type)
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(i32, i32, i8Ptr, i8Ptr, i8Ptr, i8Ptr)
+		tokenParam := types.NewParam(token.NoPos, nil, "", p.Token().raw.Type)
+		results := types.NewTuple(tokenParam)
+		p.coIDRetconTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coIDRetconTy
+}
+
+// declare token @llvm.coro.id.retcon.once(i32 <size>, i32 <align>, ptr <buffer>, ptr <prototype>, ptr <alloc>, ptr <dealloc>)
+func (p Program) tyCoIDRetconOnce() *types.Signature {
+	if p.coIDRetconOnceTy == nil {
+		i32 := types.NewParam(token.NoPos, nil, "", p.Int32().raw.Type)
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(i32, i32, i8Ptr, i8Ptr, i8Ptr, i8Ptr)
+		tokenParam := types.NewParam(token.NoPos, nil, "", p.Token().raw.Type)
+		results := types.NewTuple(tokenParam)
+		p.coIDRetconOnceTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coIDRetconOnceTy
+}
+*/
+
+// declare i1 @llvm.coro.end(ptr <handle>, i1 <unwind>, token <result.token>)
+func (p Program) tyCoEnd() *types.Signature {
+	if p.coEndTy == nil {
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		boolParam := types.NewParam(token.NoPos, nil, "", p.Bool().raw.Type)
+		tokenParam := types.NewParam(token.NoPos, nil, "", p.Token().raw.Type)
+		params := types.NewTuple(i8Ptr, boolParam, tokenParam)
+		results := types.NewTuple(boolParam)
+		p.coEndTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coEndTy
+}
+
+/*
+// TODO(lijie): varargs
+// declare token @llvm.coro.end.results(...)
+func (p Program) tyCoEndResults() *types.Signature {
+	panic("not implemented")
+}
+
+// TODO(lijie): varargs
+// declare i1 @llvm.coro.end.async(ptr <handle>, i1 <unwind>, ...)
+func (p Program) tyCoEndAsync() *types.Signature {
+	panic("not implemented")
+}
+*/
+
+// declare i8 @llvm.coro.suspend(token <save>, i1 <final>)
+func (p Program) tyCoSuspend() *types.Signature {
+	if p.coSuspendTy == nil {
+		tokenParam := types.NewParam(token.NoPos, nil, "", p.Token().raw.Type)
+		boolParam := types.NewParam(token.NoPos, nil, "", p.Bool().raw.Type)
+		params := types.NewTuple(tokenParam, boolParam)
+		paramByte := types.NewParam(token.NoPos, nil, "", p.Byte().raw.Type)
+		results := types.NewTuple(paramByte)
+		p.coSuspendTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coSuspendTy
+}
+
+/*
+// declare token @llvm.coro.save(ptr <handle>)
+func (p Program) tyCoSave() *types.Signature {
+	if p.coSaveTy == nil {
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(i8Ptr)
+		tokenParam := types.NewParam(token.NoPos, nil, "", p.Token().raw.Type)
+		results := types.NewTuple(tokenParam)
+		p.coSaveTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coSaveTy
+}
+
+// TODO(lijie): varargs
+// declare {ptr, ptr, ptr} @llvm.coro.suspend.async(ptr <resume function>, ptr <context projection function>, ... <function to call> ... <arguments to function>)
+func (p Program) tyCoSuspendAsync() *types.Signature {
+	panic("not implemented")
+}
+
+// declare ptr @llvm.coro.prepare.async(ptr <coroutine function>)
+func (p Program) tyCoPrepareAsync() *types.Signature {
+	if p.coPrepareAsyncTy == nil {
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(i8Ptr)
+		results := types.NewTuple(i8Ptr)
+		p.coPrepareAsyncTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coPrepareAsyncTy
+}
+
+// declare i1 @llvm.coro.suspend.retcon(...)
+func (p Program) tyCoSuspendRetcon() *types.Signature {
+	panic("not implemented")
+}
+
+// declare void @await_suspend_function(ptr %awaiter, ptr %hdl)
+func (p Program) tyCoAwaitSuspendFunction() *types.Signature {
+	if p.coAwaitSuspendFunctionTy == nil {
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(i8Ptr, i8Ptr)
+		p.coAwaitSuspendFunctionTy = types.NewSignatureType(nil, nil, nil, params, nil, false)
+	}
+	return p.coAwaitSuspendFunctionTy
+}
+
+// declare void @llvm.coro.await.suspend.void(ptr <awaiter>, ptr <handle>, ptr <await_suspend_function>)
+func (p Program) tyCoAwaitSuspendVoid() *types.Signature {
+	if p.coAwaitSuspendVoidTy == nil {
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(i8Ptr, i8Ptr, i8Ptr)
+		p.coAwaitSuspendVoidTy = types.NewSignatureType(nil, nil, nil, params, nil, false)
+	}
+	return p.coAwaitSuspendVoidTy
+}
+
+// declare i1 @llvm.coro.await.suspend.bool(ptr <awaiter>, ptr <handle>, ptr <await_suspend_function>)
+func (p Program) tyCoAwaitSuspendBool() *types.Signature {
+	if p.coAwaitSuspendBoolTy == nil {
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(i8Ptr, i8Ptr, i8Ptr)
+		results := types.NewTuple(types.NewParam(token.NoPos, nil, "", p.Bool().raw.Type))
+		p.coAwaitSuspendBoolTy = types.NewSignatureType(nil, nil, nil, params, results, false)
+	}
+	return p.coAwaitSuspendBoolTy
+}
+
+// declare void @llvm.coro.await.suspend.handle(ptr <awaiter>, ptr <handle>, ptr <await_suspend_function>)
+func (p Program) tyCoAwaitSuspendHandle() *types.Signature {
+	if p.coAwaitSuspendHandleTy == nil {
+		i8Ptr := types.NewParam(token.NoPos, nil, "", p.VoidPtr().raw.Type)
+		params := types.NewTuple(i8Ptr, i8Ptr, i8Ptr)
+		p.coAwaitSuspendHandleTy = types.NewSignatureType(nil, nil, nil, params, nil, false)
+	}
+	return p.coAwaitSuspendHandleTy
+}
+*/
+
+// -----------------------------------------------------------------------------
+
+func (b Builder) SetBlockOffset(offset int) {
+	b.blkOffset = offset
+}
+
+func (b Builder) BlockOffset() int {
+	return b.blkOffset
+}
+
+func (b Builder) Async() bool {
+	return b.async
+}
+
+func (b Builder) AsyncToken() Expr {
+	return b.asyncToken
+}
+
+func (b Builder) EndAsync() {
+	b.onReturn()
+}
+
+/*
+	pesudo code:
+
+retPtr := malloc(sizeof(Promise))
+id := @llvm.coro.id(0, null, null, null)
+promiseSize := sizeof(Promise[T])
+frameSize := @llvm.coro.size.i64()
+allocSize := promiseSize + frameSize
+promise := malloc(allocSize)
+needAlloc := @llvm.coro.alloc(id)
+; Allocate memory for return type and coroutine frame
+frame := null
+
+	if needAlloc {
+		frame := malloc(frameSize)
+	}
+
+hdl := @llvm.coro.begin(id, frame)
+*retPtr = hdl
+*/
+func (b Builder) BeginAsync(fn Function, entryBlk, allocBlk, cleanBlk, suspdBlk, trapBlk, beginBlk BasicBlock) {
+	ty := fn.Type.RawType().(*types.Signature).Results().At(0).Type()
+	ptrTy, ok := ty.(*types.Pointer)
+	if !ok {
+		panic("async function must return a *async.Promise")
+	}
+	promiseTy := b.Prog.Type(ptrTy.Elem(), InGo)
+
+	b.async = true
+
+	b.SetBlock(entryBlk)
+	align := b.Const(constant.MakeInt64(0), b.Prog.CInt()).SetName("align")
+	null := b.Const(nil, b.Prog.CIntPtr())
+	id := b.CoID(align, null, null, null).SetName("id")
+	b.asyncToken = id
+	promiseSize := b.Const(constant.MakeUint64(b.Prog.SizeOf(promiseTy)), b.Prog.Int64()).SetName("alloc.size")
+	frameSize := b.CoSizeI64().SetName("frame.size")
+	allocSize := b.BinOp(token.ADD, promiseSize, frameSize).SetName("alloc.size")
+	promise := b.AllocZ(allocSize).SetName("promise")
+	b.promise = promise
+	promise.Type = b.Prog.Pointer(promiseTy)
+	needAlloc := b.CoAlloc(id).SetName("need.dyn.alloc")
+	b.If(needAlloc, allocBlk, beginBlk)
+
+	b.SetBlock(allocBlk)
+	frame := b.OffsetPtr(promise, promiseSize)
+	b.Jump(beginBlk)
+
+	b.SetBlock(beginBlk)
+	phi := b.Phi(b.Prog.VoidPtr())
+	phi.SetName("frame")
+	phi.AddIncoming(b, []BasicBlock{entryBlk, allocBlk}, func(i int, blk BasicBlock) Expr {
+		if i == 0 {
+			return null
+		}
+		return frame
+	})
+	hdl := b.CoBegin(id, phi.Expr)
+	hdl.SetName("hdl")
+	b.Store(promise, hdl)
+
+	b.SetBlock(cleanBlk)
+	b.CoFree(id, hdl)
+	b.Jump(suspdBlk)
+
+	b.SetBlock(suspdBlk)
+	b.CoEnd(hdl, b.Prog.BoolVal(false), b.Prog.TokenNone())
+	b.Return(promise)
+
+	b.SetBlock(trapBlk)
+	b.LLVMTrap()
+	b.Unreachable()
+
+	b.onSuspBlk = func(nextBlk BasicBlock) (BasicBlock, BasicBlock, BasicBlock) {
+		if nextBlk == nil {
+			nextBlk = trapBlk
+		}
+		return suspdBlk, nextBlk, cleanBlk
+	}
+	b.onReturn = func() {
+		b.CoSuspend(b.asyncToken, b.Prog.BoolVal(true), trapBlk)
+	}
+}
+
+// -----------------------------------------------------------------------------
+
+// declare void @llvm.coro.destroy(ptr <handle>)
+func (b Builder) CoDestroy(hdl Expr) {
+	fn := b.Pkg.cFunc("llvm.coro.destroy", b.Prog.tyCoDestroy())
+	b.Call(fn, hdl)
+}
+
+// declare void @llvm.coro.resume(ptr <handle>)
+func (b Builder) CoResume(hdl Expr) {
+	fn := b.Pkg.cFunc("llvm.coro.resume", b.Prog.tyCoResume())
+	b.Call(fn, hdl)
+}
+
+// declare i1 @llvm.coro.done(ptr <handle>)
+func (b Builder) coDone(hdl Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.done", b.Prog.tyCoDone())
+	return b.Call(fn, hdl)
+}
+
+// return c.Char
+func (b Builder) CoDone(hdl Expr) Expr {
+	bvar := b.coDone(hdl)
+	// TODO(lijie): inefficient
+	// %6 = zext i1 %5 to i64
+	// %7 = trunc i64 %6 to i8
+	return b.valFromData(b.Prog.Byte(), bvar.impl)
+}
+
+// declare ptr @llvm.coro.promise(ptr <ptr>, i32 <alignment>, i1 <from>)
+func (b Builder) CoPromise(ptr, align, from Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.promise", b.Prog.tyCoPromise())
+	return b.Call(fn, ptr, align, from)
+}
+
+// declare i32 @llvm.coro.size.i32()
+func (b Builder) CoSizeI32() Expr {
+	fn := b.Pkg.cFunc("llvm.coro.size.i32", b.Prog.tyCoSizeI32())
+	return b.Call(fn)
+}
+
+// declare i64 @llvm.coro.size.i64()
+func (b Builder) CoSizeI64() Expr {
+	fn := b.Pkg.cFunc("llvm.coro.size.i64", b.Prog.tyCoSizeI64())
+	return b.Call(fn)
+}
+
+// declare i32 @llvm.coro.align.i32()
+func (b Builder) CoAlignI32() Expr {
+	fn := b.Pkg.cFunc("llvm.coro.align.i32", b.Prog.tyCoAlignI32())
+	return b.Call(fn)
+}
+
+// declare i64 @llvm.coro.align.i64()
+func (b Builder) CoAlignI64() Expr {
+	fn := b.Pkg.cFunc("llvm.coro.align.i64", b.Prog.tyCoAlignI64())
+	return b.Call(fn)
+}
+
+// declare ptr @llvm.coro.begin(token <id>, ptr <mem>)
+func (b Builder) CoBegin(id, mem Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.begin", b.Prog.tyCoBegin())
+	return b.Call(fn, id, mem)
+}
+
+// declare ptr @llvm.coro.free(token %id, ptr <frame>)
+func (b Builder) CoFree(id, frame Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.free", b.Prog.tyCoFree())
+	return b.Call(fn, id, frame)
+}
+
+// declare i1 @llvm.coro.alloc(token <id>)
+func (b Builder) CoAlloc(id Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.alloc", b.Prog.tyCoAlloc())
+	return b.Call(fn, id)
+}
+
+// declare ptr @llvm.coro.noop()
+func (b Builder) CoNoop() Expr {
+	fn := b.Pkg.cFunc("llvm.coro.noop", b.Prog.tyCoNoop())
+	return b.Call(fn)
+}
+
+// declare ptr @llvm.coro.frame()
+func (b Builder) CoFrame() Expr {
+	fn := b.Pkg.cFunc("llvm.coro.frame", b.Prog.tyCoFrame())
+	return b.Call(fn)
+}
+
+// declare token @llvm.coro.id(i32 <align>, ptr <promise>, ptr <coroaddr>, ptr <fnaddrs>)
+func (b Builder) CoID(align Expr, promise, coroAddr, fnAddrs Expr) Expr {
+	if align.Type != b.Prog.Int32() {
+		panic("align must be i32")
+	}
+	fn := b.Pkg.cFunc("llvm.coro.id", b.Prog.tyCoID())
+	return b.Call(fn, align, promise, coroAddr, fnAddrs)
+}
+
+/*
+// declare token @llvm.coro.id.async(i32 <context size>, i32 <align>, ptr <context arg>, ptr <async function pointer>)
+func (b Builder) CoIDAsync(contextSize, align, contextArg, asyncFnPtr Expr) Expr {
+	if contextSize.Type != b.Prog.Int32() {
+		panic("contextSize must be i32")
+	}
+	if align.Type != b.Prog.Int32() {
+		panic("align must be i32")
+	}
+	fn := b.Pkg.cFunc("llvm.coro.id.async", b.Prog.tyCoIDAsync())
+	return b.Call(fn, contextSize, align, contextArg, asyncFnPtr)
+}
+
+// declare token @llvm.coro.id.retcon(i32 <size>, i32 <align>, ptr <buffer>, ptr <continuation prototype>, ptr <alloc>, ptr <dealloc>)
+func (b Builder) CoIDRetcon(size, align, buffer, contProto, alloc, dealloc Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.id.retcon", b.Prog.tyCoIDRetcon())
+	return b.Call(fn, size, align, buffer, contProto, alloc, dealloc)
+}
+
+// declare token @llvm.coro.id.retcon.once(i32 <size>, i32 <align>, ptr <buffer>, ptr <prototype>, ptr <alloc>, ptr <dealloc>)
+func (b Builder) CoIDRetconOnce(size, align, buffer, prototype, alloc, dealloc Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.id.retcon.once", b.Prog.tyCoIDRetconOnce())
+	return b.Call(fn, size, align, buffer, prototype, alloc, dealloc)
+}
+*/
+
+// declare i1 @llvm.coro.end(ptr <handle>, i1 <unwind>, token <result.token>)
+func (b Builder) CoEnd(hdl Expr, unwind Expr, resultToken Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.end", b.Prog.tyCoEnd())
+	return b.Call(fn, hdl, unwind, resultToken)
+}
+
+/*
+// declare token @llvm.coro.end.results(...)
+func (b Builder) CoEndResults(args []Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.end.results", b.Prog.tyCoEndResults())
+	return b.Call(fn, args...)
+}
+
+// declare i1 @llvm.coro.end.async(ptr <handle>, i1 <unwind>, ...)
+func (b Builder) CoEndAsync(handle, unwind Expr, args ...Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.end.async", b.Prog.tyCoEndAsync())
+	vargs := append([]Expr{handle, unwind}, args...)
+	return b.Call(fn, vargs...)
+}
+*/
+
+// declare i8 @llvm.coro.suspend(token <save>, i1 <final>)
+func (b Builder) coSuspend(save, final Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.suspend", b.Prog.tyCoSuspend())
+	return b.Call(fn, save, final)
+}
+
+func (b Builder) CoSuspend(save, final Expr, nextBlk BasicBlock) {
+	if !b.async {
+		panic(fmt.Errorf("suspend %v not in async block", b.Func.Name()))
+	}
+	if nextBlk == nil {
+		b.Func.MakeBlock("")
+		nextBlk = b.Func.Block(b.blk.idx + 1)
+	}
+	ret := b.coSuspend(save, final)
+	susp, next, clean := b.onSuspBlk(nextBlk)
+	swt := b.Switch(ret, susp)
+	swt.Case(b.Const(constant.MakeInt64(0), b.Prog.Byte()), next)
+	swt.Case(b.Const(constant.MakeInt64(1), b.Prog.Byte()), clean)
+	swt.End(b)
+	b.SetBlock(nextBlk)
+}
+
+func (b Builder) CoReturn(setValueFn Function, value Expr) {
+	if !b.async {
+		panic(fmt.Errorf("return %v not in async block", b.Func.Name()))
+	}
+	b.Call(setValueFn.Expr, b.promise, value)
+	_, _, cleanBlk := b.onSuspBlk(nil)
+	b.Jump(cleanBlk)
+}
+
+func (b Builder) CoYield(setValueFn Function, value Expr, final Expr) {
+	if !b.async {
+		panic(fmt.Errorf("yield %v not in async block", b.Func.Name()))
+	}
+	b.Call(setValueFn.Expr, b.promise, value)
+	b.CoSuspend(b.AsyncToken(), final, nil)
+}
+
+/*
+// declare token @llvm.coro.save(ptr <handle>)
+func (b Builder) CoSave(hdl Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.save", b.Prog.tyCoSave())
+	return b.Call(fn, hdl)
+}
+
+// declare ptr @llvm.coro.prepare.async(ptr <coroutine function>)
+func (b Builder) CoPrepareAsync(f Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.prepare.async", b.Prog.tyCoPrepareAsync())
+	return b.Call(fn, f)
+}
+
+// declare i1 @llvm.coro.suspend.retcon(...)
+func (b Builder) CoSuspendRetcon(args []Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.suspend.retcon", b.Prog.tyCoSuspendRetcon())
+	return b.Call(fn, args...)
+}
+
+// declare void @llvm.coro.await.suspend.void(ptr <awaiter>, ptr <handle>, ptr <await_suspend_function>)
+func (b Builder) CoAwaitSuspendVoid(awaiter, handle, f Expr) {
+	fn := b.Pkg.cFunc("llvm.coro.await.suspend.void", b.Prog.tyCoAwaitSuspendVoid())
+	b.Call(fn, awaiter, handle, f)
+}
+
+// declare i1 @llvm.coro.await.suspend.bool(ptr <awaiter>, ptr <handle>, ptr <await_suspend_function>)
+func (b Builder) CoAwaitSuspendBool(awaiter, handle, f Expr) Expr {
+	fn := b.Pkg.cFunc("llvm.coro.await.suspend.bool", b.Prog.tyCoAwaitSuspendBool())
+	return b.Call(fn, awaiter, handle, f)
+}
+
+// declare void @llvm.coro.await.suspend.handle(ptr <awaiter>, ptr <handle>, ptr <await_suspend_function>)
+func (b Builder) CoAwaitSuspendHandle(awaiter, handle, f Expr) {
+	fn := b.Pkg.cFunc("llvm.coro.await.suspend.handle", b.Prog.tyCoAwaitSuspendHandle())
+	b.Call(fn, awaiter, handle, f)
+}
+*/

ssa/decl.go

@@ -180,11 +180,11 @@ type Function = *aFunction
 
 // NewFunc creates a new function.
 func (p Package) NewFunc(name string, sig *types.Signature, bg Background) Function {
-	return p.NewFuncEx(name, sig, bg, false)
+	return p.NewFuncEx(name, sig, bg, false, false)
 }
 
 // NewFuncEx creates a new function.
-func (p Package) NewFuncEx(name string, sig *types.Signature, bg Background, hasFreeVars bool) Function {
+func (p Package) NewFuncEx(name string, sig *types.Signature, bg Background, hasFreeVars, async bool) Function {
 	if v, ok := p.fns[name]; ok {
 		return v
 	}
@@ -193,6 +193,9 @@ func (p Package) NewFuncEx(name string, sig *types.Signature, bg Background, has
 		log.Println("NewFunc", name, t.raw.Type, "hasFreeVars:", hasFreeVars)
 	}
 	fn := llvm.AddFunction(p.mod, name, t.ll)
+	if async {
+		fn.AddFunctionAttr(p.Prog.ctx.CreateStringAttribute("presplitcoroutine", ""))
+	}
 	ret := newFunction(fn, t, p, p.Prog, hasFreeVars)
 	p.fns[name] = ret
 	return ret
@@ -268,7 +271,7 @@ func (p Function) NewBuilder() Builder {
 	b := prog.ctx.NewBuilder()
 	// TODO(xsw): Finalize may cause panic, so comment it.
 	// b.Finalize()
-	return &aBuilder{b, nil, p, p.Pkg, prog}
+	return &aBuilder{impl: b, blk: nil, Func: p, Pkg: p.Pkg, Prog: prog}
 }
 
 // HasBody reports whether the function has a body.
@@ -293,13 +296,15 @@ func (p Function) MakeBlocks(nblk int) []BasicBlock {
 		p.blks = make([]BasicBlock, 0, nblk)
 	}
 	for i := 0; i < nblk; i++ {
-		p.addBlock(n + i)
+		p.addBlock(n+i, "")
 	}
 	return p.blks[n:]
 }
 
-func (p Function) addBlock(idx int) BasicBlock {
-	label := "_llgo_" + strconv.Itoa(idx)
+func (p Function) addBlock(idx int, label string) BasicBlock {
+	if label == "" {
+		label = "_llgo_" + strconv.Itoa(idx)
+	}
 	blk := llvm.AddBasicBlock(p.impl, label)
 	ret := &aBasicBlock{blk, blk, p, idx}
 	p.blks = append(p.blks, ret)
@@ -307,8 +312,8 @@ func (p Function) addBlock(idx int) BasicBlock {
 }
 
 // MakeBlock creates a new basic block for the function.
-func (p Function) MakeBlock() BasicBlock {
-	return p.addBlock(len(p.blks))
+func (p Function) MakeBlock(label string) BasicBlock {
+	return p.addBlock(len(p.blks), label)
 }
 
 // Block returns the ith basic block of the function.

ssa/eh.go

@@ -55,6 +55,13 @@ func (p Program) tySiglongjmp() *types.Signature {
 	return p.sigljmpTy
 }
 
+func (p Program) tyLLVMTrap() *types.Signature {
+	if p.llvmTrapTy == nil {
+		p.llvmTrapTy = types.NewSignatureType(nil, nil, nil, nil, nil, false)
+	}
+	return p.llvmTrapTy
+}
+
 func (b Builder) AllocaSigjmpBuf() Expr {
 	prog := b.Prog
 	n := unsafe.Sizeof(sigjmpbuf{})
@@ -77,6 +84,11 @@ func (b Builder) Siglongjmp(jb, retval Expr) {
 	// b.Unreachable()
 }
 
+func (b Builder) LLVMTrap() {
+	fn := b.Pkg.cFunc("llvm.trap", b.Prog.tyLLVMTrap())
+	b.Call(fn)
+}
+
 // -----------------------------------------------------------------------------
 
 const (
@@ -166,7 +178,7 @@ func (b Builder) getDefer(kind DoAction) *aDefer {
 		czero := prog.IntVal(0, prog.CInt())
 		retval := b.Sigsetjmp(jb, czero)
 		if kind != DeferAlways {
-			panicBlk = self.MakeBlock()
+			panicBlk = self.MakeBlock("")
 		} else {
 			blks = self.MakeBlocks(2)
 			next, panicBlk = blks[0], blks[1]
@@ -240,7 +252,7 @@ func (b Builder) Defer(kind DoAction, fn Expr, args ...Expr) {
 // RunDefers emits instructions to run deferred instructions.
 func (b Builder) RunDefers() {
 	self := b.getDefer(DeferInCond)
-	blk := b.Func.MakeBlock()
+	blk := b.Func.MakeBlock("")
 	self.rundsNext = append(self.rundsNext, blk)
 
 	b.Store(self.rundPtr, blk.Addr())

ssa/expr.go

@@ -59,6 +59,11 @@ func (v Expr) SetOrdering(ordering AtomicOrdering) Expr {
 	return v
 }
 
+func (v Expr) SetName(name string) Expr {
+	v.impl.SetName(name)
+	return v
+}
+
 // -----------------------------------------------------------------------------
 
 type builtinTy struct {

ssa/memory.go

@@ -232,6 +232,13 @@ func (b Builder) ArrayAlloca(telem Type, n Expr) (ret Expr) {
 	return
 }
 
+func (b Builder) OffsetPtr(ptr, offset Expr) Expr {
+	if debugInstr {
+		log.Printf("OffsetPtr %v, %v\n", ptr.impl, offset.impl)
+	}
+	return Expr{llvm.CreateGEP(b.impl, ptr.Type.ll, ptr.impl, []llvm.Value{offset.impl}), ptr.Type}
+}
+
 /* TODO(xsw):
 // ArrayAlloc allocates zero initialized space for an array of n elements of type telem.
 func (b Builder) ArrayAlloc(telem Type, n Expr) (ret Expr) {

ssa/package.go

@@ -19,8 +19,10 @@ package ssa
 import (
 	"go/token"
 	"go/types"
+	"regexp"
 	"runtime"
 	"strconv"
+	"strings"
 	"unsafe"
 
 	"github.com/goplus/llgo/ssa/abi"
@@ -136,6 +138,8 @@ type aProgram struct {
 	rtMapTy    llvm.Type
 	rtChanTy   llvm.Type
 
+	tokenType llvm.Type
+
 	anyTy     Type
 	voidTy    Type
 	voidPtr   Type
@@ -166,6 +170,8 @@ type aProgram struct {
 	deferTy   Type
 	deferPtr  Type
 
+	tokenTy Type
+
 	pyImpTy      *types.Signature
 	pyNewList    *types.Signature
 	pyListSetI   *types.Signature
@@ -189,6 +195,41 @@ type aProgram struct {
 	sigsetjmpTy *types.Signature
 	sigljmpTy   *types.Signature
 
+	llvmTrapTy *types.Signature
+
+	// coroutine manipulation intrinsics (ordered by LLVM coroutine doc)
+	coDestroyTy *types.Signature
+	coResumeTy  *types.Signature
+	coDoneTy    *types.Signature
+	coPromiseTy *types.Signature
+
+	// coroutine structure intrinsics (ordered by LLVM coroutine doc)
+	coSizeI32Ty  *types.Signature
+	coSizeI64Ty  *types.Signature
+	coAlignI32Ty *types.Signature
+	coAlignI64Ty *types.Signature
+	coBeginTy    *types.Signature
+	coFreeTy     *types.Signature
+	coAllocTy    *types.Signature
+	coNoopTy     *types.Signature
+	coFrameTy    *types.Signature
+	coIDTy       *types.Signature
+	// coIDAsyncTy              *types.Signature
+	// coIDRetconTy             *types.Signature
+	// coIDRetconOnceTy         *types.Signature
+	coEndTy *types.Signature
+	// coEndResultsTy           *types.Signature
+	// coEndAsyncTy             *types.Signature
+	coSuspendTy *types.Signature
+	// coSaveTy                 *types.Signature
+	// coSuspendAsyncTy         *types.Signature
+	// coPrepareAsyncTy         *types.Signature
+	// coSuspendRetconTy        *types.Signature
+	// coAwaitSuspendFunctionTy *types.Signature
+	// coAwaitSuspendVoidTy     *types.Signature
+	// coAwaitSuspendBoolTy     *types.Signature
+	// coAwaitSuspendHandleTy   *types.Signature
+
 	paramObjPtr_ *types.Var
 
 	ptrSize int
@@ -441,6 +482,18 @@ func (p Program) Any() Type {
 	return p.anyTy
 }
 
+func (p Program) Token() Type {
+	if p.tokenTy == nil {
+		p.tokenTy = &aType{p.tyToken(), rawType{types.Typ[types.Invalid]}, vkInvalid}
+	}
+	return p.tokenTy
+}
+
+func (p Program) TokenNone() Expr {
+	impl := llvm.ConstNull(p.Token().ll)
+	return Expr{impl: impl, Type: p.Token()}
+}
+
 /*
 // Eface returns the empty interface type.
 // It is equivalent to Any.
@@ -649,9 +702,41 @@ func (p Package) Path() string {
 	return p.abi.Pkg
 }
 
+// Find presplitcoroutine attribute and replace attribute tag with it
+// e.g. attributes #0 = { noinline nounwind readnone "presplitcoroutine" }
+// replace #0 with presplitcoroutine
+// and also remove all other attributes
+func removeLLVMAttributes(ll string) string {
+	attrRe := regexp.MustCompile(`^attributes (#\d+) = {[^}]*}$`)
+	attrRe2 := regexp.MustCompile(`(\) #\d+ {|\) #\d+)$`)
+	lines := strings.Split(ll, "\n")
+	newLines := make([]string, 0, len(lines))
+	presplitcoroutine := ""
+	for _, line := range lines {
+		if m := attrRe.FindStringSubmatch(line); m != nil {
+			if strings.Contains(line, "\"presplitcoroutine\"") {
+				presplitcoroutine = " " + m[1] + " "
+			}
+		} else {
+			newLines = append(newLines, line)
+		}
+	}
+
+	for i, line := range newLines {
+		if presplitcoroutine != "" {
+			line = strings.Replace(line, presplitcoroutine, " presplitcoroutine ", 1)
+		}
+		line = attrRe2.ReplaceAllString(line, ")")
+		newLines[i] = line
+	}
+
+	return strings.Join(newLines, "\n")
+}
+
 // String returns a string representation of the package.
 func (p Package) String() string {
-	return p.mod.String()
+	// TODO(lijie): workaround for compiling errors of LLVM attributes
+	return removeLLVMAttributes(p.mod.String())
 }
 
 // SetPatch sets a patch function.

ssa/ssa_test.go

@@ -469,6 +469,47 @@ _llgo_0:
 `)
 }
 
+func TestSwitch(t *testing.T) {
+	prog := NewProgram(nil)
+	pkg := prog.NewPackage("bar", "foo/bar")
+	params := types.NewTuple(types.NewVar(0, nil, "a", 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(4)
+	cond := fn.Param(0)
+	case1 := fn.Block(1)
+	case2 := fn.Block(2)
+	defb := fn.Block(3)
+	swc := b.Switch(cond, defb)
+	swc.Case(prog.Val(1), case1)
+	swc.Case(prog.Val(2), case2)
+	swc.End(b)
+	b.SetBlock(case1).Return(prog.Val(3))
+	b.SetBlock(case2).Return(prog.Val(4))
+	b.SetBlock(defb).Return(prog.Val(5))
+	assertPkg(t, pkg, `; ModuleID = 'foo/bar'
+source_filename = "foo/bar"
+
+define i64 @fn(i64 %0) {
+_llgo_0:
+  switch i64 %0, label %_llgo_3 [
+    i64 1, label %_llgo_1
+    i64 2, label %_llgo_2
+  ]
+
+_llgo_1:                                          ; preds = %_llgo_0
+  ret i64 3
+
+_llgo_2:                                          ; preds = %_llgo_0
+  ret i64 4
+
+_llgo_3:                                          ; preds = %_llgo_0
+  ret i64 5
+}
+`)
+}
+
 func TestUnOp(t *testing.T) {
 	prog := NewProgram(nil)
 	pkg := prog.NewPackage("bar", "foo/bar")
@@ -552,3 +593,194 @@ _llgo_0:
 }
 `)
 }
+
+func TestPointerOffset(t *testing.T) {
+	prog := NewProgram(nil)
+	pkg := prog.NewPackage("bar", "foo/bar")
+	params := types.NewTuple(
+		types.NewVar(0, nil, "p", types.NewPointer(types.Typ[types.Int])),
+		types.NewVar(0, nil, "offset", types.Typ[types.Int]),
+	)
+	rets := types.NewTuple(types.NewVar(0, nil, "", types.NewPointer(types.Typ[types.Int])))
+	sig := types.NewSignatureType(nil, nil, nil, params, rets, false)
+	fn := pkg.NewFunc("fn", sig, InGo)
+	b := fn.MakeBody(1)
+	ptr := fn.Param(0)
+	offset := fn.Param(1)
+	result := b.OffsetPtr(ptr, offset)
+	b.Return(result)
+	assertPkg(t, pkg, `; ModuleID = 'foo/bar'
+source_filename = "foo/bar"
+
+define ptr @fn(ptr %0, i64 %1) {
+_llgo_0:
+  %2 = getelementptr ptr, ptr %0, i64 %1
+  ret ptr %2
+}
+`)
+}
+
+func TestLLVMTrap(t *testing.T) {
+	prog := NewProgram(nil)
+	pkg := prog.NewPackage("bar", "foo/bar")
+	b := pkg.NewFunc("fn", NoArgsNoRet, InGo).MakeBody(1)
+	b.LLVMTrap()
+	b.Unreachable()
+	assertPkg(t, pkg, `; ModuleID = 'foo/bar'
+source_filename = "foo/bar"
+
+define void @fn() {
+_llgo_0:
+  call void @llvm.trap()
+  unreachable
+}
+
+; Function Attrs: cold noreturn nounwind memory(inaccessiblemem: write)
+declare void @llvm.trap()
+
+`)
+}
+
+func TestCoroFuncs(t *testing.T) {
+	prog := NewProgram(nil)
+	pkg := prog.NewPackage("bar", "foo/bar")
+	fn := pkg.NewFunc("fn", NoArgsNoRet, InGo)
+	entryBlk := fn.MakeBlock("entry")
+	suspdBlk := fn.MakeBlock("suspend")
+	cleanBlk := fn.MakeBlock("clean")
+	b := fn.NewBuilder()
+	b.async = true
+
+	b.SetBlock(entryBlk)
+	align := b.Const(constant.MakeInt64(0), prog.Int32())
+	align8 := b.Const(constant.MakeInt64(8), prog.Int32())
+	null := b.Const(nil, b.Prog.CIntPtr())
+	b.promise = null
+	id := b.CoID(align, null, null, null)
+	bf := b.Const(constant.MakeBool(false), prog.Bool())
+	b.CoSizeI32()
+	size := b.CoSizeI64()
+	b.CoAlignI32()
+	b.CoAlignI64()
+	b.CoAlloc(id)
+	frame := b.Alloca(size)
+	hdl := b.CoBegin(id, frame)
+
+	b.SetBlock(cleanBlk)
+	b.CoFree(id, frame)
+	b.Jump(suspdBlk)
+
+	b.SetBlock(suspdBlk)
+	b.CoEnd(hdl, bf, prog.TokenNone())
+	// b.Return(b.promise)
+
+	b.SetBlock(entryBlk)
+
+	b.CoResume(hdl)
+	b.CoDone(hdl)
+	b.CoDestroy(hdl)
+
+	b.CoPromise(null, align8, bf)
+	b.CoNoop()
+	b.CoFrame()
+	setArgs := types.NewTuple(types.NewVar(0, nil, "value", types.Typ[types.Int]))
+	setSig := types.NewSignatureType(nil, nil, nil, setArgs, nil, false)
+	setFn := pkg.NewFunc("setValue", setSig, InGo)
+	one := b.Const(constant.MakeInt64(1), prog.Int())
+
+	b.onSuspBlk = func(next BasicBlock) (BasicBlock, BasicBlock, BasicBlock) {
+		return suspdBlk, next, cleanBlk
+	}
+	b.CoYield(setFn, one, bf)
+	b.CoReturn(setFn, one)
+
+	assertPkg(t, pkg, `; ModuleID = 'foo/bar'
+source_filename = "foo/bar"
+
+define void @fn() {
+entry:
+  %0 = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
+  %1 = call i32 @llvm.coro.size.i32()
+  %2 = call i64 @llvm.coro.size.i64()
+  %3 = call i32 @llvm.coro.align.i32()
+  %4 = call i64 @llvm.coro.align.i64()
+  %5 = call i1 @llvm.coro.alloc(token %0)
+  %6 = alloca i8, i64 %2, align 1
+  %7 = call ptr @llvm.coro.begin(token %0, ptr %6)
+  call void @llvm.coro.resume(ptr %7)
+  %8 = call i1 @llvm.coro.done(ptr %7)
+  %9 = zext i1 %8 to i64
+  %10 = trunc i64 %9 to i8
+  call void @llvm.coro.destroy(ptr %7)
+  %11 = call ptr @llvm.coro.promise(ptr null, i32 8, i1 false)
+  %12 = call ptr @llvm.coro.noop()
+  %13 = call ptr @llvm.coro.frame()
+  call void @setValue(ptr null, i64 1)
+  %14 = call i8 @llvm.coro.suspend(<null operand!>, i1 false)
+  switch i8 %14, label %suspend [
+    i8 0, label %suspend
+    i8 1, label %clean
+  ]
+
+suspend:                                          ; preds = %entry, %entry, %clean
+  %15 = call i1 @llvm.coro.end(ptr %7, i1 false, token none)
+  call void @setValue(ptr null, i64 1)
+  br label %clean
+
+clean:                                            ; preds = %suspend, %entry
+  %16 = call ptr @llvm.coro.free(token %0, ptr %6)
+  br label %suspend
+
+_llgo_3:                                          ; No predecessors!
+}
+
+; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
+
+; Function Attrs: nounwind memory(none)
+declare i32 @llvm.coro.size.i32()
+
+; Function Attrs: nounwind memory(none)
+declare i64 @llvm.coro.size.i64()
+
+; Function Attrs: nounwind memory(none)
+declare i32 @llvm.coro.align.i32()
+
+; Function Attrs: nounwind memory(none)
+declare i64 @llvm.coro.align.i64()
+
+; Function Attrs: nounwind
+declare i1 @llvm.coro.alloc(token)
+
+; Function Attrs: nounwind
+declare ptr @llvm.coro.begin(token, ptr writeonly)
+
+; Function Attrs: nounwind memory(argmem: read)
+declare ptr @llvm.coro.free(token, ptr nocapture readonly)
+
+; Function Attrs: nounwind
+declare i1 @llvm.coro.end(ptr, i1, token)
+
+declare void @llvm.coro.resume(ptr)
+
+; Function Attrs: nounwind memory(argmem: readwrite)
+declare i1 @llvm.coro.done(ptr nocapture readonly)
+
+declare void @llvm.coro.destroy(ptr)
+
+; Function Attrs: nounwind memory(none)
+declare ptr @llvm.coro.promise(ptr nocapture, i32, i1)
+
+; Function Attrs: nounwind memory(none)
+declare ptr @llvm.coro.noop()
+
+; Function Attrs: nounwind memory(none)
+declare ptr @llvm.coro.frame()
+
+declare void @setValue(i64)
+
+; Function Attrs: nounwind
+declare i8 @llvm.coro.suspend(token, i1)
+
+`)
+}

ssa/stmt_builder.go

@@ -63,6 +63,13 @@ type aBuilder struct {
 	Func Function
 	Pkg  Package
 	Prog Program
+
+	async      bool
+	asyncToken Expr
+	promise    Expr
+	onSuspBlk  func(blk BasicBlock) (susp BasicBlock, next BasicBlock, clean BasicBlock)
+	onReturn   func()
+	blkOffset  int
 }
 
 // Builder represents a builder for creating instructions in a function.
@@ -94,7 +101,7 @@ func (b Builder) setBlockMoveLast(blk BasicBlock) (next BasicBlock) {
 
 	impl := b.impl
 
-	next = b.Func.MakeBlock()
+	next = b.Func.MakeBlock("")
 	impl.SetInsertPointAtEnd(next.last)
 	impl.Insert(last)
 
@@ -288,7 +295,7 @@ func (b Builder) Times(n Expr, loop func(i Expr)) {
 }
 
 // -----------------------------------------------------------------------------
-/*
+
 type caseStmt struct {
 	v   llvm.Value
 	blk llvm.BasicBlock
@@ -326,7 +333,7 @@ func (b Builder) Switch(v Expr, defb BasicBlock) Switch {
 	}
 	return &aSwitch{v.impl, defb.first, nil}
 }
-*/
+
 // -----------------------------------------------------------------------------
 
 // Phi represents a phi node.

ssa/type.go

@@ -58,6 +58,7 @@ const (
 	vkIface
 	vkStruct
 	vkChan
+	vkToken
 )
 
 // -----------------------------------------------------------------------------
@@ -282,6 +283,13 @@ func (p Program) tyInt() llvm.Type {
 	return p.intType
 }
 
+func (p Program) tyToken() llvm.Type {
+	if p.tokenType.IsNil() {
+		p.tokenType = p.ctx.TokenType()
+	}
+	return p.tokenType
+}
+
 func llvmIntType(ctx llvm.Context, size int) llvm.Type {
 	if size <= 4 {
 		return ctx.Int32Type()
@@ -362,6 +370,9 @@ func (p Program) toType(raw types.Type) Type {
 			return &aType{p.rtString(), typ, vkString}
 		case types.UnsafePointer:
 			return &aType{p.tyVoidPtr(), typ, vkPtr}
+		// TODO(lijie): temporary solution, should be replaced by a proper type
+		case types.Invalid:
+			return &aType{p.tyToken(), typ, vkInvalid}
 		}
 	case *types.Pointer:
 		elem := p.rawType(t.Elem())
@@ -444,7 +455,8 @@ func (p Program) toLLVMTypes(t *types.Tuple, n int) (ret []llvm.Type) {
 	if n > 0 {
 		ret = make([]llvm.Type, n)
 		for i := 0; i < n; i++ {
-			ret[i] = p.rawType(t.At(i).Type()).ll
+			pt := t.At(i)
+			ret[i] = p.rawType(pt.Type()).ll
 		}
 	}
 	return

x/async/_demo/asyncdemo/asyncdemo.go

@@ -0,0 +1,229 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"strings"
+	"time"
+
+	"github.com/goplus/llgo/x/async"
+	"github.com/goplus/llgo/x/tuple"
+)
+
+// -----------------------------------------------------------------------------
+
+func http(method string, url string, callback func(resp *Response, err error)) {
+	go func() {
+		body := ""
+		if strings.HasPrefix(url, "http://example.com/user/") {
+			name := url[len("http://example.com/user/"):]
+			body = `{"name":"` + name + `"}`
+		} else if strings.HasPrefix(url, "http://example.com/score/") {
+			body = "99.5"
+		}
+		time.Sleep(200 * time.Millisecond)
+		resp := &Response{StatusCode: 200, Body: body}
+		callback(resp, nil)
+	}()
+}
+
+// -----------------------------------------------------------------------------
+
+type Response struct {
+	StatusCode int
+
+	Body string
+}
+
+func (r *Response) Text() (co async.Promise[tuple.Tuple2[string, error]]) {
+	co.Return(tuple.Tuple2[string, error]{V1: r.Body, V2: nil})
+	return
+}
+
+//	async AsyncHttpGet(url string) (resp *Response, err error) {
+//	  http("GET", url, func(resp *Response, err error) {
+//	    return resp, err
+//	  })
+//	}
+func AsyncHttpGet(url string) (co async.Promise[tuple.Tuple2[*Response, error]]) {
+	return co.Async(func(resolve func(tuple.Tuple2[*Response, error])) {
+		http("GET", url, func(resp *Response, err error) {
+			resolve(tuple.Tuple2[*Response, error]{V1: resp, V2: nil})
+		})
+	})
+}
+
+func AsyncHttpPost(url string) (co async.Promise[tuple.Tuple2[*Response, error]]) {
+	http("POST", url, func(resp *Response, err error) {
+		// co.Return(tuple.Tuple2[*Response, error]{V1: resp, V2: nil})
+	})
+	co.Suspend()
+	return
+}
+
+// -----------------------------------------------------------------------------
+
+type User struct {
+	Name string
+}
+
+func GetUser(name string) (co async.Promise[tuple.Tuple2[User, error]]) {
+	resp, err := AsyncHttpGet("http://example.com/user/" + name).Await().Values()
+	if err != nil {
+		// return User{}, err
+		co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: err})
+		return
+	}
+
+	if resp.StatusCode != 200 {
+		// return User{}, fmt.Errorf("http status code: %d", resp.StatusCode)
+		co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: fmt.Errorf("http status code: %d", resp.StatusCode)})
+		return
+	}
+
+	body, err := resp.Text().Await().Values()
+	if err != nil {
+		// return User{}, err
+		co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: err})
+		return
+	}
+	user := User{}
+	if err := json.Unmarshal([]byte(body), &user); err != nil {
+		// return User{}, err
+		co.Return(tuple.Tuple2[User, error]{V1: User{}, V2: err})
+		return
+	}
+
+	// return user, nil
+	co.Return(tuple.Tuple2[User, error]{V1: user, V2: nil})
+	return
+}
+
+func GetScore() (co *async.Promise[tuple.Tuple2[float64, error]]) {
+	resp, err := AsyncHttpGet("http://example.com/score/").Await().Values()
+	if err != nil {
+		co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: err})
+		return
+	}
+
+	if resp.StatusCode != 200 {
+		// return 0, fmt.Errorf("http status code: %d", resp.StatusCode)
+		co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: fmt.Errorf("http status code: %d", resp.StatusCode)})
+		return
+	}
+
+	body, err := resp.Text().Await().Values()
+	if err != nil {
+		// return 0, err
+		co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: err})
+		return
+	}
+
+	score := 0.0
+	if _, err := fmt.Sscanf(body, "%f", &score); err != nil {
+		// return 0, err
+		co.Return(tuple.Tuple2[float64, error]{V1: 0, V2: err})
+		return
+	}
+
+	// return score, nil
+	co.Return(tuple.Tuple2[float64, error]{V1: score, V2: nil})
+	return
+}
+
+func DoUpdate(op string) (co *async.Promise[error]) {
+	resp, err := AsyncHttpPost("http://example.com/update/" + op).Await().Values()
+	if err != nil {
+		co.Return(err)
+		return
+	}
+
+	if resp.StatusCode != 200 {
+		co.Return(fmt.Errorf("http status code: %d", resp.StatusCode))
+	}
+
+	co.Return(nil)
+	return
+}
+
+func GenInts() (co *async.Promise[int]) {
+	co.Yield(3)
+	co.Yield(2)
+	co.Yield(5)
+	return
+}
+
+// Generator with async calls and panic
+func GenUsers() (co *async.Promise[User]) {
+	u, err := GetUser("Alice").Await().Values()
+	if err != nil {
+		panic(err)
+	}
+	co.Yield(u)
+	u, err = GetUser("Bob").Await().Values()
+	if err != nil {
+		panic(err)
+	}
+	co.Yield(u)
+	u, err = GetUser("Cindy").Await().Values()
+	if err != nil {
+		panic(err)
+	}
+	co.Yield(u)
+	log.Printf("genUsers done\n")
+	return
+}
+
+func Demo() (co *async.Promise[async.Void]) {
+	user, err := GetUser("1").Await().Values()
+	log.Println(user, err)
+
+	// user, err = naive.Race[tuple.Tuple2[User, error]](GetUser("2"), GetUser("3"), GetUser("4")).Value().Values()
+	// log.Println(user, err)
+
+	// users := naive.All[tuple.Tuple2[User, error]]([]naive.AsyncCall[tuple.Tuple2[User, error]]{GetUser("5"), GetUser("6"), GetUser("7")}).Value()
+	// log.Println(users, err)
+
+	// user, score, _ := naive.Await3Compiled[User, float64, async.Void](GetUser("8"), GetScore(), DoUpdate("update sth.")).Value().Values()
+	// log.Println(user, score, err)
+
+	// for loop with generator
+	g := GenInts()
+	for !g.Done() {
+		log.Println("genInt:", g.Value(), g.Done())
+		g.Resume()
+	}
+
+	// for loop with async generator
+	// for u, err := range GenUsers() {...}
+	g1 := GenUsers()
+	for !g1.Done() {
+		u := g1.Value()
+		log.Println("genUser:", u)
+		g1.Resume()
+	}
+
+	// TODO(lijie): select from multiple promises without channel
+	// select {
+	// case user := <-GetUser("123").Chan():
+	// 	log.Println("user:", user)
+	// case score := <-GetScore().Chan():
+	// 	log.Println("score:", score)
+	// case <-async.Timeout(5 * time.Second).Chan():
+	// 	log.Println("timeout")
+	// }
+
+	log.Println("Demo done")
+	co.Return(async.Void{})
+	return
+}
+
+func main() {
+	log.SetFlags(log.Lshortfile | log.LstdFlags)
+
+	log.Printf("=========== Run Demo ===========\n")
+	v1 := Demo()
+	log.Println(v1)
+	log.Printf("=========== Run Demo finished ===========\n")
+}

x/async/_demo/gendemo/gendemo.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/goplus/llgo/x/async"
+)
+
+func GenInts() (co *async.Promise[int]) {
+	println("gen: 1")
+	co.Yield(1)
+	println("gen: 2")
+	co.Yield(2)
+	println("gen: 3")
+	co.Yield(3)
+	return
+}
+
+func main() {
+	co := GenInts()
+	for !co.Done() {
+		fmt.Printf("got: %v\n", co.Value())
+		co.Next()
+	}
+	fmt.Printf("done\n")
+}

x/async/async.go

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package async
+
+import (
+	"unsafe"
+	_ "unsafe"
+)
+
+const (
+	LLGoPackage = "decl"
+)
+
+type Void = [0]byte
+
+// -----------------------------------------------------------------------------
+
+type Promise[TOut any] struct {
+	hdl   unsafe.Pointer
+	value TOut
+}
+
+// // llgo:link (*Promise).Await llgo.coAwait
+func (p *Promise[TOut]) Await() TOut {
+	panic("should not executed")
+}
+
+func (p *Promise[TOut]) Return(v TOut) {
+	p.value = v
+	coReturn(p.hdl)
+}
+
+// llgo:link (*Promise).Yield llgo.coYield
+func (p *Promise[TOut]) Yield(v TOut) {}
+
+// llgo:link (*Promise).Suspend llgo.coSuspend
+func (p *Promise[TOut]) Suspend() {}
+
+func (p *Promise[TOut]) Resume() {
+	coResume(p.hdl)
+}
+
+func (p *Promise[TOut]) Next() {
+	coResume(p.hdl)
+}
+
+// TODO(lijie): should merge to Yield()
+// call by llgo.coYield
+func (p *Promise[TOut]) setValue(v TOut) {
+	p.value = v
+}
+
+func (p *Promise[TOut]) Value() TOut {
+	return p.value
+}
+
+func (p *Promise[TOut]) Done() bool {
+	return coDone(p.hdl) != 0
+}
+
+func Run[TOut any](f func() TOut) TOut {
+	panic("should not executed")
+}

x/async/coro.go

@@ -14,9 +14,26 @@
  * limitations under the License.
  */
 
-package subtle
+package async
 
-// llgo:skip XORBytes
 import (
+	"unsafe"
 	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
 )
+
+// llgo:link coDone llgo.coDone
+func coDone(hdl unsafe.Pointer) c.Char {
+	panic("should not executed")
+}
+
+// llgo:link coResume llgo.coResume
+func coResume(hdl unsafe.Pointer) {
+	panic("should not executed")
+}
+
+// llgo:link coReturn llgo.coReturn
+func coReturn(hdl unsafe.Pointer) {
+	panic("should not executed")
+}

x/io/_demo/asyncdemo/async.go

@@ -1,290 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"log"
-	"time"
-
-	"github.com/goplus/llgo/x/io"
-)
-
-// -----------------------------------------------------------------------------
-
-type Response struct {
-	StatusCode int
-
-	mockBody string
-}
-
-func (r *Response) mock(body string) {
-	r.mockBody = body
-}
-
-func (r *Response) Text() (resolve io.Promise[string]) {
-	resolve(r.mockBody, nil)
-	return
-}
-
-func (r *Response) TextCompiled() *io.PromiseImpl[string] {
-	P := &io.PromiseImpl[string]{}
-	P.Func = func(resolve func(string, error)) {
-		for {
-			switch P.Prev = P.Next; P.Prev {
-			case 0:
-				resolve(r.mockBody, nil)
-				P.Next = -1
-				return
-			default:
-				panic("Promise already done")
-			}
-		}
-	}
-	return P
-}
-
-func HttpGet(url string, callback func(resp *Response, err error)) {
-	resp := &Response{StatusCode: 200}
-	callback(resp, nil)
-}
-
-func AsyncHttpGet(url string) (resolve io.Promise[*Response]) {
-	HttpGet(url, resolve)
-	return
-}
-
-func AsyncHttpGetCompiled(url string) *io.PromiseImpl[*Response] {
-	P := &io.PromiseImpl[*Response]{}
-	P.Func = func(resolve func(*Response, error)) {
-		for {
-			switch P.Prev = P.Next; P.Prev {
-			case 0:
-				HttpGet(url, resolve)
-				P.Next = -1
-				return
-			default:
-				panic("Promise already done")
-			}
-		}
-	}
-	return P
-}
-
-// -----------------------------------------------------------------------------
-
-type User struct {
-	Name string
-}
-
-func GetUser(uid string) (resolve io.Promise[User]) {
-	resp, err := AsyncHttpGet("http://example.com/user/" + uid).Await()
-	if err != nil {
-		resolve(User{}, err)
-		return
-	}
-
-	if resp.StatusCode != 200 {
-		resolve(User{}, fmt.Errorf("http status code: %d", resp.StatusCode))
-		return
-	}
-
-	resp.mock(`{"name":"Alice"}`)
-
-	body, err := resp.Text().Await()
-	if err != nil {
-		resolve(User{}, err)
-		return
-	}
-	user := User{}
-	if err := json.Unmarshal([]byte(body), &user); err != nil {
-		resolve(User{}, err)
-		return
-	}
-
-	resolve(user, nil)
-	return
-}
-
-func GetUserCompiled(uid string) *io.PromiseImpl[User] {
-	var state1 *io.PromiseImpl[*Response]
-	var state2 *io.PromiseImpl[string]
-
-	P := &io.PromiseImpl[User]{}
-	P.Func = func(resolve func(User, error)) {
-		for {
-			switch P.Prev = P.Next; P.Prev {
-			case 0:
-				state1 = AsyncHttpGetCompiled("http://example.com/user/" + uid)
-				P.Next = 1
-				return
-			case 1:
-				state1.EnsureDone()
-				resp, err := state1.Value, state1.Err
-				if err != nil {
-					resolve(User{}, err)
-					return
-				}
-
-				if resp.StatusCode != 200 {
-					resolve(User{}, fmt.Errorf("http status code: %d", resp.StatusCode))
-					return
-				}
-
-				resp.mock(`{"name":"Alice"}`)
-
-				state2 = resp.TextCompiled()
-				P.Next = 2
-				return
-			case 2:
-				state2.EnsureDone()
-				body, err := state2.Value, state2.Err
-				if err != nil {
-					resolve(User{}, err)
-					return
-				}
-				user := User{}
-				if err := json.Unmarshal([]byte(body), &user); err != nil {
-					resolve(User{}, err)
-					return
-				}
-
-				resolve(user, nil)
-				P.Next = -1
-				return
-			default:
-				panic("Promise already done")
-			}
-		}
-	}
-	return P
-}
-
-func GetScore() *io.Promise[float64] {
-	panic("todo: GetScore")
-}
-
-func GetScoreCompiled() *io.PromiseImpl[float64] {
-	P := &io.PromiseImpl[float64]{}
-	P.Func = func(resolve func(float64, error)) {
-		for {
-			switch P.Prev = P.Next; P.Prev {
-			case 0:
-				panic("todo: GetScore")
-			default:
-				panic("Promise already done")
-			}
-		}
-	}
-	return P
-}
-
-func DoUpdate(op string) *io.Promise[io.Void] {
-	panic("todo: DoUpdate")
-}
-
-func DoUpdateCompiled(op string) *io.PromiseImpl[io.Void] {
-	P := &io.PromiseImpl[io.Void]{}
-	P.Func = func(resolve func(io.Void, error)) {
-		for {
-			switch P.Prev = P.Next; P.Prev {
-			case 0:
-				panic("todo: DoUpdate")
-			default:
-				panic("Promise already done")
-			}
-		}
-	}
-	return P
-}
-
-func Demo() (resolve io.Promise[io.Void]) {
-	user, err := GetUser("123").Await()
-	log.Println(user, err)
-
-	user, err = io.Race[User](GetUser("123"), GetUser("456"), GetUser("789")).Await()
-	log.Println(user, err)
-
-	users, err := io.All[User]([]io.AsyncCall[User]{GetUser("123"), GetUser("456"), GetUser("789")}).Await()
-	log.Println(users, err)
-
-	user, score, _, err := io.Await3[User, float64, io.Void](GetUser("123"), GetScore(), DoUpdate("update sth."))
-	log.Println(user, score, err)
-
-	// TODO(lijie): select from multiple promises without channel
-	select {
-	case user := <-GetUser("123").Chan():
-		log.Println("user:", user)
-	case score := <-GetScore().Chan():
-		log.Println("score:", score)
-	case <-io.Timeout(5 * time.Second).Chan():
-		log.Println("timeout")
-	}
-	return
-}
-
-func DemoCompiled() *io.PromiseImpl[io.Void] {
-	var state1 *io.PromiseImpl[User]
-	var state2 *io.PromiseImpl[User]
-	var state3 *io.PromiseImpl[[]User]
-	var state4 *io.PromiseImpl[io.Await3Result[User, float64, io.Void]]
-
-	P := &io.PromiseImpl[io.Void]{}
-	P.Func = func(resolve func(io.Void, error)) {
-		for {
-			switch P.Prev = P.Next; P.Prev {
-			case 0:
-				state1 = GetUserCompiled("123")
-				P.Next = 1
-				return
-			case 1:
-				state1.EnsureDone()
-				user, err := state1.Value, state1.Err
-				log.Printf("user: %v, err: %v\n", user, err)
-
-				state2 = io.Race[User](GetUserCompiled("123"), GetUserCompiled("456"), GetUserCompiled("789"))
-				P.Next = 2
-				return
-			case 2:
-				state2.EnsureDone()
-				user, err := state2.Value, state2.Err
-				log.Println(user, err)
-
-				state3 = io.All[User]([]io.AsyncCall[User]{GetUserCompiled("123"), GetUserCompiled("456"), GetUserCompiled("789")})
-				P.Next = 3
-				return
-			case 3:
-				state3.EnsureDone()
-				users, err := state3.Value, state3.Err
-				log.Println(users, err)
-
-				state4 = io.Await3Compiled[User, float64, io.Void](GetUserCompiled("123"), GetScoreCompiled(), DoUpdateCompiled("update sth."))
-				P.Next = 4
-				return
-			case 4:
-				state4.EnsureDone()
-				user, score, _, err := state4.Value.V1, state4.Value.V2, state4.Value.V3, state4.Value.Err
-				log.Println(user, score, err)
-
-				select {
-				case user := <-GetUserCompiled("123").Chan():
-					log.Println("user:", user)
-				case score := <-GetScoreCompiled().Chan():
-					log.Println("score:", score)
-				case <-io.TimeoutCompiled(5 * time.Second).Chan():
-					log.Println("timeout")
-				}
-				P.Next = -1
-				return
-			default:
-				panic("Promise already done")
-			}
-		}
-	}
-	return P
-}
-
-func main() {
-	log.SetFlags(log.Lshortfile | log.LstdFlags)
-	// io.Run(Demo())
-	io.Run(DemoCompiled())
-}

x/io/io.go

@@ -1,170 +0,0 @@
-/*
- * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io
-
-import (
-	_ "unsafe"
-
-	"time"
-)
-
-const (
-	LLGoPackage = "decl"
-)
-
-type Void = [0]byte
-
-// -----------------------------------------------------------------------------
-
-type AsyncCall[OutT any] interface {
-	Await(timeout ...time.Duration) (ret OutT, err error)
-	Chan() <-chan OutT
-	EnsureDone()
-}
-
-// llgo:link AsyncCall.Await llgo.await
-func Await[OutT any](call AsyncCall[OutT], timeout ...time.Duration) (ret OutT, err error) {
-	return
-}
-
-//go:linkname Timeout llgo.timeout
-func Timeout(time.Duration) (ret AsyncCall[Void])
-
-func TimeoutCompiled(d time.Duration) *PromiseImpl[Void] {
-	P := &PromiseImpl[Void]{}
-	P.Func = func(resolve func(Void, error)) {
-		go func() {
-			time.Sleep(d)
-			resolve(Void{}, nil)
-		}()
-	}
-	return P
-}
-
-// llgo:link Race llgo.race
-func Race[OutT any](acs ...AsyncCall[OutT]) (ret *PromiseImpl[OutT]) {
-	return
-}
-
-func All[OutT any](acs []AsyncCall[OutT]) (ret *PromiseImpl[[]OutT]) {
-	return nil
-}
-
-// llgo:link Await2 llgo.await
-func Await2[OutT1, OutT2 any](
-	ac1 AsyncCall[OutT1], ac2 AsyncCall[OutT2],
-	timeout ...time.Duration) (ret1 OutT1, ret2 OutT2, err error) {
-	return
-}
-
-type Await2Result[T1 any, T2 any] struct {
-	V1  T1
-	V2  T2
-	Err error
-}
-
-func Await2Compiled[OutT1, OutT2 any](
-	ac1 AsyncCall[OutT1], ac2 AsyncCall[OutT2],
-	timeout ...time.Duration) (ret *PromiseImpl[Await2Result[OutT1, OutT2]]) {
-	return
-}
-
-// llgo:link Await3 llgo.await
-func Await3[OutT1, OutT2, OutT3 any](
-	ac1 AsyncCall[OutT1], ac2 AsyncCall[OutT2], ac3 AsyncCall[OutT3],
-	timeout ...time.Duration) (ret1 OutT1, ret2 OutT2, ret3 OutT3, err error) {
-	return
-}
-
-type Await3Result[T1 any, T2 any, T3 any] struct {
-	V1  T1
-	V2  T2
-	V3  T3
-	Err error
-}
-
-func Await3Compiled[OutT1, OutT2, OutT3 any](
-	ac1 AsyncCall[OutT1], ac2 AsyncCall[OutT2], ac3 AsyncCall[OutT3],
-	timeout ...time.Duration) (ret *PromiseImpl[Await3Result[OutT1, OutT2, OutT3]]) {
-	return
-}
-
-func Run(ac AsyncCall[Void]) {
-	p := ac.(*PromiseImpl[Void])
-	p.Resume()
-	<-ac.Chan()
-}
-
-// -----------------------------------------------------------------------------
-
-type Promise[OutT any] func(OutT, error)
-
-// llgo:link Promise.Await llgo.await
-func (p Promise[OutT]) Await(timeout ...time.Duration) (ret OutT, err error) {
-	return
-}
-
-func (p Promise[OutT]) Chan() <-chan OutT {
-	return nil
-}
-
-func (p Promise[OutT]) EnsureDone() {
-
-}
-
-// -----------------------------------------------------------------------------
-
-type PromiseImpl[TOut any] struct {
-	Func  func(resolve func(TOut, error))
-	Value TOut
-	Err   error
-	Prev  int
-	Next  int
-
-	c chan TOut
-}
-
-func (p *PromiseImpl[TOut]) Resume() {
-	p.Func(func(v TOut, err error) {
-		p.Value = v
-		p.Err = err
-	})
-}
-
-func (p *PromiseImpl[TOut]) EnsureDone() {
-	if p.Next == -1 {
-		panic("Promise already done")
-	}
-}
-
-func (p *PromiseImpl[TOut]) Chan() <-chan TOut {
-	if p.c == nil {
-		p.c = make(chan TOut, 1)
-		p.Func(func(v TOut, err error) {
-			p.Value = v
-			p.Err = err
-			p.c <- v
-		})
-	}
-	return p.c
-}
-
-func (p *PromiseImpl[TOut]) Await(timeout ...time.Duration) (ret TOut, err error) {
-	panic("should not called")
-}
-
-// -----------------------------------------------------------------------------

x/tuple/tuple.go

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package tuple
+
+// -----------------------------------------------------------------------------
+
+type Tuple1[T any] struct {
+	V1 T
+}
+
+func (r Tuple1[T]) Values() T {
+	return r.V1
+}
+
+type Tuple2[T1 any, T2 any] struct {
+	V1 T1
+	V2 T2
+}
+
+func (r Tuple2[T1, T2]) Values() (T1, T2) {
+	return r.V1, r.V2
+}
+
+type Tuple3[T1 any, T2 any, T3 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+}
+
+func (r Tuple3[T1, T2, T3]) Values() (T1, T2, T3) {
+	return r.V1, r.V2, r.V3
+}
+
+type Tuple4[T1 any, T2 any, T3 any, T4 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+	V4 T4
+}
+
+func (r Tuple4[T1, T2, T3, T4]) Values() (T1, T2, T3, T4) {
+	return r.V1, r.V2, r.V3, r.V4
+}