Merge pull request #666 from cpunion/async-functions

Async functions

.github/workflows/go.yml

@@ -14,37 +14,65 @@ jobs:
   test:
     strategy:
       matrix:
-        os: [macos-latest, ubuntu-latest]
-        # os: [macos-latest]
+        os:
+          - macos-latest
+          - ubuntu-24.04
         llvm: [18]
-    runs-on: ${{ matrix.os }}
+    runs-on: ${{matrix.os}}
     steps:
       - uses: actions/checkout@v4
 
-      - name: Update Homebrew
-        # needed as long as LLVM 18 is still fresh
-        if: matrix.llvm == 18 && startsWith(matrix.os, 'macos')
-        run: brew update
-      - name: Install LLVM ${{ matrix.llvm }} and bdw-gc
+      - name: Install dependencies
         if: startsWith(matrix.os, 'macos')
         run: |
-          HOMEBREW_NO_AUTO_UPDATE=1 brew install llvm@${{ matrix.llvm }} bdw-gc
-          echo `brew --prefix llvm@${{ matrix.llvm }}`/bin >> $GITHUB_PATH
-      - name: Install LLVM ${{ matrix.llvm }} and libgc-dev
+          brew update
+          brew install llvm@${{matrix.llvm}} pkg-config bdw-gc openssl
+          echo "$(brew --prefix llvm@${{matrix.llvm}})/bin" >> $GITHUB_PATH
+
+          # Install optional deps for demos.
+          #
+          # NOTE: Keep this list updated as new deps are introduced.
+          opt_deps=(
+            cjson       # for github.com/goplus/llgo/c/cjson
+            sqlite      # for github.com/goplus/llgo/c/sqlite
+            python@3.12 # for github.com/goplus/llgo/py
+          )
+          brew install "${opt_deps[@]}"
+
+      - name: Install dependencies
         if: startsWith(matrix.os, 'ubuntu')
         run: |
-          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-${{ matrix.llvm }} main" | sudo tee /etc/apt/sources.list.d/llvm.list
+          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-${{matrix.llvm}} main" | sudo tee /etc/apt/sources.list.d/llvm.list
           wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
           sudo apt-get update
-          sudo apt-get install -y llvm-${{ matrix.llvm }}-dev clang-${{ matrix.llvm }} lld-${{ matrix.llvm }} pkg-config libgc-dev libcjson-dev libsqlite3-dev python3.11-dev
-          echo /usr/lib/llvm-${{ matrix.llvm }}/bin >> $GITHUB_PATH
-    
+          sudo apt-get install -y llvm-${{matrix.llvm}}-dev clang-${{matrix.llvm}} lld-${{matrix.llvm}} pkg-config libgc-dev libssl-dev zlib1g-dev
+          echo "/usr/lib/llvm-${{matrix.llvm}}/bin" >> $GITHUB_PATH
+
+          # Install optional deps for demos.
+          #
+          # NOTE: Keep this list updated as new deps are introduced.
+          opt_deps=(
+            libcjson-dev   # for github.com/goplus/llgo/c/cjson
+            libsqlite3-dev # for github.com/goplus/llgo/c/sqlite
+            python3.12-dev # for github.com/goplus/llgo/py
+          )
+          sudo apt-get install -y "${opt_deps[@]}"
+
+      - name: Install further optional dependencies for demos
+        run: |
+          wget -P ./_demo/llama2-c https://huggingface.co/karpathy/tinyllamas/resolve/main/stories15M.bin
+          py_deps=(
+            numpy # for github.com/goplus/llgo/py/numpy
+            torch # for github.com/goplus/llgo/py/torch
+          )
+          pip3 install --break-system-packages "${py_deps[@]}"
+
       - name: Clang information
         run: |
           echo $PATH
           which clang
           clang --version
-        
+
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
@@ -54,28 +82,26 @@ jobs:
         run: go build -v ./...
 
       - name: Test
-        if: matrix.os != 'macos-latest'
+        if: ${{!startsWith(matrix.os, 'macos')}}
         run: go test -v ./...
 
       - name: Test with coverage
-        if: matrix.os == 'macos-latest'
+        if: startsWith(matrix.os, 'macos')
         run: go test -v -coverprofile="coverage.txt" -covermode=atomic ./...
 
       - name: Install
         run: go install ./...
-      
+
       - name: LLGO tests
-        if: matrix.os != 'ubuntu-latest'
+        if: ${{!startsWith(matrix.os, 'ubuntu')}}
         run: |
-          echo "Test result on ${{ matrix.os }} with LLVM ${{ matrix.llvm }}" > result.md
-          LLGOROOT=$PWD bash .github/workflows/test_llgo.sh
-      
-      - name: Test _demo and _pydemo
-        run: |
-          set +e
-          LLGOROOT=$PWD bash .github/workflows/test_demo.sh
-          exit 0
-      
+          echo "Test result on ${{matrix.os}} with LLVM ${{matrix.llvm}}" > result.md
+          bash .github/workflows/test_llgo.sh
+
+      - name: Test demos
+        continue-on-error: true
+        run: bash .github/workflows/test_demo.sh
+
       - name: Show test result
         run: cat result.md
 
@@ -84,10 +110,10 @@ jobs:
         if: false
         with:
           filePath: result.md
-          comment_tag: test-result-on-${{ matrix.os }}-with-llvm-${{ matrix.llvm }}
+          comment_tag: test-result-on-${{matrix.os}}-with-llvm-${{matrix.llvm}}
 
       - name: Upload coverage reports to Codecov
         uses: codecov/codecov-action@v4
         with:
-          token: ${{ secrets.CODECOV_TOKEN }}
+          token: ${{secrets.CODECOV_TOKEN}}
           slug: goplus/llgo

.github/workflows/test_demo.sh

@@ -1,4 +1,5 @@
 #!/bin/bash
+set -e
 
 # llgo run subdirectories under _demo and _pydemo
 total=0
@@ -8,7 +9,7 @@ for d in ./_demo/* ./_pydemo/*; do
   total=$((total+1))
   if [ -d "$d" ]; then
     echo "Testing $d"
-    if ! llgo run "$d"; then
+    if ! (cd "$d" && llgo run .); then
       echo "FAIL"
       failed=$((failed+1))
       failed_cases="$failed_cases\n* :x: $d"

.github/workflows/test_llgo.sh

@@ -1,8 +1,6 @@
 #!/bin/bash
 set -e
 
-export LLGOROOT=$PWD
-
 testcmd=/tmp/test
 llgo build -o $testcmd ./c/bdwgc/_test
 cases=$($testcmd)

.goreleaser.yaml

@@ -20,8 +20,8 @@ builds:
     flags:
       - -tags=darwin,amd64,byollvm
     ldflags:
-      - -X github.com/goplus/llgo/xtool/env.buildVersion=v{{.Version}}
-      - -X github.com/goplus/llgo/xtool/env.buildDate={{.Date}}
+      - -X github.com/goplus/llgo/x/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/x/env.buildTime={{.Date}}
       - -X github.com/goplus/llgo/xtool/env/llvm.ldLLVMConfigBin=/usr/local/opt/llvm@18/bin/llvm-config
     env:
       - CC=o64-clang
@@ -36,8 +36,8 @@ builds:
     flags:
       - -tags=darwin,arm64,byollvm
     ldflags:
-      - -X github.com/goplus/llgo/xtool/env.buildVersion=v{{.Version}}
-      - -X github.com/goplus/llgo/xtool/env.buildDate={{.Date}}
+      - -X github.com/goplus/llgo/x/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/x/env.buildTime={{.Date}}
       - -X github.com/goplus/llgo/xtool/env/llvm.ldLLVMConfigBin=/opt/homebrew/opt/llvm@18/bin/llvm-config
     env:
       - CC=oa64-clang
@@ -52,8 +52,8 @@ builds:
     flags:
       - -tags=linux,amd64,byollvm
     ldflags:
-      - -X github.com/goplus/llgo/xtool/env.buildVersion=v{{.Version}}
-      - -X github.com/goplus/llgo/xtool/env.buildDate={{.Date}}
+      - -X github.com/goplus/llgo/x/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/x/env.buildTime={{.Date}}
       - -X github.com/goplus/llgo/xtool/env/llvm.ldLLVMConfigBin=/usr/lib/llvm-18/bin/llvm-config
     env:
       - CC=x86_64-linux-gnu-gcc
@@ -68,8 +68,8 @@ builds:
     flags:
       - -tags=linux,arm64,byollvm
     ldflags:
-      - -X github.com/goplus/llgo/xtool/env.buildVersion=v{{.Version}}
-      - -X github.com/goplus/llgo/xtool/env.buildDate={{.Date}}
+      - -X github.com/goplus/llgo/x/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/x/env.buildTime={{.Date}}
       - -X github.com/goplus/llgo/xtool/env/llvm.ldLLVMConfigBin=/usr/lib/llvm-18/bin/llvm-config
     env:
       - CC=aarch64-linux-gnu-gcc

README.md

@@ -218,6 +218,7 @@ The currently supported libraries include:
 * [c/llama2](https://pkg.go.dev/github.com/goplus/llgo/c/llama2)
 * [c/lua](https://pkg.go.dev/github.com/goplus/llgo/c/lua)
 * [c/neco](https://pkg.go.dev/github.com/goplus/llgo/c/neco)
+* [c/openssl](https://pkg.go.dev/github.com/goplus/llgo/c/openssl)
 * [c/raylib](https://pkg.go.dev/github.com/goplus/llgo/c/raylib)
 * [c/sqlite](https://pkg.go.dev/github.com/goplus/llgo/c/sqlite)
 * [c/zlib](https://pkg.go.dev/github.com/goplus/llgo/c/zlib)
@@ -243,7 +244,7 @@ All Go syntax (not including `cgo`) is already supported. Here are some examples
 * [goroutine](_demo/goroutine/goroutine.go): goroutine demo
 
 
-## Defer
+### Defer
 
 LLGo `defer` does not support usage in loops. This is not a bug but a feature, because we think that using `defer` in a loop is a very unrecommended practice.
 
@@ -268,17 +269,25 @@ Here are the Go packages that can be imported correctly:
 * [unicode/utf8](https://pkg.go.dev/unicode/utf8)
 * [unicode/utf16](https://pkg.go.dev/unicode/utf16)
 * [math](https://pkg.go.dev/math)
+* [math/big](https://pkg.go.dev/math/big) (partially)
 * [math/bits](https://pkg.go.dev/math/bits)
 * [math/cmplx](https://pkg.go.dev/math/cmplx)
+* [math/rand](https://pkg.go.dev/math/rand)
+* [net/url](https://pkg.go.dev/net/url)
 * [errors](https://pkg.go.dev/errors)
 * [context](https://pkg.go.dev/context)
 * [io](https://pkg.go.dev/io)
 * [io/fs](https://pkg.go.dev/io/fs)
+* [io/ioutil](https://pkg.go.dev/io/ioutil)
 * [log](https://pkg.go.dev/log)
 * [flag](https://pkg.go.dev/flag)
 * [sort](https://pkg.go.dev/sort)
-* [strconv](https://pkg.go.dev/strconv)
+* [bytes](https://pkg.go.dev/bytes)
+* [bufio](https://pkg.go.dev/bufio)
 * [strings](https://pkg.go.dev/strings)
+* [strconv](https://pkg.go.dev/strconv)
+* [path](https://pkg.go.dev/path)
+* [path/filepath](https://pkg.go.dev/path/filepath)
 * [sync/atomic](https://pkg.go.dev/sync/atomic)
 * [sync](https://pkg.go.dev/sync) (partially)
 * [syscall](https://pkg.go.dev/syscall) (partially)
@@ -288,19 +297,39 @@ Here are the Go packages that can be imported correctly:
 * [fmt](https://pkg.go.dev/fmt) (partially)
 * [reflect](https://pkg.go.dev/reflect) (partially)
 * [time](https://pkg.go.dev/time) (partially)
+* [encoding](https://pkg.go.dev/encoding)
+* [encoding/binary](https://pkg.go.dev/encoding/binary)
+* [encoding/hex](https://pkg.go.dev/encoding/hex)
+* [encoding/base32](https://pkg.go.dev/encoding/base32)
+* [encoding/base64](https://pkg.go.dev/encoding/base64)
+* [encoding/csv](https://pkg.go.dev/encoding/csv)
+* [hash](https://pkg.go.dev/hash)
+* [hash/adler32](https://pkg.go.dev/hash/adler32)
+* [hash/crc32](https://pkg.go.dev/hash/crc32) (partially)
+* [hash/crc64](https://pkg.go.dev/hash/crc64)
+* [crypto](https://pkg.go.dev/crypto)
+* [crypto/md5](https://pkg.go.dev/crypto/md5)
+* [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/rand](https://pkg.go.dev/crypto/rand) (partially)
+* [regexp](https://pkg.go.dev/regexp)
+* [regexp/syntax](https://pkg.go.dev/regexp/syntax)
+* [go/token](https://pkg.go.dev/go/token)
+* [go/scanner](https://pkg.go.dev/go/scanner)
 
 
 ## Dependencies
 
-- [Go 1.20+](https://go.dev) (build only)
+- [Go 1.20+](https://go.dev)
 - [LLVM 18](https://llvm.org)
 - [LLD 18](https://lld.llvm.org)
 - [Clang 18](https://clang.llvm.org)
 - [pkg-config 0.29+](https://www.freedesktop.org/wiki/Software/pkg-config/)
 - [bdwgc/libgc 8.0+](https://www.hboehm.info/gc/)
-- [cJSON 1.7+](https://github.com/DaveGamble/cJSON) (optional, for [github.com/goplus/llgo/c/cjson](https://pkg.go.dev/github.com/goplus/llgo/c/cjson))
-- [SQLite 3](https://www.sqlite.org) (optional, for [github.com/goplus/llgo/c/sqlite](https://pkg.go.dev/github.com/goplus/llgo/c/sqlite))
-- [Python 3.11+](https://www.python.org) (optional, for [github.com/goplus/llgo/py](https://pkg.go.dev/github.com/goplus/llgo/py))
+- [OpenSSL 3.0+](https://www.openssl.org/)
+- [zlib 1.2+](https://www.zlib.net)
+- [Python 3.12+](https://www.python.org) (optional, for [github.com/goplus/llgo/py](https://pkg.go.dev/github.com/goplus/llgo/py))
 
 ## How to install
 
@@ -309,10 +338,9 @@ Follow these steps to generate the `llgo` command (its usage is the same as the
 ### on macOS
 
 ```sh
-brew update # execute if needed
-brew install llvm@18 pkg-config libgc
-brew install cjson sqlite python@3.12 # optional
-export PATH=$(brew --prefix llvm@18)/bin:$PATH # you may want to add this to your shell RC file, e.g. ~/.zshrc
+brew update
+brew install llvm@18 pkg-config bdw-gc openssl
+brew install python@3.12 # optional
 go install -v github.com/goplus/llgo/cmd/llgo@latest
 ```
 
@@ -321,10 +349,9 @@ go install -v github.com/goplus/llgo/cmd/llgo@latest
 ```sh
 echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-18 main" | sudo tee /etc/apt/sources.list.d/llvm.list
 wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-sudo apt-get update # execute if needed
-sudo apt-get install -y llvm-18-dev clang-18 lld-18 pkg-config libgc-dev
-sudo apt-get install -y libcjson-dev libsqlite3-dev python3.12-dev # optional
-export PATH=/usr/lib/llvm-18/bin:$PATH # you may want to add this to your shell RC file, e.g. ~/.bashrc
+sudo apt-get update
+sudo apt-get install -y llvm-18-dev clang-18 lld-18 pkg-config libgc-dev libssl-dev zlib1g-dev
+sudo apt-get install -y python3.12-dev # optional
 go install -v github.com/goplus/llgo/cmd/llgo@latest
 ```
 

_cmptest/_bigsqrt2/sqrt2.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"fmt"
+	"math"
+	"math/big"
+)
+
+func main() {
+	// We'll do computations with 200 bits of precision in the mantissa.
+	const prec = 200
+
+	// Compute the square root of 2 using Newton's Method. We start with
+	// an initial estimate for sqrt(2), and then iterate:
+	//     x_{n+1} = 1/2 * ( x_n + (2.0 / x_n) )
+
+	// Since Newton's Method doubles the number of correct digits at each
+	// iteration, we need at least log_2(prec) steps.
+	steps := int(math.Log2(prec))
+
+	// Initialize values we need for the computation.
+	two := new(big.Float).SetPrec(prec).SetInt64(2)
+	half := new(big.Float).SetPrec(prec).SetFloat64(0.5)
+
+	// Use 1 as the initial estimate.
+	x := new(big.Float).SetPrec(prec).SetInt64(1)
+
+	// We use t as a temporary variable. There's no need to set its precision
+	// since big.Float values with unset (== 0) precision automatically assume
+	// the largest precision of the arguments when used as the result (receiver)
+	// of a big.Float operation.
+	t := new(big.Float)
+
+	// Iterate.
+	for i := 0; i <= steps; i++ {
+		t.Quo(two, x)  // t = 2.0 / x_n
+		t.Add(x, t)    // t = x_n + (2.0 / x_n)
+		x.Mul(half, t) // x_{n+1} = 0.5 * t
+	}
+
+	// We can use the usual fmt.Printf verbs since big.Float implements fmt.Formatter
+	fmt.Printf("sqrt(2) = %.50f\n", x)
+
+	// Print the error between 2 and x*x.
+	t.Mul(x, x) // t = x*x
+	fmt.Printf("error = %e\n", t.Sub(two, t))
+}

_cmptest/_goparsedemo/parse.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"fmt"
+	"go/parser"
+	"go/token"
+)
+
+func main() {
+	fset := token.NewFileSet() // positions are relative to fset
+
+	src := `package foo
+
+import (
+	"fmt"
+	"time"
+)
+
+func bar() {
+	fmt.Println(time.Now())
+}`
+
+	// Parse src but stop after processing the imports.
+	f, err := parser.ParseFile(fset, "", src, parser.ImportsOnly)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	// Print the imports from the file's AST.
+	for _, s := range f.Imports {
+		fmt.Println(s.Path.Value)
+	}
+}

_cmptest/_jsondemo/json.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"unsafe"
+)
+
+func main() {
+	s := `{"name":"math","items":[{"name":"sqrt","sig":"(x, /)"},{"name":"pi"}]}`
+	data := unsafe.Slice(unsafe.StringData(s), len(s))
+	var v any
+	json.Unmarshal(data, &v)
+	b, _ := json.MarshalIndent(v, "", "  ")
+	fmt.Println(string(b))
+}

_cmptest/_timeout/timer.go

@@ -13,7 +13,7 @@ func main() {
 	select {
 	case m := <-c:
 		handle(m)
-	case <-time.After(10 * time.Second):
+	case <-time.After(time.Second / 10):
 		fmt.Println("timed out")
 	}
 }

_cmptest/base64demo/base64.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"encoding/base32"
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+	"log"
+)
+
+func base64Demo() {
+	msg := "Hello, 世界"
+	encoded := base64.StdEncoding.EncodeToString([]byte(msg))
+	fmt.Println(encoded)
+	decoded, err := base64.StdEncoding.DecodeString(encoded)
+	if err != nil {
+		fmt.Println("decode error:", err)
+		return
+	}
+	fmt.Println(string(decoded))
+}
+
+func base32Demo() {
+	str := "JBSWY3DPFQQHO33SNRSCC==="
+	dst := make([]byte, base32.StdEncoding.DecodedLen(len(str)))
+	n, err := base32.StdEncoding.Decode(dst, []byte(str))
+	if err != nil {
+		fmt.Println("decode error:", err)
+		return
+	}
+	dst = dst[:n]
+	fmt.Printf("%q\n", dst)
+}
+
+func hexDemo() {
+	const s = "48656c6c6f20476f7068657221"
+	decoded, err := hex.DecodeString(s)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Printf("%s\n", decoded)
+
+}
+func main() {
+	base64Demo()
+	base32Demo()
+	hexDemo()
+}

_cmptest/bigintdemo/fib.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"math/big"
+)
+
+func main() {
+	// Initialize two big ints with the first two numbers in the sequence.
+	a := big.NewInt(0)
+	b := big.NewInt(1)
+
+	// Initialize limit as 10^99, the smallest integer with 100 digits.
+	var limit big.Int
+	limit.Exp(big.NewInt(10), big.NewInt(99), nil)
+
+	// Loop while a is smaller than 1e100.
+	for a.Cmp(&limit) < 0 {
+		// Compute the next Fibonacci number, storing it in a.
+		a.Add(a, b)
+		// Swap a and b so that b is the next number in the sequence.
+		a, b = b, a
+	}
+	fmt.Println(a) // 100-digit Fibonacci number
+}

_cmptest/crcdemo/crc.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+	"hash/adler32"
+	"hash/crc32"
+	"hash/crc64"
+)
+
+func crc64Demo() {
+	crc := crc64.MakeTable(crc64.ECMA)
+	fmt.Printf("%016x\n", crc64.Checksum([]byte("Hello world"), crc))
+}
+
+func crc32Demo() {
+	crc32q := crc32.MakeTable(crc32.IEEE)
+	fmt.Printf("%08x\n", crc32.Checksum([]byte("Hello world"), crc32q))
+}
+
+func adler32Demo() {
+	fmt.Printf("%08x\n", adler32.Checksum([]byte("Hello world")))
+}
+
+func main() {
+	adler32Demo()
+	crc32Demo()
+	crc64Demo()
+}

_cmptest/csvdemo/csv.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"encoding/csv"
+	"fmt"
+	"io"
+	"log"
+	"strings"
+)
+
+func main() {
+	in := `first_name,last_name,username
+"Rob","Pike",rob
+Ken,Thompson,ken
+"Robert","Griesemer","gri"
+`
+	r := csv.NewReader(strings.NewReader(in))
+
+	for {
+		record, err := r.Read()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		fmt.Println(record)
+	}
+}

_cmptest/envexpand/expand.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	mapper := func(placeholderName string) string {
+		switch placeholderName {
+		case "DAY_PART":
+			return "morning"
+		case "NAME":
+			return "Gopher"
+		}
+		return ""
+	}
+
+	fmt.Println(os.Expand("Good ${DAY_PART}, $NAME!", mapper))
+}

_cmptest/goscandemo/scan.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"fmt"
+	"go/scanner"
+	"go/token"
+)
+
+func main() {
+	// src is the input that we want to tokenize.
+	src := []byte("cos(x) + 1i*sin(x) // Euler")
+
+	// Initialize the scanner.
+	var s scanner.Scanner
+	fset := token.NewFileSet()                      // positions are relative to fset
+	file := fset.AddFile("", fset.Base(), len(src)) // register input "file"
+	s.Init(file, src, nil /* no error handler */, scanner.ScanComments)
+
+	// Repeated calls to Scan yield the token sequence found in the input.
+	for {
+		pos, tok, lit := s.Scan()
+		if tok == token.EOF {
+			break
+		}
+		fmt.Printf("%s\t%s\t%q\n", fset.Position(pos), tok, lit)
+	}
+}

_cmptest/ioutildemo/ioutil.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"strings"
+)
+
+func main() {
+	r := strings.NewReader("Go is a general-purpose language designed with systems programming in mind.")
+
+	b, err := ioutil.ReadAll(r)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Printf("%s\n", b)
+}

_cmptest/md5demo/md5.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"crypto"
+	"crypto/md5"
+	"fmt"
+	"io"
+)
+
+func main() {
+	h := md5.New()
+	io.WriteString(h, "The fog is getting thicker!")
+	io.WriteString(h, "And Leon's getting laaarger!")
+	fmt.Printf("%x\n", h.Sum(nil))
+
+	h = crypto.MD5.New()
+	io.WriteString(h, "The fog is getting thicker!")
+	io.WriteString(h, "And Leon's getting laaarger!")
+	fmt.Printf("%x\n", h.Sum(nil))
+}

_cmptest/osexec/exec.go

@@ -1,9 +1,12 @@
 package main
 
 import (
+	"fmt"
 	"os"
 	"os/exec"
 	"runtime"
+
+	"github.com/goplus/llgo/xtool/env/llvm"
 )
 
 func main() {
@@ -15,4 +18,7 @@ func main() {
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 	cmd.Run()
+
+	dir := llvm.New("").BinDir()
+	fmt.Println(dir)
 }

_cmptest/printfdemo/demo.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/goplus/llgo/xtool/nm"
+)
+
+func main() {
+	sym := nm.Symbol{Name: "abc", Type: nm.Text}
+	fmt.Printf("%016x %c %s\n", sym.Addr, sym.Type, sym.Name)
+}

_cmptest/readfiledemo/readf.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	fileName := "err.log"
+	os.WriteFile(fileName, []byte("123"), 0644)
+
+	_, err := os.Stat(fileName)
+	if os.IsNotExist(err) {
+		fmt.Fprintf(os.Stderr, "File %s not found\n", fileName)
+		return
+	}
+
+	data, err := os.ReadFile(fileName)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "ReadFile: %v\n", err)
+		return
+	}
+
+	fmt.Printf("%s\n", data)
+}

_cmptest/regexdemo/regex.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/goplus/llgo/xtool/env"
+)
+
+func main() {
+	fmt.Println(env.ExpandEnv("$(pkg-config --libs bdw-gc)"))
+}

_cmptest/sha1demo/sha1.go

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

_cmptest/sha256demo/sha256.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"io"
+)
+
+func main() {
+	h := sha256.New()
+	io.WriteString(h, "The fog is getting thicker!")
+	io.WriteString(h, "And Leon's getting laaarger!")
+	fmt.Printf("%x", h.Sum(nil))
+}

_cmptest/sha512demo/sha512.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"crypto/sha512"
+	"fmt"
+	"io"
+)
+
+func main() {
+	h := sha512.New()
+	io.WriteString(h, "The fog is getting thicker!")
+	io.WriteString(h, "And Leon's getting laaarger!")
+	fmt.Printf("%x", h.Sum(nil))
+}

_cmptest/urldemo/url.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/url"
+)
+
+func main() {
+	u, err := url.Parse("http://foo.example.com/foo?bar=1")
+	if err != nil {
+		log.Fatal(err)
+	}
+	u.Scheme = "https"
+	u.Host = "bar.example.com"
+	q := u.Query()
+	q.Set("bar", "2")
+	u.RawQuery = q.Encode()
+	fmt.Println(u)
+}

_demo/crand/rand.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/math/rand"
+	"github.com/goplus/llgo/c/time"
+)
+
+func fastrand64() uint64 {
+	v1 := uint64(rand.Random())
+	v2 := uint64(rand.Random())
+	return v1 ^ (v2 << 32)
+}
+
+func main() {
+	rand.Srand(c.Uint(time.Time(nil)))
+	fmt.Printf("%x\n", rand.Rand())
+	fmt.Printf("%x\n", rand.Rand())
+
+	rand.Srandom(c.Uint(time.Time(nil)))
+	fmt.Printf("%x\n", rand.Random())
+	fmt.Printf("%x\n", rand.Random())
+	fmt.Printf("%x\n", fastrand64())
+}

_demo/llama2-c/run.go

@@ -3,6 +3,7 @@ package main
 import (
 	"github.com/goplus/llgo/c"
 	"github.com/goplus/llgo/c/llama2"
+	"github.com/goplus/llgo/c/time"
 )
 
 func main() {
@@ -11,7 +12,7 @@ func main() {
 	var tokenizerPath *c.Char = c.Str("tokenizer.bin")
 	var temperature, topp c.Float = 1.0, 0.9
 	var steps c.Int = 256
-	var rngSeed uint64 = uint64(c.Time(nil))
+	var rngSeed uint64 = uint64(time.Time(nil))
 
 loop: // parse command line arguments
 	for {

_demo/rand/rand.go

@@ -1,15 +0,0 @@
-package main
-
-import (
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/math/rand"
-)
-
-func main() {
-	var s c.Uint = 6
-	rand.Srand(s)
-	rr := rand.RandR(&s)
-	r := rand.Rand()
-	println("r:", r)
-	println("rr:", rr)
-}

_demo/randcrypt/rand.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"crypto/rand"
+	"fmt"
+)
+
+func main() {
+	c := 10
+	b := make([]byte, c)
+	_, err := rand.Read(b)
+	if err != nil {
+		fmt.Println("error:", err)
+		return
+	}
+	// The slice should now contain random bytes instead of only zeroes.
+	fmt.Printf("%x\n", b)
+}

_demo/randdemo/rand.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+)
+
+func main() {
+	fmt.Println(rand.Intn(100))
+	fmt.Println(rand.Intn(100))
+	fmt.Println(rand.Intn(100))
+}

c/c.go

@@ -227,9 +227,6 @@ func Perror(s *Char)
 
 // -----------------------------------------------------------------------------
 
-//go:linkname Time C.time
-func Time(*int32) int32
-
 //go:linkname Usleep C.usleep
 func Usleep(useconds Uint) Int
 

c/cjson/cjson.go

@@ -134,6 +134,18 @@ func (o *JSON) PrintUnformatted() *c.Char { return nil }
 // llgo:link (*JSON).PrintBuffered C.cJSON_PrintBuffered
 func (o *JSON) PrintBuffered(prebuffer c.Int, fmt c.Int) *c.Char { return nil }
 
+// llgo:link (*JSON).GetObjectItemCaseSensitive C.cJSON_GetObjectItemCaseSensitive
+func (o *JSON) GetObjectItemCaseSensitive(key *c.Char) *JSON { return nil }
+
+// llgo:link (*JSON).GetArraySize C.cJSON_GetArraySize
+func (o *JSON) GetArraySize() c.Int { return 0 }
+
+// llgo:link (*JSON).GetArrayItem C.cJSON_GetArrayItem
+func (o *JSON) GetArrayItem(index c.Int) *JSON { return nil }
+
+// llgo:link (*JSON).GetStringValue C.cJSON_GetStringValue
+func (o *JSON) GetStringValue() *c.Char { return nil }
+
 //go:linkname Free C.cJSON_free
 func Free(ptr unsafe.Pointer)
 

c/clang/_demo/symboldump/symboldump.go

@@ -12,6 +12,7 @@ import (
 type Context struct {
 	namespaceName string
 	className     string
+	unit          *clang.TranslationUnit
 }
 
 func newContext() *Context {
@@ -26,23 +27,51 @@ func (c *Context) setClassName(name string) {
 	c.className = name
 }
 
+func (c *Context) setUnit(unit *clang.TranslationUnit) {
+	c.unit = unit
+}
+
 var context = newContext()
 
-func print_cursor_info(cursor clang.Cursor) {
+func printCursorLocation(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("%s:%d:%d\n"), filename.CStr(), line, column)
+}
+
+func printMarcoInfo(cursor clang.Cursor) {
+	printCursorLocation(cursor)
+	name := cursor.String()
+	c.Printf(c.Str("Marco Name: %s\n"), name.CStr())
+	ran := cursor.Extent()
+	var numTokens c.Uint
+	var tokens *clang.Token
+	context.unit.Tokenize(ran, &tokens, &numTokens)
+	c.Printf(c.Str("Content: "))
+
+	tokensSlice := unsafe.Slice(tokens, int(numTokens))
+	for _, tok := range tokensSlice {
+		tokStr := context.unit.Token(tok)
+		c.Printf(c.Str("%s "), tokStr.CStr())
+		tokStr.Dispose()
+	}
+
+	c.Printf(c.Str("\n"))
+	println("--------------------------------")
+}
+func printFuncInfo(cursor clang.Cursor) {
+	printCursorLocation(cursor)
 
 	cursorStr := cursor.String()
 	symbol := cursor.Mangling()
 	defer symbol.Dispose()
 	defer cursorStr.Dispose()
-	defer filename.Dispose()
 
 	if context.namespaceName != "" && context.className != "" {
 		fmt.Printf("%s:%s:", context.namespaceName, context.className)
@@ -78,7 +107,9 @@ func print_cursor_info(cursor clang.Cursor) {
 }
 
 func visit(cursor, parent clang.Cursor, clientData c.Pointer) clang.ChildVisitResult {
-	if cursor.Kind == clang.Namespace {
+	if cursor.Kind == clang.MacroDefinition {
+		printMarcoInfo(cursor)
+	} else if cursor.Kind == clang.Namespace {
 		nameStr := cursor.String()
 		context.setNamespaceName(c.GoString(nameStr.CStr()))
 		clang.VisitChildren(cursor, visit, nil)
@@ -89,7 +120,7 @@ func visit(cursor, parent clang.Cursor, clientData c.Pointer) clang.ChildVisitRe
 		clang.VisitChildren(cursor, visit, nil)
 		context.setClassName("")
 	} else if cursor.Kind == clang.CXXMethod || cursor.Kind == clang.FunctionDecl {
-		print_cursor_info(cursor)
+		printFuncInfo(cursor)
 	}
 
 	return clang.ChildVisit_Continue
@@ -105,7 +136,7 @@ func parse(filename *c.Char) {
 		filename,
 		unsafe.SliceData(args), 3,
 		nil, 0,
-		clang.TranslationUnit_None,
+		clang.DetailedPreprocessingRecord,
 	)
 
 	if unit == nil {
@@ -113,6 +144,7 @@ func parse(filename *c.Char) {
 		c.Exit(1)
 	}
 
+	context.setUnit(unit)
 	cursor := unit.Cursor()
 
 	clang.VisitChildren(cursor, visit, nil)

c/clang/_wrap/cursor.cpp

@@ -35,6 +35,10 @@ void wrap_clang_getCursorResultType(CXCursor *cur, CXType *typ) { *typ = clang_g
 
 CXString wrap_clang_getTypeSpelling(CXType *typ) { return clang_getTypeSpelling(*typ); }
 
+CXString wrap_clang_getTokenSpelling(CXTranslationUnit unit, CXToken *token) {
+    return clang_getTokenSpelling(unit, *token);
+}
+
 void wrap_clang_getCursorLocation(CXCursor *cur, CXSourceLocation *loc) { *loc = clang_getCursorLocation(*cur); }
 
 void wrap_clang_getSpellingLocation(CXSourceLocation *loc, CXFile *file, unsigned *line, unsigned *column,
@@ -42,6 +46,12 @@ void wrap_clang_getSpellingLocation(CXSourceLocation *loc, CXFile *file, unsigne
     clang_getSpellingLocation(*loc, file, line, column, offset);
 }
 
+void wrap_clang_getCursorExtent(CXCursor *cur, CXSourceRange *range) { *range = clang_getCursorExtent(*cur); }
+
+void wrap_clang_tokenize(CXTranslationUnit unit, CXSourceRange *Range, CXToken **Tokens, unsigned *NumTokens) {
+    clang_tokenize(unit, *Range, Tokens, NumTokens);
+}
+
 unsigned wrap_clang_visitChildren(CXCursor *parent, wrap_CXCursorVisitor visitor, CXClientData client_data) {
     wrap_data data = {client_data, visitor};
     return clang_visitChildren(*parent, wrap_visitor, CXClientData(&data));

c/clang/clang.go

@@ -1225,7 +1225,22 @@ func (*Index) Dispose() {}
  * constructing the translation unit.
  */
 const (
+	/**
+	 * Used to indicate that no special translation-unit options are
+	 * needed.
+	 */
 	TranslationUnit_None = 0x0
+	/**
+	 * Used to indicate that the parser should construct a "detailed"
+	 * preprocessing record, including all macro definitions and instantiations.
+	 *
+	 * Constructing a detailed preprocessing record requires more memory
+	 * and time to parse, since the information contained in the record
+	 * is usually not retained. However, it can be useful for
+	 * applications that require more detailed information about the
+	 * behavior of the preprocessor.
+	 */
+	DetailedPreprocessingRecord = 0x01
 )
 
 /**
@@ -1330,6 +1345,52 @@ type SourceLocation struct {
 	intData c.Uint
 }
 
+/**
+ * Identifies a half-open character range in the source code.
+ *
+ * Use clang_getRangeStart() and clang_getRangeEnd() to retrieve the
+ * starting and end locations from a source range, respectively.
+ */
+type SourceRange struct {
+	ptrData      [2]c.Pointer
+	beginIntData c.Uint
+	endIntData   c.Uint
+}
+
+/**
+ * Describes a kind of token.
+ */
+type TokenKind c.Int
+
+const (
+	/**
+	 * A token that contains some kind of punctuation.
+	 */
+	Punctuation TokenKind = iota
+	/**
+	 * A language keyword.
+	 */
+	Keyword
+
+	/**
+	 * An identifier (that is not a keyword).
+	 */
+	Identifier
+	/**
+	 * A numeric, string, or character literal.
+	 */
+	Literal
+	/**
+	 * A comment.
+	 */
+	Comment
+)
+
+type Token struct {
+	intData [4]c.Uint
+	ptrData c.Pointer
+}
+
 /**
  * Retrieve a name for the entity referenced by this cursor.
  */
@@ -1409,6 +1470,16 @@ func (c Cursor) Argument(index c.Uint) (arg Cursor) {
 	return
 }
 
+/**
+ * Retrieve the physical location of the source constructor referenced
+ * by the given cursor.
+ *
+ * The location of a declaration is typically the location of the name of that
+ * declaration, where the name of that declaration would occur if it is
+ * unnamed, or some keyword that introduces that particular declaration.
+ * The location of a reference is where that reference occurs within the
+ * source code.
+ */
 // llgo:link (*Cursor).wrapLocation C.wrap_clang_getCursorLocation
 func (c *Cursor) wrapLocation(loc *SourceLocation) {}
 
@@ -1417,6 +1488,86 @@ func (c Cursor) Location() (loc SourceLocation) {
 	return
 }
 
+/**
+ * Retrieve the physical extent of the source construct referenced by
+ * the given cursor.
+ *
+ * The extent of a cursor starts with the file/line/column pointing at the
+ * first character within the source construct that the cursor refers to and
+ * ends with the last character within that source construct. For a
+ * declaration, the extent covers the declaration itself. For a reference,
+ * the extent covers the location of the reference (e.g., where the referenced
+ * entity was actually used).
+ */
+// llgo:link (*Cursor).wrapExtent C.wrap_clang_getCursorExtent
+func (c *Cursor) wrapExtent(loc *SourceRange) {}
+
+func (c Cursor) Extent() (loc SourceRange) {
+	c.wrapExtent(&loc)
+	return
+}
+
+/**
+ * Tokenize the source code described by the given range into raw
+ * lexical tokens.
+ *
+ * \param TU the translation unit whose text is being tokenized.
+ *
+ * \param Range the source range in which text should be tokenized. All of the
+ * tokens produced by tokenization will fall within this source range,
+ *
+ * \param Tokens this pointer will be set to point to the array of tokens
+ * that occur within the given source range. The returned pointer must be
+ * freed with clang_disposeTokens() before the translation unit is destroyed.
+ *
+ * \param NumTokens will be set to the number of tokens in the \c *Tokens
+ * array.
+ *
+ */
+// llgo:link (*TranslationUnit).wrapTokenize C.wrap_clang_tokenize
+func (t *TranslationUnit) wrapTokenize(ran *SourceRange, tokens **Token, numTokens *c.Uint) {}
+
+func (t *TranslationUnit) Tokenize(ran SourceRange, tokens **Token, numTokens *c.Uint) {
+	t.wrapTokenize(&ran, tokens, numTokens)
+}
+
+/**
+ * Determine the spelling of the given token.
+ *
+ * The spelling of a token is the textual representation of that token, e.g.,
+ * the text of an identifier or keyword.
+ */
+// llgo:link (*TranslationUnit).wrapToken C.wrap_clang_getTokenSpelling
+func (*TranslationUnit) wrapToken(token *Token) (ret String) {
+	return
+}
+
+func (c *TranslationUnit) Token(token Token) (ret String) {
+	return c.wrapToken(&token)
+}
+
+/**
+ * Retrieve the file, line, column, and offset represented by
+ * the given source location.
+ *
+ * If the location refers into a macro instantiation, return where the
+ * location was originally spelled in the source file.
+ *
+ * \param location the location within a source file that will be decomposed
+ * into its parts.
+ *
+ * \param file [out] if non-NULL, will be set to the file to which the given
+ * source location points.
+ *
+ * \param line [out] if non-NULL, will be set to the line to which the given
+ * source location points.
+ *
+ * \param column [out] if non-NULL, will be set to the column to which the given
+ * source location points.
+ *
+ * \param offset [out] if non-NULL, will be set to the offset into the
+ * buffer to which the given source location points.
+ */
 // llgo:link (*SourceLocation).wrapSpellingLocation C.wrap_clang_getSpellingLocation
 func (l *SourceLocation) wrapSpellingLocation(file *File, line, column, offset *c.Uint) {}
 

c/libuv/_demo/async_fs/async_fs.go

@@ -13,11 +13,11 @@ const BUFFER_SIZE = 1024
 var (
 	loop     *libuv.Loop
 	openReq  libuv.Fs
-	readReq  libuv.Fs
 	closeReq libuv.Fs
 
 	buffer [BUFFER_SIZE]c.Char
 	iov    libuv.Buf
+	file   libuv.File
 )
 
 func main() {
@@ -31,7 +31,11 @@ func main() {
 	libuv.FsOpen(loop, &openReq, c.Str("example.txt"), os.O_RDONLY, 0, onOpen)
 
 	// Run the loop
-	libuv.Run(loop, 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)))
+	}
 
 	// Cleanup
 	defer cleanup()
@@ -40,32 +44,45 @@ func main() {
 func onOpen(req *libuv.Fs) {
 	// Check for errors
 	if libuv.FsGetResult(req) < 0 {
-		c.Fprintf(c.Stderr, c.Str("Error opening file: %s\n"), libuv.Strerror(libuv.Errno(libuv.LoopClose(loop))))
+		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(libuv.FsGetResult(req))
+
 	// Init buffer
 	iov = libuv.InitBuf((*c.Char)(unsafe.Pointer(&buffer[0])), c.Uint(unsafe.Sizeof(buffer)))
+
 	// Read the file
-	readRes := libuv.FsRead(loop, &readReq, libuv.UvFile(libuv.FsGetResult(req)), &iov, 1, -1, onRead)
+	readFile()
+
+}
+
+func readFile() {
+	// Initialize the request every time
+	var readReq libuv.Fs
+
+	// Read the file
+	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)
 		libuv.LoopClose(loop)
-		return
 	}
 }
 
 func onRead(req *libuv.Fs) {
+	// Cleanup the request
+	defer libuv.FsReqCleanup(req)
 	// Check for errors
 	if libuv.FsGetResult(req) < 0 {
 		c.Fprintf(c.Stderr, c.Str("Read error: %s\n"), libuv.Strerror(libuv.Errno(libuv.FsGetResult(req))))
-		libuv.LoopClose(loop)
 	} else if libuv.FsGetResult(req) == 0 {
-		c.Printf(c.Str("EOF\n"))
 		// Close the file
-		closeRes := libuv.FsClose(loop, &closeReq, libuv.UvFile(libuv.FsGetResult(&openReq)), onClose)
+		closeRes := libuv.FsClose(loop, &closeReq, libuv.File(libuv.FsGetResult(&openReq)), onClose)
 		if closeRes != 0 {
-			// Print the content
 			c.Printf(c.Str("Error in FsClose: %s (code: %d)\n"), libuv.Strerror(libuv.Errno(closeRes)), closeRes)
 			libuv.LoopClose(loop)
 			return
@@ -73,7 +90,8 @@ func onRead(req *libuv.Fs) {
 	} else {
 		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])))
-		libuv.LoopClose(loop)
+		// Read the file again
+		readFile()
 	}
 }
 
@@ -84,14 +102,15 @@ func onClose(req *libuv.Fs) {
 	} else {
 		c.Printf(c.Str("\nFile closed successfully.\n"))
 	}
-	libuv.LoopClose(loop)
 }
 
 func cleanup() {
 	// Cleanup the requests
 	libuv.FsReqCleanup(&openReq)
-	libuv.FsReqCleanup(&readReq)
 	libuv.FsReqCleanup(&closeReq)
 	// Close the loop
-	libuv.LoopClose(loop)
+	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

@@ -11,8 +11,6 @@ import (
 var DEFAULT_PORT c.Int = 8080
 var DEFAULT_BACKLOG c.Int = 128
 
-var loop *libuv.Loop
-
 type WriteReq struct {
 	Req libuv.Write
 	Buf libuv.Buf
@@ -20,7 +18,7 @@ type WriteReq struct {
 
 func main() {
 	// Initialize the default event loop
-	loop = libuv.DefaultLoop()
+	var loop = libuv.DefaultLoop()
 
 	// Initialize a TCP server
 	var server libuv.Tcp
@@ -105,7 +103,7 @@ func OnNewConnection(server *libuv.Stream, status c.Int) {
 	}
 
 	// Initialize the client TCP handle.
-	if libuv.InitTcp(loop, client) < 0 {
+	if libuv.InitTcp(libuv.DefaultLoop(), client) < 0 {
 		c.Fprintf(c.Stderr, c.Str("Failed to initialize client\n"))
 		c.Free(c.Pointer(client))
 		return

c/libuv/fs.go

@@ -62,14 +62,14 @@ type FsType c.Int
 
 type DirentType c.Int
 
-type UvFile c.Int
+type File c.Int
 
 // ----------------------------------------------
 
 /* Handle types. */
 
 type Fs struct {
-	Unused [0]byte
+	Unused [440]byte
 }
 
 type FsEvent struct {
@@ -85,11 +85,6 @@ type Dirent struct {
 	Type DirentType
 }
 
-type File struct {
-	Loop *Loop
-	Req  *Fs
-}
-
 type Stat struct {
 	Unused [0]byte
 }
@@ -112,7 +107,7 @@ type FsPollCb func(handle *FsPoll, status c.Int, events c.Int)
 /* Fs related function and method */
 
 //go:linkname FsGetType C.uv_fs_get_type
-func FsGetType(req *Fs) *FsType
+func FsGetType(req *Fs) FsType
 
 //go:linkname FsGetPath C.uv_fs_get_path
 func FsGetPath(req *Fs) *c.Char
@@ -139,13 +134,13 @@ func DefaultLoop() *Loop
 func FsOpen(loop *Loop, req *Fs, path *c.Char, flags c.Int, mode c.Int, cb FsCb) c.Int
 
 //go:linkname FsClose C.uv_fs_close
-func FsClose(loop *Loop, req *Fs, file UvFile, cb FsCb) c.Int
+func FsClose(loop *Loop, req *Fs, file File, cb FsCb) c.Int
 
 //go:linkname FsRead C.uv_fs_read
-func FsRead(loop *Loop, req *Fs, file UvFile, bufs *Buf, nbufs c.Uint, offset c.LongLong, cb FsCb) c.Int
+func FsRead(loop *Loop, req *Fs, file File, bufs *Buf, nbufs c.Uint, offset c.LongLong, cb FsCb) c.Int
 
 //go:linkname FsWrite C.uv_fs_write
-func FsWrite(loop *Loop, req *Fs, file UvFile, bufs *Buf, nbufs c.Uint, offset c.LongLong, cb FsCb) c.Int
+func FsWrite(loop *Loop, req *Fs, file File, bufs *Buf, nbufs c.Uint, offset c.LongLong, cb FsCb) c.Int
 
 //go:linkname FsUnlink C.uv_fs_unlink
 func FsUnlink(loop *Loop, req *Fs, path *c.Char, cb FsCb) c.Int
@@ -166,19 +161,19 @@ func FsRmdir(loop *Loop, req *Fs, path *c.Char, cb FsCb) c.Int
 func FsStat(loop *Loop, req *Fs, path *c.Char, cb FsCb) c.Int
 
 //go:linkname FsFstat C.uv_fs_fstat
-func FsFstat(loop *Loop, req *Fs, file UvFile, cb FsCb) c.Int
+func FsFstat(loop *Loop, req *Fs, file File, cb FsCb) c.Int
 
 //go:linkname FsRename C.uv_fs_rename
 func FsRename(loop *Loop, req *Fs, path *c.Char, newPath *c.Char, cb FsCb) c.Int
 
 //go:linkname FsFsync C.uv_fs_fsync
-func FsFsync(loop *Loop, req *Fs, file UvFile, cb FsCb) c.Int
+func FsFsync(loop *Loop, req *Fs, file File, cb FsCb) c.Int
 
 //go:linkname FsFdatasync C.uv_fs_fdatasync
-func FsFdatasync(loop *Loop, req *Fs, file UvFile, cb FsCb) c.Int
+func FsFdatasync(loop *Loop, req *Fs, file File, cb FsCb) c.Int
 
 //go:linkname FsFtruncate C.uv_fs_ftruncate
-func FsFtruncate(loop *Loop, req *Fs, file UvFile, offset c.LongLong, cb FsCb) c.Int
+func FsFtruncate(loop *Loop, req *Fs, file File, offset c.LongLong, cb FsCb) c.Int
 
 //go:linkname FsSendfile C.uv_fs_sendfile
 func FsSendfile(loop *Loop, req *Fs, outFd c.Int, inFd c.Int, inOffset c.LongLong, length c.Int, cb FsCb) c.Int
@@ -190,13 +185,13 @@ func FsAccess(loop *Loop, req *Fs, path *c.Char, flags c.Int, cb FsCb) c.Int
 func FsChmod(loop *Loop, req *Fs, path *c.Char, mode c.Int, cb FsCb) c.Int
 
 //go:linkname FsFchmod C.uv_fs_fchmod
-func FsFchmod(loop *Loop, req *Fs, file UvFile, mode c.Int, cb FsCb) c.Int
+func FsFchmod(loop *Loop, req *Fs, file File, mode c.Int, cb FsCb) c.Int
 
 //go:linkname FsUtime C.uv_fs_utime
 func FsUtime(loop *Loop, req *Fs, path *c.Char, atime c.Int, mtime c.Int, cb FsCb) c.Int
 
 //go:linkname FsFutime C.uv_fs_futime
-func FsFutime(loop *Loop, req *Fs, file UvFile, atime c.Int, mtime c.Int, cb FsCb) c.Int
+func FsFutime(loop *Loop, req *Fs, file File, atime c.Int, mtime c.Int, cb FsCb) c.Int
 
 //go:linkname FsLutime C.uv_fs_lutime
 func FsLutime(loop *Loop, req *Fs, path *c.Char, atime c.Int, mtime c.Int, cb FsCb) c.Int
@@ -238,7 +233,7 @@ func FsStatfs(loop *Loop, req *Fs, path *c.Char, cb FsCb) c.Int
 func FsChown(loop *Loop, req *Fs, path *c.Char, uid c.Int, gid c.Int, cb FsCb) c.Int
 
 //go:linkname FsFchown C.uv_fs_fchown
-func FsFchown(loop *Loop, req *Fs, file UvFile, uid c.Int, gid c.Int, cb FsCb) c.Int
+func FsFchown(loop *Loop, req *Fs, file File, uid c.Int, gid c.Int, cb FsCb) c.Int
 
 //go:linkname FsLchown C.uv_fs_lchown
 func FsLchown(loop *Loop, req *Fs, path *c.Char, uid c.Int, gid c.Int, cb FsCb) c.Int

c/libuv/libuv.go

@@ -97,76 +97,16 @@ type Loop struct {
 	Unused [0]byte
 }
 
-type Handle struct {
-	Unused [96]byte
-}
-
-type Dir struct {
-	Unused [0]byte
-}
-
-type Stream struct {
-	Unused [264]byte
-}
-
-type Pipe struct {
-	Unused [0]byte
-}
-
-type Tty struct {
-	Unused [0]byte
-}
-
 type Poll struct {
 	Unused [0]byte
 }
 
-type Prepare struct {
-	Unused [0]byte
-}
-
-type Check struct {
-	Unused [0]byte
-}
-
-type Idle struct {
-	Unused [0]byte
-}
-
-type Async struct {
-	Unused [0]byte
-}
-
-type Process struct {
-	Unused [0]byte
-}
-
 /* Request types. */
 
-type Req struct {
-	Unused [0]byte
-}
-
-type GetAddrInfo struct {
-	Unused [0]byte
-}
-
-type GetNameInfo struct {
-	Unused [0]byte
-}
-
 type Shutdown struct {
 	Unused [0]byte
 }
 
-type Write struct {
-	Unused [192]byte
-}
-
-type Connect struct {
-	Unused [0]byte
-}
-
 type Buf struct {
 	Base *c.Char
 	Len  uintptr
@@ -189,21 +129,12 @@ type FreeFunc func(ptr c.Pointer)
 // llgo:type C
 type AllocCb func(handle *Handle, suggestedSize uintptr, buf *Buf)
 
-// llgo:type C
-type ReadCb func(stream *Stream, nread c.Long, buf *Buf)
-
-// llgo:type C
-type WriteCb func(req *Write, status c.Int)
-
 // llgo:type C
 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 ConnectionCb func(server *Stream, status c.Int)
-
 // llgo:type C
 type ShutdownCb func(req *Shutdown, status c.Int)
 
@@ -236,170 +167,6 @@ func (shutdown *Shutdown) Shutdown(stream *Stream, shutdownCb ShutdownCb) c.Int
 
 // ----------------------------------------------
 
-/* Handle related function and method */
-
-// llgo:link (*Handle).Ref C.uv_ref
-func (handle *Handle) Ref() {}
-
-// llgo:link (*Handle).Unref C.uv_unref
-func (handle *Handle) Unref() {}
-
-// llgo:link (*Handle).HasRef C.uv_has_ref
-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
-}
-
-// llgo:link (*Handle).GetLoop C.uv_handle_get_loop
-func (handle *Handle) GetLoop() *Loop {
-	return nil
-}
-
-// llgo:link (*Handle).SetData C.uv_handle_set_data
-func (handle *Handle) SetData(data c.Pointer) {}
-
-// llgo:link (*Handle).IsActive C.uv_is_active
-func (handle *Handle) IsActive() c.Int {
-	return 0
-}
-
-// llgo:link (*Handle).Close C.uv_close
-func (handle *Handle) Close(closeCb CloseCb) {}
-
-// llgo:link (*Handle).SendBufferSize C.uv_send_buffer_size
-func (handle *Handle) SendBufferSize(value *c.Int) c.Int {
-	return 0
-}
-
-// llgo:link (*Handle).RecvBufferSize C.uv_recv_buffer_size
-func (handle *Handle) RecvBufferSize(value *c.Int) c.Int {
-	return 0
-}
-
-// llgo:link (*Handle).Fileno C.uv_fileno
-func (handle *Handle) Fileno(fd *OsFd) c.Int {
-	return 0
-}
-
-//go:linkname UvPipe C.uv_pipe
-func UvPipe(fds [2]UvFile, readFlags c.Int, writeFlags c.Int) c.Int {
-	return 0
-}
-
-//go:linkname Socketpair C.uv_socketpair
-func Socketpair(_type c.Int, protocol c.Int, socketVector [2]OsSock, flag0 c.Int, flag1 c.Int) 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 */
-
-//go:linkname ReqSize C.uv_req_size
-func ReqSize(reqType ReqType) uintptr
-
-// llgo:link (*Req).GetData C.uv_req_get_data
-func (req *Req) GetData() c.Pointer {
-	return nil
-}
-
-// 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
-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 */
-
-// llgo:link (*Stream).GetWriteQueueSize C.uv_stream_get_write_queue_size
-func (stream *Stream) GetWriteQueueSize() uintptr {
-	return 0
-}
-
-// llgo:link (*Stream).Listen C.uv_listen
-func (stream *Stream) Listen(backlog c.Int, connectionCb ConnectionCb) c.Int {
-	return 0
-}
-
-// llgo:link (*Stream).Accept C.uv_accept
-func (server *Stream) Accept(client *Stream) c.Int {
-	return 0
-}
-
-// llgo:link (*Stream).StartRead C.uv_read_start
-func (stream *Stream) StartRead(allocCb AllocCb, readCb ReadCb) c.Int {
-	return 0
-}
-
-// llgo:link (*Stream).StopRead C.uv_read_stop
-func (stream *Stream) StopRead() c.Int {
-	return 0
-}
-
-// llgo:link (*Write).Write C.uv_write
-func (req *Write) Write(stream *Stream, bufs *Buf, nbufs c.Uint, writeCb WriteCb) c.Int {
-	return 0
-}
-
-// llgo:link (*Write).Write2 C.uv_write2
-func (req *Write) Write2(stream *Stream, bufs *Buf, nbufs c.Uint, sendStream *Stream, writeCb WriteCb) c.Int {
-	return 0
-}
-
-// llgo:link (*Stream).TryWrite C.uv_try_write
-func (stream *Stream) TryWrite(bufs *Buf, nbufs c.Uint) c.Int {
-	return 0
-}
-
-// llgo:link (*Stream).TryWrite2 C.uv_try_write2
-func (stream *Stream) TryWrite2(bufs *Buf, nbufs c.Uint, sendStream *Stream) c.Int {
-	return 0
-}
-
-// llgo:link (*Stream).IsReadable C.uv_is_readable
-func (stream *Stream) IsReadable() c.Int {
-	return 0
-}
-
-// llgo:link (*Stream).IsWritable C.uv_is_writable
-func (stream *Stream) IsWritable() c.Int {
-	return 0
-}
-
-// llgo:link (*Stream).SetBlocking C.uv_stream_set_blocking
-func (stream *Stream) SetBlocking(blocking c.Int) c.Int {
-	return 0
-}
-
-// ----------------------------------------------
-
 /* Loop related functions and method. */
 
 //go:linkname LoopSize C.uv_loop_size
@@ -469,20 +236,3 @@ 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
-
-// ----------------------------------------------
-
-/* Getaddrinfo related function and method */
-
-//go:linkname Getaddrinfo C.uv_getaddrinfo
-func Getaddrinfo(loop *Loop, req *GetAddrInfo, getaddrinfoCb GetaddrinfoCb, node *c.Char, service *c.Char, hints *net.AddrInfo) c.Int
-
-//go:linkname Freeaddrinfo C.uv_freeaddrinfo
-func Freeaddrinfo(addrInfo *net.AddrInfo)
-
-// ----------------------------------------------
-
-/* Getnameinfo related function and method */
-
-//go:linkname Getnameinfo C.uv_getnameinfo
-func Getnameinfo(loop *Loop, req *GetNameInfo, getnameinfoCb GetnameinfoCb, addr *net.SockAddr, flags c.Int) c.Int

c/libuv/net.go

@@ -65,8 +65,22 @@ type UdpFlags c.Int
 
 /* Handle types. */
 
+// TODO(spongehah): Handle
+type Handle struct {
+	Data   c.Pointer
+	Unused [88]byte
+}
+
+// TODO(spongehah): Stream
+type Stream struct {
+	Data   c.Pointer
+	Unused [256]byte
+}
+
+// TODO(spongehah): Tcp
 type Tcp struct {
-	Unused [264]byte
+	Data   c.Pointer
+	Unused [256]byte
 }
 
 type Udp struct {
@@ -75,10 +89,34 @@ type Udp struct {
 
 /* Request types. */
 
+type Req struct {
+	Unused [0]byte
+}
+
 type UdpSend struct {
 	Unused [0]byte
 }
 
+// TODO(spongehah): Write
+type Write struct {
+	Data   c.Pointer
+	Unused [184]byte
+}
+
+// TODO(spongehah): Connect
+type Connect struct {
+	Data   c.Pointer
+	Unused [88]byte
+}
+
+type GetAddrInfo struct {
+	Unused [0]byte
+}
+
+type GetNameInfo struct {
+	Unused [0]byte
+}
+
 // ----------------------------------------------
 
 /* Function type */
@@ -95,6 +133,179 @@ type UdpSendCb func(req *UdpSend, status c.Int)
 // llgo:type C
 type UdpRecvCb func(handle *Udp, nread c.Long, buf *Buf, addr *net.SockAddr, flags c.Uint)
 
+// llgo:type C
+type ReadCb func(stream *Stream, nread c.Long, buf *Buf)
+
+// llgo:type C
+type WriteCb func(req *Write, status c.Int)
+
+// llgo:type C
+type ConnectionCb func(server *Stream, status c.Int)
+
+// ----------------------------------------------
+
+/* Handle related function and method */
+
+// llgo:link (*Handle).Ref C.uv_ref
+func (handle *Handle) Ref() {}
+
+// llgo:link (*Handle).Unref C.uv_unref
+func (handle *Handle) Unref() {}
+
+// llgo:link (*Handle).HasRef C.uv_has_ref
+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
+}
+
+// llgo:link (*Handle).GetLoop C.uv_handle_get_loop
+func (handle *Handle) GetLoop() *Loop {
+	return nil
+}
+
+// llgo:link (*Handle).SetData C.uv_handle_set_data
+func (handle *Handle) SetData(data c.Pointer) {}
+
+// llgo:link (*Handle).IsActive C.uv_is_active
+func (handle *Handle) IsActive() c.Int {
+	return 0
+}
+
+// llgo:link (*Handle).Close C.uv_close
+func (handle *Handle) Close(closeCb CloseCb) {}
+
+// llgo:link (*Handle).SendBufferSize C.uv_send_buffer_size
+func (handle *Handle) SendBufferSize(value *c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Handle).RecvBufferSize C.uv_recv_buffer_size
+func (handle *Handle) RecvBufferSize(value *c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Handle).Fileno C.uv_fileno
+func (handle *Handle) Fileno(fd *OsFd) 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
+}
+
+//go:linkname Socketpair C.uv_socketpair
+func Socketpair(_type c.Int, protocol c.Int, socketVector [2]OsSock, flag0 c.Int, flag1 c.Int) 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 */
+
+//go:linkname ReqSize C.uv_req_size
+func ReqSize(reqType ReqType) uintptr
+
+// llgo:link (*Req).GetData C.uv_req_get_data
+func (req *Req) GetData() c.Pointer {
+	return nil
+}
+
+// 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
+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 */
+
+// llgo:link (*Stream).GetWriteQueueSize C.uv_stream_get_write_queue_size
+func (stream *Stream) GetWriteQueueSize() uintptr {
+	return 0
+}
+
+// llgo:link (*Stream).Listen C.uv_listen
+func (stream *Stream) Listen(backlog c.Int, connectionCb ConnectionCb) c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).Accept C.uv_accept
+func (server *Stream) Accept(client *Stream) c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).StartRead C.uv_read_start
+func (stream *Stream) StartRead(allocCb AllocCb, readCb ReadCb) c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).StopRead C.uv_read_stop
+func (stream *Stream) StopRead() c.Int {
+	return 0
+}
+
+// llgo:link (*Write).Write C.uv_write
+func (req *Write) Write(stream *Stream, bufs *Buf, nbufs c.Uint, writeCb WriteCb) c.Int {
+	return 0
+}
+
+// llgo:link (*Write).Write2 C.uv_write2
+func (req *Write) Write2(stream *Stream, bufs *Buf, nbufs c.Uint, sendStream *Stream, writeCb WriteCb) c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).TryWrite C.uv_try_write
+func (stream *Stream) TryWrite(bufs *Buf, nbufs c.Uint) c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).TryWrite2 C.uv_try_write2
+func (stream *Stream) TryWrite2(bufs *Buf, nbufs c.Uint, sendStream *Stream) c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).IsReadable C.uv_is_readable
+func (stream *Stream) IsReadable() c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).IsWritable C.uv_is_writable
+func (stream *Stream) IsWritable() c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).SetBlocking C.uv_stream_set_blocking
+func (stream *Stream) SetBlocking(blocking c.Int) c.Int {
+	return 0
+}
+
 // ----------------------------------------------
 
 /* Tcp related function and method */
@@ -273,3 +484,20 @@ func InetNtop(af c.Int, src c.Pointer, dst *c.Char, size uintptr) c.Int
 
 //go:linkname InetPton C.uv_inet_pton
 func InetPton(af c.Int, src *c.Char, dst c.Pointer) c.Int
+
+// ----------------------------------------------
+
+/* Getaddrinfo related function and method */
+
+//go:linkname Getaddrinfo C.uv_getaddrinfo
+func Getaddrinfo(loop *Loop, req *GetAddrInfo, getaddrinfoCb GetaddrinfoCb, node *c.Char, service *c.Char, hints *net.AddrInfo) c.Int
+
+//go:linkname Freeaddrinfo C.uv_freeaddrinfo
+func Freeaddrinfo(addrInfo *net.AddrInfo)
+
+// ----------------------------------------------
+
+/* Getnameinfo related function and method */
+
+//go:linkname Getnameinfo C.uv_getnameinfo
+func Getnameinfo(loop *Loop, req *GetNameInfo, getnameinfoCb GetnameinfoCb, addr *net.SockAddr, flags c.Int) c.Int

c/libuv/timer.go

@@ -10,6 +10,7 @@ import (
 
 /* Handle types. */
 
+// TODO(spongehah): Timer
 type Timer struct {
 	Unused [0]byte
 }

c/lua/_demo/coroutine-cfunc/coroutine.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/lua"
+)
+
+func coroutineFunc(L *lua.State) c.Int {
+	c.Printf(c.Str("Coroutine started\n"))
+	L.Yield(0) // Pause the coroutine
+	c.Printf(c.Str("Coroutine resumed\n"))
+	return 0
+}
+
+func main() {
+	L := lua.Newstate()
+	defer L.Close()
+
+	L.Openlibs()
+	co := L.Newthread()
+	L.Pushcfunction(coroutineFunc)
+	L.Xmove(co, 1)
+
+	var nres c.Int
+
+	c.Printf(c.Str("Resuming coroutine for the first time\n"))
+	result := co.Resume(nil, 0, &nres)
+	if result == lua.YIELD {
+		c.Printf(c.Str("Coroutine yielded\n"))
+		result = co.Resume(nil, 0, &nres)
+		if result == 0 {
+			c.Printf(c.Str("Coroutine finished\n"))
+		}
+	}
+}
+
+/* Expected output:
+Resuming coroutine for the first time
+Coroutine started
+Coroutine yielded
+Coroutine finished
+*/

c/lua/_demo/coroutine/coroutine.go

@@ -36,8 +36,8 @@ func main() {
 	// Resume coroutine and handle yields
 	for {
 		status = co.Resume(nil, 0, &nres)
-		c.Printf(c.Str("Resuming coroutine %d...\n"), status)
 		if status == lua.YIELD {
+			c.Printf(c.Str("Resuming coroutine %d...\n"), status)
 			yieldValue := co.Tointeger(-1)
 			c.Printf(c.Str("Yield value: %d\n"), yieldValue)
 			co.Pop(1) // Clean up the stack
@@ -58,3 +58,23 @@ func main() {
 	finalStatus := co.Status()
 	c.Printf(c.Str("Final status of coroutine: %d\n"), finalStatus)
 }
+
+/* Expected output:
+Resuming coroutine...
+Resuming coroutine 1...
+Yield value: 1
+Coroutine is yieldable.
+Resuming coroutine 1...
+Yield value: 2
+Coroutine is yieldable.
+Resuming coroutine 1...
+Yield value: 3
+Coroutine is yieldable.
+Resuming coroutine 1...
+Yield value: 4
+Coroutine is yieldable.
+Resuming coroutine 1...
+Yield value: 5
+Coroutine is yieldable.
+Final status of coroutine: 0
+*/

c/lua/_demo/metatable/metatable.go

@@ -0,0 +1,125 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/lua"
+)
+
+func toString(L *lua.State) c.Int {
+	L.Pushstring(c.Str("Hello from metatable!"))
+	return 1
+}
+
+func printStack(L *lua.State, message string) {
+	top := L.Gettop()
+	c.Printf(c.Str("%s - Stack size: %d\n"), c.AllocaCStr(message), c.Int(top))
+	for i := c.Int(1); i <= top; i++ {
+		t := L.Type(i)
+		switch t {
+		case c.Int(lua.STRING):
+			c.Printf(c.Str("  %d: string: %s\n"), c.Int(i), L.Tostring(i))
+		case c.Int(lua.BOOLEAN):
+			c.Printf(c.Str("  %d: boolean: %v\n"), c.Int(i), L.Toboolean(i))
+		case c.Int(lua.NUMBER):
+			c.Printf(c.Str("  %d: number: %f\n"), c.Int(i), L.Tonumber(i))
+		default:
+			c.Printf(c.Str("  %d: %s\n"), c.Int(i), L.Typename(t))
+		}
+	}
+}
+
+func main() {
+	L := lua.Newstate()
+	defer L.Close()
+
+	L.Openlibs()
+
+	L.Newtable()
+	printStack(L, "After creating main table")
+
+	L.Newtable()
+	printStack(L, "After creating metatable")
+
+	L.Pushcfunction(toString)
+	printStack(L, "After Push CFunction")
+
+	L.Setfield(-2, c.Str("__tostring"))
+	printStack(L, "After setting __tostring")
+
+	if L.Setmetatable(-2) == 0 {
+		c.Printf(c.Str("Failed to set metatable\n"))
+	}
+	printStack(L, "After setting metatable")
+
+	L.Setglobal(c.Str("obj"))
+	printStack(L, "After setting global obj")
+
+	testcode := c.Str(`
+		if obj == nil then
+			print('obj is not defined')
+		else
+			local mt = getmetatable(obj)
+			if not mt then
+				print('Metatable not set')
+			elseif not mt.__tostring then
+				print('__tostring not set in metatable')
+			else
+				print(mt.__tostring(obj))
+			end
+		end
+	`)
+
+	if L.Dostring(testcode) != lua.OK {
+		c.Printf(c.Str("Error: %s\n"), L.Tostring(-1))
+	}
+
+	L.Getglobal(c.Str("obj"))
+	if L.Getmetatable(-1) != 0 {
+		c.Printf(c.Str("Metatable get success\n"))
+		L.Pushstring(c.Str("__tostring"))
+		L.Gettable(-2)
+		if L.Isfunction(-1) {
+			c.Printf(c.Str("__tostring function found in metatable\n"))
+			if L.Iscfunction(-1) != 0 {
+				c.Printf(c.Str("__tostring is a C function\n"))
+				cfunc := L.Tocfunction(-1)
+				if cfunc != nil {
+					c.Printf(c.Str("Successfully retrieved __tostring C function pointer\n"))
+					L.Pushcfunction(cfunc)
+					if L.Call(0, 1) == lua.OK {
+						result := L.Tostring(-1)
+						c.Printf(c.Str("Result of calling __tostring: %s\n"), result)
+					}
+				}
+			}
+		} else {
+			c.Printf(c.Str("__tostring function not found in metatable\n"))
+		}
+	} else {
+		c.Printf(c.Str("No metatable found using GetTable\n"))
+	}
+}
+
+/* Expected output:
+After creating main table - Stack size: 1
+  1: table
+After creating metatable - Stack size: 2
+  1: table
+  2: table
+After Push CFunction - Stack size: 3
+  1: table
+  2: table
+  3: function
+After setting __tostring - Stack size: 2
+  1: table
+  2: table
+After setting metatable - Stack size: 1
+  1: table
+After setting global obj - Stack size: 0
+Hello from metatable!
+Metatable get success
+__tostring function found in metatable
+__tostring is a C function
+Successfully retrieved __tostring C function pointer
+Result of calling __tostring: Hello from metatable!
+*/

c/lua/lua.go

@@ -41,17 +41,17 @@ type State struct {
 // ** basic types
 // */
 const (
-	NONE          = int(-1)
-	NIL           = int(0)
-	BOOLEAN       = int(1)
-	LIGHTUSERDATA = int(2)
-	NUMBER        = int(3)
-	STRING        = int(4)
-	TABLE         = int(5)
-	FUNCTION      = int(6)
-	USERDATA      = int(7)
-	THREAD        = int(8)
-	UMTYPES       = int(9)
+	NONE          c.Int = -1
+	NIL           c.Int = 0
+	BOOLEAN       c.Int = 1
+	LIGHTUSERDATA c.Int = 2
+	NUMBER        c.Int = 3
+	STRING        c.Int = 4
+	TABLE         c.Int = 5
+	FUNCTION      c.Int = 6
+	USERDATA      c.Int = 7
+	THREAD        c.Int = 8
+	UMTYPES       c.Int = 9
 )
 
 // /* minimum Lua stack available to a C function */
@@ -78,13 +78,15 @@ type Integer = c.Int
 type Unsigned = c.Uint
 
 // /* type for continuation-function contexts */
-// TODO(zzy): Context may not be c.Int
-type KContext c.Int
+type KContext = c.Pointer
 
 // /*
 // ** Type for C functions registered with Lua
 // */
 
+// llgo:type C
+type CFunction func(L *State) c.Int
+
 // /*
 // ** Type for continuation functions
 // */
@@ -144,7 +146,6 @@ type KFunction func(L *State, status c.Int, ctx KContext) c.Int
 func (L *State) Close() {}
 
 // State *(lua_newstate) (lua_Alloc f, void *ud);
-// State *(lua_newthread) (State *L);
 
 // llgo:link (*State).Newthread C.lua_newthread
 func (L *State) Newthread() *State { return nil }
@@ -185,9 +186,6 @@ func (L *State) Xmove(to *State, n c.Int) {}
 // /*
 // ** access functions (stack -> C)
 // */
-// LUA_API int             (lua_isinteger) (State *L, int idx);
-// llgo:link (*State).Isinteger C.lua_isinteger
-func (L *State) Isinteger(idx c.Int) c.Int { return 0 }
 
 // llgo:link (*State).Isnumber C.lua_isnumber
 func (L *State) Isnumber(idx c.Int) c.Int { return 0 }
@@ -195,11 +193,17 @@ func (L *State) Isnumber(idx c.Int) c.Int { return 0 }
 // llgo:link (*State).Isstring C.lua_isstring
 func (L *State) Isstring(idx c.Int) c.Int { return 0 }
 
-// TODO(zzy):add to demo
+// llgo:link (*State).Iscfunction C.lua_iscfunction
+func (L *State) Iscfunction(idx c.Int) c.Int { return 0 }
+
+// llgo:link (*State).Isinteger C.lua_isinteger
+func (L *State) Isinteger(idx c.Int) c.Int { return 0 }
+
+// LUA_API int             (lua_isuserdata) (State *L, int idx);
+
 // llgo:link (*State).Type C.lua_type
 func (L *State) Type(idx c.Int) c.Int { return 0 }
 
-// TODO(zzy)
 // llgo:link (*State).Typename C.lua_typename
 func (L *State) Typename(tp c.Int) *c.Char { return nil }
 
@@ -215,11 +219,11 @@ func (L *State) Toboolean(idx c.Int) bool { return false }
 // llgo:link (*State).Tolstring C.lua_tolstring
 func (L *State) Tolstring(idx c.Int, len *c.Ulong) *c.Char { return nil }
 
-// LUA_API int             (lua_iscfunction) (State *L, int idx);
-// LUA_API int             (lua_isuserdata) (State *L, int idx);
-
 // LUA_API lua_Unsigned    (lua_rawlen) (State *L, int idx);
-// LUA_API lua_CFunction   (lua_tocfunction) (State *L, int idx);
+
+// llgo:link (*State).Tocfunction C.lua_tocfunction
+func (L *State) Tocfunction(idx c.Int) CFunction { return nil }
+
 // LUA_API void	       *(lua_touserdata) (State *L, int idx);
 // LUA_API State      *(lua_tothread) (State *L, int idx);
 // LUA_API const void     *(lua_topointer) (State *L, int idx);
@@ -240,24 +244,21 @@ func (L *State) Pushnumber(n Number) {}
 // llgo:link (*State).Pushinteger C.lua_pushinteger
 func (L *State) Pushinteger(n Integer) {}
 
-// llgo:link (*State).Pushstring C.lua_pushstring
-func (L *State) Pushstring(s *c.Char) *c.Char {
-	return nil
-}
-
 // llgo:link (*State).Pushlstring C.lua_pushlstring
-func (L *State) Pushlstring(s *c.Char, len c.Ulong) *c.Char {
-	return nil
-}
+func (L *State) Pushlstring(s *c.Char, len c.Ulong) *c.Char { return nil }
+
+// llgo:link (*State).Pushstring C.lua_pushstring
+func (L *State) Pushstring(s *c.Char) *c.Char { return nil }
 
 // llgo:link (*State).Pushfstring C.lua_pushfstring
 func (L *State) Pushfstring(format *c.Char, __llgo_va_list ...any) *c.Char { return nil }
 
+// llgo:link (*State).Pushcclosure C.lua_pushcclosure
+func (L *State) Pushcclosure(fn CFunction, n c.Int) {}
+
 // llgo:link (*State).Pushboolean C.lua_pushboolean
 func (L *State) Pushboolean(b c.Int) {}
 
-//const char *(lua_pushvfstring) (State *L, const char *fmt,va_list argp);
-//void  (lua_pushcclosure) (State *L, lua_CFunction fn, int n);
 //void  (lua_pushlightuserdata) (State *L, void *p);
 //int   (lua_pushthread) (State *L);
 
@@ -274,23 +275,25 @@ func (L *State) Gettable(idx c.Int) c.Int { return 0 }
 // llgo:link (*State).Getfield C.lua_getfield
 func (L *State) Getfield(idx c.Int, k *c.Char) c.Int { return 0 }
 
-// llgo:link (*State).Createtable C.lua_createtable
-func (L *State) Createtable(narr c.Int, nrec c.Int) {}
-
 // LUA_API int (lua_geti) (State *L, int idx, lua_Integer n);
 // LUA_API int (lua_rawget) (State *L, int idx);
 // LUA_API int (lua_rawgeti) (State *L, int idx, lua_Integer n);
 // LUA_API int (lua_rawgetp) (State *L, int idx, const void *p);
 
+// llgo:link (*State).Createtable C.lua_createtable
+func (L *State) Createtable(narr c.Int, nrec c.Int) {}
+
 // LUA_API void *(lua_newuserdatauv) (State *L, size_t sz, int nuvalue);
-// LUA_API int   (lua_getmetatable) (State *L, int objindex);
+
+// llgo:link (*State).Getmetatable C.lua_getmetatable
+func (L *State) Getmetatable(objindex c.Int) c.Int { return 0 }
+
 // LUA_API int  (lua_getiuservalue) (State *L, int idx, int n);
 
 // /*
 // ** set functions (stack -> Lua)
 // */
 
-// TODO(zzy):add to demo
 // llgo:link (*State).Setglobal C.lua_setglobal
 func (L *State) Setglobal(name *c.Char) {}
 
@@ -304,25 +307,34 @@ func (L *State) Setfield(idx c.Int, k *c.Char) {}
 //void  (lua_rawset) (State *L, int idx);
 //void  (lua_rawseti) (State *L, int idx, lua_Integer n);
 //void  (lua_rawsetp) (State *L, int idx, const void *p);
-//int   (lua_setmetatable) (State *L, int objindex);
+
+// llgo:link (*State).Setmetatable C.lua_setmetatable
+func (L *State) Setmetatable(objindex c.Int) c.Int { return 0 }
+
 //int   (lua_setiuservalue) (State *L, int idx, int n);
 
 // /*
 // ** 'load' and 'call' functions (load and run Lua code)
 // */
 
+// llgo:link (*State).Callk C.lua_callk
+func (L *State) Callk(nargs c.Int, nresults c.Int, ctx KContext, k KFunction) c.Int {
+	return 0
+}
+
+func (L *State) Call(nargs c.Int, nresults c.Int) c.Int {
+	return L.Callk(nargs, nresults, nil, nil)
+}
+
 // llgo:link (*State).Pcallk C.lua_pcallk
-func (L *State) Pcallk(nargs c.Int, nresults c.Int, errfunc c.Int, ctx KContext, k *KFunction) c.Int {
+func (L *State) Pcallk(nargs c.Int, nresults c.Int, errfunc c.Int, ctx KContext, k KFunction) c.Int {
 	return 0
 }
 
 func (L *State) Pcall(nargs c.Int, nresults c.Int, errfunc c.Int) c.Int {
-	return L.Pcallk(nargs, nresults, errfunc, KContext(c.Int(0)), nil)
+	return L.Pcallk(nargs, nresults, errfunc, nil, nil)
 }
 
-// void  (lua_callk) (State *L, int nargs, int nresults, lua_KContext ctx, lua_KFunction k);
-// #define lua_call(L,n,r)		lua_callk(L, (n), (r), 0, NULL)
-
 // int   (lua_load) (State *L, lua_Reader reader, void *dt, const char *chunkname, const char *mode);
 
 // int (lua_dump) (State *L, lua_Writer writer, void *data, int strip);
@@ -340,9 +352,9 @@ func (L *State) Status() c.Int { return 0 }
 // llgo:link (*State).Isyieldable C.lua_isyieldable
 func (L *State) Isyieldable() c.Int { return 0 }
 
-// TODO(zzy)
-// int  (lua_yieldk)     (State *L, int nresults, lua_KContext ctx, lua_KFunction k);
-// #define lua_yield(L,n)	lua_yieldk(L, (n), 0, NULL)
+// llgo:link (*State).Yieldk C.lua_yieldk
+func (L *State) Yieldk(nresults c.Int, ctx KContext, k KFunction) c.Int { return 0 }
+func (L *State) Yield(nresults c.Int) c.Int                             { return L.Yieldk(nresults, nil, nil) }
 
 // /*
 // ** Warning-related functions
@@ -396,11 +408,17 @@ func (L *State) Next(idx c.Int) c.Int { return 0 }
 // ** ===============================================================
 // */
 
-func (L *State) Tonumber(idx c.Int) Number    { return L.Tonumberx(idx, nil) }
-func (L *State) Tostring(idx c.Int) *c.Char   { return L.Tolstring(idx, nil) }
-func (L *State) Tointeger(idx c.Int) Integer  { return L.Tointegerx(idx, nil) }
-func (L *State) Pop(n c.Int)                  { L.Settop(-(n) - 1) }
-func (L *State) Newtable()                    { L.Createtable(0, 0) }
+// #define lua_getextraspace(L)	((void *)((char *)(L) - LUA_EXTRASPACE))
+
+func (L *State) Tonumber(idx c.Int) Number   { return L.Tonumberx(idx, nil) }
+func (L *State) Tostring(idx c.Int) *c.Char  { return L.Tolstring(idx, nil) }
+func (L *State) Tointeger(idx c.Int) Integer { return L.Tointegerx(idx, nil) }
+func (L *State) Pop(n c.Int)                 { L.Settop(-(n) - 1) }
+func (L *State) Newtable()                   { L.Createtable(0, 0) }
+
+// #define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+func (L *State) Pushcfunction(f CFunction) { L.Pushcclosure(f, 0) }
+
 func (L *State) Isfunction(n c.Int) bool      { return L.Type(n) == c.Int(FUNCTION) }
 func (L *State) Istable(n c.Int) bool         { return L.Type(n) == c.Int(TABLE) }
 func (L *State) Islightuserdata(n c.Int) bool { return L.Type(n) == c.Int(LIGHTUSERDATA) }
@@ -410,20 +428,11 @@ func (L *State) Isthread(n c.Int) bool        { return L.Type(n) == c.Int(THREAD
 func (L *State) Isnone(n c.Int) bool          { return L.Type(n) == c.Int(NONE) }
 func (L *State) Isnoneornil(n c.Int) bool     { return L.Type(n) <= 0 }
 
-// #define lua_getextraspace(L)	((void *)((char *)(L) - LUA_EXTRASPACE))
-
-// #define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
-
-// #define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)
-
 // #define lua_pushliteral(L, s)	lua_pushstring(L, "" s)
-
 // #define lua_pushglobaltable(L)  ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS))
 
 // #define lua_insert(L,idx)	lua_rotate(L, (idx), 1)
-
 // #define lua_remove(L,idx)	(lua_rotate(L, (idx), -1), lua_pop(L, 1))
-
 // #define lua_replace(L,idx)	(lua_copy(L, -1, (idx)), lua_pop(L, 1))
 
 // /* }============================================================== */

c/openssl/_demo/cbigintdemo/fib.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/openssl"
+)
+
+func newInt(n openssl.BN_ULONG) *openssl.BIGNUM {
+	ret := openssl.BNNew()
+	ret.SetWord(n)
+	return ret
+}
+
+func main() {
+	ctx := openssl.BN_CTXNew()
+	defer ctx.Free()
+
+	// Initialize two big ints with the first two numbers in the sequence.
+	a := newInt(0)
+	b := newInt(1)
+	defer a.Free()
+	defer b.Free()
+
+	// Initialize limit as 10^99, the smallest integer with 100 digits.
+	v10, v99 := newInt(10), newInt(99)
+	defer v10.Free()
+	defer v99.Free()
+
+	limit := openssl.BNNew()
+	defer limit.Free()
+
+	limit.Exp(v10, v99, ctx)
+
+	// Loop while a is smaller than 1e100.
+	for a.Cmp(limit) < 0 {
+		// Compute the next Fibonacci number, storing it in a.
+		a.Add(a, b)
+		// Swap a and b so that b is the next number in the sequence.
+		a, b = b, a
+	}
+	cstr := a.CStr()
+	c.Printf(c.Str("%s\n"), cstr) // 100-digit Fibonacci number
+	openssl.FreeCStr(cstr)
+}

c/openssl/_demo/chmacdemo/hmac.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"fmt"
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/openssl"
+)
+
+func main() {
+	str := "Hello, World!"
+	key := "123456"
+	var lenKey = len(key)
+
+	var digest = make([]byte, openssl.EVP_MAX_MD_SIZE)
+	var digestLen c.Uint
+	ctx := openssl.NewHMAC_CTX()
+	if ctx == nil {
+		c.Fprintf(c.Stderr, c.Str("%s\n"), c.Str("Error creating HMAC_CTX"))
+		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"))
+		return
+	}
+	ret = ctx.UpdateString(str)
+	if ret == 0 {
+		c.Fprintf(c.Stderr, c.Str("%s\n"), c.Str("Error updating HMAC_CTX"))
+		return
+	}
+	ret = ctx.Final(unsafe.SliceData(digest), &digestLen)
+	if ret == 0 {
+		c.Fprintf(c.Stderr, c.Str("%s\n"), c.Str("Error finalizing HMAC_CTX"))
+		return
+	}
+	fmt.Print("HMAC: ")
+	for i := 0; i < int(digestLen); i++ {
+		fmt.Printf("%02x", digest[i])
+	}
+	fmt.Print("\n")
+}

c/openssl/_demo/cmd5demo/md5.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"unsafe"
+
+	"github.com/goplus/llgo/c/openssl"
+)
+
+func main() {
+	var md5 openssl.MD5_CTX
+	var h = make([]byte, openssl.MD5_LBLOCK)
+	md5.Init()
+	md5.UpdateString("The fog is getting thicker!")
+	md5.UpdateString("And Leon's getting laaarger!")
+	md5.Final(unsafe.SliceData(h))
+	fmt.Printf("%x", h)
+}

c/openssl/_demo/cranddemo/rand.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/goplus/llgo/c/openssl"
+)
+
+func main() {
+	b := make([]byte, 10)
+
+	openssl.RANDBytes(b)
+	fmt.Printf("%x\n", b)
+
+	openssl.RANDPrivBytes(b)
+	fmt.Printf("%x\n", b)
+}

c/openssl/_demo/cshademo/sha.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"fmt"
+	"unsafe"
+
+	"github.com/goplus/llgo/c/openssl"
+)
+
+func main() {
+	str := "His money is twice tainted:"
+
+	var sha1 openssl.SHA_CTX
+	sha1.Init()
+	sha1.UpdateString(str)
+
+	h1 := make([]byte, openssl.SHA_DIGEST_LENGTH)
+	sha1.Final(unsafe.SliceData(h1))
+	fmt.Printf("%x\n", h1)
+
+	h2 := make([]byte, openssl.SHA_DIGEST_LENGTH)
+	openssl.SHA1String(str, unsafe.SliceData(h2))
+	fmt.Printf("%x\n", h2)
+
+	var sha256 openssl.SHA256_CTX
+	sha256.Init()
+	sha256.UpdateString(str)
+	h3 := make([]byte, openssl.SHA256_DIGEST_LENGTH)
+	sha256.Final(unsafe.SliceData(h3))
+	fmt.Printf("%x\n", h3)
+
+	h4 := make([]byte, openssl.SHA256_DIGEST_LENGTH)
+	openssl.SHA256String(str, unsafe.SliceData(h4))
+	fmt.Printf("%x\n", h4)
+
+	var sha512 openssl.SHA512_CTX
+	sha512.Init()
+	sha512.UpdateString("His money is twice tainted:")
+
+	h5 := make([]byte, openssl.SHA512_DIGEST_LENGTH)
+	sha512.Final(unsafe.SliceData(h5))
+	fmt.Printf("%x\n", h5)
+
+	h6 := make([]byte, openssl.SHA512_DIGEST_LENGTH)
+	openssl.SHA512String(str, unsafe.SliceData(h6))
+	fmt.Printf("%x\n", h6)
+
+	var sha224 openssl.SHA224_CTX
+	sha224.Init()
+	sha224.UpdateString(str)
+
+	h7 := make([]byte, openssl.SHA224_DIGEST_LENGTH)
+	sha224.Final(unsafe.SliceData(h7))
+	fmt.Printf("%x\n", h7)
+	h8 := make([]byte, openssl.SHA224_DIGEST_LENGTH)
+	openssl.SHA224String(str, unsafe.SliceData(h8))
+	fmt.Printf("%x\n", h8)
+
+	var sha384 openssl.SHA384_CTX
+	sha384.Init()
+	sha384.UpdateString(str)
+	h9 := make([]byte, openssl.SHA384_DIGEST_LENGTH)
+	sha384.Final(unsafe.SliceData(h9))
+	fmt.Printf("%x\n", h9)
+	h10 := make([]byte, openssl.SHA384_DIGEST_LENGTH)
+	openssl.SHA384String(str, unsafe.SliceData(h10))
+	fmt.Printf("%x\n", h10)
+}

c/openssl/_wrap/openssl.c

@@ -0,0 +1,5 @@
+#include <openssl/crypto.h>
+
+void opensslFree(void *ptr) {
+    OPENSSL_free(ptr);
+}

c/openssl/bio.go

@@ -0,0 +1,61 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+type BIO struct {
+	Unused [0]byte
+}
+
+// BIO *BIO_new_mem_buf(const void *buf, int len);
+//
+//go:linkname BIONewMemBuf C.BIO_new_mem_buf
+func BIONewMemBuf(buf unsafe.Pointer, len c.Int) *BIO
+
+// int BIO_free(BIO *a);
+//
+// llgo:link (*BIO).Free C.BIO_free
+func (*BIO) Free() c.Int { return 0 }
+
+// int BIO_up_ref(BIO *a);
+//
+// llgo:link (*BIO).UpRef C.BIO_up_ref
+func (*BIO) UpRef() c.Int { return 0 }
+
+// int BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes);
+//
+// llgo:link (*BIO).ReadEx C.BIO_read_ex
+func (*BIO) ReadEx(data unsafe.Pointer, dlen uintptr, readbytes *uintptr) c.Int { return 0 }
+
+// int BIO_write(BIO *b, const void *data, int dlen);
+//
+// llgo:link (*BIO).Write C.BIO_write
+func (*BIO) Write(data unsafe.Pointer, dlen c.Int) c.Int { return 0 }
+
+// int BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written);
+//
+// llgo:link (*BIO).WriteEx C.BIO_write_ex
+func (*BIO) WriteEx(data unsafe.Pointer, dlen uintptr, written *uintptr) c.Int { return 0 }
+
+// -----------------------------------------------------------------------------

c/openssl/bn.go

@@ -0,0 +1,341 @@
+/*
+ * 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 openssl
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+type BN_ULONG = uint64
+
+// -----------------------------------------------------------------------------
+
+type BN_CTX struct {
+	Unused [0]byte
+}
+
+// BN_CTX *BN_CTX_new(void);
+//
+//go:linkname BN_CTXNew C.BN_CTX_new
+func BN_CTXNew() *BN_CTX
+
+// BN_CTX *BN_CTX_secure_new(void);
+//
+//go:linkname BN_CTXSecureNew C.BN_CTX_secure_new
+func BN_CTXSecureNew() *BN_CTX
+
+// BN_CTX *BN_CTX_new_ex(OSSL_LIB_CTX *ctx);
+// BN_CTX *BN_CTX_secure_new_ex(OSSL_LIB_CTX *ctx);
+
+// void BN_CTX_free(BN_CTX *c);
+//
+// llgo:link (*BN_CTX).Free C.BN_CTX_free
+func (*BN_CTX) Free() {}
+
+// void BN_CTX_start(BN_CTX *ctx);
+// BIGNUM *BN_CTX_get(BN_CTX *ctx);
+// void BN_CTX_end(BN_CTX *ctx);
+
+// -----------------------------------------------------------------------------
+
+type BIGNUM struct {
+	Unused [0]byte
+}
+
+// BIGNUM *BN_new(void);
+//
+//go:linkname BNNew C.BN_new
+func BNNew() *BIGNUM
+
+// BIGNUM *BN_secure_new(void);
+//
+//go:linkname BNSecureNew C.BN_secure_new
+func BNSecureNew() *BIGNUM
+
+// void BN_free(BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Free C.BN_free
+func (*BIGNUM) Free() {}
+
+// void BN_clear_free(BIGNUM *a);
+//
+// llgo:link (*BIGNUM).ClearFree C.BN_clear_free
+func (*BIGNUM) ClearFree() {}
+
+// void BN_clear(BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Clear C.BN_clear
+func (*BIGNUM) Clear() {}
+
+// BIGNUM *BN_dup(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Dup C.BN_dup
+func (*BIGNUM) Dup() *BIGNUM { return nil }
+
+// BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Copy C.BN_copy
+func (*BIGNUM) Copy(b *BIGNUM) *BIGNUM { return nil }
+
+// void BN_swap(BIGNUM *a, BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Swap C.BN_swap
+func (*BIGNUM) Swap(b *BIGNUM) {}
+
+// int BN_is_zero(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).IsZero C.BN_is_zero
+func (*BIGNUM) IsZero() c.Int { return 0 }
+
+// void BN_zero_ex(BIGNUM *a);
+//
+// llgo:link (*BIGNUM).SetZero C.BN_zero_ex
+func (*BIGNUM) SetZero() {}
+
+// int BN_is_one(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).IsOne C.BN_is_one
+func (*BIGNUM) IsOne() c.Int { return 0 }
+
+// int BN_is_odd(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).IsOdd C.BN_is_odd
+func (*BIGNUM) IsOdd() c.Int { return 0 }
+
+// int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w);
+//
+// llgo:link (*BIGNUM).AbsIsWord C.BN_abs_is_word
+func (*BIGNUM) AbsIsWord(w BN_ULONG) c.Int { return 0 }
+
+// int BN_is_word(const BIGNUM *a, const BN_ULONG w);
+//
+// llgo:link (*BIGNUM).IsWord C.BN_is_word
+func (*BIGNUM) IsWord(w BN_ULONG) c.Int { return 0 }
+
+// int BN_set_word(BIGNUM *a, BN_ULONG w);
+//
+// llgo:link (*BIGNUM).SetWord C.BN_set_word
+func (*BIGNUM) SetWord(w BN_ULONG) c.Int { return 0 }
+
+// BN_ULONG BN_get_word(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).GetWord C.BN_get_word
+func (*BIGNUM) GetWord() BN_ULONG { return 0 }
+
+// BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);
+//
+// llgo:link (*BIGNUM).ModWord C.BN_mod_word
+func (*BIGNUM) ModWord(w BN_ULONG) BN_ULONG { return 0 }
+
+// BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);
+//
+// llgo:link (*BIGNUM).DivWord C.BN_div_word
+func (*BIGNUM) DivWord(w BN_ULONG) BN_ULONG { return 0 }
+
+// int BN_mul_word(BIGNUM *a, BN_ULONG w);
+//
+// llgo:link (*BIGNUM).MulWord C.BN_mul_word
+func (*BIGNUM) MulWord(w BN_ULONG) c.Int { return 0 }
+
+// int BN_add_word(BIGNUM *a, BN_ULONG w);
+//
+// llgo:link (*BIGNUM).AddWord C.BN_add_word
+func (*BIGNUM) AddWord(w BN_ULONG) c.Int { return 0 }
+
+// int BN_sub_word(BIGNUM *a, BN_ULONG w);
+//
+// llgo:link (*BIGNUM).SubWord C.BN_sub_word
+func (*BIGNUM) SubWord(w BN_ULONG) c.Int { return 0 }
+
+// char *BN_bn2hex(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Bn2hex C.BN_bn2hex
+func (*BIGNUM) Bn2hex() *c.Char { return nil }
+
+// char *BN_bn2dec(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Bn2dec C.BN_bn2dec
+func (*BIGNUM) Bn2dec() *c.Char { return nil }
+
+// llgo:link (*BIGNUM).CStr C.BN_bn2dec
+func (*BIGNUM) CStr() *c.Char { return nil }
+
+// int BN_hex2bn(BIGNUM **a, const char *str);
+//
+//go:linkname BNHex2bn C.BN_hex2bn
+func BNHex2bn(a **BIGNUM, str *c.Char) c.Int
+
+// int BN_dec2bn(BIGNUM **a, const char *str);
+//
+//go:linkname BNDec2bn C.BN_dec2bn
+func BNDec2bn(a **BIGNUM, str *c.Char) c.Int
+
+// int BN_asc2bn(BIGNUM **a, const char *str);
+//
+//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);
+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);
+//
+// llgo:link (*BIGNUM).Sub C.BN_sub
+func (*BIGNUM) Sub(a, b *BIGNUM) c.Int { return 0 }
+
+// int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Add C.BN_add
+func (*BIGNUM) Add(a, b *BIGNUM) c.Int { return 0 }
+
+// int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Usub C.BN_usub
+func (*BIGNUM) Usub(a, b *BIGNUM) c.Int { return 0 }
+
+// int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Uadd C.BN_uadd
+func (*BIGNUM) Uadd(a, b *BIGNUM) c.Int { return 0 }
+
+// int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).Mul C.BN_mul
+func (*BIGNUM) Mul(r, a, b *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).Sqr C.BN_sqr
+func (*BIGNUM) Sqr(r, a *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+/** BN_set_negative sets sign of a BIGNUM
+ * \param  b  pointer to the BIGNUM object
+ * \param  n  0 if the BIGNUM b should be positive and a value != 0 otherwise
+ */
+// void BN_set_negative(BIGNUM *b, int n);
+//
+// llgo:link (*BIGNUM).SetNegative C.BN_set_negative
+func (*BIGNUM) SetNegative(n c.Int) {}
+
+/** BN_is_negative returns 1 if the BIGNUM is negative
+ * \param  b  pointer to the BIGNUM object
+ * \return 1 if a < 0 and 0 otherwise
+ */
+// int BN_is_negative(const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).IsNegative C.BN_is_negative
+func (*BIGNUM) IsNegative() c.Int { return 0 }
+
+// int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).Div C.BN_div
+func (*BIGNUM) Div(rem, m, d *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).Nnmod C.BN_nnmod
+func (*BIGNUM) Nnmod(r, m, d *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// int BN_cmp(const BIGNUM *a, const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Cmp C.BN_cmp
+func (*BIGNUM) Cmp(b *BIGNUM) c.Int { return 0 }
+
+// int BN_ucmp(const BIGNUM *a, const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Ucmp C.BN_ucmp
+func (*BIGNUM) Ucmp(b *BIGNUM) c.Int { return 0 }
+
+// int BN_is_bit_set(const BIGNUM *a, int n);
+//
+// llgo:link (*BIGNUM).IsBitSet C.BN_is_bit_set
+func (*BIGNUM) IsBitSet(n c.Int) c.Int { return 0 }
+
+// int BN_set_bit(BIGNUM *a, int n);
+//
+// llgo:link (*BIGNUM).SetBit C.BN_set_bit
+func (*BIGNUM) SetBit(n c.Int) c.Int { return 0 }
+
+// int BN_clear_bit(BIGNUM *a, int n);
+//
+// llgo:link (*BIGNUM).ClearBit C.BN_clear_bit
+func (*BIGNUM) ClearBit(n c.Int) c.Int { return 0 }
+
+// int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);
+//
+// llgo:link (*BIGNUM).Lshift C.BN_lshift
+func (*BIGNUM) Lshift(a *BIGNUM, n c.Int) c.Int { return 0 }
+
+// int BN_lshift1(BIGNUM *r, const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Lshift1 C.BN_lshift1
+func (*BIGNUM) Lshift1(a *BIGNUM) c.Int { return 0 }
+
+// int BN_rshift(BIGNUM *r, const BIGNUM *a, int n);
+//
+// llgo:link (*BIGNUM).Rshift C.BN_rshift
+func (*BIGNUM) Rshift(a *BIGNUM, n c.Int) c.Int { return 0 }
+
+// int BN_rshift1(BIGNUM *r, const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Rshift1 C.BN_rshift1
+func (*BIGNUM) Rshift1(a *BIGNUM) c.Int { return 0 }
+
+// int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).Exp C.BN_exp
+func (*BIGNUM) Exp(a, p *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).ModExp C.BN_mod_exp
+func (*BIGNUM) ModExp(a, p, m *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).Gcd C.BN_gcd
+func (*BIGNUM) Gcd(a, b *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// int BN_are_coprime(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).AreCoprime C.BN_are_coprime
+func (*BIGNUM) AreCoprime(b *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// -----------------------------------------------------------------------------
+
+type BN_GENCB struct {
+	Unused [0]byte
+}
+
+// -----------------------------------------------------------------------------

c/openssl/err.go

@@ -0,0 +1,156 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+/*-
+ * The error code packs differently depending on if it records a system
+ * error or an OpenSSL error.
+ *
+ * A system error packs like this (we follow POSIX and only allow positive
+ * numbers that fit in an |int|):
+ *
+ * +-+-------------------------------------------------------------+
+ * |1|                     system error number                     |
+ * +-+-------------------------------------------------------------+
+ *
+ * An OpenSSL error packs like this:
+ *
+ * <---------------------------- 32 bits -------------------------->
+ *    <--- 8 bits ---><------------------ 23 bits ----------------->
+ * +-+---------------+---------------------------------------------+
+ * |0|    library    |                    reason                   |
+ * +-+---------------+---------------------------------------------+
+ *
+ * A few of the reason bits are reserved as flags with special meaning:
+ *
+ *                    <5 bits-<>--------- 19 bits ----------------->
+ *                   +-------+-+-----------------------------------+
+ *                   | rflags| |          reason                   |
+ *                   +-------+-+-----------------------------------+
+ *                            ^
+ *                            |
+ *                           ERR_RFLAG_FATAL = ERR_R_FATAL
+ *
+ * The reason flags are part of the overall reason code for practical
+ * reasons, as they provide an easy way to place different types of
+ * reason codes in different numeric ranges.
+ *
+ * The currently known reason flags are:
+ *
+ * ERR_RFLAG_FATAL      Flags that the reason code is considered fatal.
+ *                      For backward compatibility reasons, this flag
+ *                      is also the code for ERR_R_FATAL (that reason
+ *                      code served the dual purpose of flag and reason
+ *                      code in one in pre-3.0 OpenSSL).
+ * ERR_RFLAG_COMMON     Flags that the reason code is common to all
+ *                      libraries.  All ERR_R_ macros must use this flag,
+ *                      and no other _R_ macro is allowed to use it.
+ */
+type Errno c.Ulong
+
+// ERR_get_error returns the earliest error code from the thread's error queue and
+// removes the entry. This function can be called repeatedly until there are no more
+// error codes to return.
+//
+// unsigned long ERR_get_error(void);
+//
+//go:linkname ERRGetError C.ERR_get_error
+func ERRGetError() Errno
+
+// ERR_get_error_all() is the same as ERR_get_error(), but on success it additionally
+// stores the filename, line number and function where the error occurred in *file,
+// *line and *func, and also extra text and flags in *data, *flags. If any of those
+// parameters are NULL, it will not be changed.
+//
+// unsigned long ERR_get_error_all(
+// const char **file, int *line, const char **func, const char **data, int *flags);
+//
+//go:linkname ERRGetErrorAll C.ERR_get_error_all
+func ERRGetErrorAll(
+	file **c.Char, line *c.Int, function **c.Char, data **c.Char, flags *c.Int) Errno
+
+// unsigned long ERR_peek_error(void);
+//
+//go:linkname ERRPeekError C.ERR_peek_error
+func ERRPeekError() Errno
+
+// unsigned long ERR_peek_error_all(
+// const char **file, int *line, const char **func, const char **data, int *flags);
+//
+//go:linkname ERRPeekErrorAll C.ERR_peek_error_all
+func ERRPeekErrorAll(
+	file **c.Char, line *c.Int, function **c.Char, data **c.Char, flags *c.Int) Errno
+
+// unsigned long ERR_peek_last_error(void);
+//
+//go:linkname ERRPeekLastError C.ERR_peek_last_error
+func ERRPeekLastError() Errno
+
+// unsigned long ERR_peek_last_error_all(
+// const char **file, int *line, const char **func, const char **data, int *flags);
+//
+//go:linkname ERRPeekLastErrorAll C.ERR_peek_last_error_all
+func ERRPeekLastErrorAll(
+	file **c.Char, line *c.Int, function **c.Char, data **c.Char, flags *c.Int) Errno
+
+// void ERR_clear_error(void);
+//
+//go:linkname ERRClearError C.ERR_clear_error
+func ERRClearError()
+
+// ERR_error_string() generates a human-readable string representing the error code e,
+// and places it at buf. buf must be at least 256 bytes long.
+//
+// char *ERR_error_string(unsigned long e, char *buf);
+//
+//go:linkname ERRErrorString C.ERR_error_string
+func ERRErrorString(e Errno, buf *c.Char) *c.Char
+
+// ERR_lib_error_string() and ERR_reason_error_string() return the library name and
+// reason string respectively.
+//
+// const char *ERR_lib_error_string(unsigned long e);
+//
+//go:linkname ERRLibErrorString C.ERR_lib_error_string
+func ERRLibErrorString(e Errno) *c.Char
+
+// const char *ERR_reason_error_string(unsigned long e);
+//
+//go:linkname ERRReasonErrorString C.ERR_reason_error_string
+func ERRReasonErrorString(e Errno) *c.Char
+
+// void ERR_print_errors_cb(int (*cb) (const char *str, size_t len, void *u), void *u);
+//
+// [pid]:error:[error code]:[library name]:[function name]:[reason string]:[filename]:[line]:[optional text message]
+//
+//go:linkname ERRPrintErrorsCb C.ERR_print_errors_cb
+func ERRPrintErrorsCb(cb func(str *c.Char, len uintptr, u unsafe.Pointer) c.Int, u unsafe.Pointer)
+
+// void ERR_print_errors_fp(FILE *fp);
+//
+//go:linkname ERRPrintErrorsFp C.ERR_print_errors_fp
+func ERRPrintErrorsFp(fp c.FilePtr)
+
+// -----------------------------------------------------------------------------

c/openssl/hmac.go

@@ -0,0 +1,121 @@
+package openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const EVP_MAX_MD_SIZE = 64 /* longest known is SHA512 */
+
+// const EVP_MD *EVP_sha1(void)
+//
+//go:linkname EVP_sha1 C.EVP_sha1
+func EVP_sha1() *EVP_MD
+
+// const EVP_MD *EVP_sha224(void)
+//
+//go:linkname EVP_sha224 C.EVP_sha224
+func EVP_sha224() *EVP_MD
+
+// func EVP_sha256() *EVP_MD
+//
+//go:linkname EVP_sha256 C.EVP_sha256
+func EVP_sha256() *EVP_MD
+
+// const EVP_MD *EVP_sha512_224(void)
+//
+//go:linkname EVP_sha512_224 C.EVP_sha512_224
+func EVP_sha512_224() *EVP_MD
+
+// const EVP_MD *EVP_sha512_256(void)
+//
+//go:linkname EVP_sha512_256 C.EVP_sha512_256
+func EVP_sha512_256() *EVP_MD
+
+// const EVP_MD *EVP_sha384(void)
+//
+//go:linkname EVP_sha384 C.EVP_sha384
+func EVP_sha384() *EVP_MD
+
+// const EVP_MD *EVP_sha512(void)
+//
+//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
+}
+
+// OSSL_DEPRECATEDIN_3_0 HMAC_CTX *HMAC_CTX_new(void);
+//
+//go:linkname NewHMAC_CTX C.HMAC_CTX_new
+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() {}
+
+// 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 }
+
+// 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 }
+
+// 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 }
+
+// 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 {
+	return 0
+}
+
+// OSSL_DEPRECATEDIN_3_0 int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data,
+// 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 (c *HMAC_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(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 (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 (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 (c *HMAC_CTX) SetFlags(flags c.Ulong) {}

c/openssl/md5.go

@@ -0,0 +1,85 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+const (
+	MD5_CBLOCK = 64
+	MD5_LBLOCK = MD5_CBLOCK / 4
+)
+
+// -----------------------------------------------------------------------------
+
+type MD5_LONG = c.Uint
+
+type MD5_CTX struct {
+	A, B, C, D MD5_LONG
+	Nl, Nh     MD5_LONG
+	Data       [MD5_LBLOCK]MD5_LONG
+	Num        c.Uint
+}
+
+// OSSL_DEPRECATEDIN_3_0 int MD5_Init(MD5_CTX *c);
+//
+// llgo:link (*MD5_CTX).Init C.MD5_Init
+func (c *MD5_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int MD5_Update(MD5_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*MD5_CTX).Update C.MD5_Update
+func (c *MD5_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *MD5_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *MD5_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int MD5_Final(unsigned char *md, MD5_CTX *c);
+//
+//go:linkname md5Final C.MD5_Final
+func md5Final(md *byte, c *MD5_CTX) c.Int
+
+func (c *MD5_CTX) Final(md *byte) c.Int {
+	return md5Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 unsigned char *MD5(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname MD5 C.MD5
+func MD5(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func MD5Bytes(data []byte, md *byte) *byte {
+	return MD5(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func MD5String(data string, md *byte) *byte {
+	return MD5(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}
+
+// OSSL_DEPRECATEDIN_3_0 void MD5_Transform(MD5_CTX *c, const unsigned char *b);
+
+// -----------------------------------------------------------------------------

c/openssl/openssl.go

@@ -0,0 +1,38 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+const (
+	LLGoFiles   = "$(pkg-config --cflags openssl): _wrap/openssl.c"
+	LLGoPackage = "link: $(pkg-config --libs openssl); -lssl -lcrypto"
+)
+
+//go:linkname Free C.opensslFree
+func Free(ptr unsafe.Pointer)
+
+//go:linkname FreeCStr C.opensslFree
+func FreeCStr(ptr *c.Char)
+
+// -----------------------------------------------------------------------------

c/openssl/pem.go

@@ -0,0 +1,37 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+// typedef int (*pem_password_cb)(char *buf, int size, int rwflag, void *userdata);
+//
+// llgo:type C
+type PemPasswordCb func(buf *c.Char, size, rwflag c.Int, userdata unsafe.Pointer) c.Int
+
+// RSA *PEM_read_bio_RSAPrivateKey(BIO *bp, RSA **x, pem_password_cb *cb, void *u);
+//
+//go:linkname PEMReadBioRSAPrivateKey C.PEM_read_bio_RSAPrivateKey
+func PEMReadBioRSAPrivateKey(bp *BIO, x **RSA, cb PemPasswordCb, u unsafe.Pointer) *RSA
+
+// -----------------------------------------------------------------------------

c/openssl/rand.go

@@ -0,0 +1,80 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+// int RAND_bytes(unsigned char *buf, int num);
+//
+//go:linkname RANDBufferWithLen C.RAND_bytes
+func RANDBufferWithLen(buf *byte, num c.Int) c.Int
+
+func RANDBytes(buf []byte) c.Int {
+	return RANDBufferWithLen(unsafe.SliceData(buf), c.Int(len(buf)))
+}
+
+// int RAND_priv_bytes(unsigned char *buf, int num);
+//
+//go:linkname RANDPrivBufferWithLen C.RAND_priv_bytes
+func RANDPrivBufferWithLen(buf *byte, num c.Int) c.Int
+
+func RANDPrivBytes(buf []byte) c.Int {
+	return RANDPrivBufferWithLen(unsafe.SliceData(buf), c.Int(len(buf)))
+}
+
+// void RAND_seed(const void *buf, int num);
+//
+//go:linkname RANDSeed C.RAND_seed
+func RANDSeed(buf unsafe.Pointer, num c.Int)
+
+// void RAND_keep_random_devices_open(int keep);
+//
+//go:linkname RANDKeepRandomDevicesOpen C.RAND_keep_random_devices_open
+func RANDKeepRandomDevicesOpen(keep c.Int)
+
+// int RAND_load_file(const char *file, long max_bytes);
+//
+//go:linkname RANDLoadFile C.RAND_load_file
+func RANDLoadFile(file *c.Char, maxBytes c.Long) c.Int
+
+// int RAND_write_file(const char *file);
+//
+//go:linkname RANDWriteFile C.RAND_write_file
+func RANDWriteFile(file *c.Char) c.Int
+
+// const char *RAND_file_name(char *file, size_t num);
+//
+//go:linkname RANDFileName C.RAND_file_name
+func RANDFileName(file *c.Char, num uintptr) *c.Char
+
+// int RAND_status(void);
+//
+//go:linkname RANDStatus C.RAND_status
+func RANDStatus() c.Int
+
+// int RAND_poll(void);
+//
+//go:linkname RANDPoll C.RAND_poll
+func RANDPoll() c.Int
+
+// -----------------------------------------------------------------------------

c/openssl/rsa.go

@@ -0,0 +1,305 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+type RSA_METHOD struct {
+	Unused [0]byte
+}
+
+// OSSL_DEPRECATEDIN_3_0 RSA_METHOD *RSA_meth_new(const char *name, int flags);
+//
+//go:linkname RSAMethNew C.RSA_meth_new
+func RSAMethNew(name *byte, flags c.Int) *RSA_METHOD
+
+// OSSL_DEPRECATEDIN_3_0 void RSA_meth_free(RSA_METHOD *meth);
+//
+// llgo:link (*RSA_METHOD).Free C.RSA_meth_free
+func (*RSA_METHOD) Free() {}
+
+// OSSL_DEPRECATEDIN_3_0
+// int RSA_meth_set_init(RSA_METHOD *rsa, int (*init) (RSA *rsa));
+//
+// llgo:link (*RSA_METHOD).SetInit C.RSA_meth_set_init
+func (*RSA_METHOD) SetInit(init func(rsa *RSA) c.Int) c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0
+// int RSA_meth_set_finish(RSA_METHOD *rsa, int (*finish) (RSA *rsa));
+//
+// llgo:link (*RSA_METHOD).SetFinish C.RSA_meth_set_finish
+func (*RSA_METHOD) SetFinish(finish func(rsa *RSA) c.Int) c.Int { return 0 }
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_mod_exp(RSA_METHOD *rsa,
+                         int (*mod_exp) (BIGNUM *r0, const BIGNUM *i, RSA *rsa,
+                                         BN_CTX *ctx));
+*/
+// llgo:link (*RSA_METHOD).SetModExp C.RSA_meth_set_mod_exp
+func (*RSA_METHOD) SetModExp(modExp func(
+	r0 *BIGNUM, i *BIGNUM, rsa *RSA, ctx *BN_CTX) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_bn_mod_exp(RSA_METHOD *rsa,
+                            int (*bn_mod_exp) (BIGNUM *r,
+                                               const BIGNUM *a,
+                                               const BIGNUM *p,
+                                               const BIGNUM *m,
+                                               BN_CTX *ctx,
+                                               BN_MONT_CTX *m_ctx));
+//-llgo:link (*RSA_METHOD).SetBnModExp C.RSA_meth_set_bn_mod_exp
+func (*RSA_METHOD) SetBnModExp(bnModExp func(
+	r *BIGNUM, a *BIGNUM, p *BIGNUM, m *BIGNUM, ctx *BN_CTX, mCtx *BN_MONT_CTX) c.Int) c.Int {
+	return 0
+}
+*/
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_pub_enc(RSA_METHOD *rsa,
+                         int (*pub_enc) (int flen, const unsigned char *from,
+                                         unsigned char *to, RSA *rsa,
+                                         int padding));
+*/
+// llgo:link (*RSA_METHOD).SetPubEnc C.RSA_meth_set_pub_enc
+func (*RSA_METHOD) SetPubEnc(pubEnc func(
+	flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_pub_dec(RSA_METHOD *rsa,
+                         int (*pub_dec) (int flen, const unsigned char *from,
+                                         unsigned char *to, RSA *rsa,
+                                         int padding));
+*/
+// llgo:link (*RSA_METHOD).SetPubDec C.RSA_meth_set_pub_dec
+func (*RSA_METHOD) SetPubDec(pubDec func(
+	flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_priv_enc(RSA_METHOD *rsa,
+                          int (*priv_enc) (int flen, const unsigned char *from,
+                                           unsigned char *to, RSA *rsa,
+                                           int padding));
+*/
+// llgo:link (*RSA_METHOD).SetPrivEnc C.RSA_meth_set_priv_enc
+func (*RSA_METHOD) SetPrivEnc(privEnc func(
+	flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_priv_dec(RSA_METHOD *rsa,
+                          int (*priv_dec) (int flen, const unsigned char *from,
+                                           unsigned char *to, RSA *rsa,
+                                           int padding));
+*/
+// llgo:link (*RSA_METHOD).SetPrivDec C.RSA_meth_set_priv_dec
+func (*RSA_METHOD) SetPrivDec(privDec func(
+	flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_sign(RSA_METHOD *rsa,
+                      int (*sign) (int type, const unsigned char *m,
+                                   unsigned int m_length,
+                                   unsigned char *sigret, unsigned int *siglen,
+                                   const RSA *rsa));
+*/
+// llgo:link (*RSA_METHOD).SetSign C.RSA_meth_set_sign
+func (*RSA_METHOD) SetSign(sign func(
+	typ c.Int, msg *byte, mlen c.Uint,
+	sigret *byte, siglen *c.Uint, rsa *RSA) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_verify(RSA_METHOD *rsa,
+                        int (*verify) (int dtype, const unsigned char *m,
+                                       unsigned int m_length,
+                                       const unsigned char *sigbuf,
+                                       unsigned int siglen, const RSA *rsa));
+*/
+// llgo:link (*RSA_METHOD).SetVerify C.RSA_meth_set_verify
+func (*RSA_METHOD) SetVerify(verify func(
+	dtype c.Int, msg *byte, mlen c.Uint,
+	sigbuf *byte, siglen c.Uint, rsa *RSA) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_keygen(RSA_METHOD *rsa,
+                        int (*keygen) (RSA *rsa, int bits, BIGNUM *e,
+                                       BN_GENCB *cb));
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_multi_prime_keygen(RSA_METHOD *meth,
+                                    int (*keygen) (RSA *rsa, int bits,
+                                                   int primes, BIGNUM *e,
+                                                   BN_GENCB *cb));
+*/
+
+// -----------------------------------------------------------------------------
+
+type RSA struct {
+	Unused [0]byte
+}
+
+// OSSL_DEPRECATEDIN_3_0 RSA *RSA_new(void);
+//
+//go:linkname RSANew C.RSA_new
+func RSANew() *RSA
+
+// OSSL_DEPRECATEDIN_3_0 RSA *RSA_new_method(ENGINE *engine);
+
+// OSSL_DEPRECATEDIN_3_0 void RSA_free(RSA *r);
+//
+// llgo:link (*RSA).Free C.RSA_free
+func (*RSA) Free() {}
+
+// "up" the RSA object's reference count
+// OSSL_DEPRECATEDIN_3_0 int RSA_up_ref(RSA *r);
+//
+// llgo:link (*RSA).UpRef C.RSA_up_ref
+func (*RSA) UpRef() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_bits(const RSA *rsa);
+//
+// llgo:link (*RSA).Bits C.RSA_bits
+func (*RSA) Bits() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_size(const RSA *rsa);
+//
+// llgo:link (*RSA).Size C.RSA_size
+func (*RSA) Size() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_security_bits(const RSA *rsa);
+//
+// llgo:link (*RSA).SecurityBits C.RSA_security_bits
+func (*RSA) SecurityBits() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_flags(const RSA *r);
+//
+// llgo:link (*RSA).Flags C.RSA_flags
+func (*RSA) Flags() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 void RSA_set_flags(RSA *r, int flags);
+//
+// llgo:link (*RSA).SetFlags C.RSA_set_flags
+func (*RSA) SetFlags(flags c.Int) {}
+
+// OSSL_DEPRECATEDIN_3_0 void RSA_clear_flags(RSA *r, int flags);
+//
+// llgo:link (*RSA).ClearFlags C.RSA_clear_flags
+func (*RSA) ClearFlags(flags c.Int) {}
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_test_flags(const RSA *r, int flags);
+//
+// llgo:link (*RSA).TestFlags C.RSA_test_flags
+func (*RSA) TestFlags(flags c.Int) c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_get_version(RSA *r);
+//
+// llgo:link (*RSA).GetVersion C.RSA_get_version
+func (*RSA) GetVersion() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_set_ex_data(RSA *r, int idx, void *arg);
+//
+// llgo:link (*RSA).SetExData C.RSA_set_ex_data
+func (*RSA) SetExData(idx c.Int, arg unsafe.Pointer) c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 void *RSA_get_ex_data(const RSA *r, int idx);
+//
+// llgo:link (*RSA).GetExData C.RSA_get_ex_data
+func (*RSA) GetExData(idx c.Int) unsafe.Pointer { return nil }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_set_method(RSA *rsa, const RSA_METHOD *meth);
+//
+// llgo:link (*RSA).SetMethod C.RSA_set_method
+func (*RSA) SetMethod(meth *RSA_METHOD) c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb);
+//
+// llgo:link (*RSA).GenerateKeyEx C.RSA_generate_key_ex
+func (*RSA) GenerateKeyEx(bits c.Int, e *BIGNUM, cb *BN_GENCB) c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_generate_multi_prime_key(RSA *rsa, int bits, int primes, BIGNUM *e, BN_GENCB *cb);
+//
+// llgo:link (*RSA).GenerateMultiPrimeKey C.RSA_generate_multi_prime_key
+func (*RSA) GenerateMultiPrimeKey(bits, primes c.Int, e *BIGNUM, cb *BN_GENCB) c.Int { return 0 }
+
+/*
+// next 4 return -1 on error
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_public_encrypt(int flen, const unsigned char *from, unsigned char *to,
+						RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_private_encrypt(int flen, const unsigned char *from, unsigned char *to,
+						RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_public_decrypt(int flen, const unsigned char *from, unsigned char *to,
+						RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_private_decrypt(int flen, const unsigned char *from, unsigned char *to,
+						RSA *rsa, int padding);
+*/
+//go:linkname RSAPublicEncrypt C.RSA_public_encrypt
+func RSAPublicEncrypt(flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int
+
+//go:linkname RSAPrivateEncrypt C.RSA_private_encrypt
+func RSAPrivateEncrypt(flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int
+
+//go:linkname RSAPublicDecrypt C.RSA_public_decrypt
+func RSAPublicDecrypt(flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int
+
+//go:linkname RSAPrivateDecrypt C.RSA_private_decrypt
+func RSAPrivateDecrypt(flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_sign(
+// int type, const unsigned char *m, unsigned int m_length,
+// unsigned char *sigret, unsigned int *siglen, RSA *rsa);
+//
+//go:linkname RSASign C.RSA_sign
+func RSASign(typ c.Int, msg *byte, mlen c.Uint, sigret *byte, siglen *c.Uint, rsa *RSA) c.Int
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_verify(int type, const unsigned char *m,
+//	  unsigned int m_length,
+//	  const unsigned char *sigbuf,
+//	  unsigned int siglen, RSA *rsa);
+
+// -----------------------------------------------------------------------------

c/openssl/sha1.go

@@ -0,0 +1,94 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	SHA_DIGEST_LENGTH = 20
+	SHA_LBLOCK        = 16
+	SHA_CBLOCK        = (SHA_LBLOCK * 4)
+	SHA_LAST_BLOCK    = (SHA_CBLOCK - 8)
+
+	SHA256_CBLOCK            = (SHA_LBLOCK * 4)
+	SHA256_192_DIGEST_LENGTH = 24
+	SHA224_DIGEST_LENGTH     = 28
+	SHA256_DIGEST_LENGTH     = 32
+	SHA384_DIGEST_LENGTH     = 48
+	SHA512_DIGEST_LENGTH     = 64
+	SHA512_CBLOCK            = (SHA_LBLOCK * 8)
+)
+
+type SHA_LONG64 = c.UlongLong
+
+type SHA_LONG = c.Uint
+
+type SHA_CTX struct {
+	H0, H1, H2, H3, H4 SHA_LONG
+	Nl, Nh             SHA_LONG
+	Data               [SHA_LBLOCK]SHA_LONG
+	Num                c.Uint
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA1_Init(SHA_CTX *c);
+//
+// llgo:link (*SHA_CTX).Init C.SHA1_Init
+func (c *SHA_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA1_Update(SHA_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA_CTX).Update C.SHA1_Update
+func (c *SHA_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *SHA_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *SHA_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA1_Final(unsigned char *md, SHA_CTX *c);
+//
+//go:linkname sha1Final C.SHA1_Final
+func sha1Final(md *byte, c *SHA_CTX) c.Int
+
+func (c *SHA_CTX) Final(md *byte) c.Int {
+	return sha1Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
+//
+// llgo:link (*SHA_CTX).Transform C.SHA1_Transform
+func (c *SHA_CTX) Transform(data *byte) {}
+
+// unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA1 C.SHA1
+func SHA1(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA1Bytes(data []byte, md *byte) *byte {
+	return SHA1(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA1String(data string, md *byte) *byte {
+	return SHA1(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}

c/openssl/sha256.go

@@ -0,0 +1,117 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+type SHA256_CTX struct {
+	H          [8]SHA_LONG
+	Nl, Nh     SHA_LONG
+	Data       [SHA_LBLOCK]SHA_LONG
+	Num, MdLen c.Uint
+}
+
+type SHA224_CTX SHA256_CTX
+
+// OSSL_DEPRECATEDIN_3_0 int SHA224_Init(SHA256_CTX *c);
+//
+// llgo:link (*SHA224_CTX).Init C.SHA224_Init
+func (c *SHA224_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA224_Update(SHA256_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA224_CTX).Update C.SHA224_Update
+func (c *SHA224_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *SHA224_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *SHA224_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA224_Final(unsigned char *md, SHA256_CTX *c);
+//
+//go:linkname sha224Final C.SHA224_Final
+func sha224Final(md *byte, c *SHA224_CTX) c.Int
+
+func (c *SHA224_CTX) Final(md *byte) c.Int {
+	return sha224Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA256_Init(SHA256_CTX *c);
+//
+// llgo:link (*SHA256_CTX).Init C.SHA256_Init
+func (c *SHA256_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA256_Update(SHA256_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA256_CTX).Update C.SHA256_Update
+func (c *SHA256_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *SHA256_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *SHA256_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA256_Final(unsigned char *md, SHA256_CTX *c);
+//
+//go:linkname sha256Final C.SHA256_Final
+func sha256Final(md *byte, c *SHA256_CTX) c.Int
+
+func (c *SHA256_CTX) Final(md *byte) c.Int {
+	return sha256Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 void SHA256_Transform(SHA256_CTX *c, const unsigned char *data);
+//
+// llgo:link (*SHA256_CTX).Transform C.SHA256_Transform
+func (c *SHA256_CTX) Transform(data *byte) {}
+
+// unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA224 C.SHA224
+func SHA224(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA224Bytes(data []byte, md *byte) *byte {
+	return SHA224(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA224String(data string, md *byte) *byte {
+	return SHA224(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}
+
+// unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA256 C.SHA256
+func SHA256(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA256Bytes(data []byte, md *byte) *byte {
+	return SHA256(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA256String(data string, md *byte) *byte {
+	return SHA256(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}

c/openssl/sha512.go

@@ -0,0 +1,115 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+type SHA512_CTX struct {
+	H          [8]SHA_LONG64
+	N1, Nh     SHA_LONG64
+	D          [SHA_LBLOCK]SHA_LONG64
+	Num, MdLen c.Uint
+}
+
+type SHA384_CTX SHA512_CTX
+
+// OSSL_DEPRECATEDIN_3_0 int SHA384_Init(SHA512_CTX *c);
+//
+// llgo:link (*SHA384_CTX).Init C.SHA384_Init
+func (c *SHA384_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA384_Update(SHA512_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA384_CTX).Update C.SHA384_Update
+func (c *SHA384_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *SHA384_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *SHA384_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA384_Final(unsigned char *md, SHA512_CTX *c);
+//
+//go:linkname sha384Final C.SHA384_Final
+func sha384Final(md *byte, c *SHA384_CTX) c.Int
+
+func (c *SHA384_CTX) Final(md *byte) c.Int {
+	return sha384Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA512_Init(SHA512_CTX *c);
+//
+// llgo:link (*SHA512_CTX).Init C.SHA512_Init
+func (c *SHA512_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA512_Update(SHA512_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA512_CTX).Update C.SHA512_Update
+func (c *SHA512_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+func (c *SHA512_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+func (c *SHA512_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA512_Final(unsigned char *md, SHA512_CTX *c);
+//
+//go:linkname sha512Final C.SHA512_Final
+func sha512Final(md *byte, c *SHA512_CTX) c.Int
+
+func (c *SHA512_CTX) Final(md *byte) c.Int {
+	return sha512Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 void SHA512_Transform(SHA512_CTX *c, const unsigned char *data);
+//
+// llgo:link (*SHA512_CTX).Transform C.SHA512_Transform
+func (c *SHA512_CTX) Transform(data *byte) {}
+
+// unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA384 C.SHA384
+func SHA384(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA384Bytes(data []byte, md *byte) *byte {
+	return SHA384(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA384String(data string, md *byte) *byte {
+	return SHA384(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}
+
+// unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA512 C.SHA512
+func SHA512(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA512Bytes(data []byte, md *byte) *byte {
+	return SHA512(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA512String(data string, md *byte) *byte {
+	return SHA512(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}

c/os/_os/os.c

@@ -0,0 +1,9 @@
+#include <stdlib.h>
+
+int llgoClearenv() {
+	extern char **environ;
+	if (environ != NULL) {
+		*environ = NULL;
+	}
+	return 0;
+}

c/os/os.go

@@ -27,10 +27,6 @@ import (
 	"github.com/goplus/llgo/c/syscall"
 )
 
-const (
-	LLGoPackage = "decl"
-)
-
 const (
 	PATH_MAX = C.PATH_MAX
 )
@@ -150,9 +146,6 @@ func Putenv(env *c.Char) c.Int
 //go:linkname Unsetenv C.unsetenv
 func Unsetenv(name *c.Char) c.Int
 
-//go:linkname Clearenv C.clearenv
-func Clearenv()
-
 // -----------------------------------------------------------------------------
 
 //go:linkname Fchdir C.fchdir

c/os/os_linux.go

@@ -0,0 +1,28 @@
+//go:build linux
+
+/*
+ * 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 os
+
+import "C"
+
+const (
+	LLGoPackage = "decl"
+)
+
+//go:linkname Clearenv C.clearenv
+func Clearenv()

c/os/os_other.go

@@ -0,0 +1,29 @@
+//go:build !linux
+
+/*
+ * 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 os
+
+import "C"
+
+const (
+	LLGoFiles   = "_os/os.c"
+	LLGoPackage = "link"
+)
+
+//go:linkname Clearenv C.llgoClearenv
+func Clearenv()

c/pthread/sync/_pthd/pthd.c

@@ -5,3 +5,15 @@
 pthread_once_t llgoSyncOnceInitVal = PTHREAD_ONCE_INIT;
 
 // -----------------------------------------------------------------------------
+
+// wrap return type to void
+void wrap_pthread_mutex_lock(pthread_mutex_t *mutex) {
+    pthread_mutex_lock(mutex);
+}
+
+// wrap return type to void
+void wrap_pthread_mutex_unlock(pthread_mutex_t *mutex) {
+    pthread_mutex_unlock(mutex);
+}
+
+// -----------------------------------------------------------------------------

c/pthread/sync/sync.go

@@ -76,18 +76,14 @@ func (m *Mutex) Init(attr *MutexAttr) c.Int { return 0 }
 // llgo:link (*Mutex).Destroy C.pthread_mutex_destroy
 func (m *Mutex) Destroy() {}
 
-func (m *Mutex) Lock() { m.lockInternal() }
-
-// llgo:link (*Mutex).lockInternal C.pthread_mutex_lock
-func (m *Mutex) lockInternal() c.Int { return 0 }
-
 // llgo:link (*Mutex).TryLock C.pthread_mutex_trylock
 func (m *Mutex) TryLock() c.Int { return 0 }
 
-func (m *Mutex) Unlock() { m.unlockInternal() }
+// llgo:link (*Mutex).Lock C.wrap_pthread_mutex_lock
+func (m *Mutex) Lock() {}
 
-// llgo:link (*Mutex).unlockInternal C.pthread_mutex_unlock
-func (m *Mutex) unlockInternal() c.Int { return 0 }
+// llgo:link (*Mutex).Unlock C.wrap_pthread_mutex_unlock
+func (m *Mutex) Unlock() {}
 
 // -----------------------------------------------------------------------------
 

c/setjmp/setjmp.go

@@ -44,9 +44,6 @@ func Longjmp(env *JmpBuf, val c.Int)
 
 // -----------------------------------------------------------------------------
 
-//go:linkname Sigsetjmp C.sigsetjmp
-func Sigsetjmp(env *SigjmpBuf, savemask c.Int) c.Int
-
 //go:linkname Siglongjmp C.siglongjmp
 func Siglongjmp(env *SigjmpBuf, val c.Int)
 

c/setjmp/setjmp_linux.go

@@ -0,0 +1,12 @@
+//go:build linux
+
+package setjmp
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+//go:linkname Sigsetjmp C.__sigsetjmp
+func Sigsetjmp(env *SigjmpBuf, savemask c.Int) c.Int

c/setjmp/setjmp_other.go

@@ -0,0 +1,12 @@
+//go:build !linux
+
+package setjmp
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+//go:linkname Sigsetjmp C.sigsetjmp
+func Sigsetjmp(env *SigjmpBuf, savemask c.Int) c.Int

c/syscall/syscall.go

@@ -17,7 +17,7 @@
 package syscall
 
 const (
-	LLGoPackage = "decl"
+	LLGoPackage = "noinit"
 )
 
 type Errno = uintptr
@@ -25,3 +25,8 @@ type Errno = uintptr
 // A Signal is a number describing a process signal.
 // It implements the os.Signal interface.
 type Signal = int
+
+// Unix returns the time stored in ts as seconds plus nanoseconds.
+func (ts *Timespec) Unix() (sec int64, nsec int64) {
+	return int64(ts.Sec), int64(ts.Nsec)
+}

c/zlib/_demo/crc32demo/crc.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/goplus/llgo/c/zlib"
+)
+
+func main() {
+	fmt.Printf("%08x\n", zlib.Crc32ZString(0, "Hello world"))
+}

c/zlib/zlib.go

@@ -17,7 +17,7 @@
 package zlib
 
 import (
-	_ "unsafe"
+	"unsafe"
 
 	"github.com/goplus/llgo/c"
 )
@@ -76,17 +76,185 @@ const (
 	DEFLATED = 8
 )
 
+// -----------------------------------------------------------------------------
+
+/*
+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+
+compressBound() returns an upper bound on the compressed size after
+compress() or compress2() on sourceLen bytes.  It would be used before a
+compress() or compress2() call to allocate the destination buffer.
+*/
 //go:linkname CompressBound C.compressBound
 func CompressBound(sourceLen c.Ulong) c.Ulong
 
+/*
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+	const Bytef *source, uLong sourceLen));
+
+Compresses the source buffer into the destination buffer.  sourceLen is
+the byte length of the source buffer.  Upon entry, destLen is the total size
+of the destination buffer, which must be at least the value returned by
+compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+compressed data.  compress() is equivalent to compress2() with a level
+parameter of Z_DEFAULT_COMPRESSION.
+
+compress returns Z_OK if success, Z_MEM_ERROR if there was not
+enough memory, Z_BUF_ERROR if there was not enough room in the output
+buffer.
+*/
 //go:linkname Compress C.compress
 func Compress(dest *byte, destLen *c.Ulong, source *byte, sourceLen c.Ulong) c.Int
 
+/*
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+	const Bytef *source, uLong sourceLen, int level));
+
+Compresses the source buffer into the destination buffer.  The level
+parameter has the same meaning as in deflateInit.  sourceLen is the byte
+length of the source buffer.  Upon entry, destLen is the total size of the
+destination buffer, which must be at least the value returned by
+compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+compressed data.
+
+compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+Z_STREAM_ERROR if the level parameter is invalid.
+*/
 //go:linkname Compress2 C.compress2
 func Compress2(dest *byte, destLen *c.Ulong, source *byte, sourceLen c.Ulong, level c.Int) c.Int
 
+/*
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+	const Bytef *source, uLong sourceLen));
+
+Decompresses the source buffer into the destination buffer.  sourceLen is
+the byte length of the source buffer.  Upon entry, destLen is the total size
+of the destination buffer, which must be large enough to hold the entire
+uncompressed data.  (The size of the uncompressed data must have been saved
+previously by the compressor and transmitted to the decompressor by some
+mechanism outside the scope of this compression library.) Upon exit, destLen
+is the actual size of the uncompressed data.
+
+uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+enough memory, Z_BUF_ERROR if there was not enough room in the output
+buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.  In
+the case where there is not enough room, uncompress() will fill the output
+buffer with the uncompressed data up to that point.
+*/
 //go:linkname Uncompress C.uncompress
 func Uncompress(dest *byte, destLen *c.Ulong, source *byte, sourceLen c.Ulong) c.Int
 
+/*
+ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest,   uLongf *destLen,
+	const Bytef *source, uLong *sourceLen));
+
+Same as uncompress, except that sourceLen is a pointer, where the
+length of the source is *sourceLen.  On return, *sourceLen is the number of
+source bytes consumed.
+*/
 //go:linkname Uncompress2 C.uncompress2
 func Uncompress2(dest *byte, destLen *c.Ulong, source *byte, sourceLen *c.Ulong) c.Int
+
+// -----------------------------------------------------------------------------
+
+/*
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+
+Update a running CRC-32 with the bytes buf[0..len-1] and return the
+updated CRC-32.  If buf is Z_NULL, this function returns the required
+initial value for the crc.  Pre- and post-conditioning (one's complement) is
+performed within this function so it shouldn't be done by the application.
+
+Usage example:
+
+	uLong crc = crc32(0L, Z_NULL, 0);
+
+	while (read_buffer(buffer, length) != EOF) {
+	crc = crc32(crc, buffer, length);
+	}
+	if (crc != original_crc) error();
+*/
+//go:linkname Crc32 C.crc32
+func Crc32(crc c.Ulong, buf *byte, len c.Uint) c.Ulong
+
+/*
+ZEXTERN uLong ZEXPORT crc32_z OF((uLong adler, const Bytef *buf, z_size_t len));
+
+Same as crc32(), but with a size_t length.
+*/
+//go:linkname Crc32Z C.crc32_z
+func Crc32Z(crc c.Ulong, buf *byte, len uintptr) c.Ulong
+
+func Crc32ZBytes(crc c.Ulong, buf []byte) c.Ulong {
+	return Crc32Z(crc, unsafe.SliceData(buf), uintptr(len(buf)))
+}
+
+func Crc32ZString(crc c.Ulong, buf string) c.Ulong {
+	return Crc32Z(crc, unsafe.StringData(buf), uintptr(len(buf)))
+}
+
+/*
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+Combine two CRC-32 check values into one.  For two sequences of bytes,
+seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
+check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+len2.
+*/
+//go:linkname Crc32Combine C.crc32_combine
+func Crc32Combine(crc1 c.Ulong, crc2 c.Ulong, len2 int64) c.Ulong
+
+/*
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+
+Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+return the updated checksum.  If buf is Z_NULL, this function returns the
+required initial value for the checksum.
+
+An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed
+much faster.
+
+Usage example:
+
+	uLong adler = adler32(0L, Z_NULL, 0);
+
+	while (read_buffer(buffer, length) != EOF) {
+	adler = adler32(adler, buffer, length);
+	}
+	if (adler != original_adler) error();
+*/
+//go:linkname Adler32 C.adler32
+func Adler32(adler c.Ulong, buf *byte, len c.Uint) c.Ulong
+
+/*
+ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf, z_size_t len));
+
+Same as adler32(), but with a size_t length.
+*/
+//go:linkname Adler32Z C.adler32_z
+func Adler32Z(adler c.Ulong, buf *byte, len uintptr) c.Ulong
+
+func Adler32ZBytes(adler c.Ulong, buf []byte) c.Ulong {
+	return Adler32Z(adler, unsafe.SliceData(buf), uintptr(len(buf)))
+}
+
+func Adler32ZString(adler c.Ulong, buf string) c.Ulong {
+	return Adler32Z(adler, unsafe.StringData(buf), uintptr(len(buf)))
+}
+
+/*
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, z_off_t len2));
+
+Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
+and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.  Note
+that the z_off_t type (like off_t) is a signed integer.  If len2 is
+negative, the result has no meaning or utility.
+*/
+//go:linkname Adler32Combine C.adler32_combine
+func Adler32Combine(adler1 c.Ulong, adler2 c.Ulong, len2 int64) c.Ulong
+
+// -----------------------------------------------------------------------------

chore/_xtool/llcppsymg/config/config.go

@@ -0,0 +1,60 @@
+package config
+
+import (
+	"errors"
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/cjson"
+	"github.com/goplus/llgo/chore/llcppg/types"
+)
+
+type Conf struct {
+	*cjson.JSON
+	*types.Config
+}
+
+func GetConf(data []byte) (Conf, error) {
+	parsedConf := cjson.ParseBytes(data)
+	if parsedConf == nil {
+		return Conf{}, errors.New("failed to parse config")
+	}
+
+	config := &types.Config{
+		Name:         GetStringItem(parsedConf, "name", ""),
+		CFlags:       GetStringItem(parsedConf, "cflags", ""),
+		Libs:         GetStringItem(parsedConf, "libs", ""),
+		Include:      GetStringArrayItem(parsedConf, "include"),
+		TrimPrefixes: GetStringArrayItem(parsedConf, "trimPrefixes"),
+	}
+
+	return Conf{
+		JSON:   parsedConf,
+		Config: config,
+	}, nil
+}
+
+func GetString(obj *cjson.JSON) (value string) {
+	str := obj.GetStringValue()
+	return unsafe.String((*byte)(unsafe.Pointer(str)), c.Strlen(str))
+}
+
+func GetStringItem(obj *cjson.JSON, key string, defval string) (value string) {
+	item := obj.GetObjectItemCaseSensitive(c.AllocaCStr(key))
+	if item == nil {
+		return defval
+	}
+	return GetString(item)
+}
+
+func GetStringArrayItem(obj *cjson.JSON, key string) (value []string) {
+	item := obj.GetObjectItemCaseSensitive(c.AllocaCStr(key))
+	if item == nil {
+		return
+	}
+	value = make([]string, item.GetArraySize())
+	for i := range value {
+		value[i] = GetString(item.GetArrayItem(c.Int(i)))
+	}
+	return
+}

chore/_xtool/llcppsymg/llcppsymg.go

@@ -17,12 +17,22 @@
 package main
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"unsafe"
 
 	"github.com/goplus/llgo/c"
 	"github.com/goplus/llgo/c/cjson"
+	"github.com/goplus/llgo/chore/_xtool/llcppsymg/config"
+	"github.com/goplus/llgo/chore/_xtool/llcppsymg/parse"
+	"github.com/goplus/llgo/chore/llcppg/types"
+	"github.com/goplus/llgo/cpp/llvm"
+	"github.com/goplus/llgo/xtool/nm"
 )
 
 func main() {
@@ -40,14 +50,25 @@ func main() {
 	}
 	check(err)
 
-	conf := cjson.ParseBytes(data)
-	if conf == nil {
-		fmt.Fprintln(os.Stderr, "Failed to parse config file:", cfgFile)
-		os.Exit(1)
-	}
+	conf, err := config.GetConf(data)
+	check(err)
 	defer conf.Delete()
 
-	c.Printf(c.Str("%s"), conf.Print())
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "Failed to parse config file:", cfgFile)
+	}
+	symbols, err := parseDylibSymbols(conf.Libs)
+
+	check(err)
+
+	filepaths := generateHeaderFilePath(conf.CFlags, conf.Include)
+	astInfos, err := parse.ParseHeaderFile(filepaths)
+	check(err)
+
+	symbolInfo := getCommonSymbols(symbols, astInfos, conf.TrimPrefixes)
+
+	err = genSymbolTableFile(symbolInfo)
+	check(err)
 }
 
 func check(err error) {
@@ -55,3 +76,230 @@ func check(err error) {
 		panic(err)
 	}
 }
+
+func parseDylibSymbols(lib string) ([]types.CPPSymbol, error) {
+	dylibPath, err := generateDylibPath(lib)
+	if err != nil {
+		return nil, errors.New("failed to generate dylib path")
+	}
+
+	files, err := nm.New("").List(dylibPath)
+	if err != nil {
+		return nil, errors.New("failed to list symbols in dylib")
+	}
+
+	var symbols []types.CPPSymbol
+
+	for _, file := range files {
+		for _, sym := range file.Symbols {
+			demangleName := decodeSymbolName(sym.Name)
+			symbols = append(symbols, types.CPPSymbol{
+				Symbol:       sym,
+				DemangleName: demangleName,
+			})
+		}
+	}
+
+	return symbols, nil
+}
+
+func generateDylibPath(lib string) (string, error) {
+	output := lib
+	libPath := ""
+	libName := ""
+	for _, part := range strings.Fields(string(output)) {
+		if strings.HasPrefix(part, "-L") {
+			libPath = part[2:]
+		} else if strings.HasPrefix(part, "-l") {
+			libName = part[2:]
+		}
+	}
+
+	if libPath == "" || libName == "" {
+		return "", fmt.Errorf("failed to parse pkg-config output: %s", output)
+	}
+
+	dylibPath := filepath.Join(libPath, "lib"+libName+".dylib")
+	return dylibPath, nil
+}
+
+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)
+	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 generateHeaderFilePath(cflags string, files []string) []string {
+	prefixPath := cflags
+	prefixPath = strings.TrimPrefix(prefixPath, "-I")
+	var includePaths []string
+	for _, file := range files {
+		includePaths = append(includePaths, filepath.Join(prefixPath, "/"+file))
+	}
+	return includePaths
+}
+
+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
+			}
+		}
+	}
+
+	return commonSymbols
+}
+
+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)
+	}
+
+	fileName := "llcppg.symb.json"
+	existingSymbols, err := readExistingSymbolTable(fileName)
+	if err != nil {
+		return err
+	}
+
+	for i := range symbolInfos {
+		if existingSymbol, exists := existingSymbols[symbolInfos[i].Mangle]; exists {
+			symbolInfos[i].Go = existingSymbol.Go
+		}
+	}
+
+	root := cjson.Array()
+	defer root.Delete()
+
+	for _, symbol := range symbolInfos {
+		item := cjson.Object()
+		item.SetItem(c.Str("mangle"), cjson.String(c.AllocaCStr(symbol.Mangle)))
+		item.SetItem(c.Str("c++"), cjson.String(c.AllocaCStr(symbol.CPP)))
+		item.SetItem(c.Str("go"), cjson.String(c.AllocaCStr(symbol.Go)))
+		root.AddItem(item)
+	}
+
+	cStr := root.Print()
+	if cStr == nil {
+		return errors.New("symbol table is empty")
+	}
+	defer c.Free(unsafe.Pointer(cStr))
+
+	data := unsafe.Slice((*byte)(unsafe.Pointer(cStr)), c.Strlen(cStr))
+
+	if err := os.WriteFile(fileName, data, 0644); err != nil {
+		return errors.New("failed to write symbol table file")
+	}
+	return nil
+}
+func readExistingSymbolTable(fileName string) (map[string]types.SymbolInfo, error) {
+	existingSymbols := make(map[string]types.SymbolInfo)
+
+	if _, err := os.Stat(fileName); err != nil {
+		return existingSymbols, nil
+	}
+
+	data, err := os.ReadFile(fileName)
+	if err != nil {
+		return nil, errors.New("failed to read symbol table file")
+	}
+
+	parsedJSON := cjson.ParseBytes(data)
+	if parsedJSON == nil {
+		return nil, errors.New("failed to parse JSON")
+	}
+
+	arraySize := parsedJSON.GetArraySize()
+
+	for i := 0; i < int(arraySize); i++ {
+		item := parsedJSON.GetArrayItem(c.Int(i))
+		if item == nil {
+			continue
+		}
+		symbol := types.SymbolInfo{
+			Mangle: config.GetStringItem(item, "mangle", ""),
+			CPP:    config.GetStringItem(item, "c++", ""),
+			Go:     config.GetStringItem(item, "go", ""),
+		}
+		existingSymbols[symbol.Mangle] = symbol
+	}
+
+	return existingSymbols, nil
+}

chore/_xtool/llcppsymg/parse/parse.go

@@ -0,0 +1,153 @@
+package parse
+
+import (
+	"errors"
+	"strconv"
+	"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
+	astInfo       []types.ASTInformation
+	currentFile   string
+}
+
+func newContext() *Context {
+	return &Context{
+		astInfo: make([]types.ASTInformation, 0),
+	}
+}
+
+func (c *Context) setNamespaceName(name string) {
+	c.namespaceName = name
+}
+
+func (c *Context) setClassName(name string) {
+	c.className = name
+}
+
+func (c *Context) setCurrentFile(filename string) {
+	c.currentFile = filename
+}
+
+var context = newContext()
+
+func collectFuncInfo(cursor clang.Cursor) types.ASTInformation {
+
+	info := types.ASTInformation{
+		Namespace: context.namespaceName,
+		Class:     context.className,
+	}
+
+	cursorStr := cursor.String()
+	symbol := cursor.Mangling()
+
+	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()
+
+	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.Namespace {
+		nameStr := cursor.String()
+		context.setNamespaceName(c.GoString(nameStr.CStr()))
+		clang.VisitChildren(cursor, visit, nil)
+		context.setNamespaceName("")
+	} 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.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
+
+		loc.SpellingLocation(&file, &line, &column, nil)
+		filename := file.FileName()
+
+		if c.Strcmp(filename.CStr(), c.AllocaCStr(context.currentFile)) == 0 {
+			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()
+	}
+
+	return clang.ChildVisit_Continue
+}
+
+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()
+
+	for _, filename := range filepaths {
+		unit := index.ParseTranslationUnit(
+			c.AllocaCStr(filename),
+			unsafe.SliceData(args), 3,
+			nil, 0,
+			clang.TranslationUnit_None,
+		)
+
+		if unit == nil {
+			return nil, errors.New("Unable to parse translation unit for file " + filename)
+		}
+
+		cursor := unit.Cursor()
+		context.setCurrentFile(filename)
+
+		clang.VisitChildren(cursor, visit, nil)
+
+		unit.Dispose()
+	}
+
+	index.Dispose()
+
+	return context.astInfo, nil
+}

chore/llcppg/ast/ast.go

@@ -0,0 +1,268 @@
+/*
+ * 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 ast
+
+// =============================================================================
+
+type Node interface {
+}
+
+type Expr interface {
+	Node
+	exprNode()
+}
+
+type Decl interface {
+	Node
+	declNode()
+}
+
+type Stmt interface {
+	Node
+	stmtNode()
+}
+
+// =============================================================================
+// Expressions (Types are also expressions)
+
+type TypeKind uint
+
+const (
+	Int TypeKind = iota
+	Char
+	Float
+	Complex
+	Bool
+)
+
+type TypeFlag uint
+
+const (
+	Signed TypeFlag = 1 << iota
+	Unsigned
+	Long
+	LongLong
+	Double
+	Short
+)
+
+// [signed/unsigned/short/long/long long/double] [int]/char/float/complex/bool
+type BuiltinType struct {
+	Kind  TypeKind
+	Flags TypeFlag
+}
+
+func (*BuiltinType) exprNode() {}
+
+// ------------------------------------------------
+
+// Name
+type Ident struct {
+	Name string
+}
+
+func (*Ident) exprNode() {}
+
+// ------------------------------------------------
+
+type Tag int
+
+const (
+	Struct Tag = iota
+	Union
+	Enum
+	Class
+)
+
+// struct/union/enum/class Name
+type TagExpr struct {
+	Tag  Tag
+	Name *Ident
+}
+
+func (*TagExpr) exprNode() {}
+
+// ------------------------------------------------
+
+// (X)
+type ParenExpr struct {
+	X Expr
+}
+
+func (*ParenExpr) exprNode() {}
+
+// ------------------------------------------------
+
+// Parent::X
+type ScopingExpr struct {
+	Parent Expr
+	X      Expr
+}
+
+func (*ScopingExpr) exprNode() {}
+
+// ------------------------------------------------
+
+// X*
+type PointerType struct {
+	X Expr
+}
+
+func (*PointerType) exprNode() {}
+
+// ------------------------------------------------
+
+// X&
+type ReferenceType struct {
+	X Expr
+}
+
+func (*ReferenceType) exprNode() {}
+
+// ------------------------------------------------
+
+// Elt[Len]
+// Elt[]
+type ArrayType struct {
+	Elt Expr
+	Len Expr // optional
+}
+
+func (*ArrayType) exprNode() {}
+
+// ------------------------------------------------
+
+type Comment struct {
+	Text string // comment text (excluding '\n' for //-style comments)
+}
+
+func (*Comment) exprNode() {}
+
+type CommentGroup struct {
+	List []*Comment // len(List) > 0
+}
+
+func (*CommentGroup) exprNode() {}
+
+// ------------------------------------------------
+
+type Field struct {
+	Doc     *CommentGroup // associated documentation; or nil
+	Type    Expr          // field/method/parameter type; or nil
+	Names   []*Ident      // field/method/(type) parameter names; or nil
+	Comment *CommentGroup // line comments; or nil
+}
+
+func (*Field) exprNode() {}
+
+type FieldList struct {
+	List []*Field // field list; or nil
+}
+
+func (*FieldList) exprNode() {}
+
+// ------------------------------------------------
+
+// Ret (*)(Params)
+type FuncType struct {
+	Params *FieldList
+	Ret    Expr
+}
+
+func (*FuncType) exprNode() {}
+
+// ------------------------------------------------
+
+// Template<Arg1, Arg2, ...>
+type InstantiationType struct {
+	Template Expr
+	Args     *FieldList
+}
+
+func (*InstantiationType) exprNode() {}
+
+// =============================================================================
+// Declarations
+
+type Location struct {
+	File string
+}
+
+type DeclBase struct {
+	Doc    *CommentGroup // associated documentation; or nil
+	Loc    *Location
+	Parent Expr // namespace or class
+}
+
+// ------------------------------------------------
+
+// typedef Type Name;
+type TypedefDecl struct {
+	DeclBase
+	Type Expr
+	Name *Ident
+}
+
+func (*TypedefDecl) declNode() {}
+
+// ------------------------------------------------
+
+type EnumItem struct {
+	Name  *Ident
+	Value Expr // optional
+}
+
+// enum Name { Item1, Item2, ... };
+type EnumTypeDecl struct {
+	DeclBase
+	Name  *Ident
+	Items []*EnumItem
+}
+
+func (*EnumTypeDecl) declNode() {}
+
+// ------------------------------------------------
+
+// Ret Name(Params);
+type FuncDecl struct {
+	DeclBase
+	Name *Ident
+	Type *FuncType
+}
+
+func (*FuncDecl) declNode() {}
+
+// ------------------------------------------------
+
+// struct/union/class Name { Field1, Field2, ... };
+type TypeDecl struct {
+	DeclBase
+	Tag     Tag
+	Fields  *FieldList
+	Methods []*FuncDecl
+}
+
+func (*TypeDecl) declNode() {}
+
+// =============================================================================
+// AST File
+
+type File struct {
+	Decls []Decl
+}
+
+// =============================================================================

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"`
@@ -24,3 +28,30 @@ type Config struct {
 	Include      []string `json:"include"`
 	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
+	Go     string `json:"go"`     // Go function name
+}

chore/nmindex/nmindex.go

@@ -21,7 +21,7 @@ import (
 	"os"
 
 	"github.com/goplus/llgo/xtool/env/llvm"
-	"github.com/goplus/llgo/xtool/nm"
+	"github.com/goplus/llgo/xtool/nm/nmindex"
 )
 
 func main() {
@@ -58,7 +58,7 @@ func makeIndex() {
 	idxDir := indexDir()
 	os.MkdirAll(idxDir, 0755)
 
-	b := nm.NewIndexBuilder(env.Nm())
+	b := nmindex.NewIndexBuilder(env.Nm())
 	libDirs := []string{
 		usrLib(false),
 		usrLib(true),
@@ -78,7 +78,7 @@ func query(q string) {
 			q = "_" + q
 		}
 	}
-	files, err := nm.Query(indexDir(), q)
+	files, err := nmindex.Query(indexDir(), q)
 	check(err)
 	for _, f := range files {
 		fmt.Printf("%s:\n", f.ArFile)

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/closure/out.ll

@@ -2,6 +2,7 @@
 source_filename = "main"
 
 %"github.com/goplus/llgo/internal/runtime.String" = type { ptr, i64 }
+%main.T = type { ptr, ptr }
 
 @"main.init$guard" = global i1 false, align 1
 @__llgo_argc = global i32 0, align 4
@@ -37,12 +38,12 @@ _llgo_0:
   store i64 3, ptr %5, align 4
   %6 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %3, align 8
   store %"github.com/goplus/llgo/internal/runtime.String" %6, ptr %2, align 8
-  %7 = alloca { ptr, ptr }, align 8
-  %8 = getelementptr inbounds { ptr, ptr }, ptr %7, i32 0, i32 0
+  %7 = alloca %main.T, align 8
+  %8 = getelementptr inbounds %main.T, ptr %7, i32 0, i32 0
   store ptr @"__llgo_stub.main.main$1", ptr %8, align 8
-  %9 = getelementptr inbounds { ptr, ptr }, ptr %7, i32 0, i32 1
+  %9 = getelementptr inbounds %main.T, ptr %7, i32 0, i32 1
   store ptr null, ptr %9, align 8
-  %10 = load { ptr, ptr }, ptr %7, align 8
+  %10 = load %main.T, ptr %7, align 8
   %11 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
   %12 = getelementptr inbounds { ptr }, ptr %11, i32 0, i32 0
   store ptr %2, ptr %12, align 8
@@ -52,12 +53,15 @@ _llgo_0:
   %15 = getelementptr inbounds { ptr, ptr }, ptr %13, i32 0, i32 1
   store ptr %11, ptr %15, align 8
   %16 = load { ptr, ptr }, ptr %13, align 8
-  %17 = extractvalue { ptr, ptr } %10, 1
-  %18 = extractvalue { ptr, ptr } %10, 0
-  call void %18(ptr %17, i64 100)
-  %19 = extractvalue { ptr, ptr } %16, 1
-  %20 = extractvalue { ptr, ptr } %16, 0
-  call void %20(ptr %19, i64 200)
+  %17 = alloca %main.T, align 8
+  store { ptr, ptr } %16, ptr %17, align 8
+  %18 = load %main.T, ptr %17, align 8
+  %19 = extractvalue %main.T %10, 1
+  %20 = extractvalue %main.T %10, 0
+  call void %20(ptr %19, i64 100)
+  %21 = extractvalue %main.T %18, 1
+  %22 = extractvalue %main.T %18, 0
+  call void %22(ptr %21, i64 200)
   ret i32 0
 }
 

cl/_testgo/defer5/in.go

@@ -0,0 +1,17 @@
+package main
+
+func main() {
+	defer println("A")
+	defer func() {
+		if e := recover(); e != nil {
+			println("in defer 1")
+			panic("panic in defer 1")
+		}
+	}()
+	defer func() {
+		println("in defer 2")
+		panic("panic in defer 2")
+	}()
+	defer println("B")
+	panic("panic in main")
+}

cl/_testgo/defer5/out.ll

@@ -0,0 +1 @@
+;

cl/_testgo/invoke/out.ll

@@ -304,13 +304,13 @@ _llgo_0:
   %14 = getelementptr inbounds %main.T5, ptr %13, i32 0, i32 0
   store i64 300, ptr %14, align 4
   %15 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 16)
-  %16 = alloca { ptr, ptr }, align 8
-  %17 = getelementptr inbounds { ptr, ptr }, ptr %16, i32 0, i32 0
+  %16 = alloca %main.T6, align 8
+  %17 = getelementptr inbounds %main.T6, ptr %16, i32 0, i32 0
   store ptr @"__llgo_stub.main.main$1", ptr %17, align 8
-  %18 = getelementptr inbounds { ptr, ptr }, ptr %16, i32 0, i32 1
+  %18 = getelementptr inbounds %main.T6, ptr %16, i32 0, i32 1
   store ptr null, ptr %18, align 8
-  %19 = load { ptr, ptr }, ptr %16, align 8
-  store { ptr, ptr } %19, ptr %15, align 8
+  %19 = load %main.T6, ptr %16, align 8
+  store %main.T6 %19, ptr %15, align 8
   %20 = load %main.T, ptr %2, align 8
   %21 = load ptr, ptr @_llgo_main.T, align 8
   %22 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 16)

cl/_testrt/closureconv/in.go

@@ -0,0 +1,63 @@
+package main
+
+type Func func(a int, b int) int
+type Func2 func(a int, b int) int
+
+type Call struct {
+	fn Func
+	n  int
+}
+
+func (c *Call) add(a int, b int) int {
+	return a + b + c.n
+}
+
+func add(a int, b int) int {
+	return a + b
+}
+
+func demo1(n int) Func {
+	m := &Call{n: n}
+	m.fn = m.add
+	return m.fn
+}
+
+func demo2() Func {
+	m := &Call{}
+	return m.add
+}
+
+func demo3() Func {
+	return add
+}
+
+func demo4() Func {
+	return func(a, b int) int { return a + b }
+}
+
+func demo5(n int) Func {
+	return func(a, b int) int { return a + b + n }
+}
+
+func main() {
+	n1 := demo1(1)(99, 200)
+	println(n1)
+
+	n2 := demo2()(100, 200)
+	println(n2)
+
+	n3 := demo3()(100, 200)
+	println(n3)
+
+	n4 := demo4()(100, 200)
+	println(n4)
+
+	n5 := demo5(1)(99, 200)
+	println(n5)
+
+	var fn func(a int, b int) int = demo5(1)
+	println(fn(99, 200))
+
+	var fn2 Func2 = (Func2)(demo5(1))
+	println(fn2(99, 200))
+}

cl/_testrt/closureconv/out.ll

@@ -0,0 +1,220 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%main.Call = type { %main.Func, i64 }
+%main.Func = type { ptr, ptr }
+
+@"main.init$guard" = global i1 false, align 1
+@__llgo_argc = global i32 0, align 4
+@__llgo_argv = global ptr null, align 8
+
+define i64 @"main.(*Call).add"(ptr %0, i64 %1, i64 %2) {
+_llgo_0:
+  %3 = add i64 %1, %2
+  %4 = getelementptr inbounds %main.Call, ptr %0, i32 0, i32 1
+  %5 = load i64, ptr %4, align 4
+  %6 = add i64 %3, %5
+  ret i64 %6
+}
+
+define i64 @main.add(i64 %0, i64 %1) {
+_llgo_0:
+  %2 = add i64 %0, %1
+  ret i64 %2
+}
+
+define %main.Func @main.demo1(i64 %0) {
+_llgo_0:
+  %1 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 24)
+  %2 = getelementptr inbounds %main.Call, ptr %1, i32 0, i32 1
+  store i64 %0, ptr %2, align 4
+  %3 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
+  %4 = getelementptr inbounds { ptr }, ptr %3, i32 0, i32 0
+  store ptr %1, ptr %4, align 8
+  %5 = alloca { ptr, ptr }, align 8
+  %6 = getelementptr inbounds { ptr, ptr }, ptr %5, i32 0, i32 0
+  store ptr @"main.add$bound", ptr %6, align 8
+  %7 = getelementptr inbounds { ptr, ptr }, ptr %5, i32 0, i32 1
+  store ptr %3, ptr %7, align 8
+  %8 = load { ptr, ptr }, ptr %5, align 8
+  %9 = getelementptr inbounds %main.Call, ptr %1, i32 0, i32 0
+  %10 = alloca %main.Func, align 8
+  store { ptr, ptr } %8, ptr %10, align 8
+  %11 = load %main.Func, ptr %10, align 8
+  store %main.Func %11, ptr %9, align 8
+  %12 = getelementptr inbounds %main.Call, ptr %1, i32 0, i32 0
+  %13 = load %main.Func, ptr %12, align 8
+  ret %main.Func %13
+}
+
+define %main.Func @main.demo2() {
+_llgo_0:
+  %0 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 24)
+  %1 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
+  %2 = getelementptr inbounds { ptr }, ptr %1, i32 0, i32 0
+  store ptr %0, ptr %2, align 8
+  %3 = alloca { ptr, ptr }, align 8
+  %4 = getelementptr inbounds { ptr, ptr }, ptr %3, i32 0, i32 0
+  store ptr @"main.add$bound", ptr %4, align 8
+  %5 = getelementptr inbounds { ptr, ptr }, ptr %3, i32 0, i32 1
+  store ptr %1, ptr %5, align 8
+  %6 = load { ptr, ptr }, ptr %3, align 8
+  %7 = alloca %main.Func, align 8
+  store { ptr, ptr } %6, ptr %7, align 8
+  %8 = load %main.Func, ptr %7, align 8
+  ret %main.Func %8
+}
+
+define %main.Func @main.demo3() {
+_llgo_0:
+  %0 = alloca %main.Func, align 8
+  %1 = getelementptr inbounds %main.Func, ptr %0, i32 0, i32 0
+  store ptr @__llgo_stub.main.add, ptr %1, align 8
+  %2 = getelementptr inbounds %main.Func, ptr %0, i32 0, i32 1
+  store ptr null, ptr %2, align 8
+  %3 = load %main.Func, ptr %0, align 8
+  ret %main.Func %3
+}
+
+define %main.Func @main.demo4() {
+_llgo_0:
+  %0 = alloca %main.Func, align 8
+  %1 = getelementptr inbounds %main.Func, ptr %0, i32 0, i32 0
+  store ptr @"__llgo_stub.main.demo4$1", ptr %1, align 8
+  %2 = getelementptr inbounds %main.Func, ptr %0, i32 0, i32 1
+  store ptr null, ptr %2, align 8
+  %3 = load %main.Func, ptr %0, align 8
+  ret %main.Func %3
+}
+
+define i64 @"main.demo4$1"(i64 %0, i64 %1) {
+_llgo_0:
+  %2 = add i64 %0, %1
+  ret i64 %2
+}
+
+define %main.Func @main.demo5(i64 %0) {
+_llgo_0:
+  %1 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 8)
+  store i64 %0, ptr %1, align 4
+  %2 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
+  %3 = getelementptr inbounds { ptr }, ptr %2, i32 0, i32 0
+  store ptr %1, ptr %3, align 8
+  %4 = alloca { ptr, ptr }, align 8
+  %5 = getelementptr inbounds { ptr, ptr }, ptr %4, i32 0, i32 0
+  store ptr @"main.demo5$1", ptr %5, align 8
+  %6 = getelementptr inbounds { ptr, ptr }, ptr %4, i32 0, i32 1
+  store ptr %2, ptr %6, align 8
+  %7 = load { ptr, ptr }, ptr %4, align 8
+  %8 = alloca %main.Func, align 8
+  store { ptr, ptr } %7, ptr %8, align 8
+  %9 = load %main.Func, ptr %8, align 8
+  ret %main.Func %9
+}
+
+define i64 @"main.demo5$1"(ptr %0, i64 %1, i64 %2) {
+_llgo_0:
+  %3 = add i64 %1, %2
+  %4 = load { ptr }, ptr %0, align 8
+  %5 = extractvalue { ptr } %4, 0
+  %6 = load i64, ptr %5, align 4
+  %7 = add i64 %3, %6
+  ret i64 %7
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define i32 @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call %main.Func @main.demo1(i64 1)
+  %3 = extractvalue %main.Func %2, 1
+  %4 = extractvalue %main.Func %2, 0
+  %5 = call i64 %4(ptr %3, i64 99, i64 200)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintInt"(i64 %5)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintByte"(i8 10)
+  %6 = call %main.Func @main.demo2()
+  %7 = extractvalue %main.Func %6, 1
+  %8 = extractvalue %main.Func %6, 0
+  %9 = call i64 %8(ptr %7, i64 100, i64 200)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintInt"(i64 %9)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintByte"(i8 10)
+  %10 = call %main.Func @main.demo3()
+  %11 = extractvalue %main.Func %10, 1
+  %12 = extractvalue %main.Func %10, 0
+  %13 = call i64 %12(ptr %11, i64 100, i64 200)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintInt"(i64 %13)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintByte"(i8 10)
+  %14 = call %main.Func @main.demo4()
+  %15 = extractvalue %main.Func %14, 1
+  %16 = extractvalue %main.Func %14, 0
+  %17 = call i64 %16(ptr %15, i64 100, i64 200)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintInt"(i64 %17)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintByte"(i8 10)
+  %18 = call %main.Func @main.demo5(i64 1)
+  %19 = extractvalue %main.Func %18, 1
+  %20 = extractvalue %main.Func %18, 0
+  %21 = call i64 %20(ptr %19, i64 99, i64 200)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintInt"(i64 %21)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintByte"(i8 10)
+  %22 = call %main.Func @main.demo5(i64 1)
+  %23 = alloca { ptr, ptr }, align 8
+  store %main.Func %22, ptr %23, align 8
+  %24 = load { ptr, ptr }, ptr %23, align 8
+  %25 = extractvalue { ptr, ptr } %24, 1
+  %26 = extractvalue { ptr, ptr } %24, 0
+  %27 = call i64 %26(ptr %25, i64 99, i64 200)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintInt"(i64 %27)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintByte"(i8 10)
+  %28 = call %main.Func @main.demo5(i64 1)
+  %29 = extractvalue %main.Func %28, 1
+  %30 = extractvalue %main.Func %28, 0
+  %31 = call i64 %30(ptr %29, i64 99, i64 200)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintInt"(i64 %31)
+  call void @"github.com/goplus/llgo/internal/runtime.PrintByte"(i8 10)
+  ret i32 0
+}
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64)
+
+define i64 @"main.add$bound"(ptr %0, i64 %1, i64 %2) {
+_llgo_0:
+  %3 = load { ptr }, ptr %0, align 8
+  %4 = extractvalue { ptr } %3, 0
+  %5 = call i64 @"main.(*Call).add"(ptr %4, i64 %1, i64 %2)
+  ret i64 %5
+}
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64)
+
+define linkonce i64 @__llgo_stub.main.add(ptr %0, i64 %1, i64 %2) {
+_llgo_0:
+  %3 = tail call i64 @main.add(i64 %1, i64 %2)
+  ret i64 %3
+}
+
+define linkonce i64 @"__llgo_stub.main.demo4$1"(ptr %0, i64 %1, i64 %2) {
+_llgo_0:
+  %3 = tail call i64 @"main.demo4$1"(i64 %1, i64 %2)
+  ret i64 %3
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare void @"github.com/goplus/llgo/internal/runtime.PrintInt"(i64)
+
+declare void @"github.com/goplus/llgo/internal/runtime.PrintByte"(i8)

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/builtin_test.go

@@ -282,3 +282,68 @@ func TestErrVarOf(t *testing.T) {
 	g := &ssa.Global{Pkg: ssaPkg}
 	ctx.varOf(nil, g)
 }
+
+func TestContextResolveLinkname(t *testing.T) {
+	tests := []struct {
+		name    string
+		context *context
+		input   string
+		want    string
+		panics  bool
+	}{
+		{
+			name: "Normal",
+			context: &context{
+				link: map[string]string{
+					"foo": "C.bar",
+				},
+			},
+			input: "foo",
+			want:  "bar",
+		},
+		{
+			name: "MultipleLinks",
+			context: &context{
+				link: map[string]string{
+					"foo1": "C.bar1",
+					"foo2": "C.bar2",
+				},
+			},
+			input: "foo2",
+			want:  "bar2",
+		},
+		{
+			name:    "NoLink",
+			context: &context{link: map[string]string{}},
+			input:   "foo",
+			want:    "foo",
+		},
+		{
+			name: "InvalidLink",
+			context: &context{
+				link: map[string]string{
+					"foo": "invalid.bar",
+				},
+			},
+			input:  "foo",
+			panics: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.panics {
+				defer func() {
+					if r := recover(); r == nil {
+						t.Error("want panic")
+					}
+				}()
+			}
+			got := tt.context.resolveLinkname(tt.input)
+			if !tt.panics {
+				if got != tt.want {
+					t.Errorf("got %q, want %q", got, tt.want)
+				}
+			}
+		})
+	}
+}

cl/compile.go

@@ -25,6 +25,7 @@ import (
 	"log"
 	"os"
 	"sort"
+	"strings"
 
 	"github.com/goplus/llgo/cl/blocks"
 	"github.com/goplus/llgo/internal/typepatch"
@@ -195,6 +196,9 @@ func (p *context) compileFuncDecl(pkg llssa.Package, f *ssa.Function) (llssa.Fun
 	isInit := (f.Name() == "init" && sig.Recv() == nil)
 	if isInit && state == pkgHasPatch {
 		name = initFnNameOfHasPatch(name)
+		// TODO(xsw): pkg.init$guard has been set, change ssa.If to ssa.Jump
+		block := f.Blocks[0].Instrs[1].(*ssa.If).Block()
+		block.Succs[0], block.Succs[1] = block.Succs[1], block.Succs[0]
 	}
 
 	fn := pkg.FuncOf(name)
@@ -214,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])
@@ -223,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
@@ -245,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 {
@@ -280,13 +300,13 @@ 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 {
 			last = len(instrs) - 1
 			instrs = instrs[:last]
-		} else {
+		} else if p.state != pkgHasPatch {
 			// TODO(xsw): confirm pyMod don't need to call AfterInit
 			p.inits = append(p.inits, func() {
 				pkg.AfterInit(b, ret)
@@ -303,7 +323,7 @@ func (p *context) compileBlock(b llssa.Builder, block *ssa.BasicBlock, n int, do
 		b.Call(pkg.FuncOf("main.init").Expr)
 	}
 	for i, instr := range instrs {
-		if i == 1 && doModInit && p.state == pkgInPatch {
+		if i == 1 && doModInit && p.state == pkgInPatch { // in patch package but no pkgFNoOldInit
 			initFnNameOld := initFnNameOfHasPatch(p.fn.Name())
 			fnOld := pkg.NewFunc(initFnNameOld, llssa.NoArgsNoRet, llssa.InC)
 			b.Call(fnOld.Expr)
@@ -318,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))
@@ -650,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)
@@ -809,6 +833,7 @@ func NewPackageEx(prog llssa.Program, patches Patches, pkg *ssa.Package, files [
 	ctx.initPyModule()
 	ctx.initFiles(pkgPath, files)
 	ret.SetPatch(ctx.patchType)
+	ret.SetResolveLinkname(ctx.resolveLinkname)
 
 	if hasPatch {
 		skips := ctx.skips
@@ -901,4 +926,15 @@ func (p *context) patchType(typ types.Type) types.Type {
 	return typ
 }
 
+func (p *context) resolveLinkname(name string) string {
+	if link, ok := p.link[name]; ok {
+		prefix, ltarget, _ := strings.Cut(link, ".")
+		if prefix != "C" {
+			panic("resolveLinkname: invalid link: " + link)
+		}
+		return ltarget
+	}
+	return name
+}
+
 // -----------------------------------------------------------------------------

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) {
@@ -500,41 +509,6 @@ func (p *context) ensureLoaded(pkgTypes *types.Package) *types.Package {
 	return pkgTypes
 }
 
-func pkgKindByPath(pkgPath string) int {
-	switch pkgPath {
-	case "runtime/cgo", "unsafe":
-		return PkgDeclOnly
-	}
-	return PkgNormal
-}
-
-func replaceGoName(v string, pos int) string {
-	switch v[:pos] {
-	case "runtime":
-		return "github.com/goplus/llgo/internal/runtime" + v[pos:]
-	}
-	return v
-}
-
-func ignoreName(name string) bool {
-	/* TODO(xsw): confirm this is not needed more
-	if name == "unsafe.init" {
-		return true
-	}
-	*/
-	const internal = "internal/"
-	return (strings.HasPrefix(name, internal) && !supportedInternal(name[len(internal):])) ||
-		strings.HasPrefix(name, "crypto/") || strings.HasPrefix(name, "runtime/") ||
-		strings.HasPrefix(name, "arena.") || strings.HasPrefix(name, "maps.") ||
-		strings.HasPrefix(name, "plugin.")
-}
-
-func supportedInternal(name string) bool {
-	return strings.HasPrefix(name, "abi.") || strings.HasPrefix(name, "bytealg.") ||
-		strings.HasPrefix(name, "oserror.") || strings.HasPrefix(name, "reflectlite.") ||
-		strings.HasPrefix(name, "syscall/unix.") || strings.HasPrefix(name, "syscall/execenv.")
-}
-
 // -----------------------------------------------------------------------------
 
 const (
@@ -600,3 +574,39 @@ func toBackground(bg string) llssa.Background {
 }
 
 // -----------------------------------------------------------------------------
+
+func pkgKindByPath(pkgPath string) int {
+	switch pkgPath {
+	case "runtime/cgo", "unsafe":
+		return PkgDeclOnly
+	}
+	return PkgNormal
+}
+
+func replaceGoName(v string, pos int) string {
+	switch v[:pos] {
+	case "runtime":
+		return "github.com/goplus/llgo/internal/runtime" + v[pos:]
+	}
+	return v
+}
+
+func ignoreName(name string) bool {
+	/* TODO(xsw): confirm this is not needed more
+	if name == "unsafe.init" {
+		return true
+	}
+	*/
+	const internal = "internal/"
+	return (strings.HasPrefix(name, internal) && !supportedInternal(name[len(internal):])) ||
+		strings.HasPrefix(name, "runtime/") || strings.HasPrefix(name, "arena.") ||
+		strings.HasPrefix(name, "maps.") || strings.HasPrefix(name, "plugin.")
+}
+
+func supportedInternal(name string) bool {
+	return strings.HasPrefix(name, "abi.") || strings.HasPrefix(name, "bytealg.") ||
+		strings.HasPrefix(name, "itoa.") || strings.HasPrefix(name, "oserror.") || strings.HasPrefix(name, "reflectlite.") ||
+		strings.HasPrefix(name, "syscall/unix.") || strings.HasPrefix(name, "syscall/execenv.")
+}
+
+// -----------------------------------------------------------------------------

cl/instr.go

@@ -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)

cmd/internal/version/version.go

@@ -21,7 +21,7 @@ import (
 	"runtime"
 
 	"github.com/goplus/llgo/cmd/internal/base"
-	"github.com/goplus/llgo/xtool/env"
+	"github.com/goplus/llgo/x/env"
 )
 
 // llgo version

cpp/std/std_gc.go

@@ -0,0 +1,39 @@
+//go:build !nogc
+// +build !nogc
+
+/*
+ * 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 std
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/bdwgc"
+)
+
+// -----------------------------------------------------------------------------
+
+func allocString() *String {
+	ptr := bdwgc.Malloc(unsafe.Sizeof(String{}))
+	bdwgc.RegisterFinalizer(ptr, func(obj, data c.Pointer) {
+		(*String)(obj).Dispose()
+	}, nil, nil, nil)
+	return (*String)(ptr)
+}
+
+// -----------------------------------------------------------------------------

cpp/std/std_nogc.go

@@ -0,0 +1,35 @@
+//go:build nogc
+// +build nogc
+
+/*
+ * 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 std
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+func allocString() *String {
+	ptr := c.Malloc(unsafe.Sizeof(String{}))
+	return (*String)(ptr)
+}
+
+// -----------------------------------------------------------------------------

cpp/std/string.go

@@ -20,7 +20,6 @@ import (
 	"unsafe"
 
 	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/bdwgc"
 )
 
 // -----------------------------------------------------------------------------
@@ -32,7 +31,7 @@ type StringView = string
 
 // String represents a C++ std::string object.
 type String struct {
-	Unused [24]byte
+	Unused [3 * unsafe.Sizeof(0)]byte
 }
 
 // llgo:link (*String).InitEmpty C.stdStringInitEmpty
@@ -52,14 +51,6 @@ func (s *String) Dispose() {}
 
 // -----------------------------------------------------------------------------
 
-func allocString() *String {
-	ptr := bdwgc.Malloc(unsafe.Sizeof(String{}))
-	bdwgc.RegisterFinalizer(ptr, func(obj, data c.Pointer) {
-		(*String)(obj).Dispose()
-	}, nil, nil, nil)
-	return (*String)(ptr)
-}
-
 // NewString creates a C++ std::string object.
 func NewString(v string) *String {
 	ret := allocString()