Merge pull request #673 from cpunion/libuv-async

Add libuv async

README.md

@@ -312,7 +312,9 @@ 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/hmacdemo/hmac.go

@@ -0,0 +1,15 @@
+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,6 +79,9 @@ 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

@@ -1,61 +0,0 @@
-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.CXXMethod || cursor.Kind == clang.FunctionDecl {
+	if cursor.Kind == clang.CursorCXXMethod || cursor.Kind == clang.CursorFunctionDecl {
 		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.MacroDefinition {
+	if cursor.Kind == clang.CursorMacroDefinition {
 		printMarcoInfo(cursor)
-	} else if cursor.Kind == clang.Namespace {
+	} else if cursor.Kind == clang.CursorNamespace {
 		nameStr := cursor.String()
 		context.setNamespaceName(c.GoString(nameStr.CStr()))
 		clang.VisitChildren(cursor, visit, nil)
 		context.setNamespaceName("")
-	} else if cursor.Kind == clang.ClassDecl {
+	} else if cursor.Kind == clang.CursorClassDecl {
 		nameStr := cursor.String()
 		context.setClassName(c.GoString(nameStr.CStr()))
 		clang.VisitChildren(cursor, visit, nil)
 		context.setClassName("")
-	} else if cursor.Kind == clang.CXXMethod || cursor.Kind == clang.FunctionDecl {
+	} else if cursor.Kind == clang.CursorCXXMethod || cursor.Kind == clang.CursorFunctionDecl {
 		printFuncInfo(cursor)
 	}
 

c/clang/_wrap/cursor.cpp

@@ -33,6 +33,24 @@ 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) {
@@ -46,6 +64,10 @@ 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

@@ -0,0 +1,41 @@
+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 := libuv.Run(loop, libuv.RUN_DEFAULT)
+	result := loop.Run(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 libuv.FsGetResult(req) < 0 {
+	if req.GetResult() < 0 {
-		c.Fprintf(c.Stderr, c.Str("Error opening file: %s\n"), libuv.Strerror(libuv.Errno(libuv.FsGetResult(req))))
+		c.Fprintf(c.Stderr, c.Str("Error opening file: %s\n"), libuv.Strerror(libuv.Errno(req.GetResult())))
-		libuv.LoopClose(loop)
+		loop.Close()
 		return
 	}
 
 	// Store the file descriptor
-	file = libuv.File(libuv.FsGetResult(req))
+	file = libuv.File(req.GetResult())
 
 	// 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)
-		libuv.FsReqCleanup(&readReq)
+		readReq.ReqCleanup()
-		libuv.LoopClose(loop)
+		loop.Close()
 	}
 }
 
 func onRead(req *libuv.Fs) {
 	// Cleanup the request
-	defer libuv.FsReqCleanup(req)
+	defer req.ReqCleanup()
 	// Check for errors
-	if libuv.FsGetResult(req) < 0 {
+	if req.GetResult() < 0 {
-		c.Fprintf(c.Stderr, c.Str("Read error: %s\n"), libuv.Strerror(libuv.Errno(libuv.FsGetResult(req))))
+		c.Fprintf(c.Stderr, c.Str("Read error: %s\n"), libuv.Strerror(libuv.Errno(req.GetResult())))
-	} else if libuv.FsGetResult(req) == 0 {
+	} else if req.GetResult() == 0 {
 		// Close the file
-		closeRes := libuv.FsClose(loop, &closeReq, libuv.File(libuv.FsGetResult(&openReq)), onClose)
+		closeRes := libuv.FsClose(loop, &closeReq, libuv.File(openReq.GetResult()), onClose)
 		if closeRes != 0 {
 			c.Printf(c.Str("Error in FsClose: %s (code: %d)\n"), libuv.Strerror(libuv.Errno(closeRes)), closeRes)
-			libuv.LoopClose(loop)
+			loop.Close()
 			return
 		}
 	} else {
-		c.Printf(c.Str("Read %d bytes\n"), libuv.FsGetResult(req))
+		c.Printf(c.Str("Read %d bytes\n"), req.GetResult())
-		c.Printf(c.Str("Read content: %.*s\n"), libuv.FsGetResult(req), (*c.Char)(unsafe.Pointer(&buffer[0])))
+		c.Printf(c.Str("Read content: %.*s\n"), req.GetResult(), (*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 libuv.FsGetResult(req) < 0 {
+	if req.GetResult() < 0 {
-		c.Fprintf(c.Stderr, c.Str("Error closing file: %s\n"), libuv.Strerror(libuv.Errno(libuv.FsGetResult(req))))
+		c.Fprintf(c.Stderr, c.Str("Error closing file: %s\n"), libuv.Strerror(libuv.Errno(req.GetResult())))
 	} else {
 		c.Printf(c.Str("\nFile closed successfully.\n"))
 	}
@@ -106,10 +106,10 @@ func onClose(req *libuv.Fs) {
 
 func cleanup() {
 	// Cleanup the requests
-	libuv.FsReqCleanup(&openReq)
+	openReq.ReqCleanup()
-	libuv.FsReqCleanup(&closeReq)
+	closeReq.ReqCleanup()
 	// Close the loop
-	result := libuv.LoopClose(loop)
+	result := loop.Close()
 	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

@@ -31,14 +31,14 @@ func main() {
 
 	// 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)
+	res := (*libuv.Stream)(unsafe.Pointer(&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
-	libuv.Run(loop, libuv.RUN_DEFAULT)
+	loop.Run(libuv.RUN_DEFAULT)
 }
 
 func FreeWriteReq(req *libuv.Write) {
@@ -56,7 +56,7 @@ 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(req)
 }
@@ -77,8 +77,8 @@ func EchoRead(client *libuv.Stream, nread c.Long, buf *libuv.Buf) {
 	}
 	if nread < 0 {
 		// Handle read errors and EOF.
-		if (libuv.Errno)(nread) != libuv.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)
 	}
@@ -110,9 +110,9 @@ func OnNewConnection(server *libuv.Stream, status c.Int) {
 	}
 
 	// Accept the new connection and start reading data.
-	if server.Accept((*libuv.Stream)(client)) == 0 {
+	if server.Accept((*libuv.Stream)(unsafe.Pointer(client))) == 0 {
-		(*libuv.Stream)(client).StartRead(AllocBuffer, EchoRead)
+		(*libuv.Stream)(unsafe.Pointer(client)).StartRead(AllocBuffer, EchoRead)
 	} else {
-		(*libuv.Handle)(c.Pointer(client)).Close(nil)
+		(*libuv.Handle)(unsafe.Pointer(client)).Close(nil)
 	}
 }

c/libuv/_wrap/libuv.c

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

c/libuv/async.go

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

c/libuv/libuv.go

@@ -9,6 +9,7 @@ import (
 
 const (
 	LLGoPackage = "link: $(pkg-config --libs libuv); -luv"
+	LLGoFiles   = "$(pkg-config --cflags libuv): _wrap/libuv.c"
 )
 
 // ----------------------------------------------
@@ -103,10 +104,6 @@ type Poll struct {
 
 /* Request types. */
 
-type Shutdown struct {
-	Unused [0]byte
-}
-
 type Buf struct {
 	Base *c.Char
 	Len  uintptr
@@ -135,9 +132,6 @@ 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)
 
@@ -160,59 +154,88 @@ func ReplaceAllocator(mallocFunc MallocFunc, reallocFunc ReallocFunc, callocFunc
 
 // ----------------------------------------------
 
-// llgo:link (*Shutdown).Shutdown C.uv_shutdown
-func (shutdown *Shutdown) Shutdown(stream *Stream, shutdownCb ShutdownCb) c.Int {
-	return 0
-}
-
-// ----------------------------------------------
-
 /* Loop related functions and method. */
 
+//go:linkname DefaultLoop C.uv_default_loop
+func DefaultLoop() *Loop
+
 //go:linkname LoopSize C.uv_loop_size
 func LoopSize() uintptr
 
-//go:linkname Run C.uv_run
+// llgo:link (*Loop).Run C.uv_run
-func Run(loop *Loop, mode RunMode) c.Int
+func (loop *Loop) Run(mode RunMode) c.Int {
+	return 0
+}
 
-//go:linkname LoopAlive C.uv_loop_alive
+// llgo:link (*Loop).Alive C.uv_loop_alive
-func LoopAlive(loop *Loop) c.Int
+func (loop *Loop) Alive() c.Int {
+	return 0
+}
 
-//go:linkname LoopClose C.uv_loop_close
+// void uv_stop(uv_loop_t *loop)
-func LoopClose(loop *Loop) c.Int
+//
+// llgo:link (*Loop).Stop C.uv_stop
+func (loop *Loop) Stop() {}
 
-//go:linkname LoopConfigure C.uv_loop_configure
+// llgo:link (*Loop).Close C.uv_loop_close
-func LoopConfigure(loop *Loop, option LoopOption, arg c.Int) c.Int
+func (loop *Loop) Close() c.Int {
+	return 0
+}
 
-//go:linkname LoopDefault C.uv_default_loop
+// llgo:link (*Loop).Configure C.uv_loop_configure
-func LoopDefault() *Loop
+func (loop *Loop) Configure(option LoopOption, arg c.Int) c.Int {
+	return 0
+}
 
-//go:linkname LoopDelete C.uv_loop_delete
+// llgo:link LoopDefault C.uv_default_loop
-func LoopDelete(loop *Loop) c.Int
+func LoopDefault() *Loop {
+	return nil
+}
 
-//go:linkname LoopFork C.uv_loop_fork
+// llgo:link (*Loop).Delete C.uv_loop_delete
-func LoopFork(loop *Loop) c.Int
+func (loop *Loop) Delete() c.Int {
+	return 0
+}
 
-//go:linkname LoopInit C.uv_loop_init
+// llgo:link (*Loop).Fork C.uv_loop_fork
-func LoopInit(loop *Loop) c.Int
+func (loop *Loop) Fork() c.Int {
+	return 0
+}
 
-//go:linkname LoopNew C.uv_loop_new
+// llgo:link (*Loop).Init C.uv_loop_init
-func LoopNew() *Loop
+func (loop *Loop) Init() c.Int {
+	return 0
+}
 
-//go:linkname LoopNow C.uv_now
+// llgo:link LoopNew C.uv_loop_new
-func LoopNow(loop *Loop) c.UlongLong
+func LoopNew() *Loop {
+	return nil
+}
 
-//go:linkname LoopUpdateTime C.uv_update_time
+// llgo:link (*Loop).Now C.uv_now
-func LoopUpdateTime(loop *Loop)
+func (loop *Loop) Now() c.UlongLong {
+	return 0
+}
 
-//go:linkname LoopBackendFd C.uv_backend_fd
+// llgo:link (*Loop).UpdateTime C.uv_update_time
-func LoopBackendFd(loop *Loop) c.Int
+func (loop *Loop) UpdateTime() {
+	// No return value needed for this method
+}
 
-//go:linkname LoopBackendTimeout C.uv_backend_timeout
+// llgo:link (*Loop).BackendFd C.uv_backend_fd
-func LoopBackendTimeout(loop *Loop) c.Int
+func (loop *Loop) BackendFd() c.Int {
+	return 0
+}
 
-//go:linkname LoopWalk C.uv_walk
+// llgo:link (*Loop).BackendTimeout C.uv_backend_timeout
-func LoopWalk(loop *Loop, walkCb WalkCb, arg c.Pointer)
+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
+}
 
 // ----------------------------------------------
 
@@ -228,11 +251,15 @@ 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,6 +117,10 @@ type GetNameInfo struct {
 	Unused [0]byte
 }
 
+type Shutdown struct {
+	Unused [0]byte
+}
+
 // ----------------------------------------------
 
 /* Function type */
@@ -142,10 +146,19 @@ 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() {}
 
@@ -157,17 +170,11 @@ 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
@@ -204,6 +211,21 @@ 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
@@ -214,11 +236,6 @@ 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 */
@@ -226,6 +243,9 @@ func (handle *Handle) IsClosing() 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
@@ -239,9 +259,6 @@ 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 */
@@ -306,6 +323,11 @@ 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 */
@@ -356,6 +378,11 @@ 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
 
@@ -429,9 +456,6 @@ 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
@@ -462,8 +486,13 @@ 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,8 +26,17 @@ type SignalCb func(handle *Signal, sigNum c.Int)
 //go:linkname SignalInit C.uv_signal_init
 func SignalInit(loop *Loop, handle *Signal) c.Int
 
-//go:linkname SignalStart C.uv_signal_start
+// llgo:link (*Signal).Start C.uv_signal_start
-func SignalStart(handle *Signal, cb SignalCb, signum c.Int) c.Int
+func (handle *Signal) Start(cb SignalCb, signum c.Int) c.Int {
+	return 0
+}
 
-//go:linkname SignalStartOneshot C.uv_signal_start_oneshot
+// llgo:link (*Signal).StartOneshot C.uv_signal_start_oneshot
-func SignalStartOneshot(handle *Signal, cb SignalCb, signum c.Int) c.Int
+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
+}

c/openssl/_demo/chmacdemo/hmac.go

@@ -21,7 +21,6 @@ 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"))
@@ -37,9 +36,5 @@ func main() {
 		c.Fprintf(c.Stderr, c.Str("%s\n"), c.Str("Error finalizing HMAC_CTX"))
 		return
 	}
-	fmt.Print("HMAC: ")
+	fmt.Printf("HMAC:%x\n", digest[:digestLen])
-	for i := 0; i < int(digestLen); i++ {
-		fmt.Printf("%02x", digest[i])
-	}
-	fmt.Print("\n")
 }

c/openssl/hmac.go

@@ -6,7 +6,15 @@ import (
 	"github.com/goplus/llgo/c"
 )
 
-const EVP_MAX_MD_SIZE = 64 /* longest known is SHA512 */
+const (
+	EVP_MAX_MD_SIZE = 64 /* longest known is SHA512 */
+)
+
+// -----------------------------------------------------------------------------
+
+type EVP_MD struct {
+	Unused [0]byte
+}
 
 // const EVP_MD *EVP_sha1(void)
 //
@@ -43,13 +51,7 @@ 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
@@ -63,30 +65,38 @@ 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 (c *HMAC_CTX) Free() {}
+func (ctx *HMAC_CTX) Free() {}
 
 // OSSL_DEPRECATEDIN_3_0 size_t HMAC_size(const HMAC_CTX *e);
 //
 // llgo:link (*HMAC_CTX).Size C.HMAC_size
-func (c *HMAC_CTX) Size() uintptr { return 0 }
+func (ctx *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 (c *HMAC_CTX) Reset() c.Int { return 0 }
+func (ctx *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 (c *HMAC_CTX) Init(key unsafe.Pointer, len c.Int, md *EVP_MD) c.Int { return 0 }
+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)
+}
 
 // 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 (c *HMAC_CTX) InitEx(key unsafe.Pointer, len c.Int, md *EVP_MD, impl unsafe.Pointer) c.Int {
+func (ctx *HMAC_CTX) InitEx(key unsafe.Pointer, len c.Int, md *EVP_MD, impl unsafe.Pointer) c.Int {
 	return 0
 }
 
@@ -94,28 +104,30 @@ func (c *HMAC_CTX) InitEx(key unsafe.Pointer, len c.Int, md *EVP_MD, impl unsafe
 // size_t len);
 //
 // llgo:link (*HMAC_CTX).Update C.HMAC_Update
-func (c *HMAC_CTX) Update(data unsafe.Pointer, len uintptr) c.Int { return 0 }
+func (ctx *HMAC_CTX) Update(data unsafe.Pointer, len uintptr) c.Int { return 0 }
 
-func (c *HMAC_CTX) UpdateBytes(data []byte) c.Int {
+func (ctx *HMAC_CTX) UpdateBytes(data []byte) c.Int {
-	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+	return ctx.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
 }
 
-func (c *HMAC_CTX) UpdateString(data string) c.Int {
+func (ctx *HMAC_CTX) UpdateString(data string) c.Int {
-	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+	return ctx.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 (c *HMAC_CTX) Final(md *byte, len *c.Uint) c.Int { return 0 }
+func (ctx *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 (c *HMAC_CTX) Copy(sctx *HMAC_CTX) c.Int { return 0 }
+func (ctx *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 (c *HMAC_CTX) SetFlags(flags c.Ulong) {}
+func (ctx *HMAC_CTX) SetFlags(flags c.Ulong) {}
+
+// -----------------------------------------------------------------------------

chore/_xtool/castdump/castdump.go

@@ -0,0 +1,217 @@
+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)
+}

cl/_testgo/equal/out.ll

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

cl/_testrt/makemap/in.go

@@ -7,6 +7,7 @@ func main() {
 	make4()
 	make5()
 	make6()
+	make7()
 }
 
 func make1() {
@@ -113,3 +114,15 @@ 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,6 +8,7 @@ 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
@@ -36,24 +37,32 @@ _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 @"map[_llgo_int]_llgo_int", align 8
+  %2 = load ptr, ptr @_llgo_int, align 8
-  %3 = call ptr @"github.com/goplus/llgo/internal/runtime.MakeMap"(ptr %2, i64 2)
+  %3 = load ptr, ptr @_llgo_int, align 8
   %4 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
-  %5 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
+  %5 = call ptr @"github.com/goplus/llgo/internal/runtime.MakeMap"(ptr %4, i64 2)
-  store i64 23, ptr %5, align 4
+  %6 = load ptr, ptr @_llgo_int, align 8
-  %6 = call ptr @"github.com/goplus/llgo/internal/runtime.MapAssign"(ptr %4, ptr %3, ptr %5)
+  %7 = load ptr, ptr @_llgo_int, align 8
-  store i64 100, ptr %6, align 4
+  %8 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
-  %7 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
+  %9 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
-  %8 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
+  store i64 23, ptr %9, align 4
-  store i64 7, ptr %8, align 4
+  %10 = call ptr @"github.com/goplus/llgo/internal/runtime.MapAssign"(ptr %8, ptr %5, ptr %9)
-  %9 = call ptr @"github.com/goplus/llgo/internal/runtime.MapAssign"(ptr %7, ptr %3, ptr %8)
+  store i64 100, ptr %10, align 4
-  store i64 29, ptr %9, align 4
+  %11 = load ptr, ptr @_llgo_int, align 8
-  %10 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
+  %12 = load ptr, ptr @_llgo_int, align 8
-  %11 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
+  %13 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
-  store i64 23, ptr %11, align 4
+  %14 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
-  %12 = call ptr @"github.com/goplus/llgo/internal/runtime.MapAccess1"(ptr %10, ptr %3, ptr %11)
+  store i64 7, ptr %14, align 4
-  %13 = load i64, ptr %12, align 4
+  %15 = call ptr @"github.com/goplus/llgo/internal/runtime.MapAssign"(ptr %13, ptr %5, ptr %14)
-  %14 = call i32 (ptr, ...) @printf(ptr @5, i64 %13)
+  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)
   ret i32 0
 }
 
@@ -61,109 +70,119 @@ declare void @"github.com/goplus/llgo/internal/runtime.init"()
 
 define void @"main.init$after"() {
 _llgo_0:
-  %0 = load ptr, ptr @"map[_llgo_int]_llgo_int", align 8
+  %0 = load ptr, ptr @_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)
-  %3 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 34)
+  store ptr %2, ptr @_llgo_int, align 8
-  %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.MapOf"(ptr, ptr, ptr, i64)
-
 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.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/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(b llssa.Builder, args []ssa.Value) llssa.Expr {
+func (p *context) funcAddr(_ 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 {

internal/build/build.go

@@ -757,11 +757,13 @@ 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/rand":              {},
+	"crypto/subtle":            {},
 	"fmt":                      {},
 	"hash/crc32":               {},
 	"internal/abi":             {},

internal/lib/crypto/hmac/hmac.go

@@ -0,0 +1,72 @@
+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,3 +1,19 @@
+/*
+ * 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,3 +1,19 @@
+/*
+ * 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,3 +1,19 @@
+/*
+ * 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,3 +1,19 @@
+/*
+ * 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,3 +1,19 @@
+/*
+ * 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/crypto/subtle/xor.go

@@ -0,0 +1,22 @@
+/*
+ * 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 subtle
+
+// llgo:skip XORBytes
+import (
+	_ "unsafe"
+)

internal/lib/internal/fmtsort/sort.go

@@ -0,0 +1,220 @@
+// 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
+}

ssa/abitype.go

@@ -414,6 +414,9 @@ 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)