Merge pull request #1032 from cpunion/fix-linking

Remove LLVM runtime depencendy, better c toolchain integration

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

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

.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/test-helloworld/action.yml

@@ -0,0 +1,35 @@
+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/llgo/c"
+        )
+        func main() {
+            fmt.Println("Hello, LLGo!")
+            println("Hello, LLGo!")
+            c.Printf(c.Str("Hello, LLGo!\n"))
+        }
+        EOL
+        go mod tidy
+        llgo run .

.github/codecov.yml

@@ -0,0 +1,9 @@
+coverage:
+  ignore:
+    - "compiler/chore"
+    - "compiler/cmd/internal"
+    - "compiler/internal/build"
+    - "compiler/internal/llgen"
+    - "compiler/internal/mockable"
+    - "compiler/internal/packages"
+    - "compiler/internal/typepatch"

.github/dependabot.yml

@@ -17,3 +17,13 @@ updates:
     directory: "/" # Location of package manifests
     schedule:
       interval: "daily"
+
+  - package-ecosystem: "gomod" # See documentation for possible values
+    directory: "/compiler/" # Location of package manifests
+    schedule:
+      interval: "daily"
+
+  - package-ecosystem: "gomod" # See documentation for possible values
+    directory: "/runtime/" # Location of package manifests
+    schedule:
+      interval: "daily"

.github/workflows/doc.yml

@@ -0,0 +1,165 @@
+name: Docs
+
+on:
+  push:
+    branches: [ "**" ]
+  pull_request:
+    branches: [ "**" ]
+
+jobs:
+  doc_verify:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        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:
+    strategy:
+      matrix:
+        os:
+          - macos-latest
+          - ubuntu-24.04
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: '1.23.6'
+
+      - 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:
+    strategy:
+      matrix:
+        os:
+          - macos-latest
+          - ubuntu-24.04
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        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:
+    strategy:
+      matrix:
+        os:
+          - macos-latest
+          - ubuntu-24.04
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        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_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/fmt.yml

@@ -0,0 +1,30 @@
+name: Format Check
+
+on:
+  push:
+    branches: [ "**" ]
+  pull_request:
+    branches: [ "**" ]
+
+jobs:
+  fmt:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: '1.24.0'
+
+      - name: Check formatting
+        run: |
+          for dir in . compiler runtime; do
+            pushd $dir
+            if [ -n "$(go fmt ./...)" ]; 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,53 @@ name: Go
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ "**" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "**" ]
 
 jobs:
-
-  test-macos:
-    runs-on: macos-latest
+  test:
+    continue-on-error: true
     strategy:
       matrix:
-        llvm: [17]
+        os:
+          - macos-latest
+          - ubuntu-24.04
+        llvm: [18]
+    runs-on: ${{matrix.os}}
+    defaults:
+      run:
+        working-directory: compiler
     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
+      - 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.0'
 
       - 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,236 @@
+# 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: [ "**" ]
+  pull_request:
+    branches: [ "**" ]
+
+jobs:
+  download-model:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download model file
+        run: |
+          mkdir -p ./_demo/llama2-c
+          wget -P ./_demo/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/llama2-c/stories15M.bin
+          retention-days: 1
+
+  llgo:
+    needs: download-model
+    continue-on-error: true
+    strategy:
+      matrix:
+        os:
+          - macos-latest
+          - ubuntu-24.04
+        llvm: [18]
+        go: ['1.20.14', '1.21.13', '1.22.12', '1.23.6', '1.24.0']
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install dependencies
+        uses: ./.github/actions/setup-deps
+        with:
+          llvm-version: ${{matrix.llvm}}
+      - name: Download model artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: llama2-model
+          path: ./_demo/llama2-c/
+      - name: Install further optional dependencies for demos
+        run: |
+          py_deps=(
+            numpy # for github.com/goplus/llgo/py/numpy
+            torch # for github.com/goplus/llgo/py/torch
+          )
+          pip3.12 install --break-system-packages "${py_deps[@]}"
+
+      - name: Set up Go for build
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: '1.24.0'
+
+      - name: Install
+        working-directory: compiler
+        run: |
+          go install ./...
+          echo "LLGO_ROOT=$GITHUB_WORKSPACE" >> $GITHUB_ENV
+
+      - name: Set up Go for testing
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{matrix.go}}
+
+      - name: Verify Go version
+        run: |
+          go_version=$(go version | cut -d' ' -f3 | sed 's/go//')
+          if [[ "$go_version" != "${{matrix.go}}"* ]]; then
+            echo "Expected Go version ${{matrix.go}}, but got $go_version"
+            exit 1
+          fi
+          echo "Using Go version: $go_version"
+
+      - name: _xtool build tests
+        run: |
+          cd _xtool
+          llgo build -v ./...
+
+      - name: LLGO tests
+        if: ${{!startsWith(matrix.os, 'ubuntu')}}
+        run: |
+          echo "Test result on ${{matrix.os}} with LLVM ${{matrix.llvm}}" > result.md
+          bash ./.github/workflows/test_llgo.sh
+
+      - name: Test demos
+        run: |
+          # TODO(lijie): force python3-embed to be linked with python-3.12-embed
+          # Currently, python3-embed is python-3.13-embed, doesn't work with pytorch
+          # Will remove this after pytorch is fixed.
+          pcdir=$HOME/pc
+          mkdir -p $pcdir
+          libdir=$(pkg-config --variable=libdir python-3.12-embed)
+          echo "libdir: $libdir"
+          ln -s $libdir/pkgconfig/python-3.12-embed.pc $pcdir/python3-embed.pc
+          export PKG_CONFIG_PATH=$pcdir
+          bash .github/workflows/test_demo.sh
+
+      - name: Show test result
+        run: cat result.md
+
+      - name: LLDB tests
+        if: ${{startsWith(matrix.os, 'macos')}}
+        working-directory: compiler
+        run: |
+          echo "Test lldb with llgo plugin on ${{matrix.os}} with LLVM ${{matrix.llvm}}"
+          bash _lldb/runtest.sh -v
+
+  test:
+    continue-on-error: true
+    strategy:
+      matrix:
+        os:
+          - macos-latest
+          - ubuntu-24.04
+        llvm: [18]
+        go: ['1.24.0']
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v4
+      - 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/llgo/py/numpy
+            torch # for github.com/goplus/llgo/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.0'
+
+      - name: Install
+        working-directory: compiler
+        run: |
+          go install ./...
+          echo "LLGO_ROOT=$GITHUB_WORKSPACE" >> $GITHUB_ENV
+
+      - name: Set up Go for testing
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{matrix.go}}
+
+      - name: Verify Go version
+        run: |
+          go_version=$(go version | cut -d' ' -f3 | sed 's/go//')
+          if [[ "$go_version" != "${{matrix.go}}"* ]]; then
+            echo "Expected Go version ${{matrix.go}}, but got $go_version"
+            exit 1
+          fi
+          echo "Using Go version: $go_version"
+
+      - name: run llgo test
+        run: |
+          llgo test ./...
+          cd _demo
+          llgo test -v ./runtest
+
+  hello:
+    continue-on-error: true
+    strategy:
+      matrix:
+        os: [ubuntu-24.04, macos-latest]
+        llvm: [18]
+        go: ['1.20.14', '1.21.13', '1.22.12', '1.23.6', '1.24.0']
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v4
+      - 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.0'
+
+      - name: Install llgo
+        working-directory: compiler
+        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.20
+        if: startsWith(matrix.go, '1.20') || 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.20'
+
+      - 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'

.github/workflows/populate_darwin_sysroot.sh

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

.github/workflows/populate_linux_sysroot.sh

@@ -0,0 +1,146 @@
+#!/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 lsb-release gnupg2 wget rsync
+
+echo "deb http://apt.llvm.org/\$(lsb_release -cs)/ llvm-toolchain-\$(lsb_release -cs)-18 main" | tee /etc/apt/sources.list.d/llvm.list
+wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -
+apt-get update
+apt-get install -y llvm-18-dev
+
+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+=("--info=progress2")
+	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}" &
+populate_linux_sysroot arm64 "${LINUX_ARM64_PREFIX}" &
+
+# Wait for both background processes to complete
+wait

.github/workflows/release-build.yml

@@ -0,0 +1,60 @@
+name: Release Build
+
+on:
+  push:
+    tags:
+      - "*"
+
+jobs:
+  populate-darwin-sysroot:
+    runs-on: macos-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Populate Darwin sysroot
+        run: bash .github/workflows/populate_darwin_sysroot.sh
+      - name: Create Darwin sysroot tarball
+        run: tar -czvf .sysroot/darwin.tar.gz -C .sysroot darwin
+      - name: Upload Darwin sysroot tarball
+        uses: actions/upload-artifact@v4
+        with:
+          name: darwin-sysroot-tarball
+          path: .sysroot/darwin.tar.gz
+          compression-level: 0
+  build:
+    runs-on: ubuntu-latest
+    needs: populate-darwin-sysroot
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: 1.24.x
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          image: tonistiigi/binfmt:qemu-v7.0.0-28
+      - name: Download Darwin sysroot tarball
+        uses: actions/download-artifact@v4
+        with:
+          name: darwin-sysroot-tarball
+          path: .sysroot
+      - name: Populate Darwin sysroot
+        run: tar -xzvf .sysroot/darwin.tar.gz -C .sysroot
+      - name: Populate Linux sysroot
+        run: bash .github/workflows/populate_linux_sysroot.sh
+      - name: Run GoReleaser
+        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 --clean --skip nfpm,snapcraft

.github/workflows/test_demo.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+set -e
+
+# llgo run subdirectories under _demo and _pydemo that contain *.go files
+total=0
+failed=0
+failed_cases=""
+for d in ./_demo/* ./_pydemo/*; 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

.github/workflows/test_llgo.sh

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

.gitignore

@@ -8,16 +8,27 @@
 *.so
 *.dylib
 
+test.db
+demo.ll
+llgo_autogen*.ll
+stories*.bin
 .DS_Store
 err.log
+numpy.txt
 
 _go/
 _runtime/
 _tinygo/
+_output/
+build.dir/
+.vscode/
 
 # Test binary, built with `go test -c`
 *.test
 
+# Debug symbols
+*.dSYM
+
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 *.swp
@@ -27,3 +38,7 @@ _tinygo/
 
 # Go workspace file
 go.work*
+
+# GoReleaser
+.dist/
+.sysroot/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "c/llama2/llama2.c"]
+	path = c/llama2/llama2.c
+	url = https://github.com/karpathy/llama2.c.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
+    dir: compiler
+    main: ./cmd/llgo
+    binary: bin/llgo
+    flags:
+      - -tags=darwin,amd64,byollvm
+    ldflags:
+      - -X github.com/goplus/llgo/compiler/internal/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/compiler/internal/env.buildTime={{.Date}}
+      - -X github.com/goplus/llgo/xtool/env/llvm.ldLLVMConfigBin=/usr/local/opt/llvm@18/bin/llvm-config
+    env:
+      - CC=o64-clang
+      - CXX=o64-clang++
+      - CGO_CPPFLAGS=-I{{.Env.SYSROOT_DARWIN_AMD64}}/usr/local/opt/llvm@18/include -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+      - CGO_LDFLAGS=-L{{.Env.SYSROOT_DARWIN_AMD64}}/usr/local/opt/llvm@18/lib -Wl,-search_paths_first -Wl,-headerpad_max_install_names -lLLVM-18 -lz -lm
+    targets:
+      - darwin_amd64
+    mod_timestamp: "{{.CommitTimestamp}}"
+  - id: llgo-darwin-arm64
+    dir: compiler
+    main: ./cmd/llgo
+    binary: bin/llgo
+    flags:
+      - -tags=darwin,arm64,byollvm
+    ldflags:
+      - -X github.com/goplus/llgo/compiler/internal/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/compiler/internal/env.buildTime={{.Date}}
+      - -X github.com/goplus/llgo/xtool/env/llvm.ldLLVMConfigBin=/opt/homebrew/opt/llvm@18/bin/llvm-config
+    env:
+      - CC=oa64-clang
+      - CXX=oa64-clang++
+      - CGO_CPPFLAGS=-I{{.Env.SYSROOT_DARWIN_ARM64}}/opt/homebrew/opt/llvm@18/include -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+      - CGO_LDFLAGS=-L{{.Env.SYSROOT_DARWIN_ARM64}}/opt/homebrew/opt/llvm@18/lib -Wl,-search_paths_first -Wl,-headerpad_max_install_names -lLLVM-18 -lz -lm
+    targets:
+      - darwin_arm64
+    mod_timestamp: "{{.CommitTimestamp}}"
+  - id: llgo-linux-amd64
+    dir: compiler
+    main: ./cmd/llgo
+    binary: bin/llgo
+    flags:
+      - -tags=linux,amd64,byollvm
+    ldflags:
+      - -X github.com/goplus/llgo/compiler/internal/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/compiler/internal/env.buildTime={{.Date}}
+      - -X github.com/goplus/llgo/xtool/env/llvm.ldLLVMConfigBin=/usr/lib/llvm-18/bin/llvm-config
+    env:
+      - CC=x86_64-linux-gnu-gcc
+      - CXX=x86_64-linux-gnu-g++
+      - CGO_CPPFLAGS=--sysroot={{.Env.SYSROOT_LINUX_AMD64}} -I{{.Env.SYSROOT_LINUX_AMD64}}/usr/include/llvm-18 -I{{.Env.SYSROOT_LINUX_AMD64}}/usr/include/llvm-c-18 -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+      - CGO_LDFLAGS=--sysroot={{.Env.SYSROOT_LINUX_AMD64}} -L{{.Env.SYSROOT_LINUX_AMD64}}/usr/lib/llvm-18/lib -lLLVM-18
+    targets:
+      - linux_amd64
+    mod_timestamp: "{{.CommitTimestamp}}"
+  - id: llgo-linux-arm64
+    dir: compiler
+    main: ./cmd/llgo
+    binary: bin/llgo
+    flags:
+      - -tags=linux,arm64,byollvm
+    ldflags:
+      - -X github.com/goplus/llgo/compiler/internal/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/compiler/internal/env.buildTime={{.Date}}
+      - -X github.com/goplus/llgo/xtool/env/llvm.ldLLVMConfigBin=/usr/lib/llvm-18/bin/llvm-config
+    env:
+      - CC=aarch64-linux-gnu-gcc
+      - CXX=aarch64-linux-gnu-g++
+      - CGO_CPPFLAGS=--sysroot={{.Env.SYSROOT_LINUX_ARM64}} -I{{.Env.SYSROOT_LINUX_ARM64}}/usr/include/llvm-18 -I{{.Env.SYSROOT_LINUX_ARM64}}/usr/include/llvm-c-18 -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+      - CGO_LDFLAGS=--sysroot={{.Env.SYSROOT_LINUX_ARM64}} -L{{.Env.SYSROOT_LINUX_ARM64}}/usr/lib/llvm-18/lib -lLLVM-18
+    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
+
+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 Go+ project.
+
+      LLGo aims to expand the boundaries of Go/Go+, 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 Go+ project.
+
+      LLGo aims to expand the boundaries of Go/Go+, 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

README.md

@@ -8,4 +8,433 @@ llgo - A Go compiler based on LLVM
 [![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)
 
-This is a Go compiler based on LLVM in order to better integrate Go with the C ecosystem. 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. It's a subproject of [the Go+ project](https://github.com/goplus/gop).
+
+LLGo aims to expand the boundaries of Go/Go+, providing limitless possibilities such as:
+
+* Game development
+* AI and data science
+* WebAssembly
+* Embedded development
+* ...
+
+How can these be achieved?
+
+```
+LLGo := Go + C + Python
+```
+
+LLGo is compatible with C and Python through the language's **Application Binary Interface (ABI)**, while LLGo is compatible with Go through its **syntax (source code)**. And here C doesn't just include C, but all languages that are ABI compatible with C, including C/C++, Objective-C, Swift, etc.
+
+
+## C/C++ standard libary support
+
+You can import a C/C++ standard library in LLGo!
+
+* [c](https://pkg.go.dev/github.com/goplus/llgo/c)
+* [c/syscall](https://pkg.go.dev/github.com/goplus/llgo/c/syscall)
+* [c/sys](https://pkg.go.dev/github.com/goplus/llgo/c/sys)
+* [c/os](https://pkg.go.dev/github.com/goplus/llgo/c/os)
+* [c/math](https://pkg.go.dev/github.com/goplus/llgo/c/math)
+* [c/math/cmplx](https://pkg.go.dev/github.com/goplus/llgo/c/math/cmplx)
+* [c/math/rand](https://pkg.go.dev/github.com/goplus/llgo/c/math/rand)
+* [c/pthread](https://pkg.go.dev/github.com/goplus/llgo/c/pthread)
+* [c/pthread/sync](https://pkg.go.dev/github.com/goplus/llgo/c/pthread/sync)
+* [c/sync/atomic](https://pkg.go.dev/github.com/goplus/llgo/c/sync/atomic)
+* [c/time](https://pkg.go.dev/github.com/goplus/llgo/c/time)
+* [c/net](https://pkg.go.dev/github.com/goplus/llgo/c/net)
+* [cpp/std](https://pkg.go.dev/github.com/goplus/llgo/cpp/std)
+
+Here is a simple example:
+
+<!-- embedme doc/_readme/llgo_simple/simple.go -->
+
+```go
+package main
+
+import "github.com/goplus/llgo/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.
+
+The `_demo` directory contains some C standard libary related demos (it start with `_` to prevent the `go` command from compiling it):
+
+* [hello](_demo/hello/hello.go): call C `printf` to print `Hello world`
+* [concat](_demo/concat/concat.go): call C `fprintf` with `stderr`
+* [qsort](_demo/qsort/qsort.go): call C function with a callback (eg. `qsort`)
+
+To run these demos (If you haven't installed `llgo` yet, please refer to [How to install](#how-to-install)):
+
+```sh
+cd <demo-directory>  # eg. cd _demo/hello
+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/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](c/math/math.go)):
+
+<!-- embedme doc/_readme/llgo_call_cmath/call_cmath.go -->
+
+```go
+package main
+
+import "github.com/goplus/llgo/c/math"
+
+func main() {
+	println("sqrt(2) =", math.Sqrt(2))
+}
+```
+
+
+## Python support
+
+You can import a Python library in LLGo!
+
+And you can import any Python library into `llgo` through a program called `llpyg` (see [Development tools](#development-tools)). The following libraries have been included in `llgo`:
+
+* [py](https://pkg.go.dev/github.com/goplus/llgo/py) (abi)
+* [py/std](https://pkg.go.dev/github.com/goplus/llgo/py/std) (builtins)
+* [py/sys](https://pkg.go.dev/github.com/goplus/llgo/py/sys)
+* [py/os](https://pkg.go.dev/github.com/goplus/llgo/py/os)
+* [py/math](https://pkg.go.dev/github.com/goplus/llgo/py/math)
+* [py/json](https://pkg.go.dev/github.com/goplus/llgo/py/json)
+* [py/inspect](https://pkg.go.dev/github.com/goplus/llgo/py/inspect)
+* [py/statistics](https://pkg.go.dev/github.com/goplus/llgo/py/statistics)
+* [py/numpy](https://pkg.go.dev/github.com/goplus/llgo/py/numpy)
+* [py/pandas](https://pkg.go.dev/github.com/goplus/llgo/py/pandas)
+* [py/torch](https://pkg.go.dev/github.com/goplus/llgo/py/torch)
+* [py/matplotlib](https://pkg.go.dev/github.com/goplus/llgo/py/matplotlib)
+
+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/py"
+	"github.com/goplus/llgo/py/math"
+	"github.com/goplus/llgo/py/std"
+)
+
+func main() {
+	x := math.Sqrt(py.Float(2))       // x = sqrt(2)
+	std.Print(py.Str("sqrt(2) ="), x) // print("sqrt(2) =", x)
+}
+```
+
+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/llgo/py"
+	"github.com/goplus/llgo/py/numpy"
+	"github.com/goplus/llgo/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 `_pydemo` directory contains some python related demos:
+
+* [callpy](_pydemo/callpy/callpy.go): call Python standard library function `math.sqrt`
+* [pi](_pydemo/pi/pi.go): print python constants `math.pi`
+* [statistics](_pydemo/statistics/statistics.go): define a python list and call `statistics.mean` to get the mean
+* [matrix](_pydemo/matrix/matrix.go): a basic `numpy` demo
+
+To run these demos (If you haven't installed `llgo` yet, please refer to [How to install](#how-to-install)):
+
+```sh
+cd <demo-directory>  # eg. cd _pydemo/callpy
+llgo run .
+```
+
+
+## Other frequently used libraries
+
+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/llgo/c/bdwgc)
+* [c/cjson](https://pkg.go.dev/github.com/goplus/llgo/c/cjson)
+* [c/clang](https://pkg.go.dev/github.com/goplus/llgo/c/clang)
+* [c/ffi](https://pkg.go.dev/github.com/goplus/llgo/c/ffi)
+* [c/libuv](https://pkg.go.dev/github.com/goplus/llgo/c/libuv)
+* [c/llama2](https://pkg.go.dev/github.com/goplus/llgo/c/llama2)
+* [c/lua](https://pkg.go.dev/github.com/goplus/llgo/c/lua)
+* [c/neco](https://pkg.go.dev/github.com/goplus/llgo/c/neco)
+* [c/openssl](https://pkg.go.dev/github.com/goplus/llgo/c/openssl)
+* [c/raylib](https://pkg.go.dev/github.com/goplus/llgo/c/raylib)
+* [c/sqlite](https://pkg.go.dev/github.com/goplus/llgo/c/sqlite)
+* [c/zlib](https://pkg.go.dev/github.com/goplus/llgo/c/zlib)
+* [cpp/inih](https://pkg.go.dev/github.com/goplus/llgo/cpp/inih)
+* [cpp/llvm](https://pkg.go.dev/github.com/goplus/llgo/cpp/llvm)
+
+Here are some examples related to them:
+
+* [llama2-c](_demo/llama2-c): inference Llama 2 (It's the first llgo AI example)
+* [mkjson](c/cjson/_demo/mkjson/mkjson.go): create a json object and print it
+* [sqlitedemo](c/sqlite/_demo/sqlitedemo/demo.go): a basic sqlite demo
+* [tetris](c/raylib/_demo/tetris/tetris.go): a tetris game based on raylib
+
+
+## Go syntax support
+
+All Go syntax (including `cgo`) is already supported. Here are some examples:
+
+* [concat](_demo/concat/concat.go): define a variadic function
+* [genints](_demo/genints/genints.go): various forms of closure usage (including C function, recv.method and anonymous function)
+* [errors](_cmptest/errors/errors.go): demo to implement error interface
+* [defer](_cmptest/defer/defer.go): defer demo
+* [goroutine](_demo/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)
+* [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)
+
+
+## Dependencies
+
+- [Go 1.20+](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/llgo/py](https://pkg.go.dev/github.com/goplus/llgo/py))
+
+## How to install
+
+Follow these steps to generate the `llgo` command (its usage is the same as the `go` command):
+
+### on macOS
+
+<!-- embedme doc/_readme/scripts/install_macos.sh#L2-L1000 -->
+
+```sh
+brew update
+brew install llvm@18 bdw-gc openssl cjson libffi libuv pkg-config
+brew install python@3.12 # optional
+brew link --force libffi
+curl https://raw.githubusercontent.com/goplus/llgo/refs/heads/main/install.sh | bash
+
+```
+
+### on Linux
+
+#### Debian/Ubuntu
+
+<!-- embedme doc/_readme/scripts/install_ubuntu.sh#L2-L1000 -->
+
+```sh
+echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-18 main" | sudo tee /etc/apt/sources.list.d/llvm.list
+wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+sudo apt-get update
+sudo apt-get install -y llvm-18-dev clang-18 libclang-18-dev lld-18 pkg-config libgc-dev libssl-dev zlib1g-dev libcjson-dev libsqlite3-dev libunwind-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
+```
+
+#### Alpine Linux
+
+```sh
+apk add go llvm18-dev clang18-dev lld18 pkgconf gc-dev openssl-dev zlib-dev
+apk add python3-dev # optional
+apk add g++ # build only
+export LLVM_CONFIG=/usr/lib/llvm18/bin/llvm-config
+export 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
+```
+
+### on Windows
+
+TODO
+
+### Install from source
+
+<!-- embedme doc/_readme/scripts/install_llgo.sh#L2-L1000 -->
+
+```sh
+git clone https://github.com/goplus/llgo.git
+cd llgo
+./install.sh
+```
+
+## Development tools
+
+* [pydump](_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](compiler/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](compiler/chore/llgen): It is used to compile Go packages into LLVM IR files (*.ll).
+* [ssadump](compiler/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
+git clone https://github.com/goplus/llgo.git
+cd llgo/compiler
+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
+```
+
+## Key modules
+
+Below are the key modules for understanding the implementation principles of `llgo`:
+
+* [ssa](https://pkg.go.dev/github.com/goplus/llgo/compiler/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/compiler/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/compiler/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/_goparsedemo/parse.go

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

_cmptest/_jsondemo/json.go

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

_cmptest/_timeout/timer.go

@@ -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/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/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/async/async/async.go

@@ -0,0 +1,31 @@
+package async
+
+import (
+	_ "unsafe"
+)
+
+type Void = [0]byte
+
+type Future[T any] interface {
+	Then(cb func(T))
+}
+
+type future[T any] struct {
+	cb func(func(T))
+}
+
+func (f *future[T]) Then(cb func(T)) {
+	f.cb(cb)
+}
+
+func Async[T any](fn func(func(T))) Future[T] {
+	return &future[T]{fn}
+}
+
+func Run[T any](future Future[T]) T {
+	var ret T
+	future.Then(func(v T) {
+		ret = v
+	})
+	return ret
+}

_demo/async/main.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"time"
+
+	"github.com/goplus/llgo/_demo/async/async"
+	"github.com/goplus/llgo/_demo/async/timeout"
+)
+
+func Sleep(i int, d time.Duration) async.Future[int] {
+	return async.Async(func(resolve func(int)) {
+		timeout.Timeout(d).Then(func(async.Void) {
+			resolve(i)
+		})
+	})
+}
+
+func main() {
+	async.Run(async.Async(func(resolve func(async.Void)) {
+		println("read file")
+		defer resolve(async.Void{})
+	}))
+}

_demo/async/timeout/timeout.go

@@ -0,0 +1,16 @@
+package timeout
+
+import (
+	"time"
+
+	"github.com/goplus/llgo/_demo/async/async"
+)
+
+func Timeout(d time.Duration) async.Future[async.Void] {
+	return async.Async(func(resolve func(async.Void)) {
+		go func() {
+			time.Sleep(d)
+			resolve(async.Void{})
+		}()
+	})
+}

_demo/catomic/atomic.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"github.com/goplus/llgo/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/cexec/exec.go

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

_demo/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/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/cgofull/pymod1"
+	"github.com/goplus/llgo/_demo/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/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/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/cgofull/foo.h

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

_demo/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/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/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/checkfile/demo.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+func main() {
+	tempDir := os.TempDir()
+	noexist := filepath.Join(tempDir, "noexist.txt")
+
+	if _, err := os.Stat(noexist); err != nil {
+		if os.IsNotExist(err) {
+			fmt.Println("noexist:", err.Error())
+		} else {
+			fmt.Println("exist,other err:", err.Error())
+		}
+	}
+
+	if _, err := os.Open(noexist); err != nil {
+		if os.IsNotExist(err) {
+			fmt.Println("noexist:", err.Error())
+		} else {
+			fmt.Println("exist,other err:", err.Error())
+		}
+	}
+}

_demo/commandrun/commandrun.go

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

_demo/complex/cmplx.go

@@ -0,0 +1,9 @@
+package main
+
+import (
+	"math/cmplx"
+)
+
+func main() {
+	println("abs(3+4i):", cmplx.Abs(3+4i))
+}

_demo/concat/concat.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/goplus/llgo/internal/runtime/c"
+	"github.com/goplus/llgo/c"
 )
 
 func concat(args ...string) (ret string) {
@@ -15,3 +15,7 @@ func main() {
 	result := concat("Hello", " ", "World")
 	c.Fprintf(c.Stderr, c.Str("Hi, %s\n"), c.AllocaCStr(result))
 }
+
+/* Expected output (stderr):
+Hi, Hello World
+*/

_demo/cppintf/cppintf.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"github.com/goplus/llgo/_demo/cppintf/foo"
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/math"
+)
+
+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/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/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/cppmintf/cpp_multi_intf.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/_demo/cppmintf/foo"
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/math"
+)
+
+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/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/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/crand/rand.go

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

_demo/ctime/time.go

@@ -0,0 +1,12 @@
+package main
+
+import "github.com/goplus/llgo/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/defer/main.go

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

_demo/failed/stacktrace/main.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"fmt"
+)
+
+type MyStruct[T any] struct {
+	value T
+}
+
+func (m *MyStruct[T]) Method() {
+	fmt.Println("In generic method")
+	genericFunc[T](m.value)
+}
+
+func genericFunc[T any](v T) {
+	fmt.Println("In generic function")
+	normalFunc()
+}
+
+func normalFunc() {
+	fmt.Println("In normal function")
+	panic("panic occurs here")
+}
+
+func main() {
+	m := &MyStruct[string]{value: "hello"}
+	m.Method()
+}
+
+//Expected:
+// In generic method
+// In generic function
+// In normal function
+// panic: panic occurs here
+
+// [0x00C6D310 github.com/goplus/llgo/internal/runtime.Rethrow+0x2f, SP = 0x60]
+// [0x00C6CF44 github.com/goplus/llgo/internal/runtime.Panic+0x2d, SP = 0x50]
+// [0x00C69420 main.normalFunc+0xf, SP = 0xa8]
+// [0x00C69564 main.genericFunc[string]+0x18, SP = 0x74]
+// [0x00C694A8 main.(*MyStruct[string]).Method+0x1f, SP = 0x84]
+// [0x00C6936C main+0x4, SP = 0x40]

_demo/fcntl/fcntl.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/os"
+	"unsafe"
+)
+
+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/genints/genints.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+)
+
+type generator struct {
+	val c.Int
+}
+
+func (g *generator) next() c.Int {
+	g.val++
+	return g.val
+}
+
+func genInts(n int, gen func() c.Int) []c.Int {
+	a := make([]c.Int, n)
+	for i := range a {
+		a[i] = gen()
+	}
+	return a
+}
+
+func main() {
+	// generate 5 random integers
+	for _, v := range genInts(5, c.Rand) {
+		c.Printf(c.Str("%d\n"), v)
+	}
+
+	// generate 5 integers, each is double of the previous one
+	initVal := c.Int(1)
+	ints := genInts(5, func() c.Int {
+		initVal *= 2
+		return initVal
+	})
+	for _, v := range ints {
+		c.Printf(c.Str("%d\n"), v)
+	}
+
+	// generate 5 integers, each is incremented by 1
+	g := &generator{val: 1}
+	for _, v := range genInts(5, g.next) {
+		c.Printf(c.Str("%d\n"), v)
+	}
+}
+
+/* Posible output:
+16807
+282475249
+1622650073
+984943658
+1144108930
+2
+4
+8
+16
+32
+2
+3
+4
+5
+6
+*/

_demo/getcwd/getcwd.go

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

_demo/goroutine/goroutine.go

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	done := false
+	go func() {
+		println("Hello, goroutine")
+		done = true
+	}()
+	for !done {
+		print(".")
+	}
+}

_demo/gotime/time.go

@@ -0,0 +1,7 @@
+package main
+
+import "time"
+
+func main() {
+	println(time.Now().String())
+}

_demo/hello/hello.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/goplus/llgo/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"))
+}
+
+/* Expected output:
+Hello world
+*/

_demo/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))
+}

_demo/llama2-c/README.md

@@ -0,0 +1,137 @@
+llama2 - Inference Llama 2 in LLGo
+=====
+
+<p align="center">
+  <img src="assets/llama_cute.jpg" width="300" height="300" alt="Cute Llama">
+</p>
+
+Have you ever wanted to inference a baby [Llama 2](https://ai.meta.com/llama/) model in Go? No? Well, now you can!
+
+This is based on [llama2.c](https://github.com/karpathy/llama2.c), we didn't port anything! So it's very different from these Go implementations:
+* https://github.com/nikolaydubina/llama2.go
+* https://github.com/tmc/go-llama2
+
+llgo plays a great role as a bridge, allowing the C ecosystem to be seamlessly connected to Go.
+
+You might think that you need many billion parameter LLMs to do anything useful, but in fact very small LLMs can have surprisingly strong performance if you make the domain narrow enough (ref: [TinyStories](https://huggingface.co/datasets/roneneldan/TinyStories) paper). This repo is a "fullstack" train + inference solution for Llama 2 LLM, with focus on minimalism and simplicity.
+
+As the architecture is identical, you can also load and inference Meta's Llama 2 models. However, the current code only inferences models in fp32, so you will most likely not be able to productively load models larger than 7B.
+
+## feel the magic
+
+How to run this example? The simplest way is to run it without any arguments:
+
+```bash
+llgo run .
+```
+
+This means it uses the default model checkpoint file (`stories15M.bin`), and the default prompt (`Once upon a time`).
+
+You need download the model checkpoint file first. Download this 15M parameter model trained on the [TinyStories](https://huggingface.co/datasets/roneneldan/TinyStories) dataset (~60MB download):
+
+```bash
+wget https://huggingface.co/karpathy/tinyllamas/resolve/main/stories15M.bin
+```
+
+If you want to specify a prompt (eg. `Long long ago`):
+
+```bash
+llgo run . 'Long long ago'
+```
+
+We can also try a bit bigger 42M parameter model (ie. `stories42M.bin`):
+
+```bash
+wget https://huggingface.co/karpathy/tinyllamas/resolve/main/stories42M.bin
+llgo run . -m stories42M.bin 'Long long ago'
+```
+
+There is also an even better 110M param model available, see [models](#models).
+
+Quick note on sampling, the recommendation for ~best results is to sample with `-t 1.0 -p 0.9`, i.e. temperature 1.0 (default) but also top-p sampling at 0.9 (default). Intuitively, top-p ensures that tokens with tiny probabilities do not get sampled, so we can't get "unlucky" during sampling, and we are less likely to go "off the rails" afterwards. More generally, to control the diversity of samples use either the temperature (i.e. vary `-t` between 0 and 1 and keep top-p off with `-p 0`) or the top-p value (i.e. vary `-p` between 0 and 1 and keep `-t 1`), but not both. Nice explainers on LLM sampling strategies include [this](https://peterchng.com/blog/2023/05/02/token-selection-strategies-top-k-top-p-and-temperature/), [this](https://docs.cohere.com/docs/controlling-generation-with-top-k-top-p) or [this](https://huggingface.co/blog/how-to-generate).
+
+
+## Meta's Llama 2 models
+
+As the neural net architecture is identical, we can also inference the Llama 2 models released by Meta. Sadly there is a bit of friction here due to licensing (I can't directly upload the checkpoints, I think). So Step 1, get the Llama 2 checkpoints by following the [Meta instructions](https://github.com/facebookresearch/llama). Once we have those checkpoints, we have to convert them into the llama2.c format.
+For this we need to install the python dependencies (`pip install -r requirements.txt`) and then use the `export.py` file, e.g. for 7B model:
+
+```bash
+python export.py llama2_7b.bin --meta-llama path/to/llama/model/7B
+```
+
+The export will take ~10 minutes or so and generate a 26GB file (the weights of the 7B model in float32) called `llama2_7b.bin` in the current directory. It has been [reported](https://github.com/karpathy/llama2.c/pull/85) that despite efforts. I would not attempt to run anything above 7B right now for two reasons: first, 13B+ currently doesn't work because of integer flow in pointer arithmetic, which is yet to be fixed, and second, even if it were fixed, this repo is doing float32 inference right now, so it would be fairly unusably slow. Once the export is done, we can run it:
+
+```bash
+./run llama2_7b.bin
+```
+
+This ran at about 4 tokens/s compiled with [OpenMP](#OpenMP) on 96 threads on my CPU Linux box in the cloud. (On my MacBook Air M1, currently it's closer to 30 seconds per token if you just build with `make runfast`.) Example output:
+
+> The purpose of this document is to highlight the state-of-the-art of CoO generation technologies, both recent developments and those in commercial use. The focus is on the technologies with the highest merit to become the dominating processes of the future and therefore to be technologies of interest to S&amp;T ... R&amp;D. As such, CoO generation technologies developed in Russia, Japan and Europe are described in some depth. The document starts with an introduction to cobalt oxides as complex products and a short view on cobalt as an essential material. The document continues with the discussion of the available CoO generation processes with respect to energy and capital consumption as well as to environmental damage.
+
+base models... ¯\\_(ツ)_/¯. Since we can inference the base model, it should be possible to also inference the chat model quite easily, and have a conversation with it. And if we can find a way to run 7B more efficiently, we can start adding LoRA to our training script, and going wild with finetunes all within the repo!
+
+You can also try Meta's Code Llama models even if support for them is incomplete. In particular, some hyperparameters changed (e.g. the constant in RoPE layer), so the inference is not exactly correct and a bit buggy right now. Looking into fixes. Make sure to build the tokenizer for the plain and instruct variants and pass it when doing inference.
+
+```bash
+python export.py codellama2_7b.bin --meta-llama /path/to/CodeLlama-7b
+python tokenizer.py --tokenizer-model=/path/to/CodeLlama-7b/tokenizer.model
+./run codellama2_7b.bin -z /path/to/CodeLlama-7b/tokenizer.bin
+```
+
+Chat with Code Llama Instruct:
+
+```bash
+python export.py codellama2_7b_instruct.bin --meta-llama /path/to/CodeLlama-7b-Instruct
+python tokenizer.py --tokenizer-model=/path/to/CodeLlama-7b-Instruct/tokenizer.model
+./run codellama2_7b_instruct.bin -m chat -z /path/to/CodeLlama-7b-Instruct/tokenizer.bin
+```
+
+
+## huggingface models
+
+We can load any huggingface models that use the Llama 2 architecture. See the script [export.py](export.py) and the `--hf` flag to export the model .bin file.
+
+## models
+
+For the sake of examples of smaller, from-scratch models, I trained a small model series on TinyStories. All of these trained in a few hours on my training setup (4X A100 40GB GPUs). The 110M took around 24 hours. I am hosting them on huggingface hub [tinyllamas](https://huggingface.co/karpathy/tinyllamas), both in the original PyTorch .pt, and also in the llama2.c format .bin:
+
+| model | dim | n_layers | n_heads | n_kv_heads | max context length | parameters | val loss | download
+| --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| 260K | 64 | 5 | 8 | 4 | 512 | 260K | 1.297 | [stories260K](https://huggingface.co/karpathy/tinyllamas/tree/main/stories260K)
+| OG | 288 | 6 | 6 | 6 | 256 | 15M | 1.072 | [stories15M.bin](https://huggingface.co/karpathy/tinyllamas/resolve/main/stories15M.bin) |
+| 42M| 512 | 8 | 8 | 8 | 1024 | 42M | 0.847 | [stories42M.bin](https://huggingface.co/karpathy/tinyllamas/resolve/main/stories42M.bin) |
+| 110M| 768 | 12 | 12 | 12 | 1024 | 110M | 0.760 | [stories110M.bin](https://huggingface.co/karpathy/tinyllamas/resolve/main/stories110M.bin) |
+
+You'll notice that the 110M model is equivalent to GPT-1 in size. Alternatively, this is also the smallest model in the GPT-2 series (`GPT-2 small`), except the max context length is only 1024 instead of 2048. The only notable changes from GPT-1/2 architecture is that Llama uses RoPE relatively positional embeddings instead of absolute/learned positional embeddings, a bit more fancy SwiGLU non-linearity in the MLP, RMSNorm instead of LayerNorm, bias=False on all Linear layers, and is optionally multiquery.
+
+
+## training
+
+Let's see how we can train a baby Llama 2 from scratch using the code in this repo. First let's download and pretokenize some source dataset, e.g. I like [TinyStories](https://huggingface.co/datasets/roneneldan/TinyStories) so this is the only example currently available in this repo. But it should be very easy to add datasets, see the code.
+
+```bash
+python tinystories.py download
+python tinystories.py pretokenize
+```
+
+Then train our model:
+
+```bash
+python train.py
+```
+
+**brief training guide**. See the train.py script for more exotic launches and hyperparameter overrides. Here is a brief guide to how to set the parameters. Look at the table at the very end of the [Chinchilla paper](https://arxiv.org/abs/2203.15556) to get a sense of how the Transformer parameters (dim, n_layers, n_heads) grow or shrink together. Extrapolate/interpolate this pattern to get bigger or smaller transformers. Set the max context length however you wish, depending on the problem: this should be the max number of tokens that matter to predict the next token. E.g. Llama 2 uses 2048. Next, you want the _total_ batch size per update (printed by the script as "tokens per iteration will be:") to be somewhere around 100K tokens for medium-sized applications. For tiny applications it could be lower, for large training (e.g. GPTs/LLamas) it is usually ~0.5M, or even more. You get there by first maxing out the batch_size to whatever your system allows (e.g. mine was 16 in a recent run because after that my GPU runs out of memory), and then you want to increase gradient_accumulation_steps to be as high as necessary to reach the total batch size of ~100K. Finally, you want to tune your learning_rate (LR). You want this to be as high as your training allows. Very small networks can get away with a large LR (e.g. 1e-3 or even higher). Large networks need lower LRs. 3e-4 is a safe choice in most medium-sized applications, but can be too low for small networks, so try to increase it! Finally, max_iters is the length of training. Play with different settings. I mostly only ever tune these parameters and leave most of the others unchanged. Here is an example of how I trained the 110M model, which I don't think is anywhere near optimal, but looked sensible to me: dim 768, n_layers 12, n_heads 12 (so size of each head is 768 / 12 = 64 channels), seq len of 1024, batch size 16 (this is the most that fit my A100 40GB GPU), gradient_accumulation_steps = 8 was needed to get total tokens batch size to be 16 batch size * 1024 tokens in sequence * 8 grad_accum = 131,072 tokens per update. Good. Learning rate 4e-4 (probably a little too low). max_iters 200K (probably a bit too high). Dropout 0.1, as that usually helps a bit at medium size. That was it. I ran using Distributed Data Parallel (DDP) on 4 GPUs on my cloud machine, training took ~day or so.
+
+Totally understand if you want to skip model training, for simple demo just download one of the pretrained models (see [models](#models) section), e.g.:
+
+```bash
+wget https://huggingface.co/karpathy/tinyllamas/resolve/main/stories15M.bin
+```
+
+Once we have the model.bin file, we can inference in C. Compile the C code first:
+
+```bash
+llgo run . -m stories15M.bin
+```

_demo/llama2-c/run.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/llama2"
+	"github.com/goplus/llgo/c/time"
+)
+
+func main() {
+	var prompt *c.Char = c.Str("Once upon a time")
+	var checkpointPath *c.Char = c.Str("stories15M.bin")
+	var tokenizerPath *c.Char = c.Str("tokenizer.bin")
+	var temperature, topp c.Float = 1.0, 0.9
+	var steps c.Int = 256
+	var rngSeed uint64 = uint64(time.Time(nil))
+
+loop: // parse command line arguments
+	for {
+		switch c.Getopt(c.Argc, c.Argv, c.Str("m:")) {
+		case 'm':
+			checkpointPath = c.Optarg
+			c.Fprintf(c.Stderr, c.Str("==> use model: %s\n"), checkpointPath)
+		case -1:
+			break loop
+		}
+	}
+	if c.Optind < c.Argc {
+		prompt = c.Index(c.Argv, c.Optind)
+		c.Fprintf(c.Stderr, c.Str("==> prompt: %s\n"), prompt)
+	}
+
+	// build the Transformer via the model .bin file
+	var transformer llama2.Transformer
+	llama2.BuildTransformer(&transformer, checkpointPath)
+
+	// build the Tokenizer via the tokenizer .bin file
+	var tokenizer llama2.Tokenizer
+	llama2.BuildTokenizer(&tokenizer, tokenizerPath, transformer.Config.VocabSize)
+
+	// build the Sampler
+	var sampler llama2.Sampler
+	llama2.BuildSampler(&sampler, transformer.Config.VocabSize, temperature, topp, rngSeed)
+
+	// run!
+	llama2.Generate(&transformer, &tokenizer, &sampler, prompt, steps)
+
+	// memory and file handles cleanup
+	llama2.FreeSampler(&sampler)
+	llama2.FreeTokenizer(&tokenizer)
+	llama2.FreeTransformer(&transformer)
+}

_demo/logdemo/log.go

@@ -0,0 +1,9 @@
+package main
+
+import (
+	"log"
+)
+
+func main() {
+	log.Println("Hello")
+}

_demo/math/math.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"math"
+)
+
+func main() {
+	println(math.Sqrt(2))
+	println(math.Abs(-1.2))
+	println(math.Ldexp(1.2, 3))
+}

_demo/mimeheader/mimeheader.go

@@ -0,0 +1,13 @@
+package main
+
+import "net/textproto"
+
+func main() {
+	h := make(textproto.MIMEHeader)
+	h.Set("host", "www.example.com")
+	println(h.Get("Host"))
+}
+
+/* Expected output:
+www.example.com
+*/