refactor(runtime): combine two if cases in methods() function

Simplified the methods() function in z_face.go by combining two
if statements that both return u.Methods() into a single condition
using logical OR operator.

Generated with [codeagent](https://github.com/qbox/codeagent)
Co-authored-by: luoliwoshang <51194195+luoliwoshang@users.noreply.github.com>

.github/actions/setup-deps/action.yml

@@ -0,0 +1,72 @@
+name: "Setup LLGO Dependencies"
+description: "Install all required dependencies for LLGO"
+inputs:
+  llvm-version:
+    description: "LLVM version to install"
+    required: true
+    default: "19"
+  install-llvm:
+    description: "Whether to install LLVM"
+    required: false
+    default: "true"
+
+runs:
+  using: "composite"
+  steps:
+    - name: Install macOS dependencies
+      if: runner.os == 'macOS'
+      shell: bash
+      run: |
+        brew update
+        
+        # Install LLVM if requested
+        if [[ "${{ inputs.install-llvm }}" == "true" ]]; then
+          brew install llvm@${{inputs.llvm-version}} lld@${{inputs.llvm-version}}
+          brew link --overwrite llvm@${{inputs.llvm-version}} lld@${{inputs.llvm-version}}
+          echo "$(brew --prefix llvm@${{inputs.llvm-version}})/bin" >> $GITHUB_PATH
+        fi
+        
+        # Install common dependencies
+        brew install bdw-gc openssl libffi libuv
+        brew link --overwrite libffi
+
+        # Install optional deps for demos.
+        #
+        # NOTE: Keep this list updated as new deps are introduced.
+        opt_deps=(
+          cjson       # for github.com/goplus/lib/c/cjson
+          sqlite      # for github.com/goplus/lib/c/sqlite
+        )
+        brew install "${opt_deps[@]}"
+        
+        brew install python@3.12 || true # for github.com/goplus/lib/py
+        brew link --overwrite python@3.12
+
+    - name: Install Ubuntu dependencies
+      if: runner.os == 'Linux'
+      shell: bash
+      run: |
+        # Install LLVM if requested
+        if [[ "${{ inputs.install-llvm }}" == "true" ]]; then
+          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-${{inputs.llvm-version}} 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-${{inputs.llvm-version}}-dev clang-${{inputs.llvm-version}} libclang-${{inputs.llvm-version}}-dev lld-${{inputs.llvm-version}} libunwind-${{inputs.llvm-version}}-dev libc++-${{inputs.llvm-version}}-dev
+          echo "PATH=/usr/lib/llvm-${{inputs.llvm-version}}/bin:$PATH" >> $GITHUB_ENV
+        else
+          sudo apt-get update
+        fi
+        
+        # Install common dependencies
+        sudo apt-get install -y pkg-config libgc-dev libssl-dev zlib1g-dev libffi-dev libcjson-dev libuv1-dev
+
+        # Install optional deps for demos.
+        #
+        # NOTE: Keep this list updated as new deps are introduced.
+        opt_deps=(
+          libcjson-dev   # for github.com/goplus/lib/c/cjson
+          libsqlite3-dev # for github.com/goplus/lib/c/sqlite
+          python3.12-dev # for github.com/goplus/lib/py
+        )
+        sudo apt-get install -y "${opt_deps[@]}"
+

.github/actions/setup-go/action.yml

@@ -0,0 +1,51 @@
+name: "Setup Go"
+description: "Setup Go environment by downloading and extracting from go.dev"
+inputs:
+  go-version:
+    description: "The Go version to download and use"
+    required: true
+runs:
+  using: "composite"
+  steps:
+    - name: Download and setup Go
+      shell: bash
+      run: |
+        set -e
+        GO_VERSION="${{ inputs.go-version }}"
+        GO_VERSION="${GO_VERSION#go}" # Remove 'go' prefix if present
+
+        # Determine OS and architecture
+        if [[ "$RUNNER_OS" == "macOS" ]]; then
+          OS="darwin"
+          ARCH="arm64"
+        else
+          OS="linux"
+          ARCH="amd64"
+        fi
+
+        DOWNLOAD_URL="https://go.dev/dl/go${GO_VERSION}.${OS}-${ARCH}.tar.gz"
+        echo "Downloading Go from: ${DOWNLOAD_URL}"
+
+        # Create temporary directory for download
+        TMP_DIR=$(mktemp -d)
+        curl -L "${DOWNLOAD_URL}" -o "${TMP_DIR}/go.tar.gz"
+
+        # Remove existing Go installation if any
+        sudo rm -rf /usr/local/go
+
+        # Extract to /usr/local
+        sudo tar -C /usr/local -xzf "${TMP_DIR}/go.tar.gz"
+
+        # Clean up
+        rm -rf "${TMP_DIR}"
+
+        # Add to PATH
+        echo "/usr/local/go/bin" >> $GITHUB_PATH
+        echo "$HOME/go/bin" >> $GITHUB_PATH
+
+    - name: Verify Go installation
+      shell: bash
+      run: |
+        # Verify installation
+        echo "Verifying Go installation..."
+        go version

.github/actions/setup-goreleaser/action.yml

@@ -0,0 +1,28 @@
+name: "Setup GoReleaser"
+description: "Setup GoReleaser environment"
+inputs:
+  linux-cache-key:
+    description: "Linux sysroot cache key"
+    required: true
+runs:
+  using: "composite"
+  steps:
+    - name: Set up Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: 1.24.x
+    - name: Restore Linux sysroot cache
+      id: cache-linux-sysroot
+      uses: actions/cache/restore@v4
+      with:
+        path: .sysroot/linux.tar.gz
+        key: ${{ inputs.linux-cache-key }}
+    - name: Populate Linux sysroot
+      run: tar -xzvf .sysroot/linux.tar.gz -C .sysroot
+      shell: bash
+    - name: Check file
+      run: tree .sysroot
+      shell: bash
+    - name: Get Esp clang
+      run: bash .github/workflows/download_esp_clang.sh
+      shell: bash

.github/actions/test-helloworld/action.yml

@@ -0,0 +1,63 @@
+name: "Test Hello World"
+description: "Test Hello World with specific Go and module versions"
+inputs:
+  go-version:
+    description: "Go version being tested"
+    required: true
+  mod-version:
+    description: "Go module version to use"
+    required: true
+runs:
+  using: "composite"
+  steps:
+    - name: Test Hello World
+      shell: bash
+      run: |
+        echo "Testing with Go ${{ inputs.go-version }} and go.mod ${{ inputs.mod-version }}"
+        mkdir -p _test/helloworld && cd _test/helloworld
+        cat > go.mod << 'EOL'
+        module hello
+        go ${{ inputs.mod-version }}
+        EOL
+        cat > main.go << 'EOL'
+        package main
+        import (
+          "fmt"
+          "github.com/goplus/lib/c"
+          "github.com/goplus/lib/cpp/std"
+        )
+        func main() {
+            fmt.Println("Hello, LLGo!")
+            println("Hello, LLGo!")
+            c.Printf(c.Str("Hello, LLGo!\n"))
+            c.Printf(std.Str("Hello LLGo by cpp/std.Str\n").CStr())
+        }
+        EOL
+        go mod tidy
+        EXPECTED="Hello, LLGo!
+        Hello, LLGo!
+        Hello, LLGo!
+        Hello LLGo by cpp/std.Str"
+        OUTPUT=$(llgo run . 2>&1 | tee /dev/stderr)
+        if echo "$OUTPUT" | grep -qF "$EXPECTED"; then
+            echo "Basic test passed"
+        else
+            echo "Basic test failed"
+            echo "Expected to contain:"
+            echo "$EXPECTED"
+            echo "Got:"
+            echo "$OUTPUT"
+            exit 1
+        fi
+
+        cd ../..
+        mkdir -p _test/emb && cd _test/emb
+        cat > main.go << 'EOL'
+        package main
+
+        func main() {
+        }
+        EOL
+        llgo build -v -target esp32-coreboard-v2 -o demo.out .
+        test -f demo.out.elf && echo "ESP32 cross-compilation test passed: demo.out.elf generated"
+        exit $?

.github/codecov.yml

@@ -0,0 +1,15 @@
+coverage:
+  ignore:
+    - "chore"
+    - "cmd"
+    - "cl/cltest"
+    - "internal/build"
+    - "internal/llgen"
+    - "internal/mockable"
+    - "internal/packages"
+    - "internal/typepatch"
+    - "internal/github"
+    - "internal/firmware"
+    - "internal/flash"
+    - "internal/monitor"
+    - "xtool"

.github/workflows/doc.yml

@@ -2,41 +2,57 @@ name: Docs
 
 on:
   push:
-    branches: [ "**" ]
+    branches:
+      - "**"
+      - "!dependabot/**"
+      - "!xgopilot/**"
   pull_request:
-    branches: [ "**" ]
+    branches: ["**"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
 
 jobs:
   doc_verify:
     runs-on: ubuntu-latest
+    timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Set up Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
-          node-version: '20'
+          node-version: "20"
 
       - name: Install embedme
         run: npm install -g embedme
 
       - name: Verify README.md embedded code
-        run: npx embedme --verify README.md
+        run: embedme --verify README.md
 
-  doc_test:
+      - name: Link Checker
+        id: lychee
+        uses: lycheeverse/lychee-action@v2
+        with:
+          args: --max-concurrency 3 --retry-wait-time 15 README.md
+
+  remote_install:
+    continue-on-error: true
+    timeout-minutes: 30
     strategy:
       matrix:
         os:
           - macos-latest
-          - ubuntu-24.04
+          - ubuntu-latest
     runs-on: ${{matrix.os}}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Set up Go
-        uses: actions/setup-go@v5
+        uses: ./.github/actions/setup-go
         with:
-          go-version: '1.20'
+          go-version: "1.24.2"
 
       - name: Install dependencies on macOS
         if: startsWith(matrix.os, 'macos')
@@ -52,7 +68,44 @@ jobs:
           set -x
           source doc/_readme/scripts/install_ubuntu.sh
 
-      - name: Install llgo
+      - name: Test doc code blocks
+        run: |
+          set -e
+          set -x
+          source doc/_readme/scripts/run.sh
+
+  local_install:
+    continue-on-error: true
+    timeout-minutes: 30
+    strategy:
+      matrix:
+        os:
+          - macos-latest
+          - ubuntu-latest
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up Go
+        uses: actions/setup-go@v6
+        with:
+          go-version: "1.23"
+
+      - name: Install dependencies on macOS
+        if: startsWith(matrix.os, 'macos')
+        run: |
+          set -e
+          set -x
+          source doc/_readme/scripts/install_macos.sh
+
+      - name: Install dependencies on Ubuntu
+        if: startsWith(matrix.os, 'ubuntu')
+        run: |
+          set -e
+          set -x
+          source doc/_readme/scripts/install_ubuntu.sh
+
+      - name: Install llgo with tools
         run: |
           set -e
           set -x
@@ -65,6 +118,7 @@ jobs:
             fi
           }
           source doc/_readme/scripts/install_llgo.sh
+          echo "LLGO_ROOT=$GITHUB_WORKSPACE" >> $GITHUB_ENV
 
       - name: Test doc code blocks
         run: |
@@ -72,3 +126,55 @@ jobs:
           set -x
           source doc/_readme/scripts/run.sh
 
+  local_install_full:
+    continue-on-error: true
+    timeout-minutes: 30
+    strategy:
+      matrix:
+        os:
+          - macos-latest
+          - ubuntu-latest
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up Go
+        uses: actions/setup-go@v6
+        with:
+          go-version: "1.23"
+
+      - name: Install dependencies on macOS
+        if: startsWith(matrix.os, 'macos')
+        run: |
+          set -e
+          set -x
+          source doc/_readme/scripts/install_macos.sh
+
+      - name: Install dependencies on Ubuntu
+        if: startsWith(matrix.os, 'ubuntu')
+        run: |
+          set -e
+          set -x
+          source doc/_readme/scripts/install_ubuntu.sh
+          echo "PATH=/usr/lib/llvm-19/bin:$PATH" >> $GITHUB_ENV
+
+      - name: Install llgo with tools
+        run: |
+          set -e
+          set -x
+          git() {
+            if [ "$1" = "clone" ]; then
+              # do nothing because we already have the branch
+              cd ..
+            else
+              command git "$@"
+            fi
+          }
+          source doc/_readme/scripts/install_full.sh
+          echo "LLGO_ROOT=$GITHUB_WORKSPACE" >> $GITHUB_ENV
+
+      - name: Test doc code blocks
+        run: |
+          set -e
+          set -x
+          source doc/_readme/scripts/run.sh

.github/workflows/download_esp_clang.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+set -e
+
+ESP_CLANG_VERSION="19.1.2_20250905-3"
+BASE_URL="https://github.com/goplus/espressif-llvm-project-prebuilt/releases/download/${ESP_CLANG_VERSION}"
+
+get_esp_clang_platform() {
+    local platform="$1"
+    local os="${platform%-*}"
+    local arch="${platform##*-}"
+    
+    case "${os}" in
+        "darwin")
+            case "${arch}" in
+                "amd64") echo "x86_64-apple-darwin" ;;
+                "arm64") echo "aarch64-apple-darwin" ;;
+                *) echo "Error: Unsupported darwin architecture: ${arch}" >&2; exit 1 ;;
+            esac
+            ;;
+        "linux")
+            case "${arch}" in
+                "amd64") echo "x86_64-linux-gnu" ;;
+                "arm64") echo "aarch64-linux-gnu" ;;
+                *) echo "Error: Unsupported linux architecture: ${arch}" >&2; exit 1 ;;
+            esac
+            ;;
+        *)
+            echo "Error: Unsupported OS: ${os}" >&2
+            exit 1
+            ;;
+    esac
+}
+
+get_filename() {
+    local platform="$1"
+    local platform_suffix=$(get_esp_clang_platform "${platform}")
+    echo "clang-esp-${ESP_CLANG_VERSION}-${platform_suffix}.tar.xz"
+}
+
+download_and_extract() {
+    local platform="$1"
+    local os="${platform%-*}"
+    local arch="${platform##*-}"
+    local filename=$(get_filename "${platform}")
+    local download_url="${BASE_URL}/${filename}"
+    
+    echo "Downloading ESP Clang for ${platform}..."
+    echo "  URL: ${download_url}"
+    
+    mkdir -p ".sysroot/${os}/${arch}/crosscompile/clang"
+    curl -fsSL "${download_url}" | tar -xJ -C ".sysroot/${os}/${arch}/crosscompile/clang" --strip-components=1
+    
+    if [[ ! -f ".sysroot/${os}/${arch}/crosscompile/clang/bin/clang++" ]]; then
+        echo "Error: clang++ not found in ${platform} toolchain"
+        exit 1
+    fi
+    
+    echo "${platform} ESP Clang ready in .sysroot/${os}/${arch}/crosscompile/clang"
+}
+
+echo "Downloading ESP Clang toolchain version ${ESP_CLANG_VERSION}..."
+
+for platform in "darwin-amd64" "darwin-arm64" "linux-amd64" "linux-arm64"; do
+    download_and_extract "${platform}"
+done
+
+echo "ESP Clang toolchain completed successfully!"

.github/workflows/fmt.yml

@@ -0,0 +1,38 @@
+name: Format Check
+
+on:
+  push:
+    branches:
+      - "**"
+      - "!dependabot/**"
+      - "!xgopilot/**"
+  pull_request:
+    branches: ["**"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  fmt:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up Go
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: "1.24.2"
+
+      - name: Check formatting
+        run: |
+          for dir in . runtime; do
+            pushd $dir
+            if [ -n "$(go fmt ./... | grep -v xgo_autogen.go)" ]; then
+              echo "Some files are not properly formatted. Please run 'go fmt ./...'"
+              exit 1
+            fi
+            popd
+          done
+          echo "All files are properly formatted."

.github/workflows/go.yml

@@ -5,84 +5,34 @@ name: Go
 
 on:
   push:
-    branches: [ "**" ]
+    branches:
+      - "**"
+      - "!dependabot/**"
+      - "!xgopilot/**"
   pull_request:
-    branches: [ "**" ]
+    branches: ["**"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
 
 jobs:
-  fmt:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.20'
-
-      - name: Check formatting
-        run: |
-          if [ -n "$(go fmt ./...)" ]; then
-            echo "Some files are not properly formatted. Please run 'go fmt ./...'"
-            exit 1
-          fi
-
   test:
+    continue-on-error: true
+    timeout-minutes: 30
     strategy:
       matrix:
         os:
           - macos-latest
-          - ubuntu-24.04
-        llvm: [18]
+          - ubuntu-latest
+        llvm: [19]
     runs-on: ${{matrix.os}}
     steps:
-      - uses: actions/checkout@v4
-
+      - uses: actions/checkout@v5
       - name: Install dependencies
-        if: startsWith(matrix.os, 'macos')
-        run: |
-          brew update
-          brew install llvm@${{matrix.llvm}} bdw-gc openssl libffi
-          brew link --force libffi
-          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
-          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}} libclang-${{matrix.llvm}}-dev lld-${{matrix.llvm}} pkg-config libgc-dev libssl-dev zlib1g-dev libffi-dev libcjson-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.12 install --break-system-packages "${py_deps[@]}"
+        uses: ./.github/actions/setup-deps
+        with:
+          llvm-version: ${{matrix.llvm}}
 
       - name: Clang information
         run: |
@@ -91,66 +41,22 @@ jobs:
           clang --version
 
       - name: Set up Go
-        uses: actions/setup-go@v5
+        uses: ./.github/actions/setup-go
         with:
-          go-version: '1.20'
+          go-version: "1.24.2"
 
       - name: Build
         run: go build -v ./...
 
-      - name: Install
-        run: go install ./...
-
       - name: Test
         if: ${{!startsWith(matrix.os, 'macos')}}
-        run: go test -v ./...
+        run: go test ./...
 
       - name: Test with coverage
         if: startsWith(matrix.os, 'macos')
-        run: go test -v -coverprofile="coverage.txt" -covermode=atomic ./...
-
-      - name: LLGO tests
-        if: ${{!startsWith(matrix.os, 'ubuntu')}}
-        run: |
-          echo "Test result on ${{matrix.os}} with LLVM ${{matrix.llvm}}" > result.md
-          bash .github/workflows/test_llgo.sh
-
-      - name: chore/_xtool build tests
-        run: |
-          cd chore/_xtool
-          llgo build -v ./...
-
-      - name: LLDB tests
-        if: ${{startsWith(matrix.os, 'macos')}}
-        run: |
-          echo "Test lldb with llgo plugin on ${{matrix.os}} with LLVM ${{matrix.llvm}}"
-          bash _lldb/runtest.sh -v
-
-      - name: Test demos
-        run: |
-          # TODO(lijie): force python3-embed to be linked with python-3.12-embed
-          # Currently, python3-embed is python-3.13-embed, doesn't work with pytorch
-          # Will remove this after pytorch is fixed.
-          pcdir=$HOME/pc
-          mkdir -p $pcdir
-          libdir=$(pkg-config --variable=libdir python-3.12-embed)
-          echo "libdir: $libdir"
-          ln -s $libdir/pkgconfig/python-3.12-embed.pc $pcdir/python3-embed.pc
-          export PKG_CONFIG_PATH=$pcdir
-          bash .github/workflows/test_demo.sh
-
-      - name: Show test result
-        run: cat result.md
-
-      - name: PR comment with test result
-        uses: thollander/actions-comment-pull-request@v3
-        if: false
-        with:
-          filePath: result.md
-          comment_tag: test-result-on-${{matrix.os}}-with-llvm-${{matrix.llvm}}
+        run: go test -coverprofile="coverage.txt" -covermode=atomic ./...
 
       - name: Upload coverage reports to Codecov
         uses: codecov/codecov-action@v5
         with:
           token: ${{secrets.CODECOV_TOKEN}}
-          slug: goplus/llgo

.github/workflows/llgo.yml

@@ -0,0 +1,300 @@
+# This workflow will build a golang project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-go
+
+name: LLGo
+
+on:
+  push:
+    branches:
+      - "**"
+      - "!dependabot/**"
+      - "!xgopilot/**"
+  pull_request:
+    branches: ["**"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  download-model:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - name: Download model file
+        run: |
+          mkdir -p ./_demo/c/llama2-c
+          wget -P ./_demo/c/llama2-c https://huggingface.co/karpathy/tinyllamas/resolve/main/stories15M.bin
+
+      - name: Upload model as artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: llama2-model
+          path: ./_demo/c/llama2-c/stories15M.bin
+          retention-days: 1
+
+  llgo:
+    needs: download-model
+    continue-on-error: true
+    timeout-minutes: 30
+    strategy:
+      matrix:
+        os:
+          - macos-latest
+          - ubuntu-latest
+        llvm: [19]
+        go: ["1.21.13", "1.22.12", "1.23.6", "1.24.2"]
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v5
+      - name: Install dependencies
+        uses: ./.github/actions/setup-deps
+        with:
+          llvm-version: ${{matrix.llvm}}
+      - name: Download model artifact
+        uses: actions/download-artifact@v5
+        with:
+          name: llama2-model
+          path: ./_demo/c/llama2-c/
+      - name: Download platform-specific demo libs
+        run: |
+          if ${{ startsWith(matrix.os, 'macos') }}; then
+            DEMO_PKG="cargs_darwin_arm64.zip"
+          else
+            DEMO_PKG="cargs_linux_amd64.zip"  
+          fi
+
+          mkdir -p ./_demo/c/cargs/libs
+          cd ./_demo/c/cargs/libs
+          wget https://github.com/goplus/llpkg/releases/download/cargs/v1.0.0/${DEMO_PKG}
+          unzip ${DEMO_PKG}
+
+          # Process pc template files - replace {{.Prefix}} with actual path
+          ACTUAL_PREFIX="$(pwd)"
+          for tmpl in lib/pkgconfig/*.pc.tmpl; do
+            pc_file="${tmpl%.tmpl}"
+            sed "s|{{.Prefix}}|${ACTUAL_PREFIX}|g" "$tmpl" > "$pc_file"
+          done
+
+          echo "PKG_CONFIG_PATH=${ACTUAL_PREFIX}/lib/pkgconfig:${PKG_CONFIG_PATH}" >> $GITHUB_ENV
+      - name: Install further optional dependencies for demos
+        run: |
+          py_deps=(
+            numpy # for github.com/goplus/lib/py/numpy
+            torch # for github.com/goplus/lib/py/torch
+          )
+          pip3.12 install --break-system-packages "${py_deps[@]}"
+
+      - name: Set up Go for build
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: "1.24.2"
+
+      - name: Install
+        run: |
+          go install ./...
+          echo "LLGO_ROOT=$GITHUB_WORKSPACE" >> $GITHUB_ENV
+
+      - name: Set up Go for testing
+        uses: actions/setup-go@v6
+        with:
+          go-version: ${{matrix.go}}
+
+      - name: Test demo without RPATH (expect failure)
+        run: |
+          echo "Testing demo without RPATH (should fail)..."
+          export LLGO_FULL_RPATH=false
+          pkg-config --libs cargs
+          if (cd ./_demo/c/cargs && llgo run .); then
+            echo "ERROR: cargs demo should have failed without RPATH!"
+            exit 1
+          else
+            echo "✓ cargs demo correctly failed without RPATH"
+          fi
+
+      - name: Test demos
+        run: |
+          # TODO(lijie): force python3-embed to be linked with python-3.12-embed
+          # Currently, python3-embed is python-3.13-embed, doesn't work with pytorch
+          # Will remove this after pytorch is fixed.
+          pcdir=$HOME/pc
+          mkdir -p $pcdir
+          libdir=$(pkg-config --variable=libdir python-3.12-embed)
+          echo "libdir: $libdir"
+          ln -s $libdir/pkgconfig/python-3.12-embed.pc $pcdir/python3-embed.pc
+          export PKG_CONFIG_PATH=$pcdir:${PKG_CONFIG_PATH}
+          export LLGO_FULL_RPATH=true
+          bash .github/workflows/test_demo.sh
+
+      - name: Test C header generation
+        run: |
+          echo "Testing C header generation in different build modes..."
+          cd _demo/go/export
+          chmod +x test.sh
+          ./test.sh
+
+      - name: _xtool build tests
+        run: |
+          cd _xtool
+          llgo build -v ./...
+
+      - name: Show test result
+        run: cat result.md
+
+      - name: LLDB tests
+        if: ${{startsWith(matrix.os, 'macos')}}
+        run: |
+          echo "Test lldb with llgo plugin on ${{matrix.os}} with LLVM ${{matrix.llvm}}"
+          bash _lldb/runtest.sh -v
+
+  test:
+    continue-on-error: true
+    timeout-minutes: 30
+    strategy:
+      matrix:
+        os:
+          - macos-latest
+          - ubuntu-latest
+        llvm: [19]
+        go: ["1.24.2"]
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v5
+      - name: Install dependencies
+        uses: ./.github/actions/setup-deps
+        with:
+          llvm-version: ${{matrix.llvm}}
+      - name: Install further optional dependencies for demos
+        run: |
+          py_deps=(
+            numpy # for github.com/goplus/lib/py/numpy
+            torch # for github.com/goplus/lib/py/torch
+          )
+          pip3.12 install --break-system-packages "${py_deps[@]}"
+
+      - name: Set up Go for build
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: "1.24.2"
+
+      - name: Install
+        run: |
+          go install ./...
+          echo "LLGO_ROOT=$GITHUB_WORKSPACE" >> $GITHUB_ENV
+
+      - name: Set up Go for testing
+        uses: actions/setup-go@v6
+        with:
+          go-version: ${{matrix.go}}
+
+      - name: run llgo test
+        run: |
+          llgo test ./...
+
+  hello:
+    continue-on-error: true
+    timeout-minutes: 30
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        llvm: [19]
+        go: ["1.21.13", "1.22.12", "1.23.6", "1.24.2"]
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v5
+      - name: Install dependencies
+        uses: ./.github/actions/setup-deps
+        with:
+          llvm-version: ${{matrix.llvm}}
+
+      - name: Set up Go 1.23 for building llgo
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: "1.24.2"
+
+      - name: Install llgo
+        run: |
+          go install ./...
+          echo "LLGO_ROOT=$GITHUB_WORKSPACE" >> $GITHUB_ENV
+
+      - name: Set up Go for testing
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: ${{matrix.go}}
+
+      - name: Test Hello World with go.mod 1.21
+        if: startsWith(matrix.go, '1.21') || startsWith(matrix.go, '1.22') || startsWith(matrix.go, '1.23') || startsWith(matrix.go, '1.24')
+        uses: ./.github/actions/test-helloworld
+        with:
+          go-version: ${{matrix.go}}
+          mod-version: "1.21"
+
+      - name: Test Hello World with go.mod 1.22
+        if: startsWith(matrix.go, '1.22') || startsWith(matrix.go, '1.23') || startsWith(matrix.go, '1.24')
+        uses: ./.github/actions/test-helloworld
+        with:
+          go-version: ${{matrix.go}}
+          mod-version: "1.22"
+
+      - name: Test Hello World with go.mod 1.23
+        if: startsWith(matrix.go, '1.23') || startsWith(matrix.go, '1.24')
+        uses: ./.github/actions/test-helloworld
+        with:
+          go-version: ${{matrix.go}}
+          mod-version: "1.23"
+
+      - name: Test Hello World with go.mod 1.24
+        if: startsWith(matrix.go, '1.24')
+        uses: ./.github/actions/test-helloworld
+        with:
+          go-version: ${{matrix.go}}
+          mod-version: "1.24"
+
+  cross-compile:
+    continue-on-error: true
+    timeout-minutes: 30
+    strategy:
+      matrix:
+        os: [macos-latest]
+        llvm: [19]
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v5
+      - name: Install dependencies
+        uses: ./.github/actions/setup-deps
+        with:
+          llvm-version: ${{matrix.llvm}}
+
+      - name: Set up Go for building llgo
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: "1.24.2"
+
+      - name: Install wamr
+        run: |
+          git clone https://github.com/bytecodealliance/wasm-micro-runtime.git
+          mkdir wasm-micro-runtime/product-mini/platforms/darwin/build
+          cd wasm-micro-runtime/product-mini/platforms/darwin/build
+          cmake -D WAMR_BUILD_EXCE_HANDLING=1 -D WAMR_BUILD_FAST_INTERP=0 -DWAMR_BUILD_SHARED_MEMORY=1 -DWAMR_BUILD_LIB_WASI_THREADS=1 -DWAMR_BUILD_LIB_PTHREAD=1 -DCMAKE_BUILD_TYPE=Debug -DWAMR_BUILD_DEBUG_INTERP=1 ..
+          make -j8
+          echo "$PWD" >> $GITHUB_PATH
+
+      - name: Install llgo
+        run: |
+          go install ./...
+          echo "LLGO_ROOT=$GITHUB_WORKSPACE" >> $GITHUB_ENV
+
+      - name: Test Cross Compilation (wasm)
+        shell: bash
+        working-directory: _demo/c
+        run: |
+          echo "Testing cross-compilation wasm with Go 1.24.2"
+
+          # Compile for wasm architecture
+          GOOS=wasip1 GOARCH=wasm llgo build -o hello -tags=nogc -v ./helloc
+
+          # Check file type
+          file hello.wasm
+
+          # Run the wasm binary using llgo_wasm
+          iwasm --stack-size=819200000 --heap-size=800000000 hello.wasm

.github/workflows/populate_darwin_sysroot.sh

@@ -1,40 +0,0 @@
-#!/bin/bash
-
-set -e
-
-TMPDIR="$(mktemp -d)"
-export TMPDIR
-trap 'rm -rf "${TMPDIR}"' EXIT
-
-DARWIN_AMD64_LLVM_PREFIX=.sysroot/darwin/amd64/usr/local/opt/llvm@18
-DARWIN_ARM64_LLVM_PREFIX=.sysroot/darwin/arm64/opt/homebrew/opt/llvm@18
-mkdir -p "${DARWIN_AMD64_LLVM_PREFIX}" "${DARWIN_ARM64_LLVM_PREFIX}"
-
-BREW_LLVM_FORMULA_JSON="$(mktemp)"
-curl -fsSL https://formulae.brew.sh/api/formula/llvm@18.json > "${BREW_LLVM_FORMULA_JSON}"
-BREW_LLVM_AMD64_BOTTLE_URL=$(jq -r '.bottle.stable.files.sonoma.url' "${BREW_LLVM_FORMULA_JSON}")
-BREW_LLVM_ARM64_BOTTLE_URL=$(jq -r '.bottle.stable.files.arm64_sonoma.url' "${BREW_LLVM_FORMULA_JSON}")
-curl -fsSL -H "Authorization: Bearer QQ==" "${BREW_LLVM_AMD64_BOTTLE_URL}" | tar -xzf - --strip-components=2 -C "${DARWIN_AMD64_LLVM_PREFIX}"
-curl -fsSL -H "Authorization: Bearer QQ==" "${BREW_LLVM_ARM64_BOTTLE_URL}" | tar -xzf - --strip-components=2 -C "${DARWIN_ARM64_LLVM_PREFIX}"
-
-patch_homebrew_lib_dir() {
-	local LIB_DIR="$1"
-	local HOMEBREW_PREFIX="$2"
-	for DYLIB_FILE in "${LIB_DIR}"/*.dylib; do
-		if [[ -f "${DYLIB_FILE}" ]]; then
-			ID=$(otool -D "${DYLIB_FILE}" | grep '@@HOMEBREW_PREFIX@@' | awk '{print $1}')
-			if [[ -n "${ID}" ]]; then
-				NEW_ID=${ID/'@@HOMEBREW_PREFIX@@'/${HOMEBREW_PREFIX}}
-				install_name_tool -id "${NEW_ID}" "${DYLIB_FILE}"
-			fi
-
-			DEPS=$(otool -L "${DYLIB_FILE}" | grep '@@HOMEBREW_PREFIX@@' | awk '{print $1}')
-			for DEP in ${DEPS}; do
-				NEW_DEP=${DEP/'@@HOMEBREW_PREFIX@@'/${HOMEBREW_PREFIX}}
-				install_name_tool -change "${DEP}" "${NEW_DEP}" "${DYLIB_FILE}"
-			done
-		fi
-	done
-}
-patch_homebrew_lib_dir "${DARWIN_AMD64_LLVM_PREFIX}/lib" /usr/lib
-patch_homebrew_lib_dir "${DARWIN_ARM64_LLVM_PREFIX}/lib" /opt/homebrew

.github/workflows/populate_linux_sysroot.sh

@@ -17,12 +17,7 @@ cat > "${POPULATE_LINUX_SYSROOT_SCRIPT}" << EOF
 export DEBIAN_FRONTEND=noninteractive
 
 apt-get update
-apt-get install -y lsb-release gnupg2 wget rsync
-
-echo "deb http://apt.llvm.org/\$(lsb_release -cs)/ llvm-toolchain-\$(lsb_release -cs)-18 main" | tee /etc/apt/sources.list.d/llvm.list
-wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -
-apt-get update
-apt-get install -y llvm-18-dev
+apt-get install -y build-essential zlib1g-dev rsync
 
 error() {
 	echo -e "\$1" >&2
@@ -106,7 +101,6 @@ do-sync() {
 	args+=(-d)
 	args+=(-h)
 	args+=(--keep-dirlinks)
-	args+=("--info=progress2")
 	args+=(--delete)
 	args+=(--prune-empty-dirs)
 	args+=(--sparse)
@@ -139,5 +133,11 @@ populate_linux_sysroot() {
 		debian:bullseye \
 		/populate_linux_sysroot.sh
 }
-populate_linux_sysroot amd64 "${LINUX_AMD64_PREFIX}"
-populate_linux_sysroot arm64 "${LINUX_ARM64_PREFIX}"
+populate_linux_sysroot amd64 "${LINUX_AMD64_PREFIX}" &
+PID1=$!
+populate_linux_sysroot arm64 "${LINUX_ARM64_PREFIX}" &
+PID2=$!
+
+# Wait for both background processes to complete
+wait $PID1 || exit $?
+wait $PID2 || exit $?

.github/workflows/release-build.yml

@@ -2,49 +2,73 @@ name: Release Build
 
 on:
   push:
-    tags:
-      - "*"
+    branches:
+      - "**"
+      - "!dependabot/**"
+      - "!xgopilot/**"
+    tags: ["*"]
+  pull_request:
+    branches: ["**"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
 
 jobs:
-  populate-darwin-sysroot:
-    runs-on: macos-latest
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Populate Darwin sysroot
-        run: bash .github/workflows/populate_darwin_sysroot.sh
-      - name: Create Darwin sysroot tarball
-        run: tar -czvf .sysroot/darwin.tar.gz -C .sysroot darwin
-      - name: Upload Darwin sysroot tarball
-        uses: actions/upload-artifact@v4
-        with:
-          name: darwin-sysroot-tarball
-          path: .sysroot/darwin.tar.gz
-          compression-level: 0
-  build:
+  setup:
     runs-on: ubuntu-latest
-    needs: populate-darwin-sysroot
+    outputs:
+      linux-cache-key: ${{ steps.cache-keys.outputs.linux-key }}
     steps:
       - name: Check out code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
+      - name: Calculate cache keys
+        id: cache-keys
+        run: |
+          LINUX_KEY="linux-sysroot-${{ hashFiles('.github/workflows/populate_linux_sysroot.sh', '.github/workflows/release-build.yml') }}-v1.0.0"
+          echo "linux-key=$LINUX_KEY" >> $GITHUB_OUTPUT
+  populate-linux-sysroot:
+    runs-on: ubuntu-latest
+    needs: setup
+    timeout-minutes: 30
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v5
+      - name: Check Linux sysroot cache
+        id: cache-linux-sysroot
+        uses: actions/cache/restore@v4
         with:
-          fetch-depth: 0
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: 1.20.x
+          path: .sysroot/linux.tar.gz
+          key: ${{ needs.setup.outputs.linux-cache-key }}
+          lookup-only: true
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3
-      - name: Download Darwin sysroot tarball
-        uses: actions/download-artifact@v4
+        if: steps.cache-linux-sysroot.outputs.cache-hit != 'true'
         with:
-          name: darwin-sysroot-tarball
-          path: .sysroot
-      - name: Populate Darwin sysroot
-        run: tar -xzvf .sysroot/darwin.tar.gz -C .sysroot
+          image: tonistiigi/binfmt:qemu-v7.0.0-28
       - name: Populate Linux sysroot
+        if: steps.cache-linux-sysroot.outputs.cache-hit != 'true'
         run: bash .github/workflows/populate_linux_sysroot.sh
-      - name: Run GoReleaser
+      - name: Create Linux sysroot tarball
+        if: steps.cache-linux-sysroot.outputs.cache-hit != 'true'
+        run: tar -czvf .sysroot/linux.tar.gz -C .sysroot linux
+      - name: Save Linux sysroot cache
+        if: steps.cache-linux-sysroot.outputs.cache-hit != 'true'
+        uses: actions/cache/save@v4
+        with:
+          path: .sysroot/linux.tar.gz
+          key: ${{ needs.setup.outputs.linux-cache-key }}
+  build:
+    runs-on: ubuntu-latest
+    needs: [setup, populate-linux-sysroot]
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v5
+      - name: Set up Release
+        uses: ./.github/actions/setup-goreleaser
+        with:
+          linux-cache-key: ${{ needs.setup.outputs.linux-cache-key }}
+      - name: Run GoReleaser (Build & Test)
         env:
           GITHUB_TOKEN: ${{github.token}}
         run: |
@@ -55,4 +79,129 @@ jobs:
             -v $(pwd):/go/src/llgo \
             -w /go/src/llgo \
             ghcr.io/goreleaser/goreleaser-cross:v1.22 \
-            release --clean --skip nfpm,snapcraft
+            release --verbose --skip=publish,nfpm,snapcraft --snapshot --clean
+
+      - name: Upload Darwin AMD64 Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: llgo-darwin-amd64
+          path: .dist/*darwin-amd64.tar.gz
+          retention-days: 3
+          include-hidden-files: true
+
+      - name: Upload Darwin ARM64 Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: llgo-darwin-arm64
+          path: .dist/*darwin-arm64.tar.gz
+          retention-days: 3
+          include-hidden-files: true
+
+      - name: Upload Linux AMD64 Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: llgo-linux-amd64
+          path: .dist/*linux-amd64.tar.gz
+          retention-days: 3
+          include-hidden-files: true
+
+      - name: Upload Linux ARM64 Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: llgo-linux-arm64
+          path: .dist/*linux-arm64.tar.gz
+          retention-days: 3
+          include-hidden-files: true
+
+      - name: Upload Checksums
+        uses: actions/upload-artifact@v4
+        with:
+          name: llgo-checksums
+          path: .dist/*checksums.txt
+          retention-days: 3
+          include-hidden-files: true
+
+  test-artifacts:
+    needs: build
+    strategy:
+      matrix:
+        include:
+          - os: macos-15-intel
+            goos: darwin
+            goarch: amd64
+            go-version: "1.24.2"
+            go-mod-version: "1.24"
+          - os: macos-latest
+            goos: darwin
+            goarch: arm64
+            go-version: "1.24.2"
+            go-mod-version: "1.24"
+          - os: ubuntu-latest
+            goos: linux
+            goarch: amd64
+            go-version: "1.24.2"
+            go-mod-version: "1.24"
+          - os: ubuntu-24.04-arm
+            goos: linux
+            goarch: arm64
+            go-version: "1.24.2"
+            go-mod-version: "1.24"
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v5
+      - name: Install dependencies
+        uses: ./.github/actions/setup-deps
+        with:
+          install-llvm: false
+      - name: Set up Go
+        uses: actions/setup-go@v6
+        with:
+          go-version: ${{ matrix.go-version }}
+      - name: Download Platform Artifact
+        uses: actions/download-artifact@v5
+        with:
+          name: llgo-${{ matrix.goos }}-${{ matrix.goarch }}
+          path: .
+
+      - name: Extract LLGO Archive
+        run: |
+          echo "Looking for ${{ matrix.goos }}_${{ matrix.goarch }} archive..."
+          ARCHIVE=$(ls *.tar.gz | head -n1)
+          mkdir -p release-llgo
+          tar -xzf "$ARCHIVE" -C release-llgo
+          ls -la release-llgo/
+          echo "${{ github.workspace }}/release-llgo/bin/" >> $GITHUB_PATH
+
+      - name: Test Hello World
+        uses: ./.github/actions/test-helloworld
+        with:
+          go-version: ${{matrix.go-version}}
+          mod-version: ${{ matrix.go-mod-version }}
+
+  release:
+    needs: [setup, test-artifacts, populate-linux-sysroot]
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - name: Set up Release
+        uses: ./.github/actions/setup-goreleaser
+        with:
+          linux-cache-key: ${{ needs.setup.outputs.linux-cache-key }}
+      - name: Run GoReleaser (Release)
+        env:
+          GITHUB_TOKEN: ${{github.token}}
+        run: |
+          echo "Publishing release for tag: ${{ github.ref }}"
+          echo "All artifact tests passed, proceeding with release..."
+          docker run \
+            --rm \
+            -e GITHUB_TOKEN=${GITHUB_TOKEN} \
+            -v /var/run/docker.sock:/var/run/docker.sock \
+            -v $(pwd):/go/src/llgo \
+            -w /go/src/llgo \
+            ghcr.io/goreleaser/goreleaser-cross:v1.22 \
+            release --clean --verbose --skip nfpm,snapcraft

.github/workflows/targets.yml

@@ -0,0 +1,48 @@
+
+name: Targets
+
+on:
+  push:
+    branches:
+      - "**"
+      - "!dependabot/**"
+      - "!xgopilot/**"
+  pull_request:
+    branches: ["**"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  llgo:
+    continue-on-error: true
+    timeout-minutes: 30
+    strategy:
+      matrix:
+        os:
+          - macos-latest
+          - ubuntu-latest
+        llvm: [19]
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v5
+      - name: Install dependencies
+        uses: ./.github/actions/setup-deps
+        with:
+          llvm-version: ${{matrix.llvm}}
+
+      - name: Set up Go for build
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: "1.24.2"
+
+      - name: Install
+        run: |
+          go install ./...
+          echo "LLGO_ROOT=$GITHUB_WORKSPACE" >> $GITHUB_ENV
+
+      - name: Build targets
+        run: |
+          cd _demo/embed/targetsbuild
+          bash build.sh

.github/workflows/test_demo.sh

@@ -1,11 +1,11 @@
 #!/bin/bash
 set -e
 
-# llgo run subdirectories under _demo and _pydemo that contain *.go files
+# llgo run subdirectories under _demo that contain *.go files
 total=0
 failed=0
 failed_cases=""
-for d in ./_demo/* ./_pydemo/*; do
+for d in ./_demo/go/* ./_demo/py/* ./_demo/c/*; do
   if [ -d "$d" ] && [ -n "$(ls "$d"/*.go 2>/dev/null)" ]; then
     total=$((total+1))
     echo "Testing $d"

.github/workflows/test_llgo.sh

@@ -1,36 +0,0 @@
-#!/bin/bash
-set -e
-
-testcmd=/tmp/test
-llgo build -o $testcmd ./c/bdwgc/_test
-cases=$($testcmd)
-total=$(echo "$cases" | wc -l | tr -d ' ')
-failed=0
-failed_cases=""
-
-for idx in $(seq 1 $((total))); do
-  case=$(echo "$cases" | sed -n "${idx}p")
-  case_name=$(echo "$case" | cut -d',' -f2)
-  echo "=== Test case: $case_name"
-  set +e
-  out=$("$testcmd" "$((idx-1))" 2>&1)
-  exit_code=$?
-  set -e
-  if [ "${exit_code:-0}" -ne 0 ]; then
-    echo "failed: $out"
-    failed=$((failed+1))
-    failed_cases="$failed_cases\n* :x: $case_name"
-  else
-    echo "passed"
-  fi
-done
-echo "=== Done"
-echo "$((total-failed))/$total tests passed"
-
-if [ "$failed" -ne 0 ]; then
-  echo ":bangbang: Failed llgo cases:" | tee -a result.md
-  echo -e "$failed_cases" | tee -a result.md
-  exit 1
-else
-  echo ":white_check_mark: All llgo tests passed" | tee -a result.md
-fi

.gitignore

@@ -7,6 +7,7 @@
 *.dll
 *.so
 *.dylib
+*.a
 
 test.db
 demo.ll
@@ -15,6 +16,7 @@ stories*.bin
 .DS_Store
 err.log
 numpy.txt
+result.txt
 
 _go/
 _runtime/
@@ -22,6 +24,7 @@ _tinygo/
 _output/
 build.dir/
 .vscode/
+.venv/
 
 # Test binary, built with `go test -c`
 *.test
@@ -42,3 +45,11 @@ go.work*
 # GoReleaser
 .dist/
 .sysroot/
+
+# Embedded firmware files
+*.bin
+*.hex
+*.elf
+*.uf2
+*.img
+*.zip

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "c/llama2/llama2.c"]
-	path = c/llama2/llama2.c
-	url = https://github.com/karpathy/llama2.c.git

.goreleaser.yaml

@@ -17,65 +17,69 @@ before:
 builds:
   - id: llgo-darwin-amd64
     main: ./cmd/llgo
+    binary: bin/llgo
     flags:
       - -tags=darwin,amd64,byollvm
     ldflags:
-      - -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
+      - -X github.com/goplus/llgo/internal/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/internal/env.buildTime={{.Date}}
     env:
       - CC=o64-clang
       - CXX=o64-clang++
-      - CGO_CPPFLAGS=-I{{.Env.SYSROOT_DARWIN_AMD64}}/usr/local/opt/llvm@18/include -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
-      - CGO_LDFLAGS=-L{{.Env.SYSROOT_DARWIN_AMD64}}/usr/local/opt/llvm@18/lib -Wl,-search_paths_first -Wl,-headerpad_max_install_names -lLLVM-18 -lz -lm
+      - CGO_CPPFLAGS=-I{{.Env.SYSROOT_DARWIN_AMD64}}/crosscompile/clang/include -mmacosx-version-min=10.13 -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+      - CGO_LDFLAGS=-L{{.Env.SYSROOT_DARWIN_AMD64}}/crosscompile/clang/lib -mmacosx-version-min=10.13 -Wl,-search_paths_first -Wl,-headerpad_max_install_names -lLLVM-19 -lz -lm -Wl,-rpath,@executable_path/../crosscompile/clang/lib
     targets:
       - darwin_amd64
     mod_timestamp: "{{.CommitTimestamp}}"
   - id: llgo-darwin-arm64
     main: ./cmd/llgo
+    binary: bin/llgo
     flags:
       - -tags=darwin,arm64,byollvm
     ldflags:
-      - -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
+      - -X github.com/goplus/llgo/internal/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/internal/env.buildTime={{.Date}}
     env:
       - CC=oa64-clang
       - CXX=oa64-clang++
-      - CGO_CPPFLAGS=-I{{.Env.SYSROOT_DARWIN_ARM64}}/opt/homebrew/opt/llvm@18/include -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
-      - CGO_LDFLAGS=-L{{.Env.SYSROOT_DARWIN_ARM64}}/opt/homebrew/opt/llvm@18/lib -Wl,-search_paths_first -Wl,-headerpad_max_install_names -lLLVM-18 -lz -lm
+      - CGO_CPPFLAGS=-I{{.Env.SYSROOT_DARWIN_ARM64}}/crosscompile/clang/include -mmacosx-version-min=10.13 -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+      - CGO_LDFLAGS=-L{{.Env.SYSROOT_DARWIN_ARM64}}/crosscompile/clang/lib -mmacosx-version-min=10.13 -Wl,-search_paths_first -Wl,-headerpad_max_install_names -lLLVM-19 -lz -lm -Wl,-rpath,@executable_path/../crosscompile/clang/lib
     targets:
       - darwin_arm64
     mod_timestamp: "{{.CommitTimestamp}}"
   - id: llgo-linux-amd64
     main: ./cmd/llgo
+    binary: bin/llgo
     flags:
       - -tags=linux,amd64,byollvm
     ldflags:
-      - -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
+      - -X github.com/goplus/llgo/internal/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/internal/env.buildTime={{.Date}}
+      - "-extldflags=-Wl,-rpath,$ORIGIN/../crosscompile/clang/lib"
     env:
       - CC=x86_64-linux-gnu-gcc
       - CXX=x86_64-linux-gnu-g++
-      - CGO_CPPFLAGS=--sysroot={{.Env.SYSROOT_LINUX_AMD64}} -I{{.Env.SYSROOT_LINUX_AMD64}}/usr/include/llvm-18 -I{{.Env.SYSROOT_LINUX_AMD64}}/usr/include/llvm-c-18 -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
-      - CGO_LDFLAGS=--sysroot={{.Env.SYSROOT_LINUX_AMD64}} -L{{.Env.SYSROOT_LINUX_AMD64}}/usr/lib/llvm-18/lib -lLLVM-18
+      - CGO_CPPFLAGS=--sysroot={{.Env.SYSROOT_LINUX_AMD64}} -I{{.Env.SYSROOT_LINUX_AMD64}}/crosscompile/clang/include -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+      - CGO_LDFLAGS=--sysroot={{.Env.SYSROOT_LINUX_AMD64}} -L{{.Env.SYSROOT_LINUX_AMD64}}/crosscompile/clang/lib -L{{.Env.SYSROOT_LINUX_AMD64}}/lib/x86_64-linux-gnu -lLLVM-19 -lz
+      - CGO_LDFLAGS_ALLOW=--sysroot.*
     targets:
       - linux_amd64
     mod_timestamp: "{{.CommitTimestamp}}"
   - id: llgo-linux-arm64
     main: ./cmd/llgo
+    binary: bin/llgo
     flags:
       - -tags=linux,arm64,byollvm
     ldflags:
-      - -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
+      - -X github.com/goplus/llgo/internal/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/internal/env.buildTime={{.Date}}
+      - "-extldflags=-Wl,-rpath,$ORIGIN/../crosscompile/clang/lib"
     env:
       - CC=aarch64-linux-gnu-gcc
       - CXX=aarch64-linux-gnu-g++
-      - CGO_CPPFLAGS=--sysroot={{.Env.SYSROOT_LINUX_ARM64}} -I{{.Env.SYSROOT_LINUX_ARM64}}/usr/include/llvm-18 -I{{.Env.SYSROOT_LINUX_ARM64}}/usr/include/llvm-c-18 -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
-      - CGO_LDFLAGS=--sysroot={{.Env.SYSROOT_LINUX_ARM64}} -L{{.Env.SYSROOT_LINUX_ARM64}}/usr/lib/llvm-18/lib -lLLVM-18
+      - CGO_CPPFLAGS=--sysroot={{.Env.SYSROOT_LINUX_ARM64}} -I{{.Env.SYSROOT_LINUX_ARM64}}/crosscompile/clang/include -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+      - CGO_LDFLAGS=--sysroot={{.Env.SYSROOT_LINUX_ARM64}} -L{{.Env.SYSROOT_LINUX_ARM64}}/crosscompile/clang/lib -L{{.Env.SYSROOT_LINUX_ARM64}}/lib/aarch64-linux-gnu -lLLVM-19 -lz
+      - CGO_LDFLAGS_ALLOW=--sysroot.*
     targets:
       - linux_arm64
     mod_timestamp: "{{.CommitTimestamp}}"
@@ -88,7 +92,12 @@ archives:
     files:
       - LICENSE
       - README.md
-
+      - runtime
+      - targets
+      - src: ".sysroot/{{.Os}}/{{.Arch}}/crosscompile/clang"
+        dst: crosscompile/clang
+        info:
+          mode: 0755
 checksum:
   name_template: "{{.ProjectName}}{{.Version}}.checksums.txt"
 
@@ -99,9 +108,9 @@ nfpms:
     maintainer: Aofei Sheng <aofei@aofeisheng.com>
     description: |
       LLGo is a Go compiler based on LLVM in order to better integrate Go with the C ecosystem including Python. It's a
-      subproject of the Go+ project.
+      subproject of the XGo project.
 
-      LLGo aims to expand the boundaries of Go/Go+, providing limitless possibilities such as:
+      LLGo aims to expand the boundaries of Go/XGo, providing limitless possibilities such as:
 
       - Game development
       - AI and data science
@@ -123,9 +132,9 @@ snapcrafts:
     summary: A Go compiler based on LLVM
     description: |
       LLGo is a Go compiler based on LLVM in order to better integrate Go with the C ecosystem including Python. It's a
-      subproject of the Go+ project.
+      subproject of the XGo project.
 
-      LLGo aims to expand the boundaries of Go/Go+, providing limitless possibilities such as:
+      LLGo aims to expand the boundaries of Go/XGo, providing limitless possibilities such as:
 
       - Game development
       - AI and data science

CLAUDE.md

@@ -0,0 +1,132 @@
+# LLGo Project AI Assistant Guide
+
+This document provides essential information for AI assistants to help fix bugs and implement features in the LLGo project.
+
+## About LLGo
+
+LLGo is a Go compiler based on LLVM designed to better integrate Go with the C ecosystem, including Python and JavaScript. It's a subproject of the XGo project that aims to expand the boundaries of Go/XGo for game development, AI and data science, WebAssembly, and embedded development.
+
+## Project Structure
+
+- `cmd/llgo` - Main llgo compiler command (usage similar to `go` command)
+- `cl/` - Core compiler logic that converts Go packages to LLVM IR
+- `ssa/` - LLVM IR file generation using Go SSA semantics
+- `internal/build/` - Build process orchestration
+- `runtime/` - LLGo runtime library
+- `chore/` - Development tools (llgen, llpyg, ssadump, etc.)
+- `_demo/` - Example programs demonstrating C/C++ interop (`c/hello`, `c/qsort`) and Python integration (`py/callpy`, `py/numpy`)
+- `_cmptest/` - Comparison tests to verify the same program gets the same output with Go and LLGo
+
+## Development Environment
+
+For detailed dependency requirements and installation instructions, see the [Dependencies](README.md#dependencies) and [How to install](README.md#how-to-install) sections in the README.
+
+## Testing & Validation
+
+The following commands and workflows are essential when fixing bugs or implementing features in the LLGo project:
+
+### Run all tests
+```bash
+go test ./...
+```
+
+**Note:** Some tests may fail if optional dependencies (like Python) are not properly configured. The test suite includes comprehensive tests for:
+- Compiler functionality
+- SSA generation
+- C interop
+- Python integration (requires Python development headers)
+
+### Write and run tests for your changes
+
+When adding new functionality or fixing bugs, create appropriate test cases:
+
+```bash
+# Add your test to the relevant package's *_test.go file
+# Then run tests for that package
+go test ./path/to/package
+
+# Or run all tests
+go test ./...
+```
+
+**Important:** The `LLGO_ROOT` environment variable must be set to the repository root when running llgo commands during development.
+
+## Code Quality
+
+Before submitting any code updates, you must run the following formatting and validation commands:
+
+### Format code
+```bash
+go fmt ./...
+```
+
+**Important:** Always run `go fmt ./...` before committing code changes. This ensures consistent code formatting across the project.
+
+### Run static analysis
+```bash
+go vet ./...
+```
+
+**Note:** Currently reports some issues related to lock passing by value in `ssa/type_cvt.go` and a possible unsafe.Pointer misuse in `cl/builtin_test.go`. These are known issues.
+
+
+## Common Development Tasks
+
+### Build the entire project
+```bash
+go build -v ./...
+```
+
+### Build llgo command specifically
+```bash
+go build -o llgo ./cmd/llgo
+```
+
+### Check llgo version
+```bash
+llgo version
+```
+
+### Install llgo for system-wide use
+```bash
+./install.sh
+```
+
+### Build development tools
+```bash
+go install -v ./cmd/...
+go install -v ./chore/...
+```
+
+## Key Modules for Understanding
+
+- `ssa` - Generates LLVM IR using Go SSA semantics
+- `cl` - Core compiler converting Go to LLVM IR
+- `internal/build` - Orchestrates the compilation process
+
+## Debugging
+
+### Disable Garbage Collection
+For testing purposes, you can disable GC:
+```bash
+LLGO_ROOT=/path/to/llgo llgo run -tags nogc .
+```
+
+## LLGO_ROOT Environment Variable
+
+**CRITICAL:** Always set `LLGO_ROOT` to the repository root when running llgo during development:
+
+```bash
+export LLGO_ROOT=/path/to/llgo
+# or
+LLGO_ROOT=/path/to/llgo llgo run .
+```
+
+## Important Notes
+
+1. **Testing Requirement:** All bug fixes and features MUST include tests
+2. **Demo Directory:** Examples in `_demo` are prefixed with `_` to prevent standard `go` command from trying to compile them
+3. **Defer in Loops:** LLGo intentionally does not support `defer` in loops (considered bad practice)
+4. **C Ecosystem Integration:** LLGo uses `go:linkname` directive to link external symbols through ABI
+5. **Python Integration:** Third-party Python libraries require separate installation of library files
+

README.md

@@ -6,11 +6,11 @@ llgo - A Go compiler based on LLVM
 [![GitHub release](https://img.shields.io/github/v/tag/goplus/llgo.svg?label=release)](https://github.com/goplus/llgo/releases)
 [![Coverage Status](https://codecov.io/gh/goplus/llgo/branch/main/graph/badge.svg)](https://codecov.io/gh/goplus/llgo)
 [![GoDoc](https://pkg.go.dev/badge/github.com/goplus/llgo.svg)](https://pkg.go.dev/github.com/goplus/llgo)
-[![Language](https://img.shields.io/badge/language-Go+-blue.svg)](https://github.com/goplus/gop)
+[![Language](https://img.shields.io/badge/language-XGo-blue.svg)](https://github.com/goplus/gop)
 
-LLGo is a Go compiler based on LLVM in order to better integrate Go with the C ecosystem including Python. It's a subproject of [the Go+ project](https://github.com/goplus/gop).
+LLGo is a Go compiler based on LLVM in order to better integrate Go with the C ecosystem including Python and JavaScript. It's a subproject of [the XGo project](https://github.com/goplus/gop).
 
-LLGo aims to expand the boundaries of Go/Go+, providing limitless possibilities such as:
+LLGo aims to expand the boundaries of Go/XGo, providing limitless possibilities such as:
 
 * Game development
 * AI and data science
@@ -21,29 +21,29 @@ LLGo aims to expand the boundaries of Go/Go+, providing limitless possibilities
 How can these be achieved?
 
 ```
-LLGo := Go + C + Python
+LLGo := Go * C ecosystem
 ```
 
-LLGo is compatible with C and Python through the language's **Application Binary Interface (ABI)**, while LLGo is compatible with Go through its **syntax (source code)**.
+LLGo is compatible with C ecosystem through the language's **Application Binary Interface (ABI)**, while LLGo is compatible with Go through its **syntax (source code)**. C ecosystem includes all languages that are ABI compatible with C (eg. C/C++, Python, JavaScript, Objective-C, Swift, etc).
 
 
 ## C/C++ standard libary support
 
 You can import a C/C++ standard library in LLGo!
 
-* [c](https://pkg.go.dev/github.com/goplus/llgo/c)
-* [c/syscall](https://pkg.go.dev/github.com/goplus/llgo/c/syscall)
-* [c/sys](https://pkg.go.dev/github.com/goplus/llgo/c/sys)
-* [c/os](https://pkg.go.dev/github.com/goplus/llgo/c/os)
-* [c/math](https://pkg.go.dev/github.com/goplus/llgo/c/math)
-* [c/math/cmplx](https://pkg.go.dev/github.com/goplus/llgo/c/math/cmplx)
-* [c/math/rand](https://pkg.go.dev/github.com/goplus/llgo/c/math/rand)
-* [c/pthread](https://pkg.go.dev/github.com/goplus/llgo/c/pthread)
-* [c/pthread/sync](https://pkg.go.dev/github.com/goplus/llgo/c/pthread/sync)
-* [c/sync/atomic](https://pkg.go.dev/github.com/goplus/llgo/c/sync/atomic)
-* [c/time](https://pkg.go.dev/github.com/goplus/llgo/c/time)
-* [c/net](https://pkg.go.dev/github.com/goplus/llgo/c/net)
-* [cpp/std](https://pkg.go.dev/github.com/goplus/llgo/cpp/std)
+* [c](https://pkg.go.dev/github.com/goplus/lib/c)
+* [c/syscall](https://pkg.go.dev/github.com/goplus/lib/c/syscall)
+* [c/sys](https://pkg.go.dev/github.com/goplus/lib/c/sys)
+* [c/os](https://pkg.go.dev/github.com/goplus/lib/c/os)
+* [c/math](https://pkg.go.dev/github.com/goplus/lib/c/math)
+* [c/math/cmplx](https://pkg.go.dev/github.com/goplus/lib/c/math/cmplx)
+* [c/math/rand](https://pkg.go.dev/github.com/goplus/lib/c/math/rand)
+* [c/pthread](https://pkg.go.dev/github.com/goplus/lib/c/pthread)
+* [c/pthread/sync](https://pkg.go.dev/github.com/goplus/lib/c/pthread/sync)
+* [c/sync/atomic](https://pkg.go.dev/github.com/goplus/lib/c/sync/atomic)
+* [c/time](https://pkg.go.dev/github.com/goplus/lib/c/time)
+* [c/net](https://pkg.go.dev/github.com/goplus/lib/c/net)
+* [cpp/std](https://pkg.go.dev/github.com/goplus/lib/cpp/std)
 
 Here is a simple example:
 
@@ -52,7 +52,7 @@ Here is a simple example:
 ```go
 package main
 
-import "github.com/goplus/llgo/c"
+import "github.com/goplus/lib/c"
 
 func main() {
 	c.Printf(c.Str("Hello world\n"))
@@ -63,19 +63,19 @@ This is a simple example of calling the C `printf` function to print `Hello worl
 
 The `_demo` directory contains some C standard libary related demos (it start with `_` to prevent the `go` command from compiling it):
 
-* [hello](_demo/hello/hello.go): call C `printf` to print `Hello world`
-* [concat](_demo/concat/concat.go): call C `fprintf` with `stderr`
-* [qsort](_demo/qsort/qsort.go): call C function with a callback (eg. `qsort`)
+* [hello](_demo/c/hello/hello.go): call C `printf` to print `Hello world`
+* [concat](_demo/c/concat/concat.go): call C `fprintf` with `stderr`
+* [qsort](_demo/c/qsort/qsort.go): call C function with a callback (eg. `qsort`)
 
 To run these demos (If you haven't installed `llgo` yet, please refer to [How to install](#how-to-install)):
 
 ```sh
-cd <demo-directory>  # eg. cd _demo/hello
+cd <demo-directory>  # eg. cd _demo/c/hello
 llgo run .
 ```
 
 
-## How support C/C++ and Python
+## How to support C/C++ and Python
 
 LLGo use `go:linkname` to link an extern symbol througth its ABI:
 
@@ -88,7 +88,7 @@ import _ "unsafe" // for go:linkname
 func Sqrt(x float64) float64
 ```
 
-You can directly integrate it into [your own code](_demo/linkname/linkname.go):
+You can directly integrate it into [your own code](_demo/c/linkname/linkname.go):
 
 <!-- embedme doc/_readme/llgo_call_c/call_c.go -->
 
@@ -105,14 +105,14 @@ func main() {
 }
 ```
 
-Or put it into a package (see [c/math](c/math/math.go)):
+Or put it into a package (see [c/math](https://github.com/goplus/lib/tree/main/c/math/math.go)):
 
 <!-- embedme doc/_readme/llgo_call_cmath/call_cmath.go -->
 
 ```go
 package main
 
-import "github.com/goplus/llgo/c/math"
+import "github.com/goplus/lib/c/math"
 
 func main() {
 	println("sqrt(2) =", math.Sqrt(2))
@@ -126,18 +126,18 @@ You can import a Python library in LLGo!
 
 And you can import any Python library into `llgo` through a program called `llpyg` (see [Development tools](#development-tools)). The following libraries have been included in `llgo`:
 
-* [py](https://pkg.go.dev/github.com/goplus/llgo/py) (abi)
-* [py/std](https://pkg.go.dev/github.com/goplus/llgo/py/std) (builtins)
-* [py/sys](https://pkg.go.dev/github.com/goplus/llgo/py/sys)
-* [py/os](https://pkg.go.dev/github.com/goplus/llgo/py/os)
-* [py/math](https://pkg.go.dev/github.com/goplus/llgo/py/math)
-* [py/json](https://pkg.go.dev/github.com/goplus/llgo/py/json)
-* [py/inspect](https://pkg.go.dev/github.com/goplus/llgo/py/inspect)
-* [py/statistics](https://pkg.go.dev/github.com/goplus/llgo/py/statistics)
-* [py/numpy](https://pkg.go.dev/github.com/goplus/llgo/py/numpy)
-* [py/pandas](https://pkg.go.dev/github.com/goplus/llgo/py/pandas)
-* [py/torch](https://pkg.go.dev/github.com/goplus/llgo/py/torch)
-* [py/matplotlib](https://pkg.go.dev/github.com/goplus/llgo/py/matplotlib)
+* [py](https://pkg.go.dev/github.com/goplus/lib/py) (abi)
+* [py/std](https://pkg.go.dev/github.com/goplus/lib/py/std) (builtins)
+* [py/sys](https://pkg.go.dev/github.com/goplus/lib/py/sys)
+* [py/os](https://pkg.go.dev/github.com/goplus/lib/py/os)
+* [py/math](https://pkg.go.dev/github.com/goplus/lib/py/math)
+* [py/json](https://pkg.go.dev/github.com/goplus/lib/py/json)
+* [py/inspect](https://pkg.go.dev/github.com/goplus/lib/py/inspect)
+* [py/statistics](https://pkg.go.dev/github.com/goplus/lib/py/statistics)
+* [py/numpy](https://pkg.go.dev/github.com/goplus/lib/py/numpy)
+* [py/pandas](https://pkg.go.dev/github.com/goplus/lib/py/pandas)
+* [py/torch](https://pkg.go.dev/github.com/goplus/lib/py/torch)
+* [py/matplotlib](https://pkg.go.dev/github.com/goplus/lib/py/matplotlib)
 
 Note: For third-party libraries (such as pandas and pytorch), you still need to install the library files.
 
@@ -149,9 +149,9 @@ Here is an example:
 package main
 
 import (
-	"github.com/goplus/llgo/py"
-	"github.com/goplus/llgo/py/math"
-	"github.com/goplus/llgo/py/std"
+	"github.com/goplus/lib/py"
+	"github.com/goplus/lib/py/math"
+	"github.com/goplus/lib/py/std"
 )
 
 func main() {
@@ -181,9 +181,9 @@ Let's look at a slightly more complex example. For example, we use `numpy` to ca
 package main
 
 import (
-	"github.com/goplus/llgo/py"
-	"github.com/goplus/llgo/py/numpy"
-	"github.com/goplus/llgo/py/std"
+	"github.com/goplus/lib/py"
+	"github.com/goplus/lib/py/numpy"
+	"github.com/goplus/lib/py/std"
 )
 
 func main() {
@@ -204,17 +204,17 @@ func main() {
 
 Here we define two 3x3 matrices a and b, add them to get x, and then print the result.
 
-The `_pydemo` directory contains some python related demos:
+The `_demo/py/` directory contains some python related demos:
 
-* [callpy](_pydemo/callpy/callpy.go): call Python standard library function `math.sqrt`
-* [pi](_pydemo/pi/pi.go): print python constants `math.pi`
-* [statistics](_pydemo/statistics/statistics.go): define a python list and call `statistics.mean` to get the mean
-* [matrix](_pydemo/matrix/matrix.go): a basic `numpy` demo
+* [callpy](_demo/py/callpy/callpy.go): call Python standard library function `math.sqrt`
+* [pi](_demo/py/pi/pi.go): print python constants `math.pi`
+* [statistics](_demo/py/statistics/statistics.go): define a python list and call `statistics.mean` to get the mean
+* [matrix](_demo/py/matrix/matrix.go): a basic `numpy` demo
 
 To run these demos (If you haven't installed `llgo` yet, please refer to [How to install](#how-to-install)):
 
 ```sh
-cd <demo-directory>  # eg. cd _pydemo/callpy
+cd <demo-directory>  # eg. cd _demo/py/callpy
 llgo run .
 ```
 
@@ -225,38 +225,38 @@ LLGo can easily import any libraries from the C ecosystem. Currently, this impor
 
 The currently supported libraries include:
 
-* [c/bdwgc](https://pkg.go.dev/github.com/goplus/llgo/c/bdwgc)
-* [c/cjson](https://pkg.go.dev/github.com/goplus/llgo/c/cjson)
-* [c/clang](https://pkg.go.dev/github.com/goplus/llgo/c/clang)
-* [c/ffi](https://pkg.go.dev/github.com/goplus/llgo/c/ffi)
-* [c/libuv](https://pkg.go.dev/github.com/goplus/llgo/c/libuv)
-* [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)
-* [cpp/inih](https://pkg.go.dev/github.com/goplus/llgo/cpp/inih)
-* [cpp/llvm](https://pkg.go.dev/github.com/goplus/llgo/cpp/llvm)
+* [c/bdwgc](https://pkg.go.dev/github.com/goplus/lib/c/bdwgc)
+* [c/cjson](https://pkg.go.dev/github.com/goplus/lib/c/cjson)
+* [c/clang](https://pkg.go.dev/github.com/goplus/lib/c/clang)
+* [c/ffi](https://pkg.go.dev/github.com/goplus/lib/c/ffi)
+* [c/libuv](https://pkg.go.dev/github.com/goplus/lib/c/libuv)
+* [c/llama2](https://pkg.go.dev/github.com/goplus/lib/c/llama2)
+* [c/lua](https://pkg.go.dev/github.com/goplus/lib/c/lua)
+* [c/neco](https://pkg.go.dev/github.com/goplus/lib/c/neco)
+* [c/openssl](https://pkg.go.dev/github.com/goplus/lib/c/openssl)
+* [c/raylib](https://pkg.go.dev/github.com/goplus/lib/c/raylib)
+* [c/sqlite](https://pkg.go.dev/github.com/goplus/lib/c/sqlite)
+* [c/zlib](https://pkg.go.dev/github.com/goplus/lib/c/zlib)
+* [cpp/inih](https://pkg.go.dev/github.com/goplus/lib/cpp/inih)
+* [cpp/llvm](https://pkg.go.dev/github.com/goplus/lib/cpp/llvm)
 
 Here are some examples related to them:
 
-* [llama2-c](_demo/llama2-c): inference Llama 2 (It's the first llgo AI example)
-* [mkjson](c/cjson/_demo/mkjson/mkjson.go): create a json object and print it
-* [sqlitedemo](c/sqlite/_demo/sqlitedemo/demo.go): a basic sqlite demo
-* [tetris](c/raylib/_demo/tetris/tetris.go): a tetris game based on raylib
+* [llama2-c](_demo/c/llama2-c): inference Llama 2 (It's the first llgo AI example)
+* [mkjson](https://github.com/goplus/lib/tree/main/c/cjson/_demo/mkjson/mkjson.go): create a json object and print it
+* [sqlitedemo](https://github.com/goplus/lib/tree/main/c/sqlite/_demo/sqlitedemo/demo.go): a basic sqlite demo
+* [tetris](https://github.com/goplus/lib/tree/main/c/raylib/_demo/tetris/tetris.go): a tetris game based on raylib
 
 
 ## Go syntax support
 
 All Go syntax (including `cgo`) is already supported. Here are some examples:
 
-* [concat](_demo/concat/concat.go): define a variadic function
-* [genints](_demo/genints/genints.go): various forms of closure usage (including C function, recv.method and anonymous function)
+* [concat](_demo/c/concat/concat.go): define a variadic function
+* [genints](_demo/c/genints/genints.go): various forms of closure usage (including C function, recv.method and anonymous function)
 * [errors](_cmptest/errors/errors.go): demo to implement error interface
 * [defer](_cmptest/defer/defer.go): defer demo
-* [goroutine](_demo/goroutine/goroutine.go): goroutine demo
+* [goroutine](_demo/go/goroutine/goroutine.go): goroutine demo
 
 
 ### Defer
@@ -323,6 +323,7 @@ Here are the Go packages that can be imported correctly:
 * [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)
+* [hash/maphash](https://pkg.go.dev/hash/maphash) (partially)
 * [crypto](https://pkg.go.dev/crypto)
 * [crypto/md5](https://pkg.go.dev/crypto/md5)
 * [crypto/sha1](https://pkg.go.dev/crypto/sha1)
@@ -335,11 +336,12 @@ Here are the Go packages that can be imported correctly:
 * [regexp/syntax](https://pkg.go.dev/regexp/syntax)
 * [go/token](https://pkg.go.dev/go/token)
 * [go/scanner](https://pkg.go.dev/go/scanner)
+* [go/parser](https://pkg.go.dev/go/parser)
 
 
 ## Dependencies
 
-- [Go 1.20+](https://go.dev)
+- [Go 1.21+](https://go.dev)
 - [LLVM 18](https://llvm.org)
 - [Clang 18](https://clang.llvm.org)
 - [LLD 18](https://lld.llvm.org)
@@ -347,7 +349,7 @@ Here are the Go packages that can be imported correctly:
 - [bdwgc/libgc 8.0+](https://www.hboehm.info/gc/)
 - [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))
+- [Python 3.12+](https://www.python.org) (optional, for [github.com/goplus/lib/py](https://pkg.go.dev/github.com/goplus/lib/py))
 
 ## How to install
 
@@ -359,11 +361,11 @@ Follow these steps to generate the `llgo` command (its usage is the same as the
 
 ```sh
 brew update
-brew install llvm@18 bdw-gc openssl cjson libffi
+brew install llvm@19 lld@19 bdw-gc openssl cjson libffi libuv pkg-config
 brew install python@3.12 # optional
-brew link --force libffi
-go install -v github.com/goplus/llgo/cmd/llgo@latest
-
+brew link --overwrite llvm@19 lld@19 libffi
+# curl https://raw.githubusercontent.com/goplus/llgo/refs/heads/main/install.sh | bash
+./install.sh
 ```
 
 ### on Linux
@@ -373,35 +375,52 @@ go install -v github.com/goplus/llgo/cmd/llgo@latest
 <!-- embedme doc/_readme/scripts/install_ubuntu.sh#L2-L1000 -->
 
 ```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
+echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-19 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-18-dev clang-18 libclang-18-dev lld-18 pkg-config libgc-dev libssl-dev zlib1g-dev libcjson-dev libsqlite3-dev
+sudo apt-get install -y llvm-19-dev clang-19 libclang-19-dev lld-19 libunwind-19-dev libc++-19-dev pkg-config libgc-dev libssl-dev zlib1g-dev libcjson-dev libsqlite3-dev libuv1-dev
 sudo apt-get install -y python3.12-dev # optional
-go install -v github.com/goplus/llgo/cmd/llgo@latest
+#curl https://raw.githubusercontent.com/goplus/llgo/refs/heads/main/install.sh | bash
+./install.sh
 ```
 
 #### Alpine Linux
 
 ```sh
-apk add go llvm18-dev clang18-dev lld18 pkgconf gc-dev openssl-dev zlib-dev
+apk add go llvm19-dev clang19-dev lld19 pkgconf gc-dev libunwind-dev openssl-dev zlib-dev
 apk add python3-dev # optional
 apk add g++ # build only
-export LLVM_CONFIG=/usr/lib/llvm18/bin/llvm-config
+export LLVM_CONFIG=/usr/lib/llvm19/bin/llvm-config
 export CGO_CPPFLAGS="$($LLVM_CONFIG --cppflags)"
 export CGO_CXXFLAGS=-std=c++17
 export CGO_LDFLAGS="$($LLVM_CONFIG --ldflags) $($LLVM_CONFIG --libs all)"
-go install -v -tags=byollvm -ldflags="-X github.com/goplus/llgo/xtool/env/llvm.ldLLVMConfigBin=$LLVM_CONFIG" github.com/goplus/llgo/cmd/llgo@latest
+curl https://raw.githubusercontent.com/goplus/llgo/refs/heads/main/install.sh | bash
+```
+
+docker alpine 386 llgo environment
+```
+export GCC_ROOT_DIR=$(gcc -print-search-dirs | grep 'install:' | awk -F': ' '{print $2}')
+export LDFLAGS="-L$GCC_ROOT_DIR -B$GCC_ROOT_DIR -Wl,-dynamic-linker,/lib/ld-musl-i386.so.1"
+llgo run .
 ```
 
 ### on Windows
 
 TODO
 
+### Install from source
+
+<!-- embedme doc/_readme/scripts/install_llgo.sh#L2-L1000 -->
+
+```sh
+git clone https://github.com/goplus/llgo.git
+cd llgo
+./install.sh
+```
 
 ## Development tools
 
-* [pydump](chore/_xtool/pydump): It's the first program compiled by `llgo` (NOT `go`) in a production environment. It outputs symbol information (functions, variables, and constants) from a Python library in JSON format, preparing for the generation of corresponding packages in `llgo`.
+* [pydump](_xtool/pydump): It's the first program compiled by `llgo` (NOT `go`) in a production environment. It outputs symbol information (functions, variables, and constants) from a Python library in JSON format, preparing for the generation of corresponding packages in `llgo`.
 * [pysigfetch](https://github.com/goplus/hdq/tree/main/chore/pysigfetch): It generates symbol information by extracting information from Python's documentation site. This tool is not part of the `llgo` project, but we depend on it.
 * [llpyg](chore/llpyg): It is used to automatically convert Python libraries into Go packages that `llgo` can import. It depends on `pydump` and `pysigfetch` to accomplish the task.
 * [llgen](chore/llgen): It is used to compile Go packages into LLVM IR files (*.ll).
@@ -409,22 +428,24 @@ TODO
 
 How do I generate these tools?
 
-<!-- embedme doc/_readme/scripts/install_llgo.sh#L2-L1000 -->
+<!-- embedme doc/_readme/scripts/install_full.sh#L2-L1000 -->
 
 ```sh
 git clone https://github.com/goplus/llgo.git
 cd llgo
 go install -v ./cmd/...
 go install -v ./chore/...  # compile all tools except pydump
-cd chore/_xtool
+export LLGO_ROOT=$PWD
+cd _xtool
 llgo install ./...   # compile pydump
 go install github.com/goplus/hdq/chore/pysigfetch@v0.8.1  # compile pysigfetch
+
 ```
 
 ## Key modules
 
 Below are the key modules for understanding the implementation principles of `llgo`:
 
-* [llgo/ssa](https://pkg.go.dev/github.com/goplus/llgo/ssa): It generates LLVM IR files (LLVM SSA) using the semantics (interfaces) of Go SSA. Although `LLVM SSA` and `Go SSA` are both IR languages, they work at completely different levels. `LLVM SSA` is closer to machine code, which abstracts different instruction sets. While `Go SSA` is closer to a high-level language. We can think of it as the instruction set of the `Go computer`. `llgo/ssa` is not just limited to the `llgo` compiler. If we view it as the high-level expressive power of `LLVM`, you'll find it very useful. Prior to `llgo/ssa`, you had to operate `LLVM` using machine code semantics. But now, with the advanced SSA form (in the semantics of Go SSA), you can conveniently utilize `LLVM`.
-* [llgo/cl](https://pkg.go.dev/github.com/goplus/llgo/cl): It is the core of the llgo compiler. It converts a Go package into LLVM IR files. It depends on `llgo/ssa`.
-* [llgo/internal/build](https://pkg.go.dev/github.com/goplus/llgo/internal/build): It strings together the entire compilation process of `llgo`. It depends on `llgo/ssa` and `llgo/cl`.
+* [ssa](https://pkg.go.dev/github.com/goplus/llgo/ssa): It generates LLVM IR files (LLVM SSA) using the semantics (interfaces) of Go SSA. Although `LLVM SSA` and `Go SSA` are both IR languages, they work at completely different levels. `LLVM SSA` is closer to machine code, which abstracts different instruction sets. While `Go SSA` is closer to a high-level language. We can think of it as the instruction set of the `Go computer`. `llgo/ssa` is not just limited to the `llgo` compiler. If we view it as the high-level expressive power of `LLVM`, you'll find it very useful. Prior to `llgo/ssa`, you had to operate `LLVM` using machine code semantics. But now, with the advanced SSA form (in the semantics of Go SSA), you can conveniently utilize `LLVM`.
+* [cl](https://pkg.go.dev/github.com/goplus/llgo/cl): It is the core of the llgo compiler. It converts a Go package into LLVM IR files. It depends on `llgo/ssa`.
+* [internal/build](https://pkg.go.dev/github.com/goplus/llgo/internal/build): It strings together the entire compilation process of `llgo`. It depends on `llgo/ssa` and `llgo/cl`.

_cmptest/_goconstdemo/goconst.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"fmt"
+	"go/constant"
+	"go/token"
+)
+
+func main() {
+	// Create the complex number 2.3 + 5i.
+	ar := constant.MakeFloat64(2.3)
+	ai := constant.MakeImag(constant.MakeInt64(5))
+	a := constant.BinaryOp(ar, token.ADD, ai)
+
+	// Compute (2.3 + 5i) * 11.
+	b := constant.MakeUint64(11)
+	c := constant.BinaryOp(a, token.MUL, b)
+
+	// Convert c into a complex128.
+	Ar, exact := constant.Float64Val(constant.Real(c))
+	if !exact {
+		fmt.Printf("Could not represent real part %s exactly as float64\n", constant.Real(c))
+	}
+	Ai, exact := constant.Float64Val(constant.Imag(c))
+	if !exact {
+		fmt.Printf("Could not represent imaginary part %s as exactly as float64\n", constant.Imag(c))
+	}
+	C := complex(Ar, Ai)
+
+	fmt.Println("literal", 25.3+55i)
+	fmt.Println("go/constant", c)
+	fmt.Println("complex128", C)
+}

_cmptest/mathbigdemo/big.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
+}

_demo/c/asmcall/asmcall.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+//llgo:link asm llgo.asm
+func asm(instruction string) {}
+
+func main() {
+	start := time.Now()
+	for i := 0; i < 100000; i++ {
+		asm("nop")
+	}
+	duration := time.Since(start)
+	fmt.Println("Duration:", duration)
+}

_demo/c/asmfullcall/asmfullcall.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"fmt"
+)
+
+//llgo:link asmFull llgo.asm
+func asmFull(instruction string, regs map[string]any) uintptr { return 0 }
+
+var testVar = 0
+
+func main() {
+	verify()
+}
+
+func check(expected, actual int) {
+	if expected != actual {
+		panic(fmt.Sprintf("Expected: %d, Got: %d\n", expected, actual))
+	}
+	fmt.Println("asm check passed:", actual)
+}

_demo/c/asmfullcall/asmfullcall_darwin.go

@@ -0,0 +1,31 @@
+//go:build darwin && arm64
+
+package main
+
+import "unsafe"
+
+func verify() {
+	// 0 output & 0 input
+	asmFull("nop", nil)
+
+	// 0 output & 1 input with memory address
+	addr := uintptr(unsafe.Pointer(&testVar))
+	asmFull("str {value}, [{addr}]", map[string]any{
+		"addr":  addr,
+		"value": 43,
+	})
+	check(43, testVar)
+
+	// 1 output & 1 input
+	res1 := asmFull("mov {}, {value}", map[string]any{
+		"value": 41,
+	})
+	check(41, int(res1))
+
+	// 1 output & 2 inputs
+	res2 := asmFull("add {}, {a}, {b}", map[string]any{
+		"a": 25,
+		"b": 17,
+	})
+	check(42, int(res2))
+}

_demo/c/asmfullcall/asmfullcall_linux.go

@@ -0,0 +1,30 @@
+//go:build linux && amd64
+
+package main
+
+import "unsafe"
+
+func verify() {
+	// 0 output & 0 input
+	asmFull("nop", nil)
+
+	// 0 output & 1 input with memory address
+	addr := uintptr(unsafe.Pointer(&testVar))
+	asmFull("movq {value}, ({addr})", map[string]any{
+		"addr":  addr,
+		"value": 43,
+	})
+	check(43, testVar)
+
+	// 1 output & 1 input
+	res1 := asmFull("movq {value}, {}", map[string]any{
+		"value": 41,
+	})
+	check(41, int(res1))
+
+	res2 := asmFull("leaq ({a},{b}), {}", map[string]any{
+		"a": 25,
+		"b": 17,
+	})
+	check(42, int(res2))
+}

_demo/c/cabi/main.go

@@ -0,0 +1,395 @@
+package main
+
+import (
+	_ "unsafe"
+)
+
+const (
+	LLGoFiles = "wrap/wrap.c"
+)
+
+type point struct {
+	x int32
+	y int32
+}
+
+//go:linkname pt C.pt
+func pt(pt point) point
+
+type point1 struct {
+	x int32
+	y int32
+	z int32
+}
+
+//go:linkname pt1 C.pt1
+func pt1(pt point1) point1
+
+type point2 struct {
+	x int8
+	y int32
+	z int32
+}
+
+//go:linkname pt2 C.pt2
+func pt2(pt point2) point2
+
+type point3 struct {
+	x int8
+	y int8
+	z int8
+}
+
+//go:linkname pt3 C.pt3
+func pt3(pt point3) point3
+
+type point4 struct {
+	x int8
+	y int8
+	z int8
+	m int32
+}
+
+//go:linkname pt4 C.pt4
+func pt4(pt point4) point4
+
+type point5 struct {
+	x int8
+	y int8
+	z int8
+	m int8
+	n int8
+}
+
+//go:linkname pt5 C.pt5
+func pt5(pt point5) point5
+
+type point6 struct {
+	x int8
+	y int8
+	z int8
+	m int8
+	n int8
+	k int32
+}
+
+//go:linkname pt6 C.pt6
+func pt6(pt point6) point6
+
+type point7 struct {
+	x int8
+	y int8
+	z int8
+	m int8
+	n int8
+	k int32
+	o int8
+}
+
+//go:linkname pt7 C.pt7
+func pt7(pt point7) point7
+
+type data1 struct {
+	x int8
+	y int64
+}
+
+//go:linkname fn1 C.fn1
+func fn1(data1) data1
+
+type data2 struct {
+	x int32
+	y int64
+}
+
+//go:linkname fn2 C.fn2
+func fn2(data2) data2
+
+type data3 struct {
+	x int64
+	y int8
+}
+
+//go:linkname fn3 C.fn3
+func fn3(data3) data3
+
+type fdata1 struct {
+	x float32
+}
+
+//go:linkname ff1 C.ff1
+func ff1(fdata1) fdata1
+
+type fdata2 struct {
+	x float32
+	y float32
+}
+
+//go:linkname ff2 C.ff2
+func ff2(fdata2) fdata2
+
+type fdata2i struct {
+	x float32
+	y int32
+}
+
+//go:linkname ff2i C.ff2i
+func ff2i(fdata2i) fdata2i
+
+type fdata3 struct {
+	x float32
+	y float32
+	z float32
+}
+
+//go:linkname ff3 C.ff3
+func ff3(fdata3) fdata3
+
+type fdata4 struct {
+	x float32
+	y float32
+	z float32
+	m float32
+}
+
+//go:linkname ff4 C.ff4
+func ff4(fdata4) fdata4
+
+type fdata5 struct {
+	x float32
+	y float32
+	z float32
+	m float32
+	n float32
+}
+
+//go:linkname ff5 C.ff5
+func ff5(fdata5) fdata5
+
+type fdata2id struct {
+	x int8
+	y int8
+	z float64
+}
+
+//go:linkname ff2id C.ff2id
+func ff2id(fdata2id) fdata2id
+
+type fdata7if struct {
+	x [7]int8
+	y float32
+}
+
+//go:linkname ff7if C.ff7if
+func ff7if(fdata7if) fdata7if
+
+type fdata4if struct {
+	x float32
+	y int8
+	z float32
+	m float32
+}
+
+//go:linkname ff4if C.ff4if
+func ff4if(fdata4if) fdata4if
+
+type array struct {
+	x [8]int32
+}
+
+//go:linkname demo64 C.demo64
+func demo64(n int64) int64
+
+//go:linkname demo32 C.demo32
+func demo32(n int32) int32
+
+type struct32 struct {
+	v int32
+}
+
+//go:linkname demo32s C.demo32s
+func demo32s(v struct32) struct32
+
+type point64 struct {
+	x int64
+	y int64
+}
+
+//go:linkname pt64 C.pt64
+func pt64(pt point64) point64
+
+//go:linkname demo C.demo
+func demo(a array) array
+
+//go:linkname demo2 C.demo2
+func demo2(x int32) array
+
+type ddata1 struct {
+	x float64
+}
+
+//go:linkname dd1 C.dd1
+func dd1(d ddata1) ddata1
+
+type ddata2 struct {
+	x float64
+	y float64
+}
+
+//go:linkname dd2 C.dd2
+func dd2(d ddata2) ddata2
+
+type ddata3 struct {
+	x float64
+	y float64
+	z float64
+}
+
+//go:linkname dd3 C.dd3
+func dd3(d ddata3) ddata3
+
+//llgo:type C
+type Callback func(array, point, point1) array
+
+//go:linkname callback C.callback
+func callback(fn Callback, ar array)
+
+//llgo:type C
+type Callback1 func(array, point, point1) point
+
+//go:linkname callback1 C.callback1
+func callback1(fn Callback1, ar array)
+
+//go:linkname mycallback C.mycallback
+func mycallback(ar array, pt point, pt1 point1) point
+
+func myfn1(ar array, pt point, pt1 point1) point {
+	println("=>", ar.x[0], ar.x[1], ar.x[7], pt.x, pt.y, pt1.x, pt1.y, pt1.z)
+	return point{100, 200}
+}
+
+//export export_demo
+func export_demo(ar array) array {
+	println("=> export", ar.x[0], ar.x[1], ar.x[7])
+	return ar
+}
+
+func main() {
+	cabi_demo()
+	callback_demo()
+}
+
+func callback_demo() {
+	export_demo(array{x: [8]int32{1, 2, 3, 4, 5, 6, 7, 8}})
+
+	callback(func(ar array, pt point, pt1 point1) array {
+		println("=> callback", ar.x[0], ar.x[1], ar.x[7], pt.x, pt.y, pt1.x, pt1.y, pt1.z)
+		return array{x: [8]int32{8, 7, 6, 5, 4, 3, 2, 1}}
+	}, array{x: [8]int32{1, 2, 3, 4, 5, 6, 7, 8}})
+
+	callback1(func(ar array, pt point, pt1 point1) point {
+		println("=> callback1", ar.x[0], ar.x[1], ar.x[7], pt.x, pt.y, pt1.x, pt1.y, pt1.z)
+		return point{100, 200}
+	}, array{x: [8]int32{1, 2, 3, 4, 5, 6, 7, 8}})
+	ret := mycallback(array{x: [8]int32{1, 2, 3, 4, 5, 6, 7, 8}}, point{1, 2}, point1{1, 2, 3})
+	println("=> mycallback", ret.x, ret.y)
+	callback1(myfn1, array{x: [8]int32{1, 2, 3, 4, 5, 6, 7, 8}})
+	callback1(myfn1, array{x: [8]int32{8, 7, 6, 5, 4, 3, 2, 1}})
+	callback1(mycallback, array{x: [8]int32{10, 20, 30, 40, 50, 60, 70, 80}})
+}
+
+func cabi_demo() {
+	i32 := demo32(1024)
+	println("=> demo32", i32)
+
+	s32 := demo32s(struct32{100})
+	println("=> demo32s", s32.v)
+
+	i64 := demo64(1024)
+	println("=> demo64", i64)
+
+	p64 := pt64(point64{1024, -1024})
+	println("=> pt64", p64.x, p64.y)
+
+	r := demo(array{x: [8]int32{1, 2, 3, 4, 5, 6, 7, 8}})
+	println("=> demo", r.x[0], r.x[1])
+
+	r2 := demo2(100)
+	println("=> demo2", r2.x[0], r2.x[1], r2.x[7])
+
+	p0 := pt(point{1, 2})
+	println("=> pt0", p0.x, p0.y)
+
+	p1 := pt1(point1{1, 2, 3})
+	println("=> pt1", p1.x, p1.y, p1.z)
+
+	p2 := pt2(point2{1, 2, 3})
+	println("=> pt2", p2.x, p2.y, p2.z)
+
+	p3 := pt3(point3{1, 2, 3})
+	println("=> pt3", p3.x, p3.y, p3.z)
+
+	p4 := pt4(point4{1, 2, 3, 4})
+	println("=> pt4", p4.x, p4.y, p4.z, p4.m)
+
+	p5 := pt5(point5{1, 2, 3, 4, 5})
+	println("=> pt5", p5.x, p5.y, p5.z, p5.m, p5.n)
+
+	p6 := pt6(point6{1, 2, 3, 4, 5, 6})
+	println("=> pt6", p6.x, p6.y, p6.z, p6.m, p6.n, p6.k)
+
+	p7 := pt7(point7{1, 2, 3, 4, 5, 6, 7})
+	println("=> pt7", p7.x, p7.y, p7.z, p7.m, p7.n, p7.k, p7.o)
+
+	// skip wrap
+	fd1 := fn1(data1{1, 2})
+	println("=> fd1", fd1.x, fd1.y)
+
+	fd2 := fn2(data2{1, 2})
+	println("=> fd2", fd2.x, fd2.y)
+
+	fd3 := fn3(data3{1, 2})
+	println("=> fd3", fd3.x, fd3.y)
+
+	// float
+	f1 := ff1(fdata1{1.1})
+	println("=> f1", f1.x)
+
+	// float
+	f2 := ff2(fdata2{1.1, 2.1})
+	println("=> f2", f2.x, f2.y)
+
+	// float
+	f2i := ff2i(fdata2i{1.1, 2})
+	println("=> f2i", f2i.x, f2i.y)
+
+	// float
+	f3 := ff3(fdata3{1.1, 2.1, 3.1})
+	println("=> f3", f3.x, f3.y, f3.z)
+
+	// float
+	f4 := ff4(fdata4{1.1, 2.1, 3.1, 4.1})
+	println("=> f4", f4.x, f4.y, f4.z, f4.m)
+
+	// float
+	f5 := ff5(fdata5{1.1, 2.1, 3.1, 4.1, 5.1})
+	println("=> f5", f5.x, f5.y, f5.z, f5.m, f5.n)
+
+	f2id := ff2id(fdata2id{1, 2, 3.1})
+	println("=> f2id", f2id.x, f2id.y, f2id.z)
+
+	f7if := ff7if(fdata7if{[7]int8{1, 2, 3, 4, 5, 6, 7}, 3.1})
+	println("=> f7if", f7if.x[0], f7if.x[1], f7if.y)
+
+	f4if := ff4if(fdata4if{1.1, 2, 3.1, 4.1})
+	println("=> f4if", f4if.x, f4if.y, f4if.z, f4if.m)
+
+	d1 := dd1(ddata1{1.1})
+	println("=> dd1", d1.x)
+
+	d2 := dd2(ddata2{1.1, 2.1})
+	println("=> dd2", d2.x, d2.y)
+
+	d3 := dd3(ddata3{1.1, 2.1, 3.1})
+	println("=> dd3", d3.x, d3.y, d3.z)
+}

_demo/c/cabi/wrap/wrap.c

@@ -0,0 +1,325 @@
+extern int printf(const char *format, ...);
+
+int demo32(int v) {
+    return v+100;
+}
+
+long long demo64(long long v) {
+    return v+100;
+}
+
+struct struct32 {
+     int v;
+};
+
+struct point64 {
+    long long x;
+    long long y;
+};
+
+struct point64 pt64(struct point64 pt) {
+    printf("point64: %lld %lld\n",pt.x,pt.y);
+    return pt;
+}
+
+struct struct32 demo32s(struct struct32 v) {
+    printf("struct32: %d\n",v.v);
+    struct struct32 v2 = {v.v+100};
+    return v2;
+}
+
+struct point {
+    int x;
+    int y;
+};
+
+struct point pt(struct point pt) {
+    printf("point: %d %d\n",pt.x,pt.y);
+    return pt;
+}
+
+struct point1 {
+    int x;
+    int y;
+    int z;
+};
+
+struct point1 pt1(struct point1 pt) {
+    printf("point1: %d %d %d\n",pt.x,pt.y,pt.z);
+    return pt;
+}
+
+struct point2 {
+    char x;
+    int y;
+    int z;
+};
+
+struct point2 pt2(struct point2 pt) {
+    printf("point2: %d %d %d\n",pt.x,pt.y,pt.z);
+    return pt;
+}
+
+struct point3 {
+    char x;
+    char y;
+    char z;
+};
+
+struct point3 pt3(struct point3 pt) {
+    printf("point3: %d %d %d\n",pt.x,pt.y,pt.z);
+    return pt;
+}
+
+struct point4 {
+    char x;
+    char y;
+    char z;
+    int  m;
+};
+
+struct point4 pt4(struct point4 pt) {
+    printf("point4: %d %d %d %d\n",pt.x,pt.y,pt.z,pt.m);
+    return pt;
+}
+
+struct point5 {
+    char x;
+    char y;
+    char z;
+    char m;
+    char n;
+};
+
+struct point5 pt5(struct point5 pt) {
+    printf("point5: %d %d %d %d %d\n",pt.x,pt.y,pt.z,pt.m,pt.n);
+    return pt;
+}
+
+struct point6 {
+    char x;
+    char y;
+    char z;
+    char m;
+    char n;
+    int  k;
+};
+
+struct point6 pt6(struct point6 pt) {
+    printf("point6: %d %d %d %d %d %d\n",pt.x,pt.y,pt.z,pt.m,pt.n,pt.k);
+    return pt;
+}
+
+struct point7 {
+    char x;
+    char y;
+    char z;
+    char m;
+    char n;
+    int  k;
+    char o;
+};
+
+struct point7 pt7(struct point7 pt) {
+    printf("point7: %d %d %d %d %d %d %d\n",pt.x,pt.y,pt.z,pt.m,pt.n,pt.k,pt.o);
+    return pt;
+}
+
+struct data1 {
+    char x;
+    long long y;
+};
+
+struct data1 fn1(struct data1 pt) {
+    printf("data1: %d %lld\n",pt.x,pt.y);
+    return pt;
+}
+
+struct data2 {
+    int x;
+    long long y;
+};
+
+struct data2 fn2(struct data2 pt) {
+    printf("data2: %d %lld\n",pt.x,pt.y);
+    return pt;
+}
+
+struct data3 {
+    long long x;
+    char y;
+};
+
+struct data3 fn3(struct data3 pt) {
+    printf("data3: %lld %d\n",pt.x,pt.y);
+    return pt;
+}
+
+struct fdata1 {
+    float x;
+};
+
+struct fdata1 ff1(struct fdata1 pt) {
+    printf("ff1: %f\n",pt.x);
+    return pt;
+}
+
+struct ddata1 {
+    double x;
+};
+
+struct ddata1 dd1(struct ddata1 pt) {
+    printf("dd1: %f\n",pt.x);
+    return pt;
+}
+
+struct ddata2 {
+    double x;
+    double y;
+};
+
+struct ddata2 dd2(struct ddata2 pt) {
+    printf("dd2: %f %f\n",pt.x,pt.y);
+    return pt;
+}
+
+struct ddata3 {
+    double x;
+    double y;
+    double z;
+};
+
+struct ddata3 dd3(struct ddata3 pt) {
+    printf("dd3: %f %f %f\n",pt.x,pt.y,pt.z);
+    return pt;
+}
+
+struct fdata2i {
+    float x;
+    int   y;
+};
+
+struct fdata2i ff2i(struct fdata2i pt) {
+    printf("ff2i: %f %d\n",pt.x,pt.y);
+    return pt;
+}
+
+struct fdata2 {
+    float x;
+    float y;
+};
+
+struct fdata2 ff2(struct fdata2 pt) {
+    printf("ff2: %f %f\n",pt.x,pt.y);
+    return pt;
+}
+
+struct fdata3 {
+    float x;
+    float y;
+    float z;
+};
+
+struct fdata3 ff3(struct fdata3 pt) {
+    printf("ff3: %f %f %f\n",pt.x,pt.y,pt.z);
+    return pt;
+}
+
+struct fdata4 {
+    float x;
+    float y;
+    float z;
+    float m;
+};
+
+struct fdata4 ff4(struct fdata4 pt) {
+    printf("ff4: %f %f %f %f\n",pt.x,pt.y,pt.z,pt.m);
+    return pt;
+}
+
+struct fdata5 {
+    float x;
+    float y;
+    float z;
+    float m;
+    float n;
+};
+
+struct fdata5 ff5(struct fdata5 pt) {
+    printf("ff5: %f %f %f %f %f\n",pt.x,pt.y,pt.z,pt.m,pt.n);
+    return pt;
+}
+
+struct fdata2id {
+    char     x;
+    char     y;
+    double   z;
+};
+
+struct fdata2id ff2id(struct fdata2id pt) {
+    printf("ff6: %d %d %f\n",pt.x,pt.y,pt.z);
+    return pt;
+}
+
+struct fdata7if {
+    char    x[7];
+    float    z;
+};
+
+struct fdata7if ff7if(struct fdata7if pt) {
+    printf("ff7if: %d %d %f\n",pt.x[0],pt.x[1],pt.z);
+    return pt;
+}
+
+struct fdata4if {
+    float    x;
+    char     y;
+    float    z;
+    float    m;
+};
+
+struct fdata4if ff4if(struct fdata4if pt) {
+    printf("ff4if: %f %d %f %f\n",pt.x,pt.y,pt.z,pt.m);
+    return pt;
+}
+
+struct array {
+    int x[8];
+};
+
+struct array demo(struct array a) {
+    printf("demo: %d %d %d\n",a.x[0],a.x[1],a.x[2]);
+    return a;
+}
+
+struct array demo2(int a1){
+    struct array x;
+    for (int i = 0; i < 8; i++) {
+        x.x[i] = i+a1;
+    }
+    return x;
+}
+
+void callback(struct array (*fn)(struct array ar, struct point pt, struct point1 pt1), struct array ar) {
+    demo(ar);
+    struct point pt = {1,2};
+    struct point1 pt1 = {1,2,3};
+    struct array ret = fn(ar,pt,pt1);
+    demo(ret);
+}
+
+void callback1(struct point (*fn)(struct array ar, struct point pt, struct point1 pt1), struct array ar) {
+    printf("callback1 array: %d %d %d\n",ar.x[0],ar.x[1],ar.x[7]);
+    struct point pt = {1,2};
+    struct point1 pt1 = {1,2,3};
+    struct point ret = fn(ar,pt,pt1);
+    printf("callback1 ret: %d,%d\n",ret.x,ret.y);
+}
+
+struct point mycallback(struct array ar, struct point pt, struct point1 pt1) {
+    printf("mycallback array: %d %d %d\n",ar.x[0],ar.x[1],ar.x[7]);
+    printf("mycallback pt: %d %d\n",pt.x,pt.y);
+    printf("mycallback pt1: %d %d %d\n",pt1.x,pt1.y,pt1.z);
+    struct point ret = {pt.x+pt1.x, pt.y+pt1.y};
+    return ret;
+}

_demo/c/cabisret/main.go

@@ -0,0 +1,39 @@
+package main
+
+type array9 struct {
+	x [9]float32
+}
+
+func demo1(a array9) array9 {
+	a.x[0] += 1
+	return a
+}
+
+func demo2(a array9) array9 {
+	for i := 0; i < 1024*128; i++ {
+		a = demo1(a)
+	}
+	return a
+}
+
+func testDemo() {
+	ar := array9{x: [9]float32{1, 2, 3, 4, 5, 6, 7, 8, 9}}
+	for i := 0; i < 1024*128; i++ {
+		ar = demo1(ar)
+	}
+	ar = demo2(ar)
+	println(ar.x[0], ar.x[1])
+}
+
+func testSlice() {
+	var b []byte
+	for i := 0; i < 1024*128; i++ {
+		b = append(b, byte(i))
+	}
+	_ = b
+}
+
+func main() {
+	testDemo()
+	testSlice()
+}

_demo/c/cargs/demo.go

@@ -0,0 +1,144 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	_ "unsafe"
+
+	"github.com/goplus/lib/c"
+)
+
+const LLGoPackage string = "link: $(pkg-config --libs cargs);"
+
+type Option struct {
+	Identifier    c.Char
+	AccessLetters *c.Char
+	AccessName    *c.Char
+	ValueName     *c.Char
+	Description   *c.Char
+}
+
+type OptionContext struct {
+	Options     *Option
+	OptionCount c.SizeT
+	Argc        c.Int
+	Argv        **c.Char
+	Index       c.Int
+	InnerIndex  c.Int
+	ErrorIndex  c.Int
+	ErrorLetter c.Char
+	ForcedEnd   bool
+	Identifier  c.Char
+	Value       *c.Char
+}
+
+// llgo:type C
+type Printer func(__llgo_arg_0 c.Pointer, __llgo_arg_1 *c.Char, __llgo_va_list ...interface{}) c.Int
+
+// llgo:link (*OptionContext).OptionInit C.cag_option_init
+func (recv_ *OptionContext) OptionInit(options *Option, option_count c.SizeT, argc c.Int, argv **c.Char) {
+}
+
+// llgo:link (*OptionContext).OptionFetch C.cag_option_fetch
+func (recv_ *OptionContext) OptionFetch() bool {
+	return false
+}
+
+// llgo:link (*OptionContext).OptionGetIdentifier C.cag_option_get_identifier
+func (recv_ *OptionContext) OptionGetIdentifier() c.Char {
+	return 0
+}
+
+// llgo:link (*OptionContext).OptionGetValue C.cag_option_get_value
+func (recv_ *OptionContext) OptionGetValue() *c.Char {
+	return nil
+}
+
+// llgo:link (*OptionContext).OptionGetIndex C.cag_option_get_index
+func (recv_ *OptionContext) OptionGetIndex() c.Int {
+	return 0
+}
+
+// llgo:link (*OptionContext).OptionGetErrorIndex C.cag_option_get_error_index
+func (recv_ *OptionContext) OptionGetErrorIndex() c.Int {
+	return 0
+}
+
+// llgo:link (*OptionContext).OptionGetErrorLetter C.cag_option_get_error_letter
+func (recv_ *OptionContext) OptionGetErrorLetter() c.Char {
+	return 0
+}
+
+// llgo:link (*OptionContext).OptionPrintError C.cag_option_print_error
+func (recv_ *OptionContext) OptionPrintError(destination *c.FILE) {
+}
+
+// llgo:link (*OptionContext).OptionPrinterError C.cag_option_printer_error
+func (recv_ *OptionContext) OptionPrinterError(printer Printer, printer_ctx c.Pointer) {
+}
+
+// llgo:link (*Option).OptionPrint C.cag_option_print
+func (recv_ *Option) OptionPrint(option_count c.SizeT, destination *c.FILE) {
+}
+
+// llgo:link (*Option).OptionPrinter C.cag_option_printer
+func (recv_ *Option) OptionPrinter(option_count c.SizeT, printer Printer, printer_ctx c.Pointer) {
+}
+
+// llgo:link (*OptionContext).OptionPrepare C.cag_option_prepare
+func (recv_ *OptionContext) OptionPrepare(options *Option, option_count c.SizeT, argc c.Int, argv **c.Char) {
+}
+
+// llgo:link (*OptionContext).OptionGet C.cag_option_get
+func (recv_ *OptionContext) OptionGet() c.Char {
+	return 0
+}
+
+func main() {
+	options := []Option{
+		{
+			Identifier:    'h',
+			AccessLetters: c.Str("h"),
+			AccessName:    c.Str("help"),
+			ValueName:     nil,
+			Description:   c.Str("Show help information"),
+		},
+		{
+			Identifier:    'v',
+			AccessLetters: c.Str("v"),
+			AccessName:    c.Str("version"),
+			ValueName:     nil,
+			Description:   c.Str("Show version information"),
+		},
+	}
+
+	args := os.Args
+
+	// Convert Go string array to C-style argv
+	argv := make([]*int8, len(args))
+	for i, arg := range args {
+		argv[i] = c.AllocaCStr(arg)
+	}
+
+	// Initialize option context
+	var context OptionContext
+	context.OptionInit(&options[0], uintptr(len(options)), c.Int(len(args)), &argv[0])
+
+	// Process all options
+	identifierFound := false
+	for context.OptionFetch() {
+		identifierFound = true
+		identifier := context.OptionGetIdentifier()
+		switch identifier {
+		case 'h':
+			fmt.Println("Help: This is a simple command-line parser demo")
+		case 'v':
+			fmt.Println("Version: 1.0.0")
+		}
+	}
+
+	// Default output if no identifier is found
+	if !identifierFound {
+		fmt.Println("Demo Command-line Tool\nIdentifier:\n\t-h: Help\n\t-v: Version")
+	}
+}

_demo/c/catomic/atomic.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/goplus/llgo/c/sync/atomic"
+	"github.com/goplus/lib/c/sync/atomic"
 )
 
 func main() {

_demo/c/cexec/exec.go

@@ -1,8 +1,8 @@
 package main
 
 import (
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/os"
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/os"
 )
 
 func main() {

_demo/c/cgofull/bar.go

@@ -0,0 +1,16 @@
+package main
+
+/*
+#cgo CFLAGS: -DBAR
+#include <stdio.h>
+#include "foo.h"
+static void foo(Foo* f) {
+	printf("foo in bar: %d\n", f->a);
+}
+*/
+import "C"
+
+func Bar(f *C.Foo) {
+	C.print_foo(f)
+	C.foo(f)
+}

_demo/c/cgofull/cgofull.go

@@ -0,0 +1,157 @@
+package main
+
+/*
+#cgo windows,!amd64 CFLAGS: -D_WIN32
+#cgo !windows CFLAGS: -D_POSIX
+#cgo windows,amd64 CFLAGS: -D_WIN64
+#cgo linux,amd64 CFLAGS: -D_LINUX64
+#cgo !windows,amd64 CFLAGS: -D_UNIX64
+#cgo pkg-config: python3-embed
+#include <stdio.h>
+#include <Python.h>
+#include "foo.h"
+typedef struct {
+	int a;
+} s4;
+
+typedef struct {
+  int a;
+  int b;
+} s8;
+
+typedef struct {
+  int a;
+  int b;
+  int c;
+} s12;
+
+typedef struct {
+  int a;
+  int b;
+  int c;
+  int d;
+} s16;
+
+typedef struct {
+  int a;
+  int b;
+  int c;
+  int d;
+  int e;
+} s20;
+
+static int test_structs(s4* s4, s8* s8, s12* s12, s16* s16, s20* s20) {
+  printf("s4.a: %d\n", s4->a);
+  printf("s8.a: %d, s8.b: %d\n", s8->a, s8->b);
+  printf("s12.a: %d, s12.b: %d, s12.c: %d\n", s12->a, s12->b, s12->c);
+  printf("s16.a: %d, s16.b: %d, s16.c: %d, s16.d: %d\n", s16->a, s16->b, s16->c, s16->d);
+  printf("s20.a: %d, s20.b: %d, s20.c: %d, s20.d: %d, s20.e: %d\n", s20->a, s20->b, s20->c, s20->d, s20->e);
+
+  return s4->a + s8->a + s8->b + s12->a + s12->b + s12->c + s16->a + s16->b + s16->c + s16->d + s20->a + s20->b + s20->c + s20->d + s20->e;
+}
+
+static void test_macros() {
+#ifdef FOO
+	printf("FOO is defined\n");
+#endif
+#ifdef BAR
+	printf("BAR is defined\n");
+#endif
+#ifdef _WIN32
+	printf("WIN32 is defined\n");
+#endif
+#ifdef _POSIX
+	printf("POSIX is defined\n");
+#endif
+#ifdef _WIN64
+	printf("WIN64 is defined\n");
+#endif
+#ifdef _LINUX64
+	printf("LINUX64 is defined\n");
+#endif
+#ifdef _UNIX64
+	printf("UNIX64 is defined\n");
+#endif
+}
+
+#define MY_VERSION "1.0.0"
+#define MY_CODE 0x12345678
+
+static void test_void() {
+	printf("test_void\n");
+}
+
+typedef int (*Cb)(int);
+
+extern int go_callback(int);
+
+extern int c_callback(int i);
+
+static void test_callback(Cb cb) {
+	printf("test_callback, cb: %p, go_callback: %p, c_callback: %p\n", cb, go_callback, c_callback);
+	printf("test_callback, *cb: %p, *go_callback: %p, *c_callback: %p\n", *(void**)cb, *(void**)(go_callback), *(void**)(c_callback));
+	printf("cb result: %d\n", cb(123));
+	printf("done\n");
+}
+
+extern int go_callback_not_use_in_go(int);
+
+static void run_callback() {
+	test_callback(c_callback);
+	test_callback(go_callback_not_use_in_go);
+}
+*/
+import "C"
+import (
+	"fmt"
+	"unsafe"
+
+	"github.com/goplus/llgo/_demo/c/cgofull/pymod1"
+	"github.com/goplus/llgo/_demo/c/cgofull/pymod2"
+)
+
+//export go_callback_not_use_in_go
+func go_callback_not_use_in_go(i C.int) C.int {
+	return i + 1
+}
+
+//export go_callback
+func go_callback(i C.int) C.int {
+	return i + 1
+}
+
+func main() {
+	runPy()
+	f := &C.Foo{a: 1}
+	Foo(f)
+	Bar(f)
+	C.test_macros()
+	r := C.test_structs(&C.s4{a: 1}, &C.s8{a: 1, b: 2}, &C.s12{a: 1, b: 2, c: 3}, &C.s16{a: 1, b: 2, c: 3, d: 4}, &C.s20{a: 1, b: 2, c: 3, d: 4, e: 5})
+	fmt.Println(r)
+	if r != 35 {
+		panic("test_structs failed")
+	}
+	fmt.Println(C.MY_VERSION)
+	fmt.Println(int(C.MY_CODE))
+	C.test_void()
+
+	println("call run_callback")
+	C.run_callback()
+
+	// test _Cgo_ptr and _cgoCheckResult
+	println("call with go_callback")
+	C.test_callback((C.Cb)(C.go_callback))
+
+	println("call with c_callback")
+	C.test_callback((C.Cb)(C.c_callback))
+}
+
+func runPy() {
+	Initialize()
+	defer Finalize()
+	Run("print('Hello, Python!')")
+	C.PyObject_Print((*C.PyObject)(unsafe.Pointer(pymod1.Float(1.23))), C.stderr, 0)
+	C.PyObject_Print((*C.PyObject)(unsafe.Pointer(pymod2.Long(123))), C.stdout, 0)
+	// test _Cgo_use
+	C.PyObject_Print((*C.PyObject)(unsafe.Pointer(C.PyComplex_FromDoubles(C.double(1.23), C.double(4.56)))), C.stdout, 0)
+}

_demo/c/cgofull/foo.c

@@ -0,0 +1,12 @@
+#include <stdio.h>
+#include "foo.h"
+
+void print_foo(Foo *f)
+{
+	printf("print_foo: %d\n", f->a);
+}
+
+int c_callback(int i)
+{
+	return i + 1;
+}

_demo/c/cgofull/foo.go

@@ -0,0 +1,16 @@
+package main
+
+/*
+#cgo CFLAGS: -DFOO
+#include <stdio.h>
+#include "foo.h"
+static void foo(Foo* f) {
+	printf("foo in bar: %d\n", f->a);
+}
+*/
+import "C"
+
+func Foo(f *C.Foo) {
+	C.print_foo(f)
+	C.foo(f)
+}

_demo/c/cgofull/foo.h

@@ -0,0 +1,7 @@
+#pragma once
+
+typedef struct {
+	int a;
+} Foo;
+
+extern void print_foo(Foo* f);

_demo/c/cgofull/py.go

@@ -0,0 +1,24 @@
+package main
+
+/*
+#cgo pkg-config: python3-embed
+#include <Python.h>
+*/
+import "C"
+import "fmt"
+
+func Initialize() {
+	C.Py_Initialize()
+}
+
+func Finalize() {
+	C.Py_Finalize()
+}
+
+func Run(code string) error {
+	if C.PyRun_SimpleString(C.CString(code)) != 0 {
+		C.PyErr_Print()
+		return fmt.Errorf("failed to run code")
+	}
+	return nil
+}

_demo/c/cgofull/pymod1/pymod1.go

@@ -0,0 +1,11 @@
+package pymod1
+
+/*
+#cgo pkg-config: python3-embed
+#include <Python.h>
+*/
+import "C"
+
+func Float(f float64) *C.PyObject {
+	return C.PyFloat_FromDouble(C.double(f))
+}

_demo/c/cgofull/pymod2/pymod2.go

@@ -0,0 +1,11 @@
+package pymod2
+
+/*
+#cgo pkg-config: python3-embed
+#include <Python.h>
+*/
+import "C"
+
+func Long(l int64) *C.PyObject {
+	return C.PyLong_FromLongLong(C.longlong(l))
+}

_demo/c/concat/concat.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/goplus/llgo/c"
+	"github.com/goplus/lib/c"
 )
 
 func concat(args ...string) (ret string) {

_demo/c/cppintf/cppintf.go

@@ -1,9 +1,9 @@
 package main
 
 import (
-	"github.com/goplus/llgo/_demo/cppintf/foo"
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/math"
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/math"
+	"github.com/goplus/llgo/_demo/c/cppintf/foo"
 )
 
 type Bar struct {

_demo/c/cppmintf/cpp_multi_intf.go

@@ -3,9 +3,9 @@ package main
 import (
 	"unsafe"
 
-	"github.com/goplus/llgo/_demo/cppmintf/foo"
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/math"
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/math"
+	"github.com/goplus/llgo/_demo/c/cppmintf/foo"
 )
 
 type Bar struct {

_demo/c/cppstr/cppstr.go

@@ -1,8 +1,8 @@
 package main
 
 import (
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/cpp/std"
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/cpp/std"
 )
 
 func main() {

_demo/c/crand/rand.go

@@ -3,9 +3,9 @@ package main
 import (
 	"fmt"
 
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/math/rand"
-	"github.com/goplus/llgo/c/time"
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/math/rand"
+	"github.com/goplus/lib/c/time"
 )
 
 func fastrand64() uint64 {

_demo/c/ctime/time.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/goplus/llgo/c/time"
+import "github.com/goplus/lib/c/time"
 
 func main() {
 	var tv time.Timespec

_demo/c/fcntl/fcntl.go

@@ -1,9 +1,10 @@
 package main
 
 import (
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/os"
 	"unsafe"
+
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/os"
 )
 
 func main() {
@@ -45,8 +46,6 @@ func main() {
 	}
 	c.Printf(c.Str("set file status successfully\n"))
 
-
-
 	c.Printf(c.Str("111"))
 	// Close file
 	os.Close(fd)

_demo/c/genints/genints.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/goplus/llgo/c"
+	"github.com/goplus/lib/c"
 )
 
 type generator struct {

_demo/c/getcwd/getcwd.go

@@ -1,8 +1,8 @@
 package main
 
 import (
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/os"
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/os"
 )
 
 func main() {

_demo/c/go.mod

@@ -0,0 +1,5 @@
+module github.com/goplus/llgo/_demo/c
+
+go 1.20
+
+require github.com/goplus/lib v0.3.0

_demo/c/go.sum

@@ -0,0 +1,2 @@
+github.com/goplus/lib v0.3.0 h1:y0ZGb5Q/RikW1oMMB4Di7XIZIpuzh/7mlrR8HNbxXCA=
+github.com/goplus/lib v0.3.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0=

_demo/c/hello/hello.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/goplus/lib/c"
+)
+
+func main() {
+	println("hello world by println")
+	fmt.Println("hello world by fmt.Println")
+	c.Printf(c.Str("Hello world by c.Printf\n"))
+}

_demo/c/helloc/helloc.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/lib/c"
+)
+
+func main() {
+	c.Printf(c.Str("Hello world by c.Printf\n"))
+	c.Printf(c.Str("%ld\n"), unsafe.Sizeof(int(0)))
+	c.Printf(c.Str("%ld\n"), unsafe.Sizeof(uintptr(0)))
+	// var v any = int(0)
+	// c.Printf(c.Str("%ld\n"), unsafe.Sizeof(v))
+}

_demo/c/llama2-c/run.go

@@ -1,9 +1,9 @@
 package main
 
 import (
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/llama2"
-	"github.com/goplus/llgo/c/time"
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/llama2"
+	"github.com/goplus/lib/c/time"
 )
 
 func main() {
@@ -36,7 +36,6 @@ loop: // parse command line arguments
 	// build the Tokenizer via the tokenizer .bin file
 	var tokenizer llama2.Tokenizer
 	llama2.BuildTokenizer(&tokenizer, tokenizerPath, transformer.Config.VocabSize)
-
 	// build the Sampler
 	var sampler llama2.Sampler
 	llama2.BuildSampler(&sampler, transformer.Config.VocabSize, temperature, topp, rngSeed)

_demo/c/netdbdemo/netdb.go

@@ -1,8 +1,8 @@
 package main
 
 import (
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/net"
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/net"
 )
 
 func main() {

_demo/c/qsort/qsort.go

@@ -3,7 +3,7 @@ package main
 import (
 	"unsafe"
 
-	"github.com/goplus/llgo/c"
+	"github.com/goplus/lib/c"
 )
 
 func main() {

_demo/c/setjmp/setjmp.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/goplus/llgo/c/setjmp"
+	"github.com/goplus/lib/c/setjmp"
 )
 
 func main() {

_demo/c/socket/client/client.go

@@ -3,9 +3,9 @@ package main
 import (
 	"unsafe"
 
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/net"
-	"github.com/goplus/llgo/c/os"
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/net"
+	"github.com/goplus/lib/c/os"
 )
 
 func main() {

_demo/c/socket/server/server.go

@@ -3,9 +3,9 @@ package main
 import (
 	"unsafe"
 
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/net"
-	"github.com/goplus/llgo/c/os"
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/net"
+	"github.com/goplus/lib/c/os"
 )
 
 func main() {

_demo/c/syncdebug/syncdebug.go

@@ -6,7 +6,7 @@ import (
 	"sync"
 	"unsafe"
 
-	llsync "github.com/goplus/llgo/c/pthread/sync"
+	llsync "github.com/goplus/lib/c/pthread/sync"
 )
 
 type L struct {

_demo/c/thread/thd.go

@@ -1,8 +1,8 @@
 package main
 
 import (
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/pthread"
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/pthread"
 )
 
 var key pthread.Key

_demo/cgobasic

@@ -1 +0,0 @@
-../cl/_testgo/cgobasic

_demo/cgocfiles

@@ -1 +0,0 @@
-../cl/_testgo/cgocfiles

_demo/cgodefer

@@ -1 +0,0 @@
-../cl/_testgo/cgodefer

_demo/cgofull

@@ -1 +0,0 @@
-../cl/_testgo/cgofull

_demo/cgomacro

@@ -1 +0,0 @@
-../cl/_testgo/cgomacro

_demo/cgopython

@@ -1 +0,0 @@
-../cl/_testgo/cgopython

_demo/embed/esp32/hello/main.go

@@ -0,0 +1,16 @@
+package main
+
+import "github.com/goplus/lib/c"
+
+func myprint(s *c.Char) {
+	for i := 0; i < int(c.Strlen(s)); i++ {
+		WriteByte(byte(c.Index(s, i)))
+	}
+}
+
+func main() {
+	for {
+		myprint(c.Str("hello world"))
+		sleep(1)
+	}
+}

_demo/embed/esp32/hello/uart.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/lib/c"
+)
+
+//go:linkname WriteByte C.board_uart_write_char
+func WriteByte(b byte)
+
+//go:linkname sleep sleep
+func sleep(c c.Int)

_demo/embed/esp32/rt/main.go

@@ -0,0 +1,385 @@
+package main
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/_demo/embed/esp32/watchdog"
+)
+
+//
+//go:linkname absvdi2 __absvdi2
+func absvdi2(a int64) int64
+
+//go:linkname absvsi2 __absvsi2
+func absvsi2(a int32) int32
+
+//go:linkname adddf3 __adddf3
+func adddf3(a, b float64) float64
+
+//go:linkname addsf3 __addsf3
+func addsf3(a, b float32) float32
+
+//go:linkname addvdi3 __addvdi3
+func addvdi3(a, b int64) int64
+
+//go:linkname addvsi3 __addvsi3
+func addvsi3(a, b int32) int32
+
+//go:linkname udivdi3 __udivdi3
+func udivdi3(a, b uint64) uint64
+
+//go:linkname clzdi2 __clzdi2
+func clzdi2(a uint64) int32
+
+//go:linkname clzsi2 __clzsi2
+func clzsi2(a uint32) int32
+
+//go:linkname ctzdi2 __ctzdi2
+func ctzdi2(a uint64) int32
+
+//go:linkname ctzsi2 __ctzsi2
+func ctzsi2(a uint32) int32
+
+//go:linkname popcountdi2 __popcountdi2
+func popcountdi2(a uint64) int32
+
+//go:linkname popcountsi2 __popcountsi2
+func popcountsi2(a uint32) int32
+
+//go:linkname divdf3 __divdf3
+func divdf3(a, b float64) float64
+
+//go:linkname divsf3 __divsf3
+func divsf3(a, b float32) float32
+
+//go:linkname mulsf3 __mulsf3
+func mulsf3(a, b float32) float32
+
+//go:linkname divdi3 __divdi3
+func divdi3(a, b int64) int64
+
+//go:linkname muldf3 __muldf3
+func muldf3(a, b float64) float64
+
+//go:linkname muldi3 __muldi3
+func muldi3(a, b int64) int64
+
+//go:linkname subdf3 __subdf3
+func subdf3(a, b float64) float64
+
+//go:linkname subsf3 __subsf3
+func subsf3(a, b float32) float32
+
+//go:linkname extendsfdf2 __extendsfdf2
+func extendsfdf2(a float32) float64
+
+//go:linkname fixdfdi __fixdfdi
+func fixdfdi(a float64) int64
+
+//go:linkname fixdfsi __fixdfsi
+func fixdfsi(a float64) int32
+
+//go:linkname fixsfdi __fixsfdi
+func fixsfdi(a float32) int64
+
+//go:linkname fixsfsi __fixsfsi
+func fixsfsi(a float32) int32
+
+//go:linkname floatdidf __floatdidf
+func floatdidf(a int64) float64
+
+//go:linkname floatsidf __floatsidf
+func floatsidf(a int32) float64
+
+//go:linkname ashldi3 __ashldi3
+func ashldi3(a int64, b int32) int64
+
+//go:linkname ashrdi3 __ashrdi3
+func ashrdi3(a int64, b int32) int64
+
+//go:linkname lshrdi3 __lshrdi3
+func lshrdi3(a uint64, b int32) uint64
+
+//go:linkname bswapdi2 __bswapdi2
+func bswapdi2(a uint64) uint64
+
+//go:linkname bswapsi2 __bswapsi2
+func bswapsi2(a uint32) uint32
+
+var totalTests = 0
+var passedTests = 0
+var failedTests = 0
+
+func assertEqualInt32(name string, actual, expected int32) {
+	totalTests++
+	if actual != expected {
+		println("FAIL: %s: expected %d, got %d\n", name, expected, actual)
+		failedTests++
+	} else {
+		passedTests++
+	}
+}
+
+func assertEqualInt64(name string, actual, expected int64) {
+	totalTests++
+	if actual != expected {
+		println("FAIL: %s: expected %d, got %d\n", name, expected, actual)
+		failedTests++
+	} else {
+		passedTests++
+	}
+}
+
+func assertEqualUint32(name string, actual, expected uint32) {
+	totalTests++
+	if actual != expected {
+		println("FAIL: %s: expected %d, got %d\n", name, expected, actual)
+		failedTests++
+	} else {
+		passedTests++
+	}
+}
+
+func assertEqualUint64(name string, actual, expected uint64) {
+	totalTests++
+	if actual != expected {
+		println("FAIL: %s: expected %d, got %d\n", name, expected, actual)
+		failedTests++
+	} else {
+		passedTests++
+	}
+}
+
+func assertEqualFloat32(name string, actual, expected float32, epsilon float32) {
+	totalTests++
+	diff := actual - expected
+	if diff < 0 {
+		diff = -diff
+	}
+	if diff > epsilon {
+		println("FAIL: %s: expected %f, got %f\n", name, expected, actual)
+		failedTests++
+	} else {
+		passedTests++
+	}
+}
+
+func assertEqualFloat64(name string, actual, expected float64, epsilon float64) {
+	totalTests++
+	diff := actual - expected
+	if diff < 0 {
+		diff = -diff
+	}
+	if diff > epsilon {
+		println("FAIL: %s: expected %f, got %f\n", name, expected, actual)
+		failedTests++
+	} else {
+		passedTests++
+	}
+}
+
+func testAbsFunctions() {
+	println("Testing absolute value functions...")
+
+	// Test absvsi2
+	assertEqualInt32("absvsi2", absvsi2(12345), 12345)
+	assertEqualInt32("absvsi2", absvsi2(-12345), 12345)
+	assertEqualInt32("absvsi2", absvsi2(0), 0)
+
+	// Test absvdi2
+	assertEqualInt64("absvdi2", absvdi2(1234567890123456789), 1234567890123456789)
+	assertEqualInt64("absvdi2", absvdi2(-1234567890123456789), 1234567890123456789)
+	assertEqualInt64("absvdi2", absvdi2(0), 0)
+}
+
+func testAddFunctions() {
+	println("Testing addition functions...")
+
+	// Test addvsi3
+	assertEqualInt32("addvsi3", addvsi3(1000, 2000), 3000)
+	assertEqualInt32("addvsi3", addvsi3(-1000, -2000), -3000)
+	assertEqualInt32("addvsi3", addvsi3(0, 0), 0)
+
+	// Test addvdi3
+	assertEqualInt64("addvdi3", addvdi3(1000000000, 2000000000), 3000000000)
+	assertEqualInt64("addvdi3", addvdi3(-1000000000, -2000000000), -3000000000)
+	assertEqualInt64("addvdi3", addvdi3(0, 0), 0)
+
+	// Test adddf3
+	assertEqualFloat64("adddf3", adddf3(3.14, 2.71), 5.85, 1e-10)
+	assertEqualFloat64("adddf3", adddf3(-3.14, -2.71), -5.85, 1e-10)
+	assertEqualFloat64("adddf3", adddf3(0.0, 0.0), 0.0, 1e-10)
+
+	// Test addsf3
+	assertEqualFloat32("addsf3", addsf3(3.14, 2.71), 5.85, 1e-6)
+	assertEqualFloat32("addsf3", addsf3(-3.14, -2.71), -5.85, 1e-6)
+	assertEqualFloat32("addsf3", addsf3(0.0, 0.0), 0.0, 1e-6)
+}
+
+func testCountFunctions() {
+	println("Testing count functions...")
+
+	// Test clzsi2 - count leading zeros in 32-bit integer
+	assertEqualInt32("clzsi2", clzsi2(1), 31)         // 0x00000001 has 31 leading zeros
+	assertEqualInt32("clzsi2", clzsi2(0x80000000), 0) // 0x80000000 has 0 leading zeros
+	assertEqualInt32("clzsi2", clzsi2(0), 32)         // 0 has 32 leading zeros
+
+	// FIXME
+	// // Test clzdi2 - count leading zeros in 64-bit integer
+	// assertEqualInt32("clzdi2", clzdi2(1), 63)                 // 0x0000000000000001 has 63 leading zeros
+	// assertEqualInt32("clzdi2", clzdi2(0x8000000000000000), 0) // 0x8000000000000000 has 0 leading zeros
+	// assertEqualInt32("clzdi2", clzdi2(0), 64)                 // 0 has 64 leading zeros
+
+	// Test ctzsi2 - count trailing zeros in 32-bit integer
+	assertEqualInt32("ctzsi2", ctzsi2(1<<5), 5)        // 0x00000020 has 5 trailing zeros
+	assertEqualInt32("ctzsi2", ctzsi2(0x80000000), 31) // 0x80000000 has 31 trailing zeros
+	assertEqualInt32("ctzsi2", ctzsi2(0), 32)          // 0 has 32 trailing zeros
+
+	// Test ctzdi2 - count trailing zeros in 64-bit integer
+	assertEqualInt32("ctzdi2", ctzdi2(1<<10), 10)              // 0x0000000000000400 has 10 trailing zeros
+	assertEqualInt32("ctzdi2", ctzdi2(0x8000000000000000), 63) // 0x8000000000000000 has 63 trailing zeros
+	assertEqualInt32("ctzdi2", ctzdi2(0), 64)                  // 0 has 64 trailing zeros
+
+	// Test popcountsi2 - population count of 32-bit integer
+	assertEqualInt32("popcountsi2", popcountsi2(0xF0F0F0F0), 16) // 0xF0F0F0F0 has 16 ones
+	assertEqualInt32("popcountsi2", popcountsi2(0), 0)           // 0 has 0 ones
+	assertEqualInt32("popcountsi2", popcountsi2(0xFFFFFFFF), 32) // 0xFFFFFFFF has 32 ones
+
+	// Test popcountdi2 - population count of 64-bit integer
+	assertEqualInt32("popcountdi2", popcountdi2(0xFFFF0000FFFF0000), 32) // 0xFFFF0000FFFF0000 has 32 ones
+	assertEqualInt32("popcountdi2", popcountdi2(0), 0)                   // 0 has 0 ones
+	assertEqualInt32("popcountdi2", popcountdi2(0xFFFFFFFFFFFFFFFF), 64) // 0xFFFFFFFFFFFFFFFF has 64 ones
+}
+
+func testDivisionFunctions() {
+	println("Testing division functions...")
+
+	// Test udivdi3 - unsigned 64-bit division
+	assertEqualUint64("udivdi3", udivdi3(100, 5), 20)
+	assertEqualUint64("udivdi3", udivdi3(18446744073709551615, 3), 6148914691236517205)
+	assertEqualUint64("udivdi3", udivdi3(0, 123456789), 0)
+
+	// Test divdi3 - signed 64-bit division
+	assertEqualInt64("divdi3", divdi3(20, 3), 6)
+	assertEqualInt64("divdi3", divdi3(-20, 3), -6)
+	assertEqualInt64("divdi3", divdi3(20, -3), -6)
+
+	// Test divdf3 - double precision division
+	assertEqualFloat64("divdf3", divdf3(20.0, 3.0), 6.666666666666667, 1e-10)
+	assertEqualFloat64("divdf3", divdf3(-20.0, 3.0), -6.666666666666667, 1e-10)
+
+	// Test divsf3 - single precision division
+	assertEqualFloat32("divsf3", divsf3(20.0, 3.0), 6.6666665, 1e-6)
+	assertEqualFloat32("divsf3", divsf3(-20.0, 3.0), -6.6666665, 1e-6)
+}
+
+func testMultiplicationFunctions() {
+	println("Testing multiplication functions...")
+
+	// Test muldi3 - signed 64-bit multiplication
+	assertEqualInt64("muldi3", muldi3(5, 4), 20)
+	assertEqualInt64("muldi3", muldi3(-5, 4), -20)
+	assertEqualInt64("muldi3", muldi3(5, -4), -20)
+
+	// Test muldf3 - double precision multiplication
+	assertEqualFloat64("muldf3", muldf3(3.0, 4.0), 12.0, 1e-10)
+	assertEqualFloat64("muldf3", muldf3(-3.0, 4.0), -12.0, 1e-10)
+
+	// Test mulsf3 - single precision multiplication
+	assertEqualFloat32("mulsf3", mulsf3(3.0, 4.0), 12.0, 1e-6)
+	assertEqualFloat32("mulsf3", mulsf3(-3.0, 4.0), -12.0, 1e-6)
+}
+
+func testSubtractionFunctions() {
+	println("Testing subtraction functions...")
+
+	// Test subdf3 - double precision subtraction
+	assertEqualFloat64("subdf3", subdf3(5.0, 3.0), 2.0, 1e-10)
+	assertEqualFloat64("subdf3", subdf3(3.0, 5.0), -2.0, 1e-10)
+
+	// Test subsf3 - single precision subtraction
+	assertEqualFloat32("subsf3", subsf3(5.0, 3.0), 2.0, 1e-6)
+	assertEqualFloat32("subsf3", subsf3(3.0, 5.0), -2.0, 1e-6)
+}
+
+func testConversionFunctions() {
+	println("Testing conversion functions...")
+
+	// Test extendsfdf2 - single to double precision conversion
+	// FIXME
+	// assertEqualFloat64("extendsfdf2", extendsfdf2(3.14), 3.14, 1e-10)
+
+	// Test fixdfsi - double precision to int32 conversion
+	assertEqualInt32("fixdfsi", fixdfsi(123.45), 123)
+	assertEqualInt32("fixdfsi", fixdfsi(-123.45), -123)
+
+	// Test fixsfsi - single precision to int32 conversion
+	assertEqualInt32("fixsfsi", fixsfsi(123.45), 123)
+	assertEqualInt32("fixsfsi", fixsfsi(-123.45), -123)
+
+	// Test fixdfdi - double precision to int64 conversion
+	assertEqualInt64("fixdfdi", fixdfdi(123456789.123), 123456789)
+	assertEqualInt64("fixdfdi", fixdfdi(-123456789.123), -123456789)
+
+	// Test fixsfdi - single precision to int64 conversion
+	// FIXME
+	// assertEqualInt64("fixsfdi", fixsfdi(123456789.123), 123456789)
+	// assertEqualInt64("fixsfdi", fixsfdi(-123456789.123), -123456789)
+
+	// Test floatsidf - int32 to double precision conversion
+	assertEqualFloat64("floatsidf", floatsidf(42), 42.0, 1e-10)
+	assertEqualFloat64("floatsidf", floatsidf(-100), -100.0, 1e-10)
+
+	// Test floatdidf - int64 to double precision conversion
+	assertEqualFloat64("floatdidf", floatdidf(123456789), 123456789.0, 1e-10)
+	assertEqualFloat64("floatdidf", floatdidf(-123456789), -123456789.0, 1e-10)
+}
+
+func testShiftFunctions() {
+	println("Testing shift functions...")
+
+	// Test ashldi3 - arithmetic shift left
+	assertEqualInt64("ashldi3", ashldi3(1, 10), 1024)
+
+	// Test ashrdi3 - arithmetic shift right
+	assertEqualInt64("ashrdi3", ashrdi3(1024, 10), 1)
+
+	// Test lshrdi3 - logical shift right
+	assertEqualUint64("lshrdi3", lshrdi3(1024, 10), 1)
+	assertEqualUint64("lshrdi3", lshrdi3(0x8000000000000000, 63), 1)
+}
+
+func testBitManipulationFunctions() {
+	println("Testing bit manipulation functions...")
+
+	// Test bswapsi2 - byte swap 32-bit integer
+	assertEqualUint32("bswapsi2", bswapsi2(0x12345678), 0x78563412)
+
+	// Test bswapdi2 - byte swap 64-bit integer
+	assertEqualUint64("bswapdi2", bswapdi2(0x1234567890ABCDEF), 0xEFCDAB9078563412)
+}
+
+func main() {
+	watchdog.Disable()
+	println("Testing Compiler-RT Builtins Functions")
+	println("=====================================")
+	testAbsFunctions()
+	testAddFunctions()
+	testCountFunctions()
+	testDivisionFunctions()
+	testMultiplicationFunctions()
+	testSubtractionFunctions()
+	testConversionFunctions()
+	testShiftFunctions()
+	testBitManipulationFunctions()
+
+	println("\n=====================================")
+	println("Test Results: %d total, %d passed, %d failed\n", totalTests, passedTests, failedTests)
+	println("=====================================")
+
+	if failedTests == 0 {
+		println("All tests PASSED!")
+	} else {
+		println("Some tests FAILED!")
+	}
+}

_demo/embed/esp32/watchdog/watchdog.go

@@ -0,0 +1,16 @@
+package watchdog
+
+import (
+	"unsafe"
+	_ "unsafe"
+)
+
+//go:linkname StoreUint32 llgo.atomicStore
+func StoreUint32(addr *uint32, val uint32)
+
+func Disable() {
+	StoreUint32((*uint32)(unsafe.Pointer(uintptr(0x3ff480A4))), 0x50D83AA1)
+
+	StoreUint32((*uint32)(unsafe.Pointer(uintptr(0x3ff4808C))), 0)
+	StoreUint32((*uint32)(unsafe.Pointer(uintptr(0x3ff5f048))), 0)
+}

_demo/embed/esp32/write/main.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/lib/c"
+)
+
+//go:linkname write C.write
+func write(c.Int, *c.Char, c.SizeT) int
+
+func main() {
+	buf := c.Malloc(6)
+	c.Memset(buf, 0, 6)
+	c.Strncpy((*c.Char)(buf), c.Str("abcde"), 5)
+
+	if c.Strcmp((*c.Char)(buf), c.Str("abcde")) == 0 {
+		write(1, c.Str("pass strcmp"), 11)
+	}
+
+	if byte(c.Index((*c.Char)(buf), 0)) == 'a' {
+		write(1, c.Str("pass index"), 10)
+	}
+
+	c.Memset(buf, c.Int('A'), 5)
+	if c.Strcmp((*c.Char)(buf), c.Str("AAAAA")) == 0 {
+		write(1, c.Str("pass memeset"), 11)
+	}
+
+	write(1, (*c.Char)(buf), 5)
+}

_demo/embed/go.mod

@@ -0,0 +1,5 @@
+module github.com/goplus/llgo/_demo/embed
+
+go 1.20
+
+require github.com/goplus/lib v0.3.0

_demo/embed/go.sum

@@ -0,0 +1,2 @@
+github.com/goplus/lib v0.3.0 h1:y0ZGb5Q/RikW1oMMB4Di7XIZIpuzh/7mlrR8HNbxXCA=
+github.com/goplus/lib v0.3.0/go.mod h1:SgJv3oPqLLHCu0gcL46ejOP3x7/2ry2Jtxu7ta32kp0=

_demo/embed/targetsbuild/C/c.go

@@ -0,0 +1,21 @@
+package C
+
+func XhandleHardFault() {
+
+}
+
+func Reset_Handler() {
+
+}
+
+func XhandleInterrupt() {
+
+}
+
+type dyn64 struct {
+	// Fields for dynamic loader
+}
+
+// For nintendo switch
+func X__dynamic_loader(base uintptr, dyn *dyn64) {
+}

_demo/embed/targetsbuild/build.sh

@@ -0,0 +1,180 @@
+#!/bin/bash
+
+# Function to display usage information
+show_usage() {
+	cat << EOF
+Usage: $(basename "$0") [OPTIONS] [TARGET_FILE]
+
+Build targets for llgo across multiple platforms.
+
+OPTIONS:
+    -h, --help      Show this help message and exit
+
+ARGUMENTS:
+    TARGET_FILE     Optional. A text file containing target names, one per line.
+                    Lines starting with # are treated as comments and ignored.
+                    Empty lines are also ignored.
+
+BEHAVIOR:
+    Without TARGET_FILE:
+        - Automatically discovers all targets from ../../targets/*.json files
+        - Extracts target names from JSON filenames
+
+    With TARGET_FILE:
+        - Reads target names from the specified file
+        - Supports comments (lines starting with #)
+        - Ignores empty lines and whitespace
+
+IGNORED TARGETS:
+    The following targets are automatically ignored and not built:
+    atmega1280, atmega2560, atmega328p, atmega32u4, attiny85,
+    fe310, k210, riscv32, riscv64, rp2040
+
+RESULT CATEGORIES:
+    ✅ Successful: Build completed successfully
+    🔕 Ignored: Target is in the ignore list
+    ⚠️  Warned: Build failed with configuration warnings
+    ❌ Failed: Build failed with errors
+
+EXIT CODES:
+    0    All builds successful, ignored, or warned only
+    1    One or more builds failed with errors
+
+EXAMPLES:
+    $(basename "$0")                    # Build all targets from JSON files
+    $(basename "$0") my-targets.txt     # Build targets from file
+    $(basename "$0") --help             # Show this help
+
+TARGET FILE FORMAT:
+    # This is a comment
+    esp32
+    cortex-m4
+
+    # Another comment
+    riscv64
+EOF
+}
+
+# Check for help flag
+if [[ "$1" == "-h" || "$1" == "--help" ]]; then
+	show_usage
+	exit 0
+fi
+
+# Check for invalid number of arguments
+if [ $# -gt 1 ]; then
+	echo "Error: Too many arguments."
+	echo "Use '$(basename "$0") --help' for usage information."
+	exit 1
+fi
+
+# Initialize arrays to store results
+successful_targets=()
+ignored_targets=()
+warned_targets=()
+failed_targets=()
+targets_to_build=()
+
+# Define ignore list
+ignore_list=(
+	"atmega1280"
+	"atmega2560"
+	"atmega328p"
+	"atmega32u4"
+	"attiny85"
+	"fe310"
+	"k210"
+	"riscv32"
+	"riscv64"
+	"rp2040"
+)
+
+# Build the targets list based on input method
+if [ $# -eq 1 ]; then
+	# Read targets from file
+	target_file="$1"
+	if [ ! -f "$target_file" ]; then
+		echo "Error: Target file '$target_file' not found."
+		echo "Use '$(basename "$0") --help' for usage information."
+		exit 1
+	fi
+
+	while IFS= read -r target || [[ -n "$target" ]]; do
+		# Skip empty lines and comments
+		if [[ -z "$target" || "$target" =~ ^[[:space:]]*# ]]; then
+			continue
+		fi
+
+		# Trim whitespace
+		target=$(echo "$target" | xargs)
+		targets_to_build+=("$target")
+	done < "$target_file"
+else
+	# Use targets from *.json files
+	for target_file in ../../../targets/*.json; do
+		# Extract target name from filename (remove path and .json extension)
+		target=$(basename "$target_file" .json)
+		targets_to_build+=("$target")
+	done
+fi
+
+# Process each target
+for target in "${targets_to_build[@]}"; do
+	# Check if target is in ignore list
+	if [[ " ${ignore_list[@]} " =~ " ${target} " ]]; then
+		echo 🔕 $target "(ignored)"
+		ignored_targets+=("$target")
+		continue
+	fi
+
+	output=$(../../../llgo.sh build -target $target -o hello.elf . 2>&1)
+	if [ $? -eq 0 ]; then
+		echo ✅ $target `file hello.elf`
+		successful_targets+=("$target")
+	else
+		# Check if output contains warning messages
+		if echo "$output" | grep -q "does not have a valid LLVM target triple\|does not have a valid CPU configuration"; then
+			echo ⚠️ $target
+			echo "$output"
+			warned_targets+=("$target")
+		else
+			echo ❌ $target
+			echo "$output"
+			failed_targets+=("$target")
+		fi
+	fi
+done
+
+echo ""
+echo "----------------------------------------"
+
+# Output successful targets
+echo "Successful targets (${#successful_targets[@]} total):"
+for target in "${successful_targets[@]}"; do
+	echo "$target"
+done
+
+echo ""
+echo "Ignored targets (${#ignored_targets[@]} total):"
+for target in "${ignored_targets[@]}"; do
+	echo "$target"
+done
+
+echo ""
+echo "Warned targets (${#warned_targets[@]} total):"
+for target in "${warned_targets[@]}"; do
+	echo "$target"
+done
+
+echo ""
+echo "Failed targets (${#failed_targets[@]} total):"
+for target in "${failed_targets[@]}"; do
+	echo "$target"
+done
+
+# Exit with error code if there are any failed targets
+if [ ${#failed_targets[@]} -gt 0 ]; then
+	echo ""
+	echo "Build failed with ${#failed_targets[@]} failed targets."
+	exit 1
+fi

_demo/embed/targetsbuild/empty.go

@@ -0,0 +1,6 @@
+package main
+
+import _ "github.com/goplus/llgo/_demo/embed/targetsbuild/C"
+
+func main() {
+}

_demo/go/async/main.go

@@ -3,8 +3,8 @@ package main
 import (
 	"time"
 
-	"github.com/goplus/llgo/_demo/async/async"
-	"github.com/goplus/llgo/_demo/async/timeout"
+	"github.com/goplus/llgo/_demo/go/async/async"
+	"github.com/goplus/llgo/_demo/go/async/timeout"
 )
 
 func Sleep(i int, d time.Duration) async.Future[int] {

_demo/go/async/timeout/timeout.go

@@ -3,7 +3,7 @@ package timeout
 import (
 	"time"
 
-	"github.com/goplus/llgo/_demo/async/async"
+	"github.com/goplus/llgo/_demo/go/async/async"
 )
 
 func Timeout(d time.Duration) async.Future[async.Void] {

_demo/go/commandrun/commandrun.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"bytes"
+	"os/exec"
+	"path/filepath"
+)
+
+func main() {
+	var data bytes.Buffer
+	cmd := exec.Command("echo", "hello llgo")
+	cmd.Dir = filepath.Dir("./")
+	cmd.Stdout = &data
+	err := cmd.Run()
+	if err != nil {
+		panic(err)
+	}
+	println("len:", len(data.Bytes()))
+	println("data:", data.String())
+}

_demo/go/defer/main.go

@@ -0,0 +1,18 @@
+package main
+
+func main() {
+	var a int = 5
+	defer println(a)
+	defer func() {
+		println(a)
+	}()
+	defer func() {
+		println(recover().(string))
+	}()
+	a = 10
+	panic("error")
+	//Output:
+	// error
+	// 10
+	// 5
+}

_demo/go/export/.gitignore

@@ -0,0 +1 @@
+libexport.h

_demo/go/export/c/c.go

@@ -0,0 +1,29 @@
+package C
+
+// XType - struct for export.go to use
+type XType struct {
+	ID    int32   `json:"id"`
+	Name  string  `json:"name"`
+	Value float64 `json:"value"`
+	Flag  bool    `json:"flag"`
+}
+
+func XAdd(a, b int) int {
+	return a + b
+}
+
+func Sub(a, b int64) int64 {
+	return a - b
+}
+
+func sub(a, b uint32) uint32 {
+	return a - b
+}
+
+func Xmul(a, b float32) float32 {
+	return a * b
+}
+
+func Concat(a, b string) string {
+	return a + b
+}

_demo/go/export/export.go

@@ -0,0 +1,674 @@
+package main
+
+import (
+	"unsafe"
+
+	C "github.com/goplus/llgo/_demo/go/export/c"
+)
+
+// assert helper function for testing
+func assert[T comparable](got, expected T, message string) {
+	if got != expected {
+		println("ASSERTION FAILED:", message)
+		println("  Expected:", expected)
+		println("  Got:     ", got)
+		panic("assertion failed: " + message)
+	}
+	println("✓", message)
+}
+
+// Small struct
+type SmallStruct struct {
+	ID   int8 `json:"id"`
+	Flag bool `json:"flag"`
+}
+
+// Large struct
+type LargeStruct struct {
+	ID       int64          `json:"id"`
+	Name     string         `json:"name"`
+	Values   [10]float64    `json:"values"`
+	Metadata map[string]int `json:"metadata"`
+	Children []SmallStruct  `json:"children"`
+	Extra1   int32          `json:"extra1"`
+	Extra2   uint64         `json:"extra2"`
+	Extra3   float32        `json:"extra3"`
+	Extra4   bool           `json:"extra4"`
+	Extra5   uintptr        `json:"extra5"`
+}
+
+// Self-referential struct
+type Node struct {
+	Data int   `json:"data"`
+	Next *Node `json:"next"`
+}
+
+// Named types
+type MyInt int
+type MyString string
+
+// Function types for callbacks
+//
+//llgo:type C
+type IntCallback func(int) int
+
+//llgo:type C
+type StringCallback func(string) string
+
+//llgo:type C
+type VoidCallback func()
+
+// Complex struct with mixed arrays and slices
+type ComplexData struct {
+	Matrix   [3][4]int32 `json:"matrix"`    // 2D array
+	Slices   [][]string  `json:"slices"`    // slice of slices - commented out
+	IntArray [5]int      `json:"int_array"` // 1D array
+	DataList []float64   `json:"data_list"` // slice - commented out
+}
+
+//export HelloWorld
+func HelloWorld() {
+	println("Hello, World!")
+}
+
+// Functions with small struct parameters and return values
+
+//export CreateSmallStruct
+func CreateSmallStruct(id int8, flag bool) SmallStruct {
+	return SmallStruct{ID: id, Flag: flag}
+}
+
+//export ProcessSmallStruct
+func ProcessSmallStruct(s SmallStruct) SmallStruct {
+	s.ID += 1
+	s.Flag = !s.Flag
+	return s
+}
+
+//export ProcessSmallStructPtr
+func ProcessSmallStructPtr(s *SmallStruct) *SmallStruct {
+	if s != nil {
+		s.ID *= 2
+		s.Flag = !s.Flag
+	}
+	return s
+}
+
+// Functions with large struct parameters and return values
+
+//export CreateLargeStruct
+func CreateLargeStruct(id int64, name string) LargeStruct {
+	return LargeStruct{
+		ID:       id,
+		Name:     name,
+		Values:   [10]float64{1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.0},
+		Metadata: map[string]int{"count": 42, "size": 100},
+		Children: []SmallStruct{{ID: 1, Flag: true}, {ID: 2, Flag: false}},
+		Extra1:   12345,
+		Extra2:   67890,
+		Extra3:   3.14,
+		Extra4:   true,
+		Extra5:   0x1000,
+	}
+}
+
+//export ProcessLargeStruct
+func ProcessLargeStruct(ls LargeStruct) int64 {
+	total := ls.ID + int64(len(ls.Name))
+	for _, v := range ls.Values {
+		total += int64(v)
+	}
+	total += int64(len(ls.Children))
+	total += int64(ls.Extra1) + int64(ls.Extra2) + int64(ls.Extra3)
+	if ls.Extra4 {
+		total += 1000
+	}
+	total += int64(ls.Extra5)
+	return total
+}
+
+//export ProcessLargeStructPtr
+func ProcessLargeStructPtr(ls *LargeStruct) *LargeStruct {
+	if ls != nil {
+		ls.ID += 100
+		ls.Name = "processed_" + ls.Name
+		ls.Extra1 *= 2
+		ls.Extra4 = !ls.Extra4
+	}
+	return ls
+}
+
+// Functions with self-referential struct
+
+//export CreateNode
+func CreateNode(data int) *Node {
+	return &Node{Data: data, Next: nil}
+}
+
+//export LinkNodes
+func LinkNodes(first, second *Node) int {
+	if first != nil && second != nil {
+		first.Next = second
+		return first.Data + second.Data  // Return sum for verification
+	}
+	if first != nil {
+		return first.Data + 1000  // Return data + offset if only first exists
+	}
+	return 2000  // Return fixed value if both are nil
+}
+
+//export TraverseNodes
+func TraverseNodes(head *Node) int {
+	count := 0
+	current := head
+	for current != nil {
+		count++
+		current = current.Next
+		if count > 100 { // Safety check
+			break
+		}
+	}
+	return count
+}
+
+// Functions covering all basic types
+
+//export ProcessBool
+func ProcessBool(b bool) bool {
+	return !b
+}
+
+//export ProcessInt8
+func ProcessInt8(x int8) int8 {
+	return x + 1
+}
+
+//export ProcessUint8
+func ProcessUint8(x uint8) uint8 {
+	return x + 1
+}
+
+//export ProcessInt16
+func ProcessInt16(x int16) int16 {
+	return x * 2
+}
+
+//export ProcessUint16
+func ProcessUint16(x uint16) uint16 {
+	return x * 2
+}
+
+//export ProcessInt32
+func ProcessInt32(x int32) int32 {
+	return x * 3
+}
+
+//export ProcessUint32
+func ProcessUint32(x uint32) uint32 {
+	return x * 3
+}
+
+//export ProcessInt64
+func ProcessInt64(x int64) int64 {
+	return x * 4
+}
+
+//export ProcessUint64
+func ProcessUint64(x uint64) uint64 {
+	return x * 4
+}
+
+//export ProcessInt
+func ProcessInt(x int) int {
+	return x * 11
+}
+
+//export ProcessUint
+func ProcessUint(x uint) uint {
+	return x * 21
+}
+
+//export ProcessUintptr
+func ProcessUintptr(x uintptr) uintptr {
+	return x + 300
+}
+
+//export ProcessFloat32
+func ProcessFloat32(x float32) float32 {
+	return x * 1.5
+}
+
+//export ProcessFloat64
+func ProcessFloat64(x float64) float64 {
+	return x * 2.5
+}
+
+//export ProcessString
+func ProcessString(s string) string {
+	return "processed_" + s
+}
+
+//export ProcessUnsafePointer
+func ProcessUnsafePointer(p unsafe.Pointer) unsafe.Pointer {
+	return p
+}
+
+// Functions with named types
+
+//export ProcessMyInt
+func ProcessMyInt(x MyInt) MyInt {
+	return x * 10
+}
+
+//export ProcessMyString
+func ProcessMyString(s MyString) MyString {
+	return MyString("modified_" + string(s))
+}
+
+// Functions with arrays, slices, maps, channels
+
+//export ProcessIntArray
+func ProcessIntArray(arr [5]int) int {
+	total := 0
+	for _, v := range arr {
+		total += v
+	}
+	return total
+}
+
+//export CreateComplexData
+func CreateComplexData() ComplexData {
+	return ComplexData{
+		Matrix:   [3][4]int32{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}},
+		Slices:   [][]string{{"helo"}},
+		IntArray: [5]int{10, 20, 30, 40, 50},
+		DataList: []float64{1.0},
+	}
+}
+
+//export ProcessComplexData
+func ProcessComplexData(data ComplexData) int32 {
+	// Sum all matrix elements
+	var sum int32
+	for i := 0; i < 3; i++ {
+		for j := 0; j < 4; j++ {
+			sum += data.Matrix[i][j]
+		}
+	}
+	return sum
+}
+
+// Functions with multidimensional arrays as parameters and return values
+
+//export ProcessMatrix2D
+func ProcessMatrix2D(matrix [3][4]int32) int32 {
+	var sum int32
+	for i := 0; i < 3; i++ {
+		for j := 0; j < 4; j++ {
+			sum += matrix[i][j]
+		}
+	}
+	return sum
+}
+
+//export CreateMatrix1D
+func CreateMatrix1D() [4]int32 {
+	return [4]int32{1, 2, 3, 4}
+}
+
+//export CreateMatrix2D
+func CreateMatrix2D() [3][4]int32 {
+	return [3][4]int32{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
+}
+
+//export ProcessMatrix3D
+func ProcessMatrix3D(cube [2][3][4]uint8) uint32 {
+	var sum uint32
+	for i := 0; i < 2; i++ {
+		for j := 0; j < 3; j++ {
+			for k := 0; k < 4; k++ {
+				sum += uint32(cube[i][j][k])
+			}
+		}
+	}
+	return sum
+}
+
+//export CreateMatrix3D
+func CreateMatrix3D() [2][3][4]uint8 {
+	var cube [2][3][4]uint8
+	val := uint8(1)
+	for i := 0; i < 2; i++ {
+		for j := 0; j < 3; j++ {
+			for k := 0; k < 4; k++ {
+				cube[i][j][k] = val
+				val++
+			}
+		}
+	}
+	return cube
+}
+
+//export ProcessGrid5x4
+func ProcessGrid5x4(grid [5][4]float64) float64 {
+	var sum float64
+	for i := 0; i < 5; i++ {
+		for j := 0; j < 4; j++ {
+			sum += grid[i][j]
+		}
+	}
+	return sum
+}
+
+//export CreateGrid5x4
+func CreateGrid5x4() [5][4]float64 {
+	var grid [5][4]float64
+	val := 1.0
+	for i := 0; i < 5; i++ {
+		for j := 0; j < 4; j++ {
+			grid[i][j] = val
+			val += 0.5
+		}
+	}
+	return grid
+}
+
+//export ProcessIntSlice
+func ProcessIntSlice(slice []int) int {
+	total := 0
+	for _, v := range slice {
+		total += v
+	}
+	return total
+}
+
+//export ProcessStringMap
+func ProcessStringMap(m map[string]int) int {
+	total := 0
+	for _, v := range m {
+		total += v
+	}
+	return total
+}
+
+//export ProcessIntChannel
+func ProcessIntChannel(ch chan int) int {
+	select {
+	case val := <-ch:
+		return val
+	default:
+		return -1
+	}
+}
+
+// Functions with function callbacks
+
+//export ProcessWithIntCallback
+func ProcessWithIntCallback(x int, callback IntCallback) int {
+	if callback != nil {
+		return callback(x)
+	}
+	return x
+}
+
+//export ProcessWithStringCallback
+func ProcessWithStringCallback(s string, callback StringCallback) string {
+	if callback != nil {
+		return callback(s)
+	}
+	return s
+}
+
+//export ProcessWithVoidCallback
+func ProcessWithVoidCallback(callback VoidCallback) int {
+	if callback != nil {
+		callback()
+		return 123  // Return non-zero to indicate callback was called
+	}
+	return 456  // Return different value if callback is nil
+}
+
+//export ProcessThreeUnnamedParams
+func ProcessThreeUnnamedParams(a int, s string, b bool) float64 {
+	result := float64(a) + float64(len(s))
+	if b {
+		result *= 1.5
+	}
+	return result
+}
+
+// Functions with interface
+
+//export ProcessInterface
+func ProcessInterface(i interface{}) int {
+	switch v := i.(type) {
+	case int:
+		return v + 100
+	case string:
+		return len(v) * 10
+	default:
+		return 999  // Non-zero default to avoid false positives
+	}
+}
+
+// Functions with various parameter counts
+
+//export NoParams
+func NoParams() int {
+	return 42
+}
+
+//export OneParam
+func OneParam(x int) int {
+	return x * 2
+}
+
+//export TwoParams
+func TwoParams(a int, b string) string {
+	return string(rune(a)) + b
+}
+
+//export ThreeParams
+func ThreeParams(a int32, b float64, c bool) float64 {
+	result := float64(a) + b
+	if c {
+		result *= 2
+	}
+	return result
+}
+
+//export MultipleParams
+func MultipleParams(a int8, b uint16, c int32, d uint64, e float32, f float64, g string, h bool) string {
+	result := g + "_" + string(rune('A'+a)) + string(rune('0'+b%10)) + string(rune('0'+c%10))
+	if h {
+		result += "_true"
+	}
+	return result + "_" + string(rune('0'+int(d%10))) + "_" + string(rune('0'+int(e)%10)) + "_" + string(rune('0'+int(f)%10))
+}
+
+//export NoParamNames
+func NoParamNames(int8, int16, bool) int32 {
+	return 789  // Return non-zero value for testing, params are unnamed by design
+}
+
+// Functions returning no value
+
+//export NoReturn
+func NoReturn(message string) {
+	println("Message:", message)
+}
+
+// Functions using XType from c package
+
+//export CreateXType
+func CreateXType(id int32, name string, value float64, flag bool) C.XType {
+	return C.XType{
+		ID:    id,
+		Name:  name,
+		Value: value,
+		Flag:  flag,
+	}
+}
+
+//export ProcessXType
+func ProcessXType(x C.XType) C.XType {
+	x.ID += 100
+	x.Name = "processed_" + x.Name
+	x.Value *= 2.0
+	x.Flag = !x.Flag
+	return x
+}
+
+//export ProcessXTypePtr
+func ProcessXTypePtr(x *C.XType) *C.XType {
+	if x != nil {
+		x.ID *= 2
+		x.Name = "ptr_" + x.Name
+		x.Value += 10.0
+		x.Flag = !x.Flag
+	}
+	return x
+}
+
+func main() {
+	println("=== Export Demo ===")
+
+	// Test small struct
+	small := CreateSmallStruct(5, true)
+	assert(small.ID, int8(5), "CreateSmallStruct ID should be 5")
+	assert(small.Flag, true, "CreateSmallStruct Flag should be true")
+	println("Small struct:", small.ID, small.Flag)
+
+	processed := ProcessSmallStruct(small)
+	assert(processed.ID, int8(6), "ProcessSmallStruct should increment ID to 6")
+	assert(processed.Flag, false, "ProcessSmallStruct should flip Flag to false")
+	println("Processed small:", processed.ID, processed.Flag)
+
+	// Test large struct
+	large := CreateLargeStruct(12345, "test")
+	assert(large.ID, int64(12345), "CreateLargeStruct ID should be 12345")
+	assert(large.Name, "test", "CreateLargeStruct Name should be 'test'")
+	println("Large struct ID:", large.ID, "Name:", large.Name)
+
+	total := ProcessLargeStruct(large)
+	// Expected calculation:
+	// ID: 12345, Name len: 4, Values: 1+2+3+4+5+6+7+8+9+10=55, Children len: 2
+	// Extra1: 12345, Extra2: 67890, Extra3: 3, Extra4: +1000, Extra5: 4096
+	expectedTotal := int64(12345 + 4 + 55 + 2 + 12345 + 67890 + 3 + 1000 + 4096)
+	assert(total, expectedTotal, "ProcessLargeStruct total should match expected calculation")
+	println("Large struct total:", total)
+
+	// Test self-referential struct
+	node1 := CreateNode(100)
+	node2 := CreateNode(200)
+	linkResult := LinkNodes(node1, node2)
+	assert(linkResult, 300, "LinkNodes should return sum of node data (100 + 200)")
+
+	count := TraverseNodes(node1)
+	assert(count, 2, "TraverseNodes should count 2 linked nodes")
+	println("Node count:", count)
+
+	// Test basic types with assertions
+	assert(ProcessBool(true), false, "ProcessBool(true) should return false")
+	assert(ProcessInt8(10), int8(11), "ProcessInt8(10) should return 11")
+	f32Result := ProcessFloat32(3.14)
+	// Float comparison with tolerance
+	if f32Result < 4.7 || f32Result > 4.72 {
+		println("ASSERTION FAILED: ProcessFloat32(3.14) should return ~4.71, got:", f32Result)
+		panic("float assertion failed")
+	}
+	println("✓ ProcessFloat32(3.14) returns ~4.71")
+	
+	assert(ProcessString("hello"), "processed_hello", "ProcessString should prepend 'processed_'")
+	
+	println("Bool:", ProcessBool(true))
+	println("Int8:", ProcessInt8(10))
+	println("Float32:", ProcessFloat32(3.14))
+	println("String:", ProcessString("hello"))
+
+	// Test named types
+	myInt := ProcessMyInt(MyInt(42))
+	assert(myInt, MyInt(420), "ProcessMyInt(42) should return 420")
+	println("MyInt:", int(myInt))
+
+	myStr := ProcessMyString(MyString("world"))
+	assert(myStr, MyString("modified_world"), "ProcessMyString should prepend 'modified_'")
+	println("MyString:", string(myStr))
+
+	// Test collections
+	arr := [5]int{1, 2, 3, 4, 5}
+	arrSum := ProcessIntArray(arr)
+	assert(arrSum, 15, "ProcessIntArray([1,2,3,4,5]) should return 15")
+	println("Array sum:", arrSum)
+
+	slice := []int{10, 20, 30}
+	sliceSum := ProcessIntSlice(slice)
+	assert(sliceSum, 60, "ProcessIntSlice([10,20,30]) should return 60")
+	println("Slice sum:", sliceSum)
+
+	m := make(map[string]int)
+	m["a"] = 100
+	m["b"] = 200
+	mapSum := ProcessStringMap(m)
+	assert(mapSum, 300, "ProcessStringMap({'a':100,'b':200}) should return 300")
+	println("Map sum:", mapSum)
+
+	// Test multidimensional arrays
+	matrix2d := CreateMatrix2D()
+	matrix2dSum := ProcessMatrix2D(matrix2d)
+	assert(matrix2dSum, int32(78), "ProcessMatrix2D should return 78 (sum of 1+2+...+12)")
+	println("Matrix2D sum:", matrix2dSum)
+
+	matrix3d := CreateMatrix3D()
+	matrix3dSum := ProcessMatrix3D(matrix3d)
+	assert(matrix3dSum, uint32(300), "ProcessMatrix3D should return 300")
+	println("Matrix3D sum:", matrix3dSum)
+
+	grid5x4 := CreateGrid5x4()
+	gridSum := ProcessGrid5x4(grid5x4)
+	assert(gridSum, 115.0, "ProcessGrid5x4 should return 115.0")
+	println("Grid5x4 sum:", gridSum)
+
+	// Test complex data with multidimensional arrays
+	complexData := CreateComplexData()
+	complexSum := ProcessComplexData(complexData)
+	assert(complexSum, int32(78), "ProcessComplexData should return 78")
+	println("ComplexData matrix sum:", complexSum)
+
+	// Test various parameter counts
+	assert(NoParams(), 42, "NoParams should return 42")
+	assert(OneParam(5), 10, "OneParam(5) should return 10")
+	assert(TwoParams(65, "_test"), "A_test", "TwoParams should return 'A_test'")
+	assert(ThreeParams(10, 2.5, true), 25.0, "ThreeParams should return 25.0")
+	assert(NoParamNames(1, 2, false), int32(789), "NoParamNames should return 789")
+	
+	println("NoParams:", NoParams())
+	println("OneParam:", OneParam(5))
+	println("TwoParams:", TwoParams(65, "_test"))
+	println("ThreeParams:", ThreeParams(10, 2.5, true))
+	println("MultipleParams:", MultipleParams(1, 2, 3, 4, 5.0, 6.0, "result", true))
+	println("NoParamNames:", NoParamNames(1, 2, false))
+
+	// Test XType from c package
+	xtype := CreateXType(42, "test", 3.14, true)
+	println("XType:", xtype.ID, xtype.Name, xtype.Value, xtype.Flag)
+
+	processedX := ProcessXType(xtype)
+	println("Processed XType:", processedX.ID, processedX.Name, processedX.Value, processedX.Flag)
+
+	ptrX := ProcessXTypePtr(&xtype)
+	if ptrX != nil {
+		println("Ptr XType:", ptrX.ID, ptrX.Name, ptrX.Value, ptrX.Flag)
+	}
+
+	// Test callback functions
+	intResult := ProcessWithIntCallback(10, func(x int) int { return x * 3 })
+	println("IntCallback result:", intResult)
+
+	stringResult := ProcessWithStringCallback("hello", func(s string) string { return s + "_callback" })
+	println("StringCallback result:", stringResult)
+
+	ProcessWithVoidCallback(func() { println("VoidCallback executed") })
+
+	NoReturn("demo completed")
+}

_demo/go/export/libexport.h.want

@@ -0,0 +1,315 @@
+/* Code generated by llgo; DO NOT EDIT. */
+
+#ifndef __LIBEXPORT_H_
+#define __LIBEXPORT_H_
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Platform-specific symbol renaming macro
+#ifdef __APPLE__
+    #define GO_SYMBOL_RENAME(go_name) __asm("_" go_name);
+#else
+    #define GO_SYMBOL_RENAME(go_name) __asm(go_name);
+#endif
+
+// Go runtime types
+typedef struct { const char *p; intptr_t n; } GoString;
+typedef struct { void *data; intptr_t len; intptr_t cap; } GoSlice;
+typedef struct { void *data; } GoMap;
+typedef struct { void *data; } GoChan;
+typedef struct { void *data; void *type; } GoInterface;
+typedef struct { float real; float imag; } GoComplex64;
+typedef struct { double real; double imag; } GoComplex128;
+
+typedef struct {
+    int32_t Matrix[3][4];
+    GoSlice Slices;
+    intptr_t IntArray[5];
+    GoSlice DataList;
+} main_ComplexData;
+
+typedef struct {
+    double data[5][4];
+} Array_double_5_4;
+
+typedef struct {
+    int8_t ID;
+    _Bool Flag;
+} main_SmallStruct;
+
+typedef struct {
+    int64_t ID;
+    GoString Name;
+    double Values[10];
+    GoMap Metadata;
+    GoSlice Children;
+    int32_t Extra1;
+    uint64_t Extra2;
+    float Extra3;
+    _Bool Extra4;
+    uintptr_t Extra5;
+} main_LargeStruct;
+
+typedef struct {
+    int32_t data[4];
+} Array_int32_t_4;
+
+typedef struct {
+    int32_t data[3][4];
+} Array_int32_t_3_4;
+
+typedef struct {
+    uint8_t data[2][3][4];
+} Array_uint8_t_2_3_4;
+
+typedef struct main_Node main_Node;
+struct main_Node {
+    intptr_t Data;
+    main_Node* Next;
+};
+
+typedef struct {
+    int32_t ID;
+    GoString Name;
+    double Value;
+    _Bool Flag;
+} C_XType;
+
+typedef intptr_t main_MyInt;
+
+typedef GoString main_MyString;
+
+typedef intptr_t (*main_IntCallback)(intptr_t);
+
+typedef GoString (*main_StringCallback)(GoString);
+
+typedef void (*main_VoidCallback)(void);
+
+GoString
+Concat(GoString a, GoString b);
+
+int64_t
+Sub(int64_t a, int64_t b);
+
+intptr_t
+Add(intptr_t a, intptr_t b);
+
+float
+mul(float a, float b);
+
+void
+github_com_goplus_llgo__demo_go_export_c_init(void) GO_SYMBOL_RENAME("github.com/goplus/llgo/_demo/go/export/c.init")
+
+main_ComplexData
+CreateComplexData(void);
+
+Array_double_5_4
+CreateGrid5x4(void);
+
+main_LargeStruct
+CreateLargeStruct(int64_t id, GoString name);
+
+Array_int32_t_4
+CreateMatrix1D(void);
+
+Array_int32_t_3_4
+CreateMatrix2D(void);
+
+Array_uint8_t_2_3_4
+CreateMatrix3D(void);
+
+main_Node*
+CreateNode(intptr_t data);
+
+main_SmallStruct
+CreateSmallStruct(int8_t id, _Bool flag);
+
+C_XType
+CreateXType(int32_t id, GoString name, double value, _Bool flag);
+
+void
+HelloWorld(void);
+
+intptr_t
+LinkNodes(main_Node* first, main_Node* second);
+
+GoString
+MultipleParams(int8_t a, uint16_t b, int32_t c, uint64_t d, float e, double f, GoString g, _Bool h);
+
+int32_t
+NoParamNames(int8_t, int16_t, _Bool);
+
+intptr_t
+NoParams(void);
+
+void
+NoReturn(GoString message);
+
+intptr_t
+OneParam(intptr_t x);
+
+_Bool
+ProcessBool(_Bool b);
+
+int32_t
+ProcessComplexData(main_ComplexData data);
+
+float
+ProcessFloat32(float x);
+
+double
+ProcessFloat64(double x);
+
+double
+ProcessGrid5x4(double grid[5][4]);
+
+intptr_t
+ProcessInt(intptr_t x);
+
+int16_t
+ProcessInt16(int16_t x);
+
+int32_t
+ProcessInt32(int32_t x);
+
+int64_t
+ProcessInt64(int64_t x);
+
+int8_t
+ProcessInt8(int8_t x);
+
+intptr_t
+ProcessIntArray(intptr_t* arr);
+
+intptr_t
+ProcessIntChannel(GoChan ch);
+
+intptr_t
+ProcessIntSlice(GoSlice slice);
+
+intptr_t
+ProcessInterface(GoInterface i);
+
+int64_t
+ProcessLargeStruct(main_LargeStruct ls);
+
+main_LargeStruct*
+ProcessLargeStructPtr(main_LargeStruct* ls);
+
+int32_t
+ProcessMatrix2D(int32_t matrix[3][4]);
+
+uint32_t
+ProcessMatrix3D(uint8_t cube[2][3][4]);
+
+main_MyInt
+ProcessMyInt(main_MyInt x);
+
+main_MyString
+ProcessMyString(main_MyString s);
+
+main_SmallStruct
+ProcessSmallStruct(main_SmallStruct s);
+
+main_SmallStruct*
+ProcessSmallStructPtr(main_SmallStruct* s);
+
+GoString
+ProcessString(GoString s);
+
+intptr_t
+ProcessStringMap(GoMap m);
+
+double
+ProcessThreeUnnamedParams(intptr_t a, GoString s, _Bool b);
+
+uintptr_t
+ProcessUint(uintptr_t x);
+
+uint16_t
+ProcessUint16(uint16_t x);
+
+uint32_t
+ProcessUint32(uint32_t x);
+
+uint64_t
+ProcessUint64(uint64_t x);
+
+uint8_t
+ProcessUint8(uint8_t x);
+
+uintptr_t
+ProcessUintptr(uintptr_t x);
+
+void*
+ProcessUnsafePointer(void* p);
+
+intptr_t
+ProcessWithIntCallback(intptr_t x, main_IntCallback callback);
+
+GoString
+ProcessWithStringCallback(GoString s, main_StringCallback callback);
+
+intptr_t
+ProcessWithVoidCallback(main_VoidCallback callback);
+
+C_XType
+ProcessXType(C_XType x);
+
+C_XType*
+ProcessXTypePtr(C_XType* x);
+
+double
+ThreeParams(int32_t a, double b, _Bool c);
+
+intptr_t
+TraverseNodes(main_Node* head);
+
+GoString
+TwoParams(intptr_t a, GoString b);
+
+void
+github_com_goplus_llgo__demo_go_export_init(void) GO_SYMBOL_RENAME("github.com/goplus/llgo/_demo/go/export.init")
+
+void
+github_com_goplus_llgo_runtime_abi_init(void) GO_SYMBOL_RENAME("github.com/goplus/llgo/runtime/abi.init")
+
+void
+github_com_goplus_llgo_runtime_internal_clite_init(void) GO_SYMBOL_RENAME("github.com/goplus/llgo/runtime/internal/clite.init")
+
+void
+github_com_goplus_llgo_runtime_internal_clite_bdwgc_init(void) GO_SYMBOL_RENAME("github.com/goplus/llgo/runtime/internal/clite/bdwgc.init")
+
+void
+github_com_goplus_llgo_runtime_internal_clite_bitcast_init(void) GO_SYMBOL_RENAME("github.com/goplus/llgo/runtime/internal/clite/bitcast.init")
+
+void
+github_com_goplus_llgo_runtime_internal_clite_debug_init(void) GO_SYMBOL_RENAME("github.com/goplus/llgo/runtime/internal/clite/debug.init")
+
+void
+github_com_goplus_llgo_runtime_internal_clite_pthread_init(void) GO_SYMBOL_RENAME("github.com/goplus/llgo/runtime/internal/clite/pthread.init")
+
+void
+github_com_goplus_llgo_runtime_internal_clite_pthread_sync_init(void) GO_SYMBOL_RENAME("github.com/goplus/llgo/runtime/internal/clite/pthread/sync.init")
+
+void
+github_com_goplus_llgo_runtime_internal_runtime_goarch_init(void) GO_SYMBOL_RENAME("github.com/goplus/llgo/runtime/internal/runtime/goarch.init")
+
+void
+github_com_goplus_llgo_runtime_internal_runtime_math_init(void) GO_SYMBOL_RENAME("github.com/goplus/llgo/runtime/internal/runtime/math.init")
+
+void
+github_com_goplus_llgo_runtime_internal_runtime_init(void) GO_SYMBOL_RENAME("github.com/goplus/llgo/runtime/internal/runtime.init")
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __LIBEXPORT_H_ */

_demo/go/export/test.sh

@@ -0,0 +1,278 @@
+#!/bin/bash
+
+# Test script for C header generation in different build modes
+# This script tests the header generation functionality with various buildmode options
+
+set -e  # Exit on any error
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Function to print colored output
+print_status() {
+    echo -e "${GREEN}[INFO]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Function to check if file exists and is not empty
+check_file() {
+    local file="$1"
+    local description="$2"
+
+    if [[ -f "$file" ]]; then
+        if [[ -s "$file" ]]; then
+            print_status "$description exists and is not empty"
+            return 0
+        else
+            print_error "$description exists but is empty"
+            return 1
+        fi
+    else
+        print_error "$description does not exist"
+        return 1
+    fi
+}
+
+# Function to compare header with expected content
+compare_header() {
+    local header_file="$1"
+    local expected_file="$2"
+    local test_name="$3"
+
+    if [[ -f "$expected_file" ]]; then
+        if diff -q "$header_file" "$expected_file" >/dev/null 2>&1; then
+            print_status "$test_name: Header content matches expected"
+            return 0
+        else
+            print_warning "$test_name: Header content differs from expected"
+            print_warning "Run 'diff $header_file $expected_file' to see differences"
+            return 1
+        fi
+    else
+        print_warning "$test_name: No expected file found at $expected_file"
+        print_status "Generated header content:"
+        echo "--- START OF HEADER ---"
+        cat "$header_file"
+        echo "--- END OF HEADER ---"
+        return 0
+    fi
+}
+
+# Function to cleanup generated files
+cleanup() {
+    local files=("$@")
+    for file in "${files[@]}"; do
+        if [[ -f "$file" ]]; then
+            rm -f "$file"
+            print_status "Cleaned up $file"
+        fi
+    done
+}
+
+# Check if llgo.sh exists
+LLGO_SCRIPT="../../../llgo.sh"
+if [[ ! -f "$LLGO_SCRIPT" ]]; then
+    print_error "llgo.sh not found at $LLGO_SCRIPT"
+    exit 1
+fi
+
+print_status "Starting C header generation tests..."
+print_status "Working directory: $SCRIPT_DIR"
+
+echo ""
+
+# Test 1: c-shared mode
+print_status "=== Test 2: Building with -buildmode c-shared ==="
+if $LLGO_SCRIPT build -buildmode c-shared -o export .; then
+    print_status "Build succeeded"
+
+    # Check generated files (different extensions on different platforms)
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        # macOS
+        check_file "libexport.dylib" "Dynamic library (libexport.dylib)"
+        SHARED_LIB="libexport.dylib"
+    else
+        # Linux and others
+        check_file "libexport.so" "Dynamic library (libexport.so)"
+        SHARED_LIB="libexport.so"
+    fi
+
+    check_file "libexport.h" "C header (libexport.h)"
+
+    # Compare with expected header if it exists
+    if [[ -f "libexport.h" ]]; then
+        compare_header "libexport.h" "libexport.h.want" "c-shared"
+    fi
+
+    # Test C demo with shared library
+    print_status "=== Testing C demo with shared library ==="
+    if cd use; then
+        if LINK_TYPE=shared make clean && LINK_TYPE=shared make; then
+            print_status "C demo build succeeded with shared library"
+            if LINK_TYPE=shared make run; then
+                print_status "C demo execution succeeded with shared library"
+            else
+                print_warning "C demo execution failed with shared library"
+            fi
+        else
+            print_warning "C demo build failed with shared library"
+        fi
+        cd ..
+    else
+        print_error "Failed to enter use directory"
+    fi
+
+    # Cleanup
+    cleanup "$SHARED_LIB" "libexport.h"
+else
+    print_error "Build failed for c-shared mode"
+fi
+
+# Test 2: c-archive mode
+print_status "=== Test 1: Building with -buildmode c-archive ==="
+if $LLGO_SCRIPT build -buildmode c-archive -o export .; then
+    print_status "Build succeeded"
+
+    # Check generated files
+    check_file "libexport.a" "Static library (libexport.a)"
+    check_file "libexport.h" "C header (libexport.h)"
+
+    # Compare with expected header if it exists
+    if [[ -f "libexport.h" ]]; then
+        compare_header "libexport.h" "libexport.h.want" "c-archive"
+    fi
+
+    # Test C demo with static library
+    print_status "=== Testing C demo with static library ==="
+    if cd use; then
+        if make clean && make; then
+            print_status "C demo build succeeded with static library"
+            if make run; then
+                print_status "C demo execution succeeded with static library"
+            else
+                print_warning "C demo execution failed with static library"
+            fi
+        else
+            print_warning "C demo build failed with static library"
+        fi
+        cd ..
+    else
+        print_error "Failed to enter use directory"
+    fi
+
+    # # Cleanup
+    # cleanup "libexport.a" "libexport.h"
+else
+    print_error "Build failed for c-archive mode"
+fi
+
+echo ""
+
+# TODO(lijie): Uncomment if https://github.com/goplus/llgo/pull/1268 merged
+# # Test 3: ESP32 target with c-archive mode
+# print_status "=== Test 3: Building with -target esp32 -buildmode c-archive ==="
+# if $LLGO_SCRIPT build -target esp32 -buildmode c-archive -o export .; then
+#     print_status "Build succeeded"
+
+#     # Check generated files
+#     check_file "libexport.a" "Static library for ESP32 (libexport.a)"
+#     check_file "libexport.h" "C header for ESP32 (libexport.h)"
+
+#     # Compare with expected header if it exists
+#     if [[ -f "libexport.h" ]]; then
+#         compare_header "libexport.h" "libexport.h.want" "esp32-c-archive"
+#     fi
+
+#     # Don't cleanup ESP32 files - keep them for inspection
+#     print_status "ESP32 build files kept for inspection"
+# else
+#     print_error "Build failed for ESP32 target"
+# fi
+
+# echo ""
+
+# Test 3: Go export demo execution
+print_status "=== Test 3: Running Go export demo ==="
+if go run export.go > /tmp/go_export_output.log 2>&1; then
+    print_status "Go export demo execution succeeded"
+
+    # Check if output contains expected success indicators
+    if grep -q "✓" /tmp/go_export_output.log; then
+        SUCCESS_COUNT=$(grep -c "✓" /tmp/go_export_output.log)
+        print_status "All $SUCCESS_COUNT assertions passed in Go export demo"
+    else
+        print_warning "No assertion markers found in Go export demo output"
+    fi
+
+    # Show key output lines
+    print_status "Go export demo output summary:"
+    if grep -q "ASSERTION FAILED" /tmp/go_export_output.log; then
+        print_error "Found assertion failures in Go export demo"
+        grep "ASSERTION FAILED" /tmp/go_export_output.log
+    else
+        print_status "  ✅ No assertion failures detected"
+        echo "  📊 First few lines of output:"
+        head -5 /tmp/go_export_output.log | sed 's/^/    /'
+        echo "  📊 Last few lines of output:"
+        tail -5 /tmp/go_export_output.log | sed 's/^/    /'
+    fi
+else
+    print_error "Go export demo execution failed"
+    print_error "Error output:"
+    cat /tmp/go_export_output.log | sed 's/^/    /'
+fi
+
+# Cleanup temporary file
+rm -f /tmp/go_export_output.log
+
+echo ""
+
+# Final summary
+print_status "=== Test Summary ==="
+if [[ -f "libexport.a" ]] && [[ -f "libexport.h" ]]; then
+    print_status "All tests completed successfully:"
+    print_status "  ✅ Go export demo execution with assertions"
+    print_status "  ✅ C header generation (c-archive and c-shared modes)"
+    print_status "  ✅ C demo compilation and execution"
+    print_status "  ✅ Cross-platform symbol renaming"
+    print_status "  ✅ Init function export and calling"
+    print_status "  ✅ Function callback types with proper typedef syntax"
+    print_status "  ✅ Multidimensional array parameter handling"
+    print_status ""
+    print_status "Final files available:"
+    print_status "  - libexport.a (static library)"
+    print_status "  - libexport.h (C header file)"
+    print_status "  - use/main.out (C demo executable)"
+
+    echo ""
+    echo "==================="
+else
+    print_error "Some tests may have failed. Check the output above."
+fi
+
+# Show file sizes for reference
+if [[ -f "libexport.a" ]]; then
+    SIZE=$(wc -c < libexport.a)
+    print_status "Static library size: $SIZE bytes"
+fi
+
+if [[ -f "libexport.h" ]]; then
+    LINES=$(wc -l < libexport.h)
+    print_status "Header file lines: $LINES"
+fi
+
+print_status "C header generation and demo tests completed!"