refactor(ssa): rename namedIntf to originType and simplify interface type handling

- Renamed parameter from `namedIntf` to `originType` for clarity
- Removed redundant nil check since `b.abiType()` can handle both Named and Interface types
- Simplified logic by always passing the origin type directly to `b.abiType()`

🤖 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

@@ -0,0 +1,180 @@
+name: Docs
+
+on:
+  push:
+    branches:
+      - "**"
+      - "!dependabot/**"
+      - "!xgopilot/**"
+  pull_request:
+    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@v5
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: "20"
+
+      - name: Install embedme
+        run: npm install -g embedme
+
+      - name: Verify README.md embedded code
+        run: embedme --verify README.md
+
+      - 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-latest
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up Go
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: "1.24.2"
+
+      - 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: 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
+          git() {
+            if [ "$1" = "clone" ]; then
+              # do nothing because we already have the branch
+              cd ..
+            else
+              command git "$@"
+            fi
+          }
+          source doc/_readme/scripts/install_llgo.sh
+          echo "LLGO_ROOT=$GITHUB_WORKSPACE" >> $GITHUB_ENV
+
+      - name: Test doc code blocks
+        run: |
+          set -e
+          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,65 +5,58 @@ name: Go
 
 on:
   push:
-    branches: [ "main" ]
+    branches:
+      - "**"
+      - "!dependabot/**"
+      - "!xgopilot/**"
   pull_request:
-    branches: [ "main" ]
+    branches: ["**"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
 
 jobs:
-
-  test-macos:
-    runs-on: macos-latest
+  test:
+    continue-on-error: true
+    timeout-minutes: 30
     strategy:
       matrix:
-        llvm: [17]
+        os:
+          - macos-latest
+          - ubuntu-latest
+        llvm: [19]
+    runs-on: ${{matrix.os}}
     steps:
-      - uses: actions/checkout@v4
-
-      - name: Update Homebrew
-        if: matrix.llvm == 17 # needed as long as LLVM 17 is still fresh
-        run: brew update
-      - name: Install LLVM ${{ matrix.llvm }}
-        run: HOMEBREW_NO_AUTO_UPDATE=1 brew install llvm@${{ matrix.llvm }}
-        
-      - name: Set up Go
-        uses: actions/setup-go@v5
+      - uses: actions/checkout@v5
+      - name: Install dependencies
+        uses: ./.github/actions/setup-deps
         with:
-          go-version: '1.20'
+          llvm-version: ${{matrix.llvm}}
+
+      - name: Clang information
+        run: |
+          echo $PATH
+          which clang
+          clang --version
+
+      - name: Set up Go
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: "1.24.2"
 
       - name: Build
         run: go build -v ./...
 
       - name: Test
-        run: go test -v ./...
+        if: ${{!startsWith(matrix.os, 'macos')}}
+        run: go test ./...
 
-  test-linux:
-    runs-on: ubuntu-20.04
-    strategy:
-      matrix:
-        llvm: [17]
-    steps:
-    - uses: actions/checkout@v4
+      - name: Test with coverage
+        if: startsWith(matrix.os, 'macos')
+        run: go test -coverprofile="coverage.txt" -covermode=atomic ./...
 
-    - name: Install LLVM ${{ matrix.llvm }}
-      run: |
-        echo 'deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${{ 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 --no-install-recommends llvm-${{ matrix.llvm }}-dev
-
-    - name: Set up Go
-      uses: actions/setup-go@v5
-      with:
-        go-version: '1.20'
-
-    - name: Build
-      run: go build -v ./...
-
-    - name: Test
-      run: go test -v -coverprofile="coverage.txt" -covermode=atomic ./...
-
-    - name: Upload coverage reports to Codecov
-      uses: codecov/codecov-action@v4
-      with:
-        token: ${{ secrets.CODECOV_TOKEN }}
-        slug: goplus/llgo
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{secrets.CODECOV_TOKEN}}

.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_linux_sysroot.sh

@@ -0,0 +1,143 @@
+#!/bin/bash
+
+set -e
+
+TMPDIR="$(mktemp -d)"
+export TMPDIR
+trap 'rm -rf "${TMPDIR}"' EXIT
+
+LINUX_AMD64_PREFIX=.sysroot/linux/amd64
+LINUX_ARM64_PREFIX=.sysroot/linux/arm64
+mkdir -p "${LINUX_AMD64_PREFIX}" "${LINUX_ARM64_PREFIX}"
+
+POPULATE_LINUX_SYSROOT_SCRIPT="$(mktemp)"
+cat > "${POPULATE_LINUX_SYSROOT_SCRIPT}" << EOF
+#!/bin/bash
+
+export DEBIAN_FRONTEND=noninteractive
+
+apt-get update
+apt-get install -y build-essential zlib1g-dev rsync
+
+error() {
+	echo -e "\$1" >&2
+	exit 1
+}
+
+exclude_list=()
+include_list=()
+
+exclude_list+=(--exclude "/bin")
+exclude_list+=(--exclude "/boot")
+exclude_list+=(--exclude "/boot*")
+exclude_list+=(--exclude "/dev")
+exclude_list+=(--exclude "/etc")
+exclude_list+=(--exclude "/home")
+exclude_list+=(--exclude "/lib/dhcpd")
+exclude_list+=(--exclude "/lib/firmware")
+exclude_list+=(--exclude "/lib/hdparm")
+exclude_list+=(--exclude "/lib/ifupdown")
+exclude_list+=(--exclude "/lib/modules")
+exclude_list+=(--exclude "/lib/modprobe.d")
+exclude_list+=(--exclude "/lib/modules-load.d")
+exclude_list+=(--exclude "/lib/resolvconf")
+exclude_list+=(--exclude "/lib/startpar")
+exclude_list+=(--exclude "/lib/systemd")
+exclude_list+=(--exclude "/lib/terminfo")
+exclude_list+=(--exclude "/lib/udev")
+exclude_list+=(--exclude "/lib/xtables")
+exclude_list+=(--exclude "/lib/ssl/private")
+exclude_list+=(--exclude "/lost+found")
+exclude_list+=(--exclude "/media")
+exclude_list+=(--exclude "/mnt")
+exclude_list+=(--exclude "/proc")
+exclude_list+=(--exclude "/root")
+exclude_list+=(--exclude "/run")
+exclude_list+=(--exclude "/sbin")
+exclude_list+=(--exclude "/srv")
+exclude_list+=(--exclude "/sys")
+exclude_list+=(--exclude "/tmp")
+exclude_list+=(--exclude "/usr/bin")
+exclude_list+=(--exclude "/usr/games")
+exclude_list+=(--exclude "/usr/sbin")
+exclude_list+=(--exclude "/usr/share")
+exclude_list+=(--exclude "/usr/src")
+exclude_list+=(--exclude "/usr/local/bin")
+exclude_list+=(--exclude "/usr/local/etc")
+exclude_list+=(--exclude "/usr/local/games")
+exclude_list+=(--exclude "/usr/local/man")
+exclude_list+=(--exclude "/usr/local/sbin")
+exclude_list+=(--exclude "/usr/local/share")
+exclude_list+=(--exclude "/usr/local/src")
+exclude_list+=(--exclude "/usr/lib/ssl/private")
+exclude_list+=(--exclude "/var")
+exclude_list+=(--exclude "/snap")
+exclude_list+=(--exclude "*python*")
+
+include_list+=(--include "*.a")
+include_list+=(--include "*.so")
+include_list+=(--include "*.so.*")
+include_list+=(--include "*.h")
+include_list+=(--include "*.hh")
+include_list+=(--include "*.hpp")
+include_list+=(--include "*.hxx")
+include_list+=(--include "*.pc")
+include_list+=(--include "*.def")
+include_list+=(--include "*.inc")
+include_list+=(--include "/lib")
+include_list+=(--include "/lib32")
+include_list+=(--include "/lib64")
+include_list+=(--include "/libx32")
+include_list+=(--include "*/")
+
+do-sync() {
+	from=\$1
+	to=\$2
+
+	args=()
+	args+=(-a)
+	args+=(-z)
+	args+=(-m)
+	args+=(-d)
+	args+=(-h)
+	args+=(--keep-dirlinks)
+	args+=(--delete)
+	args+=(--prune-empty-dirs)
+	args+=(--sparse)
+	args+=(--links)
+	args+=(--copy-unsafe-links)
+	args+=("\${exclude_list[@]}")
+	args+=("\${include_list[@]}")
+	args+=(--exclude "*")
+	args+=("\${from}")
+	args+=("\${to}")
+
+	echo "\${args[@]}"
+	rsync "\${args[@]}"
+
+	exit \$?
+}
+
+do-sync / /sysroot/
+EOF
+chmod +x "${POPULATE_LINUX_SYSROOT_SCRIPT}"
+
+populate_linux_sysroot() {
+	local ARCH="$1"
+	local PREFIX="$2"
+	docker run \
+		--rm \
+		--platform "linux/${ARCH}" \
+		-v "$(pwd)/${PREFIX}":/sysroot \
+		-v "${POPULATE_LINUX_SYSROOT_SCRIPT}":/populate_linux_sysroot.sh \
+		debian:bullseye \
+		/populate_linux_sysroot.sh
+}
+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

@@ -0,0 +1,207 @@
+name: Release Build
+
+on:
+  push:
+    branches:
+      - "**"
+      - "!dependabot/**"
+      - "!xgopilot/**"
+    tags: ["*"]
+  pull_request:
+    branches: ["**"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  setup:
+    runs-on: ubuntu-latest
+    outputs:
+      linux-cache-key: ${{ steps.cache-keys.outputs.linux-key }}
+    steps:
+      - name: Check out code
+        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:
+          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
+        if: steps.cache-linux-sysroot.outputs.cache-hit != 'true'
+        with:
+          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: 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: |
+          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 --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

@@ -0,0 +1,30 @@
+#!/bin/bash
+set -e
+
+# llgo run subdirectories under _demo that contain *.go files
+total=0
+failed=0
+failed_cases=""
+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"
+    if ! (cd "$d" && llgo run .); then
+      echo "FAIL"
+      failed=$((failed+1))
+      failed_cases="$failed_cases\n* :x: $d"
+    else
+      echo "PASS"
+    fi
+  fi
+done
+echo "=== Done"
+echo "$((total-failed))/$total tests passed"
+
+if [ "$failed" -ne 0 ]; then
+  echo ":bangbang: Failed demo cases:" | tee -a result.md
+  echo -e "$failed_cases" | tee -a result.md
+  exit 1
+else
+  echo ":white_check_mark: All demo tests passed" | tee -a result.md
+fi

.gitignore

@@ -7,22 +7,31 @@
 *.dll
 *.so
 *.dylib
+*.a
 
 test.db
-llgo_autogen.ll
+demo.ll
+llgo_autogen*.ll
 stories*.bin
 .DS_Store
 err.log
+numpy.txt
+result.txt
 
 _go/
 _runtime/
 _tinygo/
+_output/
 build.dir/
 .vscode/
+.venv/
 
 # Test binary, built with `go test -c`
 *.test
 
+# Debug symbols
+*.dSYM
+
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 *.swp
@@ -32,3 +41,15 @@ build.dir/
 
 # Go workspace file
 go.work*
+
+# GoReleaser
+.dist/
+.sysroot/
+
+# Embedded firmware files
+*.bin
+*.hex
+*.elf
+*.uf2
+*.img
+*.zip

.gitmodules

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

.goreleaser.yaml

@@ -0,0 +1,154 @@
+version: 2
+
+dist: .dist
+
+env:
+  - SYSROOT_DARWIN_AMD64={{.Env.PWD}}/.sysroot/darwin/amd64
+  - SYSROOT_DARWIN_ARM64={{.Env.PWD}}/.sysroot/darwin/arm64
+  - SYSROOT_LINUX_AMD64={{.Env.PWD}}/.sysroot/linux/amd64
+  - SYSROOT_LINUX_ARM64={{.Env.PWD}}/.sysroot/linux/arm64
+  - CGO_ENABLED=1
+  - CGO_CXXFLAGS=-std=c++17
+
+before:
+  hooks:
+    - go mod download
+
+builds:
+  - id: llgo-darwin-amd64
+    main: ./cmd/llgo
+    binary: bin/llgo
+    flags:
+      - -tags=darwin,amd64,byollvm
+    ldflags:
+      - -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}}/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/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}}/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/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}}/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/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}}/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}}"
+
+archives:
+  - format: tar.gz
+    name_template: >-
+      {{.ProjectName}}{{.Version}}.{{.Os}}-{{.Arch}}
+      {{- if .Arm}}v{{.Arm}}{{end}}
+    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"
+
+nfpms:
+  - package_name: llgo
+    vendor: goplus
+    homepage: https://github.com/goplus/llgo
+    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 XGo project.
+
+      LLGo aims to expand the boundaries of Go/XGo, providing limitless possibilities such as:
+
+      - Game development
+      - AI and data science
+      - WebAssembly
+      - Embedded development
+      - ...
+    license: Apache-2.0
+    formats:
+      - deb
+      - rpm
+    file_name_template: >-
+      {{.ProjectName}}{{.Version}}.{{.Os}}-{{.Arch}}
+      {{- if .Arm}}v{{.Arm}}{{end}}
+    bindir: /usr/local/bin
+
+snapcrafts:
+  - name: llgo
+    title: A Go compiler based on LLVM
+    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 XGo project.
+
+      LLGo aims to expand the boundaries of Go/XGo, providing limitless possibilities such as:
+
+      - Game development
+      - AI and data science
+      - WebAssembly
+      - Embedded development
+      - ...
+    license: Apache-2.0
+    confinement: classic
+    name_template: >-
+      {{.ProjectName}}{{.Version}}.{{.Os}}-{{.Arch}}
+      {{- if .Arm}}v{{.Arm}}{{end}}
+
+snapshot:
+  name_template: '{{trimprefix .Summary "v"}}'
+
+release:
+  prerelease: auto

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,53 +6,350 @@ 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)
 
-This 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).
 
-## C standard libary support
+LLGo aims to expand the boundaries of Go/XGo, providing limitless possibilities such as:
+
+* Game development
+* AI and data science
+* WebAssembly
+* Embedded development
+* ...
+
+How can these be achieved?
+
+```
+LLGo := Go * C ecosystem
+```
+
+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/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:
+
+<!-- embedme doc/_readme/llgo_simple/simple.go -->
 
 ```go
 package main
 
-import "github.com/goplus/llgo/c"
+import "github.com/goplus/lib/c"
 
 func main() {
 	c.Printf(c.Str("Hello world\n"))
 }
 ```
 
-This is a simple example of calling the C `printf` function to print `Hello world`. Here, `c.Str` is not a function for converting a Go string to a C string, but a built-in instruction supported by llgo for generating a C string constant.
+This is a simple example of calling the C `printf` function to print `Hello world`. Here, `c.Str` is not a function for converting a Go string to a C string, but a built-in instruction supported by `llgo` for generating a C string constant.
 
-See [github.com/goplus/llgo/c](https://pkg.go.dev/github.com/goplus/llgo/c) for more detials.
+The `_demo` directory contains some C standard libary related demos (it start with `_` to prevent the `go` command from compiling it):
+
+* [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/c/hello
+llgo run .
+```
+
+
+## How to support C/C++ and Python
+
+LLGo use `go:linkname` to link an extern symbol througth its ABI:
+
+<!-- embedme doc/_readme/llgo_call_c/call_c.go#L3-L6 -->
+
+```go
+import _ "unsafe" // for go:linkname
+
+//go:linkname Sqrt C.sqrt
+func Sqrt(x float64) float64
+```
+
+You can directly integrate it into [your own code](_demo/c/linkname/linkname.go):
+
+<!-- embedme doc/_readme/llgo_call_c/call_c.go -->
+
+```go
+package main
+
+import _ "unsafe" // for go:linkname
+
+//go:linkname Sqrt C.sqrt
+func Sqrt(x float64) float64
+
+func main() {
+	println("sqrt(2) =", Sqrt(2))
+}
+```
+
+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/lib/c/math"
+
+func main() {
+	println("sqrt(2) =", math.Sqrt(2))
+}
+```
 
 
 ## Python support
 
-You can import a Python library in llgo! For example:
+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/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.
+
+Here is an example:
+
+<!-- embedme doc/_readme/llgo_call_py/call_py.go -->
 
 ```go
 package main
 
 import (
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/py"
-	"github.com/goplus/llgo/py/math"
+	"github.com/goplus/lib/py"
+	"github.com/goplus/lib/py/math"
+	"github.com/goplus/lib/py/std"
 )
 
 func main() {
-	x := math.Sqrt(py.Float(2))
-	c.Printf(c.Str("sqrt(2) = %f\n"), x.Float64())
+	x := math.Sqrt(py.Float(2))       // x = sqrt(2)
+	std.Print(py.Str("sqrt(2) ="), x) // print("sqrt(2) =", x)
 }
 ```
 
-Here, We call `py.Float(2)` to create a Python floating point number 2, and pass it to Python’s `math.sqrt` to get `x`. Then use `x.Float64()` to convert the Python object to Go's `float64` type, and finally we print the value through C `printf`.
+It is equivalent to the following Python code:
+
+<!-- embedme doc/_readme/llgo_call_py/call_math.py -->
+
+```py
+import math
+
+x = math.sqrt(2)
+print("sqrt =", x)
+```
+
+Here, We call `py.Float(2)` to create a Python number 2, and pass it to Python’s `math.sqrt` to get `x`. Then we call `std.Print` to print the result.
+
+Let's look at a slightly more complex example. For example, we use `numpy` to calculate:
+
+<!-- embedme doc/_readme/llgo_py_list/py_list.go -->
+
+```go
+package main
+
+import (
+	"github.com/goplus/lib/py"
+	"github.com/goplus/lib/py/numpy"
+	"github.com/goplus/lib/py/std"
+)
+
+func main() {
+	a := py.List(
+		py.List(1.0, 2.0, 3.0),
+		py.List(4.0, 5.0, 6.0),
+		py.List(7.0, 8.0, 9.0),
+	)
+	b := py.List(
+		py.List(9.0, 8.0, 7.0),
+		py.List(6.0, 5.0, 4.0),
+		py.List(3.0, 2.0, 1.0),
+	)
+	x := numpy.Add(a, b)
+	std.Print(py.Str("a+b ="), x)
+}
+```
+
+Here we define two 3x3 matrices a and b, add them to get x, and then print the result.
+
+The `_demo/py/` directory contains some python related demos:
+
+* [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 _demo/py/callpy
+llgo run .
+```
 
 
 ## Other frequently used libraries
 
-TODO
+LLGo can easily import any libraries from the C ecosystem. Currently, this import process is still manual, but in the future, it will be automated similar to Python library imports.
 
+The currently supported libraries include:
+
+* [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/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/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/go/goroutine/goroutine.go): goroutine demo
+
+
+### Defer
+
+LLGo `defer` does not support usage in loops. This is not a bug but a feature, because we think that using `defer` in a loop is a very unrecommended practice.
+
+
+### Garbage Collection (GC)
+
+By default, LLGo implements `gc` based on [bdwgc](https://www.hboehm.info/gc/) (also known as [libgc](https://www.hboehm.info/gc/)).
+
+However, you can disable gc by specifying the `nogc` tag. For example:
+
+```sh
+llgo run -tags nogc .
+```
+
+
+## Go packages support
+
+Here are the Go packages that can be imported correctly:
+
+* [unsafe](https://pkg.go.dev/unsafe)
+* [unicode](https://pkg.go.dev/unicode)
+* [unicode/utf8](https://pkg.go.dev/unicode/utf8)
+* [unicode/utf16](https://pkg.go.dev/unicode/utf16)
+* [math](https://pkg.go.dev/math)
+* [math/big](https://pkg.go.dev/math/big) (partially)
+* [math/bits](https://pkg.go.dev/math/bits)
+* [math/cmplx](https://pkg.go.dev/math/cmplx)
+* [math/rand](https://pkg.go.dev/math/rand)
+* [net/url](https://pkg.go.dev/net/url)
+* [errors](https://pkg.go.dev/errors)
+* [context](https://pkg.go.dev/context)
+* [io](https://pkg.go.dev/io)
+* [io/fs](https://pkg.go.dev/io/fs)
+* [io/ioutil](https://pkg.go.dev/io/ioutil)
+* [log](https://pkg.go.dev/log)
+* [flag](https://pkg.go.dev/flag)
+* [sort](https://pkg.go.dev/sort)
+* [bytes](https://pkg.go.dev/bytes)
+* [bufio](https://pkg.go.dev/bufio)
+* [strings](https://pkg.go.dev/strings)
+* [strconv](https://pkg.go.dev/strconv)
+* [path](https://pkg.go.dev/path)
+* [path/filepath](https://pkg.go.dev/path/filepath)
+* [sync/atomic](https://pkg.go.dev/sync/atomic)
+* [sync](https://pkg.go.dev/sync) (partially)
+* [syscall](https://pkg.go.dev/syscall) (partially)
+* [runtime](https://pkg.go.dev/runtime) (partially)
+* [os](https://pkg.go.dev/os) (partially)
+* [os/exec](https://pkg.go.dev/os/exec) (partially)
+* [fmt](https://pkg.go.dev/fmt) (partially)
+* [reflect](https://pkg.go.dev/reflect) (partially)
+* [time](https://pkg.go.dev/time) (partially)
+* [encoding](https://pkg.go.dev/encoding)
+* [encoding/binary](https://pkg.go.dev/encoding/binary)
+* [encoding/hex](https://pkg.go.dev/encoding/hex)
+* [encoding/base32](https://pkg.go.dev/encoding/base32)
+* [encoding/base64](https://pkg.go.dev/encoding/base64)
+* [encoding/csv](https://pkg.go.dev/encoding/csv)
+* [net/textproto](https://pkg.go.dev/net/textproto)
+* [hash](https://pkg.go.dev/hash)
+* [hash/adler32](https://pkg.go.dev/hash/adler32)
+* [hash/crc32](https://pkg.go.dev/hash/crc32) (partially)
+* [hash/crc64](https://pkg.go.dev/hash/crc64)
+* [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)
+* [crypto/sha256](https://pkg.go.dev/crypto/sha256)
+* [crypto/sha512](https://pkg.go.dev/crypto/sha512) (partially)
+* [crypto/hmac](https://pkg.go.dev/crypto/hmac) (partially)
+* [crypto/rand](https://pkg.go.dev/crypto/rand) (partially)
+* [crypto/subtle](https://pkg.go.dev/crypto/subtle) (partially)
+* [regexp](https://pkg.go.dev/regexp)
+* [regexp/syntax](https://pkg.go.dev/regexp/syntax)
+* [go/token](https://pkg.go.dev/go/token)
+* [go/scanner](https://pkg.go.dev/go/scanner)
+* [go/parser](https://pkg.go.dev/go/parser)
+
+
+## Dependencies
+
+- [Go 1.21+](https://go.dev)
+- [LLVM 18](https://llvm.org)
+- [Clang 18](https://clang.llvm.org)
+- [LLD 18](https://lld.llvm.org)
+- [pkg-config 0.29+](https://www.freedesktop.org/wiki/Software/pkg-config/)
+- [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/lib/py](https://pkg.go.dev/github.com/goplus/lib/py))
 
 ## How to install
 
@@ -60,66 +357,95 @@ Follow these steps to generate the `llgo` command (its usage is the same as the
 
 ### on macOS
 
+<!-- embedme doc/_readme/scripts/install_macos.sh#L2-L1000 -->
+
 ```sh
-brew update  # execute if needed
-brew install llvm@17
-go install -v ./...
+brew update
+brew install llvm@19 lld@19 bdw-gc openssl cjson libffi libuv pkg-config
+brew install python@3.12 # optional
+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
 
+#### Debian/Ubuntu
+
+<!-- embedme doc/_readme/scripts/install_ubuntu.sh#L2-L1000 -->
+
 ```sh
-echo 'deb http://apt.llvm.org/focal/ llvm-toolchain-focal-17 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  # execute if needed
-sudo apt-get install --no-install-recommends llvm-17-dev
-go install -v ./...
+sudo apt-get update
+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
+#curl https://raw.githubusercontent.com/goplus/llgo/refs/heads/main/install.sh | bash
+./install.sh
+```
+
+#### Alpine Linux
+
+```sh
+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/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)"
+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
 
-## Demo
-
-The `_demo` directory contains our 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, and Go variadic function
-* [qsort](_demo/qsort/qsort.go): call C function with a callback (eg. qsort)
-* [genints](_demo/genints/genints.go): various forms of closure usage (including C function, recv.method and anonymous function)
-* [llama2-c](_demo/llama2-c): inference Llama 2 (It's the first llgo AI example)
-
-And the `_pydemo` directory contains python related demos:
-
-* [callpy](_pydemo/callpy/callpy.go): call Python standard library function `math.sqrt`
-
-
-### How to run demos
-
-To run the demos in directory `_demo`:
+<!-- embedme doc/_readme/scripts/install_llgo.sh#L2-L1000 -->
 
 ```sh
-cd <demo-directory>  # eg. cd _demo/genints
-llgo run .
+git clone https://github.com/goplus/llgo.git
+cd llgo
+./install.sh
 ```
 
-To run the demos in directory `_pydemo`, you need to set the `LLGO_LIB_PYTHON` environment variable first. Assuming you use Python 3.12, and the `libpython3.12.so` (or `libpython3.12.dylib` or `python3.12.lib`) file is in the /foo/bar directory, then you need to set `LLGO_LIB_PYTHON` to:
+## Development tools
+
+* [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).
+* [ssadump](chore/ssadump): It is a Go SSA builder and interpreter.
+
+How do I generate these tools?
+
+<!-- embedme doc/_readme/scripts/install_full.sh#L2-L1000 -->
 
 ```sh
-export LLGO_LIB_PYTHON=/foo/bar/python3.12
+git clone https://github.com/goplus/llgo.git
+cd llgo
+go install -v ./cmd/...
+go install -v ./chore/...  # compile all tools except pydump
+export LLGO_ROOT=$PWD
+cd _xtool
+llgo install ./...   # compile pydump
+go install github.com/goplus/hdq/chore/pysigfetch@v0.8.1  # compile pysigfetch
+
 ```
 
-For example, `/opt/homebrew/Frameworks/Python.framework/Versions/3.12/libpython3.12.dylib` is a typical python lib location under macOS. So we should set it like this:
+## Key modules
 
-```sh
-export LLGO_LIB_PYTHON=/opt/homebrew/Frameworks/Python.framework/Versions/3.12/python3.12
-```
+Below are the key modules for understanding the implementation principles of `llgo`:
 
-Then you can run the demos in directory `_pydemo`:
-
-```sh
-cd <demo-directory>  # eg. cd _pydemo/callpy
-llgo run .
-```
+* [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/_bigsqrt2/sqrt2.go

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

_cmptest/_chandemo/chan.go

@@ -0,0 +1,21 @@
+package main
+
+func main() {
+	c1 := make(chan string)
+	c2 := make(chan string, 1)
+	go func() {
+		c1 <- "ch1"
+	}()
+	go func() {
+		c2 <- "ch2"
+	}()
+
+	for i := 0; i < 2; i++ {
+		select {
+		case msg1 := <-c1:
+			println(msg1)
+		case msg2 := <-c2:
+			println(msg2)
+		}
+	}
+}

_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/_jsondemo/json.go

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

_cmptest/_timeout/timer.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+var c chan int
+
+func handle(int) {}
+
+func main() {
+	select {
+	case m := <-c:
+		handle(m)
+	case <-time.After(time.Second / 10):
+		fmt.Println("timed out")
+	}
+}

_cmptest/base64demo/base64.go

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

_cmptest/bigintdemo/fib.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"fmt"
+	"math/big"
+)
+
+func fib() {
+	// 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
+}
+
+func abs() {
+	a := big.NewInt(64)
+	b := big.NewInt(-52)
+	a.Set(b)
+	a.Abs(a)
+	a.Set(big.NewInt(-164))
+	a.Abs(a)
+	fmt.Println("value: ", a.String())
+}
+
+func neg() {
+	fmt.Println("value: ", big.NewInt(-64).Neg(big.NewInt(-64)))
+	fmt.Println("value: ", big.NewInt(64).Neg(big.NewInt(64)))
+	fmt.Println("value: ", big.NewInt(0).Neg(big.NewInt(0)))
+}
+
+func calc() {
+	a := big.NewInt(64)
+	b := big.NewInt(-52)
+	c := big.NewInt(54)
+	fmt.Println("value:", a.Add(a, b))
+	fmt.Println("value:", a.Sub(b, c))
+	d := big.NewInt(10)
+	e := big.NewInt(4)
+	fmt.Println("value:", d.Mul(d, e))
+}
+
+func bitop() {
+	a := big.NewInt(4)
+	fmt.Println("value:", a.Lsh(a, 1))
+	b := big.NewInt(16)
+	fmt.Println("value:", b.Rsh(b, 2))
+}
+
+func main() {
+	bitop()
+}

_cmptest/chan/chan.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	ch := make(chan int, 10)
+	println(len(ch), cap(ch))
+	go func() {
+		ch <- 100
+	}()
+	n, ok := <-ch
+	println(n, ok)
+}

_cmptest/chansel/chansel.go

@@ -0,0 +1,26 @@
+package main
+
+func fibonacci(c, quit chan int) {
+	x, y := 0, 1
+	for {
+		select {
+		case c <- x:
+			x, y = y, x+y
+		case <-quit:
+			println("quit")
+			return
+		}
+	}
+}
+
+func main() {
+	c := make(chan int)
+	quit := make(chan int)
+	go func() {
+		for i := 0; i < 10; i++ {
+			println(<-c)
+		}
+		close(quit)
+	}()
+	fibonacci(c, quit)
+}

_cmptest/crcdemo/crc.go

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

_cmptest/csvdemo/csv.go

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

_cmptest/ctxcancel/ctx.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"context"
+	"fmt"
+)
+
+func main() {
+	// gen generates integers in a separate goroutine and
+	// sends them to the returned channel.
+	// The callers of gen need to cancel the context once
+	// they are done consuming generated integers not to leak
+	// the internal goroutine started by gen.
+	gen := func(ctx context.Context) <-chan int {
+		dst := make(chan int)
+		n := 1
+		go func() {
+			for {
+				select {
+				case <-ctx.Done():
+					return // returning not to leak the goroutine
+				case dst <- n:
+					n++
+				}
+			}
+		}()
+		return dst
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel() // cancel when we are finished consuming integers
+
+	for n := range gen(ctx) {
+		fmt.Println(n)
+		if n == 5 {
+			break
+		}
+	}
+}

_cmptest/defer/defer.go

@@ -0,0 +1,17 @@
+package main
+
+func f(s string) bool {
+	return len(s) > 2
+}
+
+func main() {
+	defer func() {
+		println("hi")
+	}()
+	if s := "hello"; f(s) {
+		defer println(s)
+	} else {
+		defer println("world")
+	}
+	defer println("bye")
+}

_cmptest/envexpand/expand.go

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

_cmptest/errors/errors.go

@@ -0,0 +1,21 @@
+package main
+
+// New returns an error that formats as the given text.
+// Each call to New returns a distinct error value even if the text is identical.
+func New(text string) error {
+	return &errorString{text}
+}
+
+// errorString is a trivial implementation of error.
+type errorString struct {
+	s string
+}
+
+func (e *errorString) Error() string {
+	return e.s
+}
+
+func main() {
+	err := New("an error")
+	println(err.Error())
+}

_cmptest/flagdemo/flagdemo.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+)
+
+func main() {
+	fmt.Println("args:", os.Args[1:])
+	if len(os.Args) == 1 {
+		os.Args = []string{"flagdemo", "-cpu", "100"}
+	}
+
+	verbose := flag.Bool("v", false, "verbose")
+	cpu := flag.Int("cpu", 1, "cpu number")
+	host := flag.String("host", ":8888", "host")
+	flag.Parse()
+
+	fmt.Println("host:", *host, "cpu:", *cpu, "verbose:", *verbose)
+}

_cmptest/fmtdemo/fmt.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+)
+
+func main() {
+	fmt.Println("Hello, world")
+	fmt.Printf("%f\n", 3.14)
+	fmt.Printf("%v\n", errors.New("error message"))
+}

_cmptest/goparsedemo/parse.go

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

_cmptest/goscandemo/scan.go

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

_cmptest/hmacdemo/hmac.go

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

_cmptest/interf/foo/foo.go

@@ -0,0 +1,9 @@
+package foo
+
+func Bar() any {
+	return struct{ V int }{1}
+}
+
+func F() any {
+	return struct{ v int }{1}
+}

_cmptest/interf/interf.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"github.com/goplus/llgo/_cmptest/interf/foo"
+)
+
+func Foo() any {
+	return struct{ v int }{1}
+}
+
+func main() {
+	v := Foo()
+	if x, ok := v.(struct{ v int }); ok {
+		println(x.v)
+	} else {
+		println("Foo: not ok")
+	}
+	bar := foo.Bar()
+	if x, ok := bar.(struct{ V int }); ok {
+		println(x.V)
+	} else {
+		println("Bar: not ok")
+	}
+	if x, ok := foo.F().(struct{ v int }); ok {
+		println(x.v)
+	} else {
+		println("F: not ok")
+	}
+}
+
+/* Expected output:
+1
+1
+F: not ok
+*/

_cmptest/iodemo/io.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"io"
+	"os"
+)
+
+func f(w io.Writer) {
+	w.Write([]byte("Hello, world\n"))
+}
+
+func main() {
+	f(os.Stdout)
+}

_cmptest/ioutildemo/ioutil.go

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

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

_cmptest/md5demo/md5.go

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

_cmptest/osdemo/osd.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"os"
+)
+
+func main() {
+	home, _ := os.UserHomeDir()
+	println("home:", home)
+
+	cfgdir, _ := os.UserConfigDir()
+	println("cfgdir:", cfgdir)
+
+	cache, _ := os.UserCacheDir()
+	println("cachedir:", cache)
+
+	os.Stdout.Write([]byte("Hello, World\n"))
+}

_cmptest/osexec/exec.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+
+	"github.com/goplus/llgo/xtool/env/llvm"
+)
+
+func main() {
+	ls := "ls"
+	if runtime.GOOS == "windows" {
+		ls = "dir"
+	}
+	cmd := exec.Command(ls)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Run()
+
+	dir := llvm.New("").BinDir()
+	fmt.Println(dir)
+}

_cmptest/osproc/exec.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+)
+
+func main() {
+	ls := "ls"
+	args := []string{ls, "-l"}
+	if runtime.GOOS == "windows" {
+		ls = "dir"
+		args = []string{ls}
+	}
+	lspath, _ := exec.LookPath(ls)
+	if lspath != "" {
+		ls = lspath
+	}
+	proc, err := os.StartProcess(ls, args, &os.ProcAttr{
+		Files: []*os.File{nil, os.Stdout, os.Stderr},
+	})
+	if err != nil {
+		fmt.Println("os.StartProcess error:", err)
+		return
+	}
+	proc.Wait()
+	fmt.Println("proc.Wait done")
+}

_cmptest/pipedemo/pipe.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"fmt"
+	"io"
+)
+
+func main() {
+	data := []byte("This is some data that needs to be stored in Body.")
+	pr, pw := io.Pipe()
+	go func() {
+		defer pw.Close()
+		if _, err := pw.Write(data); err != nil {
+			fmt.Println("Error writing to pipe:", err)
+			return
+		}
+	}()
+	defer pr.Close()
+
+	readData, err := io.ReadAll(pr)
+	if err != nil {
+		fmt.Println("Error reading from Body:", err)
+		return
+	}
+	fmt.Println("Body:", string(readData))
+}

_cmptest/printfdemo/demo.go

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

_cmptest/readfiledemo/readf.go

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

_cmptest/reflect/reflect.go

@@ -0,0 +1,13 @@
+package main
+
+import "reflect"
+
+func main() {
+	tyIntSlice := reflect.SliceOf(reflect.TypeOf(0))
+	v := reflect.Zero(tyIntSlice)
+	v = reflect.Append(v, reflect.ValueOf(1), reflect.ValueOf(2), reflect.ValueOf(3))
+	for i, n := 0, v.Len(); i < n; i++ {
+		item := v.Index(i)
+		println(item.Int())
+	}
+}

_cmptest/regexdemo/regex.go

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

_cmptest/rtype/rtype.go

@@ -0,0 +1,14 @@
+package main
+
+import "reflect"
+
+func main() {
+	tyIntSlice := reflect.SliceOf(reflect.TypeOf(0))
+	println(tyIntSlice.String())
+
+	v := reflect.Zero(tyIntSlice)
+	println(v.Len())
+
+	v = reflect.ValueOf(100)
+	println(v.Int())
+}

_cmptest/sha1demo/sha1.go

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

_cmptest/sha256demo/sha256.go

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

_cmptest/sha512demo/sha512.go

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

_cmptest/sortdemo/sort.go

@@ -0,0 +1,23 @@
+package main
+
+import "sort"
+
+func main() {
+	vals := []int{32, 58, 25, 92, 45, 78}
+	sort.Ints(vals)
+	for _, v := range vals {
+		println(v)
+	}
+
+	texts := []string{"apple", "banana", "cherry", "date", "elderberry", "fig"}
+	sort.Slice(texts, func(i, j int) bool {
+		leni, lenj := len(texts[i]), len(texts[j])
+		if leni != lenj {
+			return leni < lenj
+		}
+		return texts[i] < texts[j]
+	})
+	for _, v := range texts {
+		println(v)
+	}
+}

_cmptest/strconv/strconv.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func main() {
+	fmt.Println(strconv.Itoa(-123))
+	fmt.Println(strings.Split("abc,def,123", ","))
+}

_cmptest/syscall/syscall.go

@@ -0,0 +1,11 @@
+package main
+
+import "syscall"
+
+func main() {
+	wd, err := syscall.Getwd()
+	if err != nil {
+		panic(err)
+	}
+	println("cwd:", wd)
+}

_cmptest/timedemo/time.go

@@ -0,0 +1,8 @@
+package main
+
+import "time"
+
+func main() {
+	t := time.Date(2018, time.January, 1, 2, 3, 4, 5, time.UTC)
+	println(t.String())
+}

_cmptest/urldemo/url.go

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

_demo/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

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"github.com/goplus/lib/c/sync/atomic"
+)
+
+func main() {
+	var v int64
+
+	atomic.Store(&v, 100)
+	println("store:", atomic.Load(&v))
+
+	ret := atomic.Add(&v, 1)
+	println("ret:", ret, "v:", v)
+
+	ret, _ = atomic.CompareAndExchange(&v, 100, 102)
+	println("ret:", ret, "vs 100, v:", v)
+
+	ret, _ = atomic.CompareAndExchange(&v, 101, 102)
+	println("ret:", ret, "vs 101, v:", v)
+
+	ret = atomic.Sub(&v, 1)
+	println("ret:", ret, "v:", v)
+}

_demo/c/cexec/exec.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/os"
+)
+
+func main() {
+	ls := c.Str("ls")
+	os.Execlp(ls, ls, c.Str("-l"), nil)
+}

_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

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/math"
+	"github.com/goplus/llgo/_demo/c/cppintf/foo"
+)
+
+type Bar struct {
+	foo.Callback
+	a c.Int
+}
+
+func NewBar(a c.Int) *Bar {
+	return &Bar{
+		Callback: foo.Callback{
+			Vptr: &foo.CallbackVtbl{
+				Val:  c.Func((*Bar).getA),
+				Calc: c.Func((*Bar).sqrt),
+			},
+		},
+		a: a,
+	}
+}
+
+func (p *Bar) getA() c.Int {
+	return p.a
+}
+
+func (p *Bar) sqrt(v float64) float64 {
+	return math.Sqrt(v)
+}
+
+func main() {
+	bar := NewBar(1)
+	foo.F(&bar.Callback)
+	foo.G(&bar.Callback)
+}

_demo/c/cppintf/foo/bar/bar.cpp

@@ -0,0 +1,15 @@
+#include <stdio.h>
+#define interface struct
+
+interface ICallback {
+	virtual int val() = 0;
+	virtual double calc(double v) = 0;
+};
+
+extern "C" void f(ICallback* cb) {
+	printf("val: %d\ncalc(2): %lf\n", cb->val(), cb->calc(2));
+}
+
+void g(ICallback* cb) {
+	f(cb);
+}

_demo/c/cppintf/foo/foo.go

@@ -0,0 +1,25 @@
+package foo
+
+import (
+	"unsafe"
+)
+
+const (
+	LLGoFiles   = "bar/bar.cpp"
+	LLGoPackage = "link"
+)
+
+type Callback struct {
+	Vptr *CallbackVtbl
+}
+
+type CallbackVtbl struct {
+	Val  unsafe.Pointer
+	Calc unsafe.Pointer
+}
+
+//go:linkname F C.f
+func F(cb *Callback)
+
+//go:linkname G C._Z1gP9ICallback
+func G(cb *Callback)

_demo/c/cppmintf/cpp_multi_intf.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/math"
+	"github.com/goplus/llgo/_demo/c/cppmintf/foo"
+)
+
+type Bar struct {
+	foo.Callback
+	a c.Int
+}
+
+func NewBar(a c.Int) *Bar {
+	return &Bar{
+		Callback: foo.Callback{
+			ICalc: foo.ICalc{
+				Vptr: &foo.ICalcVtbl{
+					Calc: c.Func((*Bar).sqrt),
+				},
+			},
+			IVal: foo.IVal{
+				Vptr: &foo.IValVtbl{
+					Val: c.Func(bar_IVal_getA),
+				},
+			},
+		},
+		a: a,
+	}
+}
+
+func (p *Bar) getA() c.Int {
+	return p.a
+}
+
+func bar_IVal_getA(this c.Pointer) c.Int {
+	const delta = -int(unsafe.Offsetof(foo.Callback{}.IVal))
+	return (*Bar)(c.Advance(this, delta)).getA()
+}
+
+func (p *Bar) sqrt(v float64) float64 {
+	return math.Sqrt(v)
+}
+
+func main() {
+	bar := NewBar(1)
+	foo.F(&bar.Callback)
+}

_demo/c/cppmintf/foo/bar/bar.cpp

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#define interface struct
+
+interface ICalc {
+	virtual double calc(double v) = 0;
+};
+
+interface IVal {
+	virtual int val() = 0;
+};
+
+class Callback : public ICalc, public IVal {
+};
+
+extern "C" void f(Callback* cb) {
+	printf("val: %d\ncalc(2): %lf\n", cb->val(), cb->calc(2));
+}

_demo/c/cppmintf/foo/foo.go

@@ -0,0 +1,42 @@
+package foo
+
+import (
+	"unsafe"
+)
+
+const (
+	LLGoFiles   = "bar/bar.cpp"
+	LLGoPackage = "link"
+)
+
+// -----------------------------------------------------------------------------
+
+type ICalc struct {
+	Vptr *ICalcVtbl
+}
+
+type ICalcVtbl struct {
+	Calc unsafe.Pointer
+}
+
+// -----------------------------------------------------------------------------
+
+type IVal struct {
+	Vptr *IValVtbl
+}
+
+type IValVtbl struct {
+	Val unsafe.Pointer
+}
+
+// -----------------------------------------------------------------------------
+
+type Callback struct {
+	ICalc
+	IVal
+}
+
+//go:linkname F C.f
+func F(cb *Callback)
+
+// -----------------------------------------------------------------------------

_demo/c/cppstr/cppstr.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/cpp/std"
+)
+
+func main() {
+	s := std.Str("Hello world\n")
+	c.Printf(s.CStr())
+	print(s.Str(), s.Size(), "\n")
+}

_demo/c/crand/rand.go

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

_demo/c/ctime/time.go

@@ -0,0 +1,12 @@
+package main
+
+import "github.com/goplus/lib/c/time"
+
+func main() {
+	var tv time.Timespec
+	time.ClockGettime(time.CLOCK_REALTIME, &tv)
+	println("REALTIME sec:", tv.Sec, "nsec:", tv.Nsec)
+
+	time.ClockGettime(time.CLOCK_MONOTONIC, &tv)
+	println("MONOTONIC sec:", tv.Sec, "nsec:", tv.Nsec)
+}

_demo/c/fcntl/fcntl.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/os"
+)
+
+func main() {
+
+	filename := c.Str("testfile.txt")
+	data := c.Str("Hello, os!")
+	var buffer [20]c.Char
+
+	// Open a file, O_CREAT|O_WRONLY|O_TRUNC means create, write only, or clear the file
+	fd := os.Open(filename, os.O_CREAT|os.O_WRONLY|os.O_TRUNC, 0644)
+	if fd == -1 {
+		c.Printf(c.Str("open error\n"))
+		return
+	}
+
+	// Writing data to a file
+	bytesWritten := os.Write(fd, c.Pointer(data), c.Strlen(data))
+	if bytesWritten == -1 {
+		c.Printf(c.Str("write error\n"))
+		os.Close(fd)
+		return
+	}
+	c.Printf(c.Str("Written %ld bytes to %s\n"), bytesWritten, filename)
+
+	// Get file status flags
+	flags := os.Fcntl(fd, os.F_GETFL)
+	if flags == -1 {
+		c.Printf(c.Str("os error\n"))
+		os.Close(fd)
+		return
+	}
+	c.Printf(c.Str("File flags: %d\n"), flags)
+
+	// Set the file status flag to non-blocking mode
+	if os.Fcntl(fd, os.F_SETFL, flags|os.O_NONBLOCK) == -1 {
+		c.Printf(c.Str("os error\n"))
+		os.Close(fd)
+		return
+	}
+	c.Printf(c.Str("set file status successfully\n"))
+
+	c.Printf(c.Str("111"))
+	// Close file
+	os.Close(fd)
+
+	// Reopen the file, O_RDONLY means read-only
+	fd = os.Open(filename, os.O_RDONLY)
+	if fd == -1 {
+		c.Printf(c.Str("open error\n"))
+		return
+	}
+
+	// Reading data from a file
+	// &buffer[:][0]
+	// unsafe.SliceData(buffer[:])
+	bytesRead := os.Read(fd, c.Pointer(unsafe.SliceData(buffer[:])), unsafe.Sizeof(buffer)-1)
+	if bytesRead == -1 {
+		c.Printf(c.Str("read error\n"))
+		os.Close(fd)
+		return
+	}
+
+	// Ensure that the buffer is null-terminated
+	buffer[bytesRead] = c.Char(0)
+	c.Printf(c.Str("Read %ld bytes: %s\n"), bytesRead, &buffer[0])
+
+	// 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

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"github.com/goplus/lib/c"
+	"github.com/goplus/lib/c/os"
+)
+
+func main() {
+	wd := os.Getcwd(c.Alloca(os.PATH_MAX), os.PATH_MAX)
+	c.Printf(c.Str("cwd: %s\n"), wd)
+}

_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/linkname/linkname.go

@@ -0,0 +1,10 @@
+package main
+
+import _ "unsafe" // for go:linkname
+
+//go:linkname Sqrt C.sqrt
+func Sqrt(x float64) float64
+
+func main() {
+	println("sqrt(2) =", Sqrt(2))
+}