Merge pull request #155 from xushiwei/q

retract v0.8.0

.github/dependabot.yml

@@ -0,0 +1,19 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    labels:
+      - dependabot
+      - actions
+    schedule:
+      interval: daily
+
+  - package-ecosystem: "gomod" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "daily"

.github/workflows/go.yml

@@ -17,7 +17,7 @@ jobs:
       matrix:
         llvm: [17]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Update Homebrew
         if: matrix.llvm == 17 # needed as long as LLVM 17 is still fresh
@@ -26,7 +26,7 @@ jobs:
         run: HOMEBREW_NO_AUTO_UPDATE=1 brew install llvm@${{ matrix.llvm }}
         
       - name: Set up Go
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v5
         with:
           go-version: '1.20'
 
@@ -42,7 +42,7 @@ jobs:
       matrix:
         llvm: [17]
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Install LLVM ${{ matrix.llvm }}
       run: |
@@ -52,7 +52,7 @@ jobs:
         sudo apt-get install --no-install-recommends llvm-${{ matrix.llvm }}-dev
 
     - name: Set up Go
-      uses: actions/setup-go@v4
+      uses: actions/setup-go@v5
       with:
         go-version: '1.20'
 
@@ -60,4 +60,10 @@ jobs:
       run: go build -v ./...
 
     - name: Test
-      run: go test -v ./...
+      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

.gitignore

@@ -8,7 +8,17 @@
 *.so
 *.dylib
 
+test.db
+llgo_autogen.ll
+stories*.bin
+.DS_Store
+err.log
+
+_go/
+_runtime/
 _tinygo/
+build.dir/
+.vscode/
 
 # Test binary, built with `go test -c`
 *.test

.gitmodules

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

README.md

@@ -3,8 +3,123 @@ llgo - A Go compiler based on LLVM
 
 [![Build Status](https://github.com/goplus/llgo/actions/workflows/go.yml/badge.svg)](https://github.com/goplus/llgo/actions/workflows/go.yml)
 [![Go Report Card](https://goreportcard.com/badge/github.com/goplus/llgo)](https://goreportcard.com/report/github.com/goplus/llgo)
-[![GoDoc](https://pkg.go.dev/badge/github.com/goplus/llgo.svg)](https://pkg.go.dev/github.com/goplus/llgo)
-<!--
 [![GitHub release](https://img.shields.io/github/v/tag/goplus/llgo.svg?label=release)](https://github.com/goplus/llgo/releases)
 [![Coverage Status](https://codecov.io/gh/goplus/llgo/branch/main/graph/badge.svg)](https://codecov.io/gh/goplus/llgo)
--->
+[![GoDoc](https://pkg.go.dev/badge/github.com/goplus/llgo.svg)](https://pkg.go.dev/github.com/goplus/llgo)
+[![Language](https://img.shields.io/badge/language-Go+-blue.svg)](https://github.com/goplus/gop)
+
+This is a Go compiler based on LLVM in order to better integrate Go with the C ecosystem including Python. It's a subproject of [the Go+ project](https://github.com/goplus/gop).
+
+## C standard libary support
+
+```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.
+
+See [github.com/goplus/llgo/c](https://pkg.go.dev/github.com/goplus/llgo/c) for more detials.
+
+
+## Python support
+
+You can import a Python library in llgo! For example:
+
+```go
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/py"
+	"github.com/goplus/llgo/py/math"
+)
+
+func main() {
+	x := math.Sqrt(py.Float(2))
+	c.Printf(c.Str("sqrt(2) = %f\n"), x.Float64())
+}
+```
+
+Here, We call `py.Float(2)` to create a Python floating point number 2, and pass it to Python’s `math.sqrt` to get `x`. Then use `x.Float64()` to convert the Python object to Go's `float64` type, and finally we print the value through C `printf`.
+
+
+## Other frequently used libraries
+
+TODO
+
+
+## How to install
+
+Follow these steps to generate the `llgo` command (its usage is the same as the `go` command):
+
+### on macOS
+
+```sh
+brew update  # execute if needed
+brew install llvm@17
+go install -v ./...
+```
+
+### on Linux
+
+```sh
+echo 'deb http://apt.llvm.org/focal/ llvm-toolchain-focal-17 main' | sudo tee /etc/apt/sources.list.d/llvm.list
+wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+sudo apt-get update  # execute if needed
+sudo apt-get install --no-install-recommends llvm-17-dev
+go install -v ./...
+```
+
+### on Windows
+
+TODO
+
+
+## Demo
+
+The `_demo` directory contains our demos (it start with `_` to prevent the `go` command from compiling it):
+
+* [hello](_demo/hello/hello.go): call C printf to print `Hello world`
+* [concat](_demo/concat/concat.go): call C fprintf with stderr, and Go variadic function
+* [qsort](_demo/qsort/qsort.go): call C function with a callback (eg. qsort)
+* [genints](_demo/genints/genints.go): various forms of closure usage (including C function, recv.method and anonymous function)
+* [llama2-c](_demo/llama2-c): inference Llama 2 (It's the first llgo AI example)
+
+And the `_pydemo` directory contains python related demos:
+
+* [callpy](_pydemo/callpy/callpy.go): call Python standard library function `math.sqrt`
+
+
+### How to run demos
+
+To run the demos in directory `_demo`:
+
+```sh
+cd <demo-directory>  # eg. cd _demo/genints
+llgo run .
+```
+
+To run the demos in directory `_pydemo`, you need to set the `LLGO_LIB_PYTHON` environment variable first. Assuming you use Python 3.12, and the `libpython3.12.so` (or `libpython3.12.dylib` or `python3.12.lib`) file is in the /foo/bar directory, then you need to set `LLGO_LIB_PYTHON` to:
+
+```sh
+export LLGO_LIB_PYTHON=/foo/bar/python3.12
+```
+
+For example, `/opt/homebrew/Frameworks/Python.framework/Versions/3.12/libpython3.12.dylib` is a typical python lib location under macOS. So we should set it like this:
+
+```sh
+export LLGO_LIB_PYTHON=/opt/homebrew/Frameworks/Python.framework/Versions/3.12/python3.12
+```
+
+Then you can run the demos in directory `_pydemo`:
+
+```sh
+cd <demo-directory>  # eg. cd _pydemo/callpy
+llgo run .
+```

_demo/concat/concat.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+)
+
+func concat(args ...string) (ret string) {
+	for _, v := range args {
+		ret += v
+	}
+	return
+}
+
+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/genints/gen_ints.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/hello/hello.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+)
+
+func main() {
+	c.Printf(c.Str("Hello world\n"))
+}
+
+/* Expected output:
+Hello World
+*/

_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,50 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/x/llama2"
+)
+
+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(c.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/qsort/qsort.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+func main() {
+	a := [...]int{100, 8, 23, 2, 7}
+	c.Qsort(c.Pointer(&a), 5, unsafe.Sizeof(0), func(a, b c.Pointer) c.Int {
+		return c.Int(*(*int)(a) - *(*int)(b))
+	})
+	for _, v := range a {
+		c.Printf(c.Str("%d\n"), v)
+	}
+}
+
+/* Expected output:
+2
+7
+8
+23
+100
+*/

_demo/sqlite/sqlite.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/x/sqlite"
+)
+
+func main() {
+	c.Remove(c.Str("test.db"))
+
+	db, err := sqlite.Open(c.Str("test.db"))
+	check(err, db, "sqlite: Open")
+
+	err = db.Exec(c.Str("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)"), nil, nil, nil)
+	check(err, db, "sqlite: Exec CREATE TABLE")
+
+	stmt, err := db.PrepareV3("INSERT INTO users (id, name) VALUES (?, ?)", 0, nil)
+	check(err, db, "sqlite: PrepareV3 INSERT")
+
+	stmt.BindInt(1, 100)
+	stmt.BindText(2, c.Str("Hello World"), -1, nil)
+
+	err = stmt.Step()
+	checkDone(err, db, "sqlite: Step INSERT 1")
+
+	stmt.Reset()
+	stmt.BindInt(1, 200)
+	stmt.BindText(2, c.Str("This is llgo"), -1, nil)
+
+	err = stmt.Step()
+	checkDone(err, db, "sqlite: Step INSERT 2")
+
+	stmt.Close()
+
+	stmt, err = db.PrepareV3("SELECT * FROM users", 0, nil)
+	check(err, db, "sqlite: PrepareV3 SELECT")
+
+	for {
+		if err = stmt.Step(); err != sqlite.HasRow {
+			break
+		}
+		c.Printf(c.Str("==> id=%d, name=%s\n"), stmt.ColumnInt(0), stmt.ColumnText(1))
+	}
+	checkDone(err, db, "sqlite: Step done")
+
+	stmt.Close()
+	db.Close()
+}
+
+func check(err sqlite.Errno, db *sqlite.Sqlite3, at string) {
+	if err != sqlite.OK {
+		c.Printf(c.Str("==> %s Error: (%d) %s\n"), c.AllocaCStr(at), err, db.Errmsg())
+		c.Exit(1)
+	}
+}
+
+func checkDone(err sqlite.Errno, db *sqlite.Sqlite3, at string) {
+	if err != sqlite.Done {
+		check(err, db, at)
+	}
+}

_pydemo/callpy/callpy.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/py"
+	"github.com/goplus/llgo/py/math"
+)
+
+func main() {
+	x := math.Sqrt(py.Float(2))
+	c.Printf(c.Str("sqrt(2) = %f\n"), x.Float64())
+}

build/build.go

@@ -1,57 +0,0 @@
-/*
- * Copyright (c) 2023 The GoPlus Authors (goplus.org). All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package build
-
-import (
-	"go/build"
-)
-
-// An ImportMode controls the behavior of the Import method.
-type ImportMode = build.ImportMode
-
-// A Package describes the Go package found in a directory.
-type Package struct {
-	*build.Package
-}
-
-// A Context specifies the supporting context for a build.
-type Context struct {
-	*build.Context
-}
-
-// Import returns details about the Go package named by the import path,
-// interpreting local import paths relative to the srcDir directory.
-// If the path is a local import path naming a package that can be imported
-// using a standard import path, the returned package will set p.ImportPath
-// to that path.
-//
-// If an error occurs, Import returns a non-nil error and a non-nil
-// *Package containing partial information.
-func (ctxt Context) Import(path string, srcDir string, mode ImportMode) (ret Package, err error) {
-	pkg, err := build.Import(path, srcDir, mode)
-	if err != nil {
-		return
-	}
-	ret = Package{pkg}
-	return
-}
-
-// ImportDir is like Import but processes the Go package found in
-// the named directory.
-func (ctxt *Context) ImportDir(dir string, mode ImportMode) (Package, error) {
-	return ctxt.Import(".", dir, mode)
-}

c/c.go

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package c
+
+// typedef unsigned int uint;
+import "C"
+import "unsafe"
+
+const (
+	LLGoPackage = "decl"
+)
+
+type (
+	Char    = int8
+	Int     = C.int
+	Uint    = C.uint
+	Float   = float32
+	Pointer = unsafe.Pointer
+	FilePtr = unsafe.Pointer
+)
+
+type integer interface {
+	~int | ~uint | ~uintptr | ~int32 | ~uint32 | ~int64 | ~uint64
+}
+
+//go:linkname Str llgo.cstr
+func Str(string) *Char
+
+// llgo:link Advance llgo.advance
+func Advance[PtrT any](ptr PtrT, offset int) PtrT { return ptr }
+
+// llgo:link Index llgo.index
+func Index[T any, I integer](ptr *T, offset I) T { return *ptr }
+
+//go:linkname Alloca llgo.alloca
+func Alloca(size uintptr) Pointer
+
+//go:linkname AllocaCStr llgo.allocaCStr
+func AllocaCStr(s string) *Char
+
+//go:linkname Unreachable llgo.unreachable
+func Unreachable()
+
+//go:linkname Malloc C.malloc
+func Malloc(size uintptr) Pointer
+
+//go:linkname Memcpy C.memcpy
+func Memcpy(dst, src Pointer, n uintptr) Pointer
+
+//go:linkname Memset C.memset
+func Memset(s Pointer, c Int, n uintptr) Pointer
+
+// -----------------------------------------------------------------------------
+
+//go:linkname GoStringData llgo.stringData
+func GoStringData(string) *Char
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Remove C.remove
+func Remove(path *Char) Int
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Exit C.exit
+func Exit(Int)
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Rand C.rand
+func Rand() Int
+
+//go:linkname Qsort C.qsort
+func Qsort(base Pointer, count, elem uintptr, compar func(a, b Pointer) Int)
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Stdin __stdinp
+var Stdin FilePtr
+
+//go:linkname Stdout __stdoutp
+var Stdout FilePtr
+
+//go:linkname Stderr __stderrp
+var Stderr FilePtr
+
+//go:linkname Printf C.printf
+func Printf(format *Char, __llgo_va_list ...any) Int
+
+//go:linkname Fprintf C.fprintf
+func Fprintf(fp FilePtr, format *Char, __llgo_va_list ...any) Int
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Time C.time
+func Time(*int32) int32
+
+// -----------------------------------------------------------------------------
+
+type Option struct {
+	Name   *Char
+	HasArg Int
+	Flag   *Int
+	Val    Int
+}
+
+//go:linkname Argc __llgo_argc
+var Argc Int
+
+//go:linkname Argv __llgo_argv
+var Argv **Char
+
+//go:linkname Optarg optarg
+var Optarg *Char
+
+//go:linkname Optind optind
+var Optind Int
+
+//go:linkname Opterr opterr
+var Opterr Int
+
+//go:linkname Optopt optopt
+var Optopt Int
+
+//go:linkname Getopt C.getopt
+func Getopt(argc Int, argv **Char, optstring *Char) Int
+
+//go:linkname GetoptLong C.getopt_long
+func GetoptLong(argc Int, argv **Char, optstring *Char, longopts *Option, longindex *Int) Int
+
+//go:linkname GetoptLongOnly C.getopt_long_only
+func GetoptLongOnly(argc Int, argv **Char, optstring *Char, longopts *Option, longindex *Int) Int
+
+// -----------------------------------------------------------------------------

chore/ardump/ardump.go

@@ -22,7 +22,7 @@ import (
 	"log"
 	"os"
 
-	"github.com/goplus/llgo/x/ar"
+	"github.com/goplus/llgo/xtool/ar"
 )
 
 func main() {

chore/clangast/clangast.go

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2022 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/goplus/llgo/xtool/clang/parser"
+)
+
+var (
+	dump = flag.Bool("dump", false, "dump AST")
+)
+
+func usage() {
+	fmt.Fprintf(os.Stderr, "Usage: clangast [-dump] source.i\n")
+	flag.PrintDefaults()
+}
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+	if flag.NArg() < 1 {
+		usage()
+		return
+	}
+	var file = flag.Arg(0)
+	var err error
+	if *dump {
+		doc, _, e := parser.DumpAST(file, nil)
+		if e == nil {
+			os.Stdout.Write(doc)
+			return
+		}
+		err = e
+	} else {
+		doc, _, e := parser.ParseFile(file, 0)
+		if e == nil {
+			enc := json.NewEncoder(os.Stdout)
+			enc.SetIndent("", "  ")
+			check(enc.Encode(doc))
+			return
+		}
+		err = e
+	}
+	fmt.Fprintln(os.Stderr, err)
+	os.Exit(1)
+}
+
+func check(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

chore/clangpp/clangpp.go

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2022 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/goplus/llgo/xtool/clang/preprocessor"
+)
+
+func usage() {
+	fmt.Fprintf(os.Stderr, "Usage: clangpp source.c\n")
+}
+
+func main() {
+	if len(os.Args) < 2 {
+		usage()
+		return
+	}
+	infile := os.Args[1]
+	outfile := infile + ".i"
+	if err := preprocessor.Do(infile, outfile, nil); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

chore/gentests/gentests.go

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/goplus/llgo/internal/llgen"
+	"github.com/goplus/mod"
+)
+
+func main() {
+	dir, _, err := mod.FindGoMod(".")
+	check(err)
+
+	llgen.Verbose = false
+
+	llgenDir(dir + "/cl/_testlibc")
+	llgenDir(dir + "/cl/_testrt")
+	llgenDir(dir+"/cl/_testpy", "")
+	llgenDir(dir+"/cl/_testdata", "")
+}
+
+func llgenDir(dir string, pkgPath ...string) {
+	fis, err := os.ReadDir(dir)
+	check(err)
+	for _, fi := range fis {
+		name := fi.Name()
+		if !fi.IsDir() || strings.HasPrefix(name, "_") {
+			continue
+		}
+		testDir := dir + "/" + name
+		fmt.Fprintln(os.Stderr, "llgen", testDir)
+		os.Chdir(testDir)
+		llgen.SmartDoFile("in.go", pkgPath...)
+	}
+}
+
+func check(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

chore/llgen/llgen.go

@@ -19,22 +19,16 @@ package main
 import (
 	"fmt"
 	"os"
-	"path/filepath"
 
-	"github.com/goplus/llgo/x/llgen"
+	"github.com/goplus/llgo/internal/llgen"
 )
 
 func main() {
-	if len(os.Args) != 2 {
-		fmt.Fprintln(os.Stderr, "Usage: llgen xxx.go")
+	if len(os.Args) < 2 {
+		fmt.Fprintln(os.Stderr, "Usage: llgen <pkg> [pkgPath]")
 		return
 	}
 
-	inFile := os.Args[1]
-
-	dir, _ := filepath.Split(inFile)
-	outFile := dir + "out.ll"
-
 	llgen.Init()
-	llgen.Do(inFile, outFile)
+	llgen.SmartDoFile(os.Args[1], os.Args[2:]...)
 }

chore/nmdump/nmdump.go

@@ -18,9 +18,10 @@ package main
 
 import (
 	"fmt"
+	"log"
 	"os"
 
-	"github.com/goplus/llgo/x/nm"
+	"github.com/goplus/llgo/xtool/env/llvm"
 )
 
 func main() {
@@ -29,9 +30,8 @@ func main() {
 		return
 	}
 
-	nm := nm.New("nm")
+	nm := llvm.New().Nm()
 	items, err := nm.List(os.Args[1])
-	check(err)
 	for _, item := range items {
 		if item.File != "" {
 			fmt.Printf("\n%s:\n", item.File)
@@ -44,10 +44,7 @@ func main() {
 			}
 		}
 	}
-}
-
-func check(err error) {
 	if err != nil {
-		panic(err)
+		log.Println(err)
 	}
 }

chore/nmindex/nmindex.go

@@ -20,8 +20,8 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/goplus/llgo/x/env/llvm"
-	"github.com/goplus/llgo/x/nm"
+	"github.com/goplus/llgo/xtool/env/llvm"
+	"github.com/goplus/llgo/xtool/nm"
 )
 
 func main() {
@@ -64,6 +64,7 @@ func makeIndex() {
 		usrLib(true),
 		stdLib("LLGO_STDROOT"),
 		stdLib("LLGO_USRROOT"),
+		pythonLib(),
 	}
 	err := b.Index(libDirs, idxDir, func(path string) {
 		fmt.Println("==>", path)
@@ -72,6 +73,11 @@ func makeIndex() {
 }
 
 func query(q string) {
+	if len(q) > 0 {
+		if c := q[0]; c != '*' && c != '_' {
+			q = "_" + q
+		}
+	}
 	files, err := nm.Query(indexDir(), q)
 	check(err)
 	for _, f := range files {
@@ -103,6 +109,10 @@ func usrLib(local bool) string {
 	return "/usr/lib"
 }
 
+func pythonLib() string {
+	return os.Getenv("LLGO_PYTHON_ROOT")
+}
+
 func check(err error) {
 	if err != nil {
 		panic(err)

chore/ssadump/ssadump.go

@@ -0,0 +1,201 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// ssadump: a tool for displaying and interpreting the SSA form of Go programs.
+package main // import "golang.org/x/tools/cmd/ssadump"
+
+import (
+	"flag"
+	"fmt"
+	"go/build"
+	"go/types"
+	"os"
+	"runtime"
+	"runtime/pprof"
+
+	"golang.org/x/tools/go/buildutil"
+	"golang.org/x/tools/go/packages"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/interp"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+const (
+	loadFiles   = packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles
+	loadImports = loadFiles | packages.NeedImports
+	loadTypes   = loadImports | packages.NeedTypes | packages.NeedTypesSizes
+	loadSyntax  = loadTypes | packages.NeedSyntax | packages.NeedTypesInfo
+)
+
+// flags
+var (
+	mode = ssa.BuilderMode(0)
+
+	testFlag = flag.Bool("test", false, "include implicit test packages and executables")
+
+	runFlag = flag.Bool("run", false, "interpret the SSA program")
+
+	interpFlag = flag.String("interp", "", `Options controlling the SSA test interpreter.
+The value is a sequence of zero or more more of these letters:
+R	disable [R]ecover() from panic; show interpreter crash instead.
+T	[T]race execution of the program.  Best for single-threaded programs!
+`)
+
+	cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
+
+	args stringListValue
+)
+
+func init() {
+	flag.Var(&mode, "build", ssa.BuilderModeDoc)
+	flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
+	flag.Var(&args, "arg", "add argument to interpreted program")
+}
+
+const usage = `SSA builder and interpreter.
+Usage: ssadump [-build=[DBCSNFLG]] [-test] [-run] [-interp=[TR]] [-arg=...] package...
+Use -help flag to display options.
+
+Examples:
+% ssadump -build=F hello.go              # dump SSA form of a single package
+% ssadump -build=F -test fmt             # dump SSA form of a package and its tests
+% ssadump -run -interp=T hello.go        # interpret a program, with tracing
+
+The -run flag causes ssadump to build the code in a runnable form and run the first
+package named main.
+
+Interpretation of the standard "testing" package is no longer supported.
+`
+
+func main() {
+	if err := doMain(); err != nil {
+		fmt.Fprintf(os.Stderr, "ssadump: %s\n", err)
+		os.Exit(1)
+	}
+}
+
+func doMain() error {
+	flag.Parse()
+	if len(flag.Args()) == 0 {
+		fmt.Fprint(os.Stderr, usage)
+		os.Exit(1)
+	}
+
+	cfg := &packages.Config{
+		Mode:  loadSyntax,
+		Tests: *testFlag,
+	}
+
+	// Choose types.Sizes from conf.Build.
+	// TODO(adonovan): remove this when go/packages provides a better way.
+	var wordSize int64 = 8
+	switch build.Default.GOARCH {
+	case "386", "arm":
+		wordSize = 4
+	}
+	sizes := &types.StdSizes{
+		MaxAlign: 8,
+		WordSize: wordSize,
+	}
+
+	var interpMode interp.Mode
+	for _, c := range *interpFlag {
+		switch c {
+		case 'T':
+			interpMode |= interp.EnableTracing
+		case 'R':
+			interpMode |= interp.DisableRecover
+		default:
+			return fmt.Errorf("unknown -interp option: '%c'", c)
+		}
+	}
+
+	// Profiling support.
+	if *cpuprofile != "" {
+		f, err := os.Create(*cpuprofile)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		pprof.StartCPUProfile(f)
+		defer pprof.StopCPUProfile()
+	}
+
+	// Load, parse and type-check the initial packages,
+	// and, if -run, their dependencies.
+	if *runFlag {
+		cfg.Mode = loadSyntax | packages.NeedDeps
+	}
+	initial, err := packages.Load(cfg, flag.Args()...)
+	if err != nil {
+		return err
+	}
+	if len(initial) == 0 {
+		return fmt.Errorf("no packages")
+	}
+	if packages.PrintErrors(initial) > 0 {
+		return fmt.Errorf("packages contain errors")
+	}
+
+	// Turn on instantiating generics during build if the program will be run.
+	if *runFlag {
+		mode |= ssa.InstantiateGenerics
+	}
+
+	// Create SSA-form program representation.
+	prog, pkgs := ssautil.AllPackages(initial, mode)
+
+	for i, p := range pkgs {
+		if p == nil {
+			return fmt.Errorf("cannot build SSA for package %s", initial[i])
+		}
+	}
+
+	if !*runFlag {
+		// Build and display only the initial packages
+		// (and synthetic wrappers).
+		for _, p := range pkgs {
+			p.Build()
+		}
+
+	} else {
+		// Run the interpreter.
+		// Build SSA for all packages.
+		prog.Build()
+
+		// Earlier versions of the interpreter needed the runtime
+		// package; however, interp cannot handle unsafe constructs
+		// used during runtime's package initialization at the moment.
+		// The key construct blocking support is:
+		//    *((*T)(unsafe.Pointer(p)))
+		// Unfortunately, this means only trivial programs can be
+		// interpreted by ssadump.
+		if prog.ImportedPackage("runtime") != nil {
+			return fmt.Errorf("-run: program depends on runtime package (interpreter can run only trivial programs)")
+		}
+
+		if runtime.GOARCH != build.Default.GOARCH {
+			return fmt.Errorf("cross-interpretation is not supported (target has GOARCH %s, interpreter has %s)",
+				build.Default.GOARCH, runtime.GOARCH)
+		}
+
+		// Run first main package.
+		for _, main := range ssautil.MainPackages(pkgs) {
+			fmt.Fprintf(os.Stderr, "Running: %s\n", main.Pkg.Path())
+			os.Exit(interp.Interpret(main, interpMode, sizes, main.Pkg.Path(), args))
+		}
+		return fmt.Errorf("no main package")
+	}
+	return nil
+}
+
+// stringListValue is a flag.Value that accumulates strings.
+// e.g. --flag=one --flag=two would produce []string{"one", "two"}.
+type stringListValue []string
+
+func (ss *stringListValue) Get() interface{} { return []string(*ss) }
+
+func (ss *stringListValue) String() string { return fmt.Sprintf("%q", *ss) }
+
+func (ss *stringListValue) Set(s string) error { *ss = append(*ss, s); return nil }

cl/_testdata/apkg/in.go

@@ -0,0 +1,8 @@
+package apkg
+
+func Max(a, b float64) float64 {
+	if a > b {
+		return a
+	}
+	return b
+}

cl/_testdata/apkg/out.ll

@@ -0,0 +1,29 @@
+; ModuleID = 'apkg'
+source_filename = "apkg"
+
+@"apkg.init$guard" = global ptr null
+
+define double @apkg.Max(double %0, double %1) {
+_llgo_0:
+  %2 = fcmp ogt double %0, %1
+  br i1 %2, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  ret double %0
+
+_llgo_2:                                          ; preds = %_llgo_0
+  ret double %1
+}
+
+define void @apkg.init() {
+_llgo_0:
+  %0 = load i1, ptr @"apkg.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"apkg.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}

cl/_testdata/fncall/out.ll

@@ -1,22 +1,34 @@
 ; ModuleID = 'main'
 source_filename = "main"
 
-@"init$guard" = global ptr null
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
 
-define void @init() {
+define void @main.init() {
 _llgo_0:
-  %0 = load i1, ptr @"init$guard", align 1
+  %0 = load i1, ptr @"main.init$guard", align 1
   br i1 %0, label %_llgo_2, label %_llgo_1
 
 _llgo_1:                                          ; preds = %_llgo_0
-  store i1 true, ptr @"init$guard", align 1
+  store i1 true, ptr @"main.init$guard", align 1
   br label %_llgo_2
 
 _llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
   ret void
 }
 
-define i64 @max(i64 %0, i64 %1) {
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call i64 @main.max(i64 1, i64 2)
+  ret void
+}
+
+define i64 @main.max(i64 %0, i64 %1) {
 _llgo_0:
   %2 = icmp sgt i64 %0, %1
   br i1 %2, label %_llgo_1, label %_llgo_2
@@ -28,9 +40,4 @@ _llgo_2:                                          ; preds = %_llgo_0
   ret i64 %1
 }
 
-define void @main() {
-_llgo_0:
-  call void @init()
-  %0 = call i64 @max(i64 1, i64 2)
-  ret void
-}
+declare void @"github.com/goplus/llgo/internal/runtime.init"()

cl/_testdata/importpkg/in.go

@@ -0,0 +1,10 @@
+package main
+
+import "github.com/goplus/llgo/cl/internal/stdio"
+
+var hello = [...]int8{'H', 'e', 'l', 'l', 'o', '\n', 0}
+
+func main() {
+	_ = stdio.Max(2, 100)
+	stdio.Printf(&hello[0])
+}

cl/_testdata/importpkg/out.ll

@@ -0,0 +1,47 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@main.hello = global ptr null
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  call void @"github.com/goplus/llgo/cl/internal/stdio.init"()
+  store i8 72, ptr @main.hello, align 1
+  store i8 101, ptr getelementptr inbounds (i8, ptr @main.hello, i64 1), align 1
+  store i8 108, ptr getelementptr inbounds (i8, ptr @main.hello, i64 2), align 1
+  store i8 108, ptr getelementptr inbounds (i8, ptr @main.hello, i64 3), align 1
+  store i8 111, ptr getelementptr inbounds (i8, ptr @main.hello, i64 4), align 1
+  store i8 10, ptr getelementptr inbounds (i8, ptr @main.hello, i64 5), align 1
+  store i8 0, ptr getelementptr inbounds (i8, ptr @main.hello, i64 6), align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call i64 @"github.com/goplus/llgo/cl/internal/stdio.Max"(i64 2, i64 100)
+  call void (ptr, ...) @printf(ptr @main.hello)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/cl/internal/stdio.init"()
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare i64 @"github.com/goplus/llgo/cl/internal/stdio.Max"(i64, i64)
+
+declare void @printf(ptr, ...)

cl/_testdata/method/in.go

@@ -0,0 +1,19 @@
+package main
+
+import _ "unsafe"
+
+type T int
+
+func (a T) Add(b T) T {
+	return a + b
+}
+
+//go:linkname printf C.printf
+func printf(format *int8, __llgo_va_list ...any)
+
+var format = [...]int8{'H', 'e', 'l', 'l', 'o', ' ', '%', 'd', '\n', 0}
+
+func main() {
+	a := T(1)
+	printf(&format[0], a.Add(2))
+}

cl/_testdata/method/out.ll

@@ -0,0 +1,58 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@main.format = global ptr null
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+
+define i64 @"(main.T).Add"(i64 %0, i64 %1) {
+_llgo_0:
+  %2 = add i64 %0, %1
+  ret i64 %2
+}
+
+define i64 @"(*main.T).Add"(ptr %0, i64 %1) {
+_llgo_0:
+  %2 = load i64, ptr %0, align 4
+  %3 = call i64 @"(main.T).Add"(i64 %2, i64 %1)
+  ret i64 %3
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  store i8 72, ptr @main.format, align 1
+  store i8 101, ptr getelementptr inbounds (i8, ptr @main.format, i64 1), align 1
+  store i8 108, ptr getelementptr inbounds (i8, ptr @main.format, i64 2), align 1
+  store i8 108, ptr getelementptr inbounds (i8, ptr @main.format, i64 3), align 1
+  store i8 111, ptr getelementptr inbounds (i8, ptr @main.format, i64 4), align 1
+  store i8 32, ptr getelementptr inbounds (i8, ptr @main.format, i64 5), align 1
+  store i8 37, ptr getelementptr inbounds (i8, ptr @main.format, i64 6), align 1
+  store i8 100, ptr getelementptr inbounds (i8, ptr @main.format, i64 7), align 1
+  store i8 10, ptr getelementptr inbounds (i8, ptr @main.format, i64 8), align 1
+  store i8 0, ptr getelementptr inbounds (i8, ptr @main.format, i64 9), align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call i64 @"(main.T).Add"(i64 1, i64 2)
+  call void (ptr, ...) @printf(ptr @main.format, i64 %2)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare void @printf(ptr, ...)

cl/_testdata/print/in.go

@@ -0,0 +1,264 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/internal/runtime/c"
+)
+
+func gwrite(b []byte) {
+	if len(b) == 0 {
+		return
+	}
+	c.Printf(c.Str("%s"), b)
+}
+
+func printbool(v bool) {
+	if v {
+		printstring("true")
+	} else {
+		printstring("false")
+	}
+}
+
+func printfloat(v float64) {
+	switch {
+	case v != v:
+		printstring("NaN")
+		return
+	case v+v == v && v > 0:
+		printstring("+Inf")
+		return
+	case v+v == v && v < 0:
+		printstring("-Inf")
+		return
+	}
+
+	const n = 7 // digits printed
+	var buf [n + 7]byte
+	buf[0] = '+'
+	e := 0 // exp
+	if v == 0 {
+		if 1/v < 0 {
+			buf[0] = '-'
+		}
+	} else {
+		if v < 0 {
+			v = -v
+			buf[0] = '-'
+		}
+
+		// normalize
+		for v >= 10 {
+			e++
+			v /= 10
+		}
+		for v < 1 {
+			e--
+			v *= 10
+		}
+
+		// round
+		h := 5.0
+		for i := 0; i < n; i++ {
+			h /= 10
+		}
+		v += h
+		if v >= 10 {
+			e++
+			v /= 10
+		}
+	}
+
+	// format +d.dddd+edd
+	for i := 0; i < n; i++ {
+		s := int(v)
+		buf[i+2] = byte(s + '0')
+		v -= float64(s)
+		v *= 10
+	}
+	buf[1] = buf[2]
+	buf[2] = '.'
+
+	buf[n+2] = 'e'
+	buf[n+3] = '+'
+	if e < 0 {
+		e = -e
+		buf[n+3] = '-'
+	}
+
+	buf[n+4] = byte(e/100) + '0'
+	buf[n+5] = byte(e/10)%10 + '0'
+	buf[n+6] = byte(e%10) + '0'
+	gwrite(buf[:])
+}
+
+func printuint(v uint64) {
+	var buf [100]byte
+	i := len(buf)
+	for i--; i > 0; i-- {
+		buf[i] = byte(v%10 + '0')
+		if v < 10 {
+			break
+		}
+		v /= 10
+	}
+	gwrite(buf[i:])
+}
+
+func printint(v int64) {
+	if v < 0 {
+		printstring("-")
+		v = -v
+	}
+	printuint(uint64(v))
+}
+
+var minhexdigits = 0
+
+func printhex(v uint64) {
+	const dig = "0123456789abcdef"
+	var buf [100]byte
+	i := len(buf)
+	for i--; i > 0; i-- {
+		buf[i] = dig[v%16]
+		if v < 16 && len(buf)-i >= minhexdigits {
+			break
+		}
+		v /= 16
+	}
+	i--
+	buf[i] = 'x'
+	i--
+	buf[i] = '0'
+	gwrite(buf[i:])
+}
+
+func printsp() {
+	printstring(" ")
+}
+
+func printnl() {
+	printstring("\n")
+}
+
+func printstring(s string) {
+	gwrite(bytes(s))
+}
+
+type slice struct {
+	array unsafe.Pointer
+	len   int
+	cap   int
+}
+
+type stringStruct struct {
+	str unsafe.Pointer
+	len int
+}
+
+func stringStructOf(sp *string) *stringStruct {
+	return (*stringStruct)(unsafe.Pointer(sp))
+}
+
+func bytes(s string) (ret []byte) {
+	rp := (*slice)(unsafe.Pointer(&ret))
+	sp := stringStructOf(&s)
+	rp.array = sp.str
+	rp.len = sp.len
+	rp.cap = sp.len
+	return
+}
+
+func main() {
+	printstring("llgo")
+	printnl()
+	printuint(1024)
+	printnl()
+	printhex(0x1234abcf)
+	printnl()
+	prinxor(1)
+	printnl()
+	prinsub(100)
+	printnl()
+	prinusub(1<<64 - 1)
+	printnl()
+	prinfsub(100.1)
+	printnl()
+	printany(float32(1e9))
+	printnl()
+	printany(float64(2e9))
+	printnl()
+	var b bool = true
+	if b == true && b != false {
+		println("check bool", b)
+	}
+	n1 := 0b1001
+	n2 := 0b0011
+	println("check &^", n1&^n2 == 0b1000, n2&^n1 == 0b0010)
+	println(true, false, 'a', 'A', rune('中'),
+		int8(1), int16(2), int32(3), int64(4), 5,
+		uint8(1), uint16(2), uint32(3), uint64(4), uintptr(5),
+		"llgo")
+}
+
+func println(args ...any) {
+	for i, v := range args {
+		if i != 0 {
+			printstring(" ")
+		}
+		printany(v)
+	}
+	printnl()
+}
+
+func printany(v any) {
+	switch v := v.(type) {
+	case bool:
+		printbool(v)
+	case int:
+		printint(int64(v))
+	case int8:
+		printint(int64(v))
+	case int16:
+		printint(int64(v))
+	case int32:
+		printint(int64(v))
+	case int64:
+		printint(int64(v))
+	case uint:
+		printuint(uint64(v))
+	case uint8:
+		printuint(uint64(v))
+	case uint16:
+		printuint(uint64(v))
+	case uint32:
+		printuint(uint64(v))
+	case uint64:
+		printuint(uint64(v))
+	case uintptr:
+		printuint(uint64(v))
+	case float32:
+		printfloat(float64(v))
+	case float64:
+		printfloat(float64(v))
+	case string:
+		printstring(v)
+	}
+}
+
+func prinxor(n int64) {
+	printint(^n)
+}
+
+func prinsub(n int64) {
+	printint(-n)
+}
+
+func prinusub(n uint64) {
+	printuint(-n)
+}
+
+func prinfsub(n float64) {
+	printfloat(-n)
+}

cl/_testdata/print/out.ll

@@ -0,0 +1,806 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%"github.com/goplus/llgo/internal/runtime.Slice" = type { ptr, i64, i64 }
+%"github.com/goplus/llgo/internal/runtime.String" = type { ptr, i64 }
+%main.stringStruct = type { ptr, i64 }
+%main.slice = type { ptr, i64, i64 }
+%"github.com/goplus/llgo/internal/runtime.iface" = type { ptr, ptr }
+
+@"main.init$guard" = global ptr null
+@main.minhexdigits = global ptr null
+@0 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@1 = private unnamed_addr constant [5 x i8] c"llgo\00", align 1
+@2 = private unnamed_addr constant [11 x i8] c"check bool\00", align 1
+@3 = private unnamed_addr constant [9 x i8] c"check &^\00", align 1
+@4 = private unnamed_addr constant [5 x i8] c"llgo\00", align 1
+@5 = private unnamed_addr constant [5 x i8] c"true\00", align 1
+@6 = private unnamed_addr constant [6 x i8] c"false\00", align 1
+@7 = private unnamed_addr constant [4 x i8] c"NaN\00", align 1
+@8 = private unnamed_addr constant [5 x i8] c"+Inf\00", align 1
+@9 = private unnamed_addr constant [5 x i8] c"-Inf\00", align 1
+@10 = private unnamed_addr constant [17 x i8] c"0123456789abcdef\00", align 1
+@11 = private unnamed_addr constant [2 x i8] c"-\00", align 1
+@12 = private unnamed_addr constant [2 x i8] c" \00", align 1
+@13 = private unnamed_addr constant [2 x i8] c"\0A\00", align 1
+@14 = private unnamed_addr constant [2 x i8] c" \00", align 1
+
+define %"github.com/goplus/llgo/internal/runtime.Slice" @main.bytes(%"github.com/goplus/llgo/internal/runtime.String" %0) {
+_llgo_0:
+  %1 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 16)
+  store %"github.com/goplus/llgo/internal/runtime.String" %0, ptr %1, align 8
+  %2 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 24)
+  %3 = call ptr @main.stringStructOf(ptr %1)
+  %4 = getelementptr inbounds %main.stringStruct, ptr %3, i32 0, i32 0
+  %5 = load ptr, ptr %4, align 8
+  %6 = getelementptr inbounds %main.slice, ptr %2, i32 0, i32 0
+  store ptr %5, ptr %6, align 8
+  %7 = getelementptr inbounds %main.stringStruct, ptr %3, i32 0, i32 1
+  %8 = load i64, ptr %7, align 4
+  %9 = getelementptr inbounds %main.slice, ptr %2, i32 0, i32 1
+  store i64 %8, ptr %9, align 4
+  %10 = getelementptr inbounds %main.stringStruct, ptr %3, i32 0, i32 1
+  %11 = load i64, ptr %10, align 4
+  %12 = getelementptr inbounds %main.slice, ptr %2, i32 0, i32 2
+  store i64 %11, ptr %12, align 4
+  %13 = load %"github.com/goplus/llgo/internal/runtime.Slice", ptr %2, align 8
+  ret %"github.com/goplus/llgo/internal/runtime.Slice" %13
+}
+
+define void @main.gwrite(%"github.com/goplus/llgo/internal/runtime.Slice" %0) {
+_llgo_0:
+  %1 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %0)
+  %2 = icmp eq i64 %1, 0
+  br i1 %2, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  ret void
+
+_llgo_2:                                          ; preds = %_llgo_0
+  %3 = call i32 (ptr, ...) @printf(ptr @0, %"github.com/goplus/llgo/internal/runtime.Slice" %0)
+  ret void
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  store i64 0, ptr @main.minhexdigits, align 4
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @1, i64 4)
+  call void @main.printstring(%"github.com/goplus/llgo/internal/runtime.String" %2)
+  call void @main.printnl()
+  call void @main.printuint(i64 1024)
+  call void @main.printnl()
+  call void @main.printhex(i64 305441743)
+  call void @main.printnl()
+  call void @main.prinxor(i64 1)
+  call void @main.printnl()
+  call void @main.prinsub(i64 100)
+  call void @main.printnl()
+  call void @main.prinusub(i64 -1)
+  call void @main.printnl()
+  call void @main.prinfsub(double 1.001000e+02)
+  call void @main.printnl()
+  %3 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 13)
+  %4 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %3, i64 1315859240)
+  call void @main.printany(%"github.com/goplus/llgo/internal/runtime.iface" %4)
+  call void @main.printnl()
+  %5 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 14)
+  %6 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %5, i64 4746175415993761792)
+  call void @main.printany(%"github.com/goplus/llgo/internal/runtime.iface" %6)
+  call void @main.printnl()
+  br i1 true, label %_llgo_3, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_3
+  %7 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 32)
+  %8 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %7, i64 0
+  %9 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @2, i64 10)
+  %10 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %9)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %10, ptr %8, align 8
+  %11 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %7, i64 1
+  %12 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 1)
+  %13 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %12, i64 -1)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %13, ptr %11, align 8
+  %14 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %7, i64 16, i64 2, i64 0, i64 2, i64 2)
+  call void @main.println(%"github.com/goplus/llgo/internal/runtime.Slice" %14)
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_3, %_llgo_1, %_llgo_0
+  %15 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 48)
+  %16 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %15, i64 0
+  %17 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @3, i64 8)
+  %18 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %17)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %18, ptr %16, align 8
+  %19 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %15, i64 1
+  %20 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 1)
+  %21 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %20, i64 -1)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %21, ptr %19, align 8
+  %22 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %15, i64 2
+  %23 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 1)
+  %24 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %23, i64 -1)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %24, ptr %22, align 8
+  %25 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %15, i64 16, i64 3, i64 0, i64 3, i64 3)
+  call void @main.println(%"github.com/goplus/llgo/internal/runtime.Slice" %25)
+  %26 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 256)
+  %27 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 0
+  %28 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 1)
+  %29 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %28, i64 -1)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %29, ptr %27, align 8
+  %30 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 1
+  %31 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 1)
+  %32 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %31, i64 0)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %32, ptr %30, align 8
+  %33 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 2
+  %34 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 5)
+  %35 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %34, i64 97)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %35, ptr %33, align 8
+  %36 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 3
+  %37 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 5)
+  %38 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %37, i64 65)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %38, ptr %36, align 8
+  %39 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 4
+  %40 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 5)
+  %41 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %40, i64 20013)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %41, ptr %39, align 8
+  %42 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 5
+  %43 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 3)
+  %44 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %43, i64 1)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %44, ptr %42, align 8
+  %45 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 6
+  %46 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 4)
+  %47 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %46, i64 2)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %47, ptr %45, align 8
+  %48 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 7
+  %49 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 5)
+  %50 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %49, i64 3)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %50, ptr %48, align 8
+  %51 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 8
+  %52 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 6)
+  %53 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %52, i64 4)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %53, ptr %51, align 8
+  %54 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 9
+  %55 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 2)
+  %56 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %55, i64 5)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %56, ptr %54, align 8
+  %57 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 10
+  %58 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 8)
+  %59 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %58, i64 1)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %59, ptr %57, align 8
+  %60 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 11
+  %61 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 9)
+  %62 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %61, i64 2)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %62, ptr %60, align 8
+  %63 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 12
+  %64 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 10)
+  %65 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %64, i64 3)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %65, ptr %63, align 8
+  %66 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 13
+  %67 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 11)
+  %68 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %67, i64 4)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %68, ptr %66, align 8
+  %69 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 14
+  %70 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 12)
+  %71 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %70, i64 5)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %71, ptr %69, align 8
+  %72 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %26, i64 15
+  %73 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @4, i64 4)
+  %74 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %73)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %74, ptr %72, align 8
+  %75 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %26, i64 16, i64 16, i64 0, i64 16, i64 16)
+  call void @main.println(%"github.com/goplus/llgo/internal/runtime.Slice" %75)
+  ret void
+
+_llgo_3:                                          ; preds = %_llgo_0
+  br i1 true, label %_llgo_1, label %_llgo_2
+}
+
+define void @main.prinfsub(double %0) {
+_llgo_0:
+  %1 = fneg double %0
+  call void @main.printfloat(double %1)
+  ret void
+}
+
+define void @main.prinsub(i64 %0) {
+_llgo_0:
+  %1 = sub i64 0, %0
+  call void @main.printint(i64 %1)
+  ret void
+}
+
+define void @main.printany(%"github.com/goplus/llgo/internal/runtime.iface" %0) {
+_llgo_0:
+  %1 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 1)
+  %2 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %1)
+  %3 = extractvalue { i64, i1 } %2, 0
+  %4 = trunc i64 %3 to i1
+  %5 = extractvalue { i64, i1 } %2, 1
+  br i1 %5, label %_llgo_2, label %_llgo_3
+
+_llgo_1:                                          ; preds = %_llgo_30, %_llgo_29, %_llgo_28, %_llgo_26, %_llgo_24, %_llgo_22, %_llgo_20, %_llgo_18, %_llgo_16, %_llgo_14, %_llgo_12, %_llgo_10, %_llgo_8, %_llgo_6, %_llgo_4, %_llgo_2
+  ret void
+
+_llgo_2:                                          ; preds = %_llgo_0
+  call void @main.printbool(i1 %4)
+  br label %_llgo_1
+
+_llgo_3:                                          ; preds = %_llgo_0
+  %6 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 2)
+  %7 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %6)
+  %8 = extractvalue { i64, i1 } %7, 0
+  %9 = extractvalue { i64, i1 } %7, 1
+  br i1 %9, label %_llgo_4, label %_llgo_5
+
+_llgo_4:                                          ; preds = %_llgo_3
+  call void @main.printint(i64 %8)
+  br label %_llgo_1
+
+_llgo_5:                                          ; preds = %_llgo_3
+  %10 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 3)
+  %11 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %10)
+  %12 = extractvalue { i64, i1 } %11, 0
+  %13 = trunc i64 %12 to i8
+  %14 = extractvalue { i64, i1 } %11, 1
+  br i1 %14, label %_llgo_6, label %_llgo_7
+
+_llgo_6:                                          ; preds = %_llgo_5
+  %15 = sext i8 %13 to i64
+  call void @main.printint(i64 %15)
+  br label %_llgo_1
+
+_llgo_7:                                          ; preds = %_llgo_5
+  %16 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 4)
+  %17 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %16)
+  %18 = extractvalue { i64, i1 } %17, 0
+  %19 = trunc i64 %18 to i16
+  %20 = extractvalue { i64, i1 } %17, 1
+  br i1 %20, label %_llgo_8, label %_llgo_9
+
+_llgo_8:                                          ; preds = %_llgo_7
+  %21 = sext i16 %19 to i64
+  call void @main.printint(i64 %21)
+  br label %_llgo_1
+
+_llgo_9:                                          ; preds = %_llgo_7
+  %22 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 5)
+  %23 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %22)
+  %24 = extractvalue { i64, i1 } %23, 0
+  %25 = trunc i64 %24 to i32
+  %26 = extractvalue { i64, i1 } %23, 1
+  br i1 %26, label %_llgo_10, label %_llgo_11
+
+_llgo_10:                                         ; preds = %_llgo_9
+  %27 = sext i32 %25 to i64
+  call void @main.printint(i64 %27)
+  br label %_llgo_1
+
+_llgo_11:                                         ; preds = %_llgo_9
+  %28 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 6)
+  %29 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %28)
+  %30 = extractvalue { i64, i1 } %29, 0
+  %31 = extractvalue { i64, i1 } %29, 1
+  br i1 %31, label %_llgo_12, label %_llgo_13
+
+_llgo_12:                                         ; preds = %_llgo_11
+  call void @main.printint(i64 %30)
+  br label %_llgo_1
+
+_llgo_13:                                         ; preds = %_llgo_11
+  %32 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 7)
+  %33 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %32)
+  %34 = extractvalue { i64, i1 } %33, 0
+  %35 = extractvalue { i64, i1 } %33, 1
+  br i1 %35, label %_llgo_14, label %_llgo_15
+
+_llgo_14:                                         ; preds = %_llgo_13
+  call void @main.printuint(i64 %34)
+  br label %_llgo_1
+
+_llgo_15:                                         ; preds = %_llgo_13
+  %36 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 8)
+  %37 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %36)
+  %38 = extractvalue { i64, i1 } %37, 0
+  %39 = trunc i64 %38 to i8
+  %40 = extractvalue { i64, i1 } %37, 1
+  br i1 %40, label %_llgo_16, label %_llgo_17
+
+_llgo_16:                                         ; preds = %_llgo_15
+  %41 = sext i8 %39 to i64
+  call void @main.printuint(i64 %41)
+  br label %_llgo_1
+
+_llgo_17:                                         ; preds = %_llgo_15
+  %42 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 9)
+  %43 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %42)
+  %44 = extractvalue { i64, i1 } %43, 0
+  %45 = trunc i64 %44 to i16
+  %46 = extractvalue { i64, i1 } %43, 1
+  br i1 %46, label %_llgo_18, label %_llgo_19
+
+_llgo_18:                                         ; preds = %_llgo_17
+  %47 = sext i16 %45 to i64
+  call void @main.printuint(i64 %47)
+  br label %_llgo_1
+
+_llgo_19:                                         ; preds = %_llgo_17
+  %48 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 10)
+  %49 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %48)
+  %50 = extractvalue { i64, i1 } %49, 0
+  %51 = trunc i64 %50 to i32
+  %52 = extractvalue { i64, i1 } %49, 1
+  br i1 %52, label %_llgo_20, label %_llgo_21
+
+_llgo_20:                                         ; preds = %_llgo_19
+  %53 = sext i32 %51 to i64
+  call void @main.printuint(i64 %53)
+  br label %_llgo_1
+
+_llgo_21:                                         ; preds = %_llgo_19
+  %54 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 11)
+  %55 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %54)
+  %56 = extractvalue { i64, i1 } %55, 0
+  %57 = extractvalue { i64, i1 } %55, 1
+  br i1 %57, label %_llgo_22, label %_llgo_23
+
+_llgo_22:                                         ; preds = %_llgo_21
+  call void @main.printuint(i64 %56)
+  br label %_llgo_1
+
+_llgo_23:                                         ; preds = %_llgo_21
+  %58 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 12)
+  %59 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %58)
+  %60 = extractvalue { i64, i1 } %59, 0
+  %61 = extractvalue { i64, i1 } %59, 1
+  br i1 %61, label %_llgo_24, label %_llgo_25
+
+_llgo_24:                                         ; preds = %_llgo_23
+  call void @main.printuint(i64 %60)
+  br label %_llgo_1
+
+_llgo_25:                                         ; preds = %_llgo_23
+  %62 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 13)
+  %63 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %62)
+  %64 = extractvalue { i64, i1 } %63, 0
+  %65 = trunc i64 %64 to i32
+  %66 = bitcast i32 %65 to float
+  %67 = extractvalue { i64, i1 } %63, 1
+  br i1 %67, label %_llgo_26, label %_llgo_27
+
+_llgo_26:                                         ; preds = %_llgo_25
+  %68 = fpext float %66 to double
+  call void @main.printfloat(double %68)
+  br label %_llgo_1
+
+_llgo_27:                                         ; preds = %_llgo_25
+  %69 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 14)
+  %70 = call { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %69)
+  %71 = extractvalue { i64, i1 } %70, 0
+  %72 = bitcast i64 %71 to double
+  %73 = extractvalue { i64, i1 } %70, 1
+  br i1 %73, label %_llgo_28, label %_llgo_29
+
+_llgo_28:                                         ; preds = %_llgo_27
+  call void @main.printfloat(double %72)
+  br label %_llgo_1
+
+_llgo_29:                                         ; preds = %_llgo_27
+  %74 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 24)
+  %75 = call { %"github.com/goplus/llgo/internal/runtime.String", i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2String"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %74)
+  %76 = extractvalue { %"github.com/goplus/llgo/internal/runtime.String", i1 } %75, 0
+  %77 = extractvalue { %"github.com/goplus/llgo/internal/runtime.String", i1 } %75, 1
+  br i1 %77, label %_llgo_30, label %_llgo_1
+
+_llgo_30:                                         ; preds = %_llgo_29
+  call void @main.printstring(%"github.com/goplus/llgo/internal/runtime.String" %76)
+  br label %_llgo_1
+}
+
+define void @main.printbool(i1 %0) {
+_llgo_0:
+  br i1 %0, label %_llgo_1, label %_llgo_3
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %1 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @5, i64 4)
+  call void @main.printstring(%"github.com/goplus/llgo/internal/runtime.String" %1)
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_3, %_llgo_1
+  ret void
+
+_llgo_3:                                          ; preds = %_llgo_0
+  %2 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @6, i64 5)
+  call void @main.printstring(%"github.com/goplus/llgo/internal/runtime.String" %2)
+  br label %_llgo_2
+}
+
+define void @main.printfloat(double %0) {
+_llgo_0:
+  %1 = fcmp one double %0, %0
+  br i1 %1, label %_llgo_1, label %_llgo_3
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %2 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @7, i64 3)
+  call void @main.printstring(%"github.com/goplus/llgo/internal/runtime.String" %2)
+  ret void
+
+_llgo_2:                                          ; preds = %_llgo_7
+  %3 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @8, i64 4)
+  call void @main.printstring(%"github.com/goplus/llgo/internal/runtime.String" %3)
+  ret void
+
+_llgo_3:                                          ; preds = %_llgo_0
+  %4 = fadd double %0, %0
+  %5 = fcmp oeq double %4, %0
+  br i1 %5, label %_llgo_6, label %_llgo_7
+
+_llgo_4:                                          ; preds = %_llgo_10
+  %6 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @9, i64 4)
+  call void @main.printstring(%"github.com/goplus/llgo/internal/runtime.String" %6)
+  ret void
+
+_llgo_5:                                          ; preds = %_llgo_7
+  %7 = fadd double %0, %0
+  %8 = fcmp oeq double %7, %0
+  br i1 %8, label %_llgo_9, label %_llgo_10
+
+_llgo_6:                                          ; preds = %_llgo_3
+  %9 = fcmp ogt double %0, 0.000000e+00
+  br label %_llgo_7
+
+_llgo_7:                                          ; preds = %_llgo_6, %_llgo_3
+  %10 = phi i1 [ false, %_llgo_3 ], [ %9, %_llgo_6 ]
+  br i1 %10, label %_llgo_2, label %_llgo_5
+
+_llgo_8:                                          ; preds = %_llgo_10
+  %11 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 14)
+  %12 = getelementptr inbounds i8, ptr %11, i64 0
+  store i8 43, ptr %12, align 1
+  %13 = fcmp oeq double %0, 0.000000e+00
+  br i1 %13, label %_llgo_11, label %_llgo_13
+
+_llgo_9:                                          ; preds = %_llgo_5
+  %14 = fcmp olt double %0, 0.000000e+00
+  br label %_llgo_10
+
+_llgo_10:                                         ; preds = %_llgo_9, %_llgo_5
+  %15 = phi i1 [ false, %_llgo_5 ], [ %14, %_llgo_9 ]
+  br i1 %15, label %_llgo_4, label %_llgo_8
+
+_llgo_11:                                         ; preds = %_llgo_8
+  %16 = fdiv double 1.000000e+00, %0
+  %17 = fcmp olt double %16, 0.000000e+00
+  br i1 %17, label %_llgo_14, label %_llgo_12
+
+_llgo_12:                                         ; preds = %_llgo_24, %_llgo_22, %_llgo_14, %_llgo_11
+  %18 = phi double [ %0, %_llgo_11 ], [ %36, %_llgo_22 ], [ %0, %_llgo_14 ], [ %42, %_llgo_24 ]
+  %19 = phi i64 [ 0, %_llgo_11 ], [ %32, %_llgo_22 ], [ 0, %_llgo_14 ], [ %41, %_llgo_24 ]
+  br label %_llgo_27
+
+_llgo_13:                                         ; preds = %_llgo_8
+  %20 = fcmp olt double %0, 0.000000e+00
+  br i1 %20, label %_llgo_15, label %_llgo_17
+
+_llgo_14:                                         ; preds = %_llgo_11
+  %21 = getelementptr inbounds i8, ptr %11, i64 0
+  store i8 45, ptr %21, align 1
+  br label %_llgo_12
+
+_llgo_15:                                         ; preds = %_llgo_13
+  %22 = fneg double %0
+  %23 = getelementptr inbounds i8, ptr %11, i64 0
+  store i8 45, ptr %23, align 1
+  br label %_llgo_17
+
+_llgo_16:                                         ; preds = %_llgo_17
+  %24 = add i64 %27, 1
+  %25 = fdiv double %26, 1.000000e+01
+  br label %_llgo_17
+
+_llgo_17:                                         ; preds = %_llgo_16, %_llgo_15, %_llgo_13
+  %26 = phi double [ %0, %_llgo_13 ], [ %25, %_llgo_16 ], [ %22, %_llgo_15 ]
+  %27 = phi i64 [ 0, %_llgo_13 ], [ %24, %_llgo_16 ], [ 0, %_llgo_15 ]
+  %28 = fcmp oge double %26, 1.000000e+01
+  br i1 %28, label %_llgo_16, label %_llgo_20
+
+_llgo_18:                                         ; preds = %_llgo_20
+  %29 = sub i64 %32, 1
+  %30 = fmul double %31, 1.000000e+01
+  br label %_llgo_20
+
+_llgo_19:                                         ; preds = %_llgo_20
+  br label %_llgo_23
+
+_llgo_20:                                         ; preds = %_llgo_18, %_llgo_17
+  %31 = phi double [ %26, %_llgo_17 ], [ %30, %_llgo_18 ]
+  %32 = phi i64 [ %27, %_llgo_17 ], [ %29, %_llgo_18 ]
+  %33 = fcmp olt double %31, 1.000000e+00
+  br i1 %33, label %_llgo_18, label %_llgo_19
+
+_llgo_21:                                         ; preds = %_llgo_23
+  %34 = fdiv double %38, 1.000000e+01
+  %35 = add i64 %39, 1
+  br label %_llgo_23
+
+_llgo_22:                                         ; preds = %_llgo_23
+  %36 = fadd double %31, %38
+  %37 = fcmp oge double %36, 1.000000e+01
+  br i1 %37, label %_llgo_24, label %_llgo_12
+
+_llgo_23:                                         ; preds = %_llgo_21, %_llgo_19
+  %38 = phi double [ 5.000000e+00, %_llgo_19 ], [ %34, %_llgo_21 ]
+  %39 = phi i64 [ 0, %_llgo_19 ], [ %35, %_llgo_21 ]
+  %40 = icmp slt i64 %39, 7
+  br i1 %40, label %_llgo_21, label %_llgo_22
+
+_llgo_24:                                         ; preds = %_llgo_22
+  %41 = add i64 %32, 1
+  %42 = fdiv double %36, 1.000000e+01
+  br label %_llgo_12
+
+_llgo_25:                                         ; preds = %_llgo_27
+  %43 = fptosi double %59 to i64
+  %44 = add i64 %60, 2
+  %45 = add i64 %43, 48
+  %46 = trunc i64 %45 to i8
+  %47 = getelementptr inbounds i8, ptr %11, i64 %44
+  store i8 %46, ptr %47, align 1
+  %48 = sitofp i64 %43 to double
+  %49 = fsub double %59, %48
+  %50 = fmul double %49, 1.000000e+01
+  %51 = add i64 %60, 1
+  br label %_llgo_27
+
+_llgo_26:                                         ; preds = %_llgo_27
+  %52 = getelementptr inbounds i8, ptr %11, i64 2
+  %53 = load i8, ptr %52, align 1
+  %54 = getelementptr inbounds i8, ptr %11, i64 1
+  store i8 %53, ptr %54, align 1
+  %55 = getelementptr inbounds i8, ptr %11, i64 2
+  store i8 46, ptr %55, align 1
+  %56 = getelementptr inbounds i8, ptr %11, i64 9
+  store i8 101, ptr %56, align 1
+  %57 = getelementptr inbounds i8, ptr %11, i64 10
+  store i8 43, ptr %57, align 1
+  %58 = icmp slt i64 %19, 0
+  br i1 %58, label %_llgo_28, label %_llgo_29
+
+_llgo_27:                                         ; preds = %_llgo_25, %_llgo_12
+  %59 = phi double [ %18, %_llgo_12 ], [ %50, %_llgo_25 ]
+  %60 = phi i64 [ 0, %_llgo_12 ], [ %51, %_llgo_25 ]
+  %61 = icmp slt i64 %60, 7
+  br i1 %61, label %_llgo_25, label %_llgo_26
+
+_llgo_28:                                         ; preds = %_llgo_26
+  %62 = sub i64 0, %19
+  %63 = getelementptr inbounds i8, ptr %11, i64 10
+  store i8 45, ptr %63, align 1
+  br label %_llgo_29
+
+_llgo_29:                                         ; preds = %_llgo_28, %_llgo_26
+  %64 = phi i64 [ %19, %_llgo_26 ], [ %62, %_llgo_28 ]
+  %65 = sdiv i64 %64, 100
+  %66 = trunc i64 %65 to i8
+  %67 = add i8 %66, 48
+  %68 = getelementptr inbounds i8, ptr %11, i64 11
+  store i8 %67, ptr %68, align 1
+  %69 = sdiv i64 %64, 10
+  %70 = trunc i64 %69 to i8
+  %71 = urem i8 %70, 10
+  %72 = add i8 %71, 48
+  %73 = getelementptr inbounds i8, ptr %11, i64 12
+  store i8 %72, ptr %73, align 1
+  %74 = srem i64 %64, 10
+  %75 = trunc i64 %74 to i8
+  %76 = add i8 %75, 48
+  %77 = getelementptr inbounds i8, ptr %11, i64 13
+  store i8 %76, ptr %77, align 1
+  %78 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %11, i64 1, i64 14, i64 0, i64 14, i64 14)
+  call void @main.gwrite(%"github.com/goplus/llgo/internal/runtime.Slice" %78)
+  ret void
+}
+
+define void @main.printhex(i64 %0) {
+_llgo_0:
+  %1 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 100)
+  br label %_llgo_3
+
+_llgo_1:                                          ; preds = %_llgo_3
+  %2 = urem i64 %14, 16
+  %3 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @10, i64 16)
+  %4 = extractvalue %"github.com/goplus/llgo/internal/runtime.String" %3, 0
+  %5 = getelementptr inbounds i8, ptr %4, i64 %2
+  %6 = load i8, ptr %5, align 1
+  %7 = getelementptr inbounds i8, ptr %1, i64 %15
+  store i8 %6, ptr %7, align 1
+  %8 = icmp ult i64 %14, 16
+  br i1 %8, label %_llgo_5, label %_llgo_4
+
+_llgo_2:                                          ; preds = %_llgo_5, %_llgo_3
+  %9 = sub i64 %15, 1
+  %10 = getelementptr inbounds i8, ptr %1, i64 %9
+  store i8 120, ptr %10, align 1
+  %11 = sub i64 %9, 1
+  %12 = getelementptr inbounds i8, ptr %1, i64 %11
+  store i8 48, ptr %12, align 1
+  %13 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %1, i64 1, i64 100, i64 %11, i64 100, i64 100)
+  call void @main.gwrite(%"github.com/goplus/llgo/internal/runtime.Slice" %13)
+  ret void
+
+_llgo_3:                                          ; preds = %_llgo_4, %_llgo_0
+  %14 = phi i64 [ %0, %_llgo_0 ], [ %17, %_llgo_4 ]
+  %15 = phi i64 [ 99, %_llgo_0 ], [ %18, %_llgo_4 ]
+  %16 = icmp sgt i64 %15, 0
+  br i1 %16, label %_llgo_1, label %_llgo_2
+
+_llgo_4:                                          ; preds = %_llgo_5, %_llgo_1
+  %17 = udiv i64 %14, 16
+  %18 = sub i64 %15, 1
+  br label %_llgo_3
+
+_llgo_5:                                          ; preds = %_llgo_1
+  %19 = sub i64 100, %15
+  %20 = load i64, ptr @main.minhexdigits, align 4
+  %21 = icmp sge i64 %19, %20
+  br i1 %21, label %_llgo_2, label %_llgo_4
+}
+
+define void @main.printint(i64 %0) {
+_llgo_0:
+  %1 = icmp slt i64 %0, 0
+  br i1 %1, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %2 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @11, i64 1)
+  call void @main.printstring(%"github.com/goplus/llgo/internal/runtime.String" %2)
+  %3 = sub i64 0, %0
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  %4 = phi i64 [ %0, %_llgo_0 ], [ %3, %_llgo_1 ]
+  call void @main.printuint(i64 %4)
+  ret void
+}
+
+define void @main.println(%"github.com/goplus/llgo/internal/runtime.Slice" %0) {
+_llgo_0:
+  %1 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %0)
+  br label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_5, %_llgo_0
+  %2 = phi i64 [ -1, %_llgo_0 ], [ %3, %_llgo_5 ]
+  %3 = add i64 %2, 1
+  %4 = icmp slt i64 %3, %1
+  br i1 %4, label %_llgo_2, label %_llgo_3
+
+_llgo_2:                                          ; preds = %_llgo_1
+  %5 = call ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice" %0)
+  %6 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %5, i64 %3
+  %7 = load %"github.com/goplus/llgo/internal/runtime.iface", ptr %6, align 8
+  %8 = icmp ne i64 %3, 0
+  br i1 %8, label %_llgo_4, label %_llgo_5
+
+_llgo_3:                                          ; preds = %_llgo_1
+  call void @main.printnl()
+  ret void
+
+_llgo_4:                                          ; preds = %_llgo_2
+  %9 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @12, i64 1)
+  call void @main.printstring(%"github.com/goplus/llgo/internal/runtime.String" %9)
+  br label %_llgo_5
+
+_llgo_5:                                          ; preds = %_llgo_4, %_llgo_2
+  call void @main.printany(%"github.com/goplus/llgo/internal/runtime.iface" %7)
+  br label %_llgo_1
+}
+
+define void @main.printnl() {
+_llgo_0:
+  %0 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @13, i64 1)
+  call void @main.printstring(%"github.com/goplus/llgo/internal/runtime.String" %0)
+  ret void
+}
+
+define void @main.printsp() {
+_llgo_0:
+  %0 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @14, i64 1)
+  call void @main.printstring(%"github.com/goplus/llgo/internal/runtime.String" %0)
+  ret void
+}
+
+define void @main.printstring(%"github.com/goplus/llgo/internal/runtime.String" %0) {
+_llgo_0:
+  %1 = call %"github.com/goplus/llgo/internal/runtime.Slice" @main.bytes(%"github.com/goplus/llgo/internal/runtime.String" %0)
+  call void @main.gwrite(%"github.com/goplus/llgo/internal/runtime.Slice" %1)
+  ret void
+}
+
+define void @main.printuint(i64 %0) {
+_llgo_0:
+  %1 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 100)
+  br label %_llgo_3
+
+_llgo_1:                                          ; preds = %_llgo_3
+  %2 = urem i64 %8, 10
+  %3 = add i64 %2, 48
+  %4 = trunc i64 %3 to i8
+  %5 = getelementptr inbounds i8, ptr %1, i64 %9
+  store i8 %4, ptr %5, align 1
+  %6 = icmp ult i64 %8, 10
+  br i1 %6, label %_llgo_2, label %_llgo_4
+
+_llgo_2:                                          ; preds = %_llgo_3, %_llgo_1
+  %7 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %1, i64 1, i64 100, i64 %9, i64 100, i64 100)
+  call void @main.gwrite(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  ret void
+
+_llgo_3:                                          ; preds = %_llgo_4, %_llgo_0
+  %8 = phi i64 [ %0, %_llgo_0 ], [ %11, %_llgo_4 ]
+  %9 = phi i64 [ 99, %_llgo_0 ], [ %12, %_llgo_4 ]
+  %10 = icmp sgt i64 %9, 0
+  br i1 %10, label %_llgo_1, label %_llgo_2
+
+_llgo_4:                                          ; preds = %_llgo_1
+  %11 = udiv i64 %8, 10
+  %12 = sub i64 %9, 1
+  br label %_llgo_3
+}
+
+define void @main.prinusub(i64 %0) {
+_llgo_0:
+  %1 = sub i64 0, %0
+  call void @main.printuint(i64 %1)
+  ret void
+}
+
+define void @main.prinxor(i64 %0) {
+_llgo_0:
+  %1 = xor i64 %0, -1
+  call void @main.printint(i64 %1)
+  ret void
+}
+
+define ptr @main.stringStructOf(ptr %0) {
+_llgo_0:
+  ret ptr %0
+}
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64)
+
+declare i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice")
+
+declare i32 @printf(ptr, ...)
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr, i64)
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64)
+
+declare %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr, i64)
+
+declare %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String")
+
+declare %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr, i64, i64, i64, i64, i64)
+
+declare { i64, i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2Int"(%"github.com/goplus/llgo/internal/runtime.iface", ptr)
+
+declare { %"github.com/goplus/llgo/internal/runtime.String", i1 } @"github.com/goplus/llgo/internal/runtime.CheckI2String"(%"github.com/goplus/llgo/internal/runtime.iface", ptr)
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice")

cl/_testdata/printf/in.go

@@ -2,7 +2,7 @@ package main
 
 import _ "unsafe"
 
-//go:linkname printf _printf
+//go:linkname printf C.printf
 func printf(format *int8, __llgo_va_list ...any)
 
 var hello = [...]int8{'H', 'e', 'l', 'l', 'o', '\n', 0}

cl/_testdata/printf/out.ll

@@ -1,34 +1,41 @@
 ; ModuleID = 'main'
 source_filename = "main"
 
-@"init$guard" = global ptr null
-@hello = global ptr null
+@main.hello = global ptr null
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
 
-define void @init() {
+define void @main.init() {
 _llgo_0:
-  %0 = load i1, ptr @"init$guard", align 1
+  %0 = load i1, ptr @"main.init$guard", align 1
   br i1 %0, label %_llgo_2, label %_llgo_1
 
 _llgo_1:                                          ; preds = %_llgo_0
-  store i1 true, ptr @"init$guard", align 1
-  store i8 72, ptr @hello, align 1
-  store i8 101, ptr getelementptr inbounds (i8, ptr @hello, i64 1), align 1
-  store i8 108, ptr getelementptr inbounds (i8, ptr @hello, i64 2), align 1
-  store i8 108, ptr getelementptr inbounds (i8, ptr @hello, i64 3), align 1
-  store i8 111, ptr getelementptr inbounds (i8, ptr @hello, i64 4), align 1
-  store i8 10, ptr getelementptr inbounds (i8, ptr @hello, i64 5), align 1
-  store i8 0, ptr getelementptr inbounds (i8, ptr @hello, i64 6), align 1
+  store i1 true, ptr @"main.init$guard", align 1
+  store i8 72, ptr @main.hello, align 1
+  store i8 101, ptr getelementptr inbounds (i8, ptr @main.hello, i64 1), align 1
+  store i8 108, ptr getelementptr inbounds (i8, ptr @main.hello, i64 2), align 1
+  store i8 108, ptr getelementptr inbounds (i8, ptr @main.hello, i64 3), align 1
+  store i8 111, ptr getelementptr inbounds (i8, ptr @main.hello, i64 4), align 1
+  store i8 10, ptr getelementptr inbounds (i8, ptr @main.hello, i64 5), align 1
+  store i8 0, ptr getelementptr inbounds (i8, ptr @main.hello, i64 6), align 1
   br label %_llgo_2
 
 _llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
   ret void
 }
 
-declare void @printf(ptr, ...)
-
-define void @main() {
+define void @main(i32 %0, ptr %1) {
 _llgo_0:
-  call void @init()
-  call void (ptr, ...) @printf(ptr @hello)
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  call void (ptr, ...) @printf(ptr @main.hello)
   ret void
 }
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare void @printf(ptr, ...)

cl/_testdata/printval/in.go

@@ -0,0 +1,12 @@
+package main
+
+import _ "unsafe"
+
+//go:linkname printf C.printf
+func printf(format *int8, __llgo_va_list ...any)
+
+var format = [...]int8{'H', 'e', 'l', 'l', 'o', ' ', '%', 'd', '\n', 0}
+
+func main() {
+	printf(&format[0], 100)
+}

cl/_testdata/printval/out.ll

@@ -0,0 +1,44 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@main.format = global ptr null
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  store i8 72, ptr @main.format, align 1
+  store i8 101, ptr getelementptr inbounds (i8, ptr @main.format, i64 1), align 1
+  store i8 108, ptr getelementptr inbounds (i8, ptr @main.format, i64 2), align 1
+  store i8 108, ptr getelementptr inbounds (i8, ptr @main.format, i64 3), align 1
+  store i8 111, ptr getelementptr inbounds (i8, ptr @main.format, i64 4), align 1
+  store i8 32, ptr getelementptr inbounds (i8, ptr @main.format, i64 5), align 1
+  store i8 37, ptr getelementptr inbounds (i8, ptr @main.format, i64 6), align 1
+  store i8 100, ptr getelementptr inbounds (i8, ptr @main.format, i64 7), align 1
+  store i8 10, ptr getelementptr inbounds (i8, ptr @main.format, i64 8), align 1
+  store i8 0, ptr getelementptr inbounds (i8, ptr @main.format, i64 9), align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  call void (ptr, ...) @printf(ptr @main.format, i64 100)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare void @printf(ptr, ...)

cl/_testdata/ptrmthd/in.go

@@ -0,0 +1,19 @@
+package main
+
+import _ "unsafe"
+
+//go:linkname printf C.printf
+func printf(format *int8, __llgo_va_list ...any)
+
+type T int8
+
+func (f *T) Print(v int) {
+	printf((*int8)(f), v)
+}
+
+var format = [...]T{'H', 'e', 'l', 'l', 'o', ' ', '%', 'd', '\n', 0}
+
+func main() {
+	f := &format[0]
+	f.Print(100)
+}

cl/_testdata/ptrmthd/out.ll

@@ -0,0 +1,50 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@main.format = global ptr null
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+
+define void @"(*main.T).Print"(ptr %0, i64 %1) {
+_llgo_0:
+  call void (ptr, ...) @printf(ptr %0, i64 %1)
+  ret void
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  store i8 72, ptr @main.format, align 1
+  store i8 101, ptr getelementptr inbounds (i8, ptr @main.format, i64 1), align 1
+  store i8 108, ptr getelementptr inbounds (i8, ptr @main.format, i64 2), align 1
+  store i8 108, ptr getelementptr inbounds (i8, ptr @main.format, i64 3), align 1
+  store i8 111, ptr getelementptr inbounds (i8, ptr @main.format, i64 4), align 1
+  store i8 32, ptr getelementptr inbounds (i8, ptr @main.format, i64 5), align 1
+  store i8 37, ptr getelementptr inbounds (i8, ptr @main.format, i64 6), align 1
+  store i8 100, ptr getelementptr inbounds (i8, ptr @main.format, i64 7), align 1
+  store i8 10, ptr getelementptr inbounds (i8, ptr @main.format, i64 8), align 1
+  store i8 0, ptr getelementptr inbounds (i8, ptr @main.format, i64 9), align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  call void @"(*main.T).Print"(ptr @main.format, i64 100)
+  ret void
+}
+
+declare void @printf(ptr, ...)
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()

cl/_testdata/uint/in.go

@@ -0,0 +1,13 @@
+package main
+
+import "github.com/goplus/llgo/c"
+
+func f(a c.Uint) c.Uint {
+	a++
+	return a
+}
+
+func main() {
+	var a c.Uint = 100
+	c.Printf(c.Str("Hello, %u\n"), f(a))
+}

cl/_testdata/uint/out.ll

@@ -0,0 +1,41 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [11 x i8] c"Hello, %u\0A\00", align 1
+
+define i32 @main.f(i32 %0) {
+_llgo_0:
+  %1 = add i32 %0, 1
+  ret i32 %1
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call i32 @main.f(i32 100)
+  %3 = call i32 (ptr, ...) @printf(ptr @0, i32 %2)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare i32 @printf(ptr, ...)

cl/_testdata/untyped/in.go

@@ -0,0 +1,11 @@
+package main
+
+const c = 100
+
+var a float64 = 1
+
+func main() {
+	if c > 100 {
+		a = 0
+	}
+}

cl/_testdata/untyped/out.ll

@@ -0,0 +1,39 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@main.a = global ptr null
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  store double 1.000000e+00, ptr @main.a, align 8
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  br i1 false, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store double 0.000000e+00, ptr @main.a, align 8
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()

cl/_testdata/vargs/in.go

@@ -0,0 +1,13 @@
+package main
+
+import "github.com/goplus/llgo/internal/runtime/c"
+
+func test(a ...any) {
+	for _, v := range a {
+		c.Printf(c.Str("%d\n"), v.(int))
+	}
+}
+
+func main() {
+	test(1, 2, 3)
+}

cl/_testdata/vargs/out.ll

@@ -0,0 +1,89 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%"github.com/goplus/llgo/internal/runtime.iface" = type { ptr, ptr }
+%"github.com/goplus/llgo/internal/runtime.Slice" = type { ptr, i64, i64 }
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 48)
+  %3 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %2, i64 0
+  %4 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 2)
+  %5 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %4, i64 1)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %5, ptr %3, align 8
+  %6 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %2, i64 1
+  %7 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 2)
+  %8 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %7, i64 2)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %8, ptr %6, align 8
+  %9 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %2, i64 2
+  %10 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 2)
+  %11 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %10, i64 3)
+  store %"github.com/goplus/llgo/internal/runtime.iface" %11, ptr %9, align 8
+  %12 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %2, i64 16, i64 3, i64 0, i64 3, i64 3)
+  call void @main.test(%"github.com/goplus/llgo/internal/runtime.Slice" %12)
+  ret void
+}
+
+define void @main.test(%"github.com/goplus/llgo/internal/runtime.Slice" %0) {
+_llgo_0:
+  %1 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %0)
+  br label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_2, %_llgo_0
+  %2 = phi i64 [ -1, %_llgo_0 ], [ %3, %_llgo_2 ]
+  %3 = add i64 %2, 1
+  %4 = icmp slt i64 %3, %1
+  br i1 %4, label %_llgo_2, label %_llgo_3
+
+_llgo_2:                                          ; preds = %_llgo_1
+  %5 = call ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice" %0)
+  %6 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.iface", ptr %5, i64 %3
+  %7 = load %"github.com/goplus/llgo/internal/runtime.iface", ptr %6, align 8
+  %8 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 2)
+  %9 = call i64 @"github.com/goplus/llgo/internal/runtime.I2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %7, ptr %8)
+  %10 = call i32 (ptr, ...) @printf(ptr @0, i64 %9)
+  br label %_llgo_1
+
+_llgo_3:                                          ; preds = %_llgo_1
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64)
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64)
+
+declare %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr, i64)
+
+declare %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr, i64, i64, i64, i64, i64)
+
+declare i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice")
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice")
+
+declare i64 @"github.com/goplus/llgo/internal/runtime.I2Int"(%"github.com/goplus/llgo/internal/runtime.iface", ptr)
+
+declare i32 @printf(ptr, ...)

cl/_testdata/varinit/out.ll

@@ -1,29 +1,36 @@
 ; ModuleID = 'main'
 source_filename = "main"
 
-@"init$guard" = global ptr null
-@a = global ptr null
+@main.a = global ptr null
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
 
-define void @init() {
+define void @main.init() {
 _llgo_0:
-  %0 = load i1, ptr @"init$guard", align 1
+  %0 = load i1, ptr @"main.init$guard", align 1
   br i1 %0, label %_llgo_2, label %_llgo_1
 
 _llgo_1:                                          ; preds = %_llgo_0
-  store i1 true, ptr @"init$guard", align 1
-  store i64 100, ptr @a, align 4
+  store i1 true, ptr @"main.init$guard", align 1
+  store i64 100, ptr @main.a, align 4
   br label %_llgo_2
 
 _llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
   ret void
 }
 
-define void @main() {
+define void @main(i32 %0, ptr %1) {
 _llgo_0:
-  call void @init()
-  %0 = load i64, ptr @a, align 4
-  %1 = add i64 %0, 1
-  store i64 %1, ptr @a, align 4
-  %2 = load i64, ptr @a, align 4
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = load i64, ptr @main.a, align 4
+  %3 = add i64 %2, 1
+  store i64 %3, ptr @main.a, align 4
+  %4 = load i64, ptr @main.a, align 4
   ret void
 }
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()

cl/_testlibc/argv/in.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+)
+
+func main() {
+	for i := c.Int(0); i < c.Argc; i++ {
+		c.Printf(c.Str("%s\n"), c.Index(c.Argv, i))
+	}
+}

cl/_testlibc/argv/out.ll

@@ -0,0 +1,50 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  br label %_llgo_3
+
+_llgo_1:                                          ; preds = %_llgo_3
+  %2 = load ptr, ptr @__llgo_argv, align 8
+  %3 = getelementptr ptr, ptr %2, i32 %7
+  %4 = load ptr, ptr %3, align 8
+  %5 = call i32 (ptr, ...) @printf(ptr @0, ptr %4)
+  %6 = add i32 %7, 1
+  br label %_llgo_3
+
+_llgo_2:                                          ; preds = %_llgo_3
+  ret void
+
+_llgo_3:                                          ; preds = %_llgo_1, %_llgo_0
+  %7 = phi i32 [ 0, %_llgo_0 ], [ %6, %_llgo_1 ]
+  %8 = load i32, ptr @__llgo_argc, align 4
+  %9 = icmp slt i32 %7, %8
+  br i1 %9, label %_llgo_1, label %_llgo_2
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare i32 @printf(ptr, ...)

cl/_testlibc/sqlite/in.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/x/sqlite"
+)
+
+func main() {
+	db, err := sqlite.OpenV2(c.Str(":memory:"), sqlite.OpenReadWrite|sqlite.OpenMemory, nil)
+	check(err)
+
+	db.Close()
+}
+
+func check(err sqlite.Errno) {
+	if err != sqlite.OK {
+		c.Printf(c.Str("==> Error: (%d) %s\n"), err, err.Errstr())
+		c.Exit(1)
+	}
+}

cl/_testlibc/sqlite/out.ll

@@ -0,0 +1,62 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@"main.init$guard" = global ptr null
+@0 = private unnamed_addr constant [20 x i8] c"==> Error: (%d) %s\0A\00", align 1
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@1 = private unnamed_addr constant [9 x i8] c":memory:\00", align 1
+
+define void @main.check(i32 %0) {
+_llgo_0:
+  %1 = icmp ne i32 %0, 0
+  br i1 %1, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %2 = call ptr @sqlite3_errstr(i32 %0)
+  %3 = call i32 (ptr, ...) @printf(ptr @0, i32 %0, ptr %2)
+  call void @exit(i32 1)
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call { ptr, i32 } @"github.com/goplus/llgo/x/sqlite.OpenV2"(ptr @1, i32 130, ptr null)
+  %3 = extractvalue { ptr, i32 } %2, 0
+  %4 = extractvalue { ptr, i32 } %2, 1
+  call void @main.check(i32 %4)
+  %5 = call i32 @sqlite3_close(ptr %3)
+  ret void
+}
+
+declare ptr @sqlite3_errstr(i32)
+
+declare i32 @printf(ptr, ...)
+
+declare void @exit(i32)
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare { ptr, i32 } @"github.com/goplus/llgo/x/sqlite.OpenV2"(ptr, i32, ptr)
+
+declare i32 @sqlite3_close(ptr)

cl/_testpy/callpy/in.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/py"
+	"github.com/goplus/llgo/py/math"
+	"github.com/goplus/llgo/py/os"
+)
+
+func main() {
+	x := math.Sqrt(py.Float(2))
+	wd := os.Getcwd()
+	c.Printf(c.Str("sqrt(2) = %f\n"), x.Float64())
+	c.Printf(c.Str("cwd = %s\n"), wd.CStr())
+}

cl/_testpy/callpy/out.ll

@@ -0,0 +1,74 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@__llgo_py.math.sqrt = linkonce global ptr null
+@__llgo_py.os.getcwd = linkonce global ptr null
+@0 = private unnamed_addr constant [14 x i8] c"sqrt(2) = %f\0A\00", align 1
+@1 = private unnamed_addr constant [10 x i8] c"cwd = %s\0A\00", align 1
+@__llgo_py.math = external global ptr
+@2 = private unnamed_addr constant [5 x i8] c"sqrt\00", align 1
+@__llgo_py.os = external global ptr
+@3 = private unnamed_addr constant [7 x i8] c"getcwd\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  call void @"github.com/goplus/llgo/py/math.init"()
+  call void @"github.com/goplus/llgo/py/os.init"()
+  %1 = load ptr, ptr @__llgo_py.math, align 8
+  call void (ptr, ...) @llgoLoadPyModSyms(ptr %1, ptr @2, ptr @__llgo_py.math.sqrt, ptr null)
+  %2 = load ptr, ptr @__llgo_py.os, align 8
+  call void (ptr, ...) @llgoLoadPyModSyms(ptr %2, ptr @3, ptr @__llgo_py.os.getcwd, ptr null)
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  call void @Py_Initialize()
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call ptr @PyFloat_FromDouble(double 2.000000e+00)
+  %3 = load ptr, ptr @__llgo_py.math.sqrt, align 8
+  %4 = call ptr @PyObject_CallOneArg(ptr %3, ptr %2)
+  %5 = load ptr, ptr @__llgo_py.os.getcwd, align 8
+  %6 = call ptr @PyObject_CallNoArgs(ptr %5)
+  %7 = call double @PyFloat_AsDouble(ptr %4)
+  %8 = call i32 (ptr, ...) @printf(ptr @0, double %7)
+  %9 = call ptr @PyBytes_AsString(ptr %6)
+  %10 = call i32 (ptr, ...) @printf(ptr @1, ptr %9)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/py/math.init"()
+
+declare void @"github.com/goplus/llgo/py/os.init"()
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare ptr @PyFloat_FromDouble(double)
+
+declare ptr @PyObject_CallOneArg(ptr, ptr)
+
+declare ptr @PyObject_CallNoArgs(ptr)
+
+declare double @PyFloat_AsDouble(ptr)
+
+declare i32 @printf(ptr, ...)
+
+declare ptr @PyBytes_AsString(ptr)
+
+declare void @llgoLoadPyModSyms(ptr, ...)
+
+declare void @Py_Initialize()

cl/_testpy/math/in.go

@@ -0,0 +1,14 @@
+package math
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/py"
+)
+
+const (
+	LLGoPackage = "py.math"
+)
+
+//go:linkname Sqrt py.sqrt
+func Sqrt(x *py.Object) *py.Object

cl/_testpy/math/out.ll

@@ -0,0 +1,29 @@
+; ModuleID = 'math'
+source_filename = "math"
+
+@__llgo_py.math.sqrt = external global ptr
+@"math.init$guard" = global ptr null
+@__llgo_py.math = linkonce global ptr null
+@0 = private unnamed_addr constant [5 x i8] c"math\00", align 1
+
+define void @math.init() {
+_llgo_0:
+  %0 = load i1, ptr @"math.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"math.init$guard", align 1
+  %1 = load ptr, ptr @__llgo_py.math, align 8
+  %2 = icmp ne ptr %1, null
+  br i1 %2, label %_llgo_2, label %_llgo_3
+
+_llgo_2:                                          ; preds = %_llgo_3, %_llgo_1, %_llgo_0
+  ret void
+
+_llgo_3:                                          ; preds = %_llgo_1
+  %3 = call ptr @PyImport_ImportModule(ptr @0)
+  store ptr %3, ptr @__llgo_py.math, align 8
+  br label %_llgo_2
+}
+
+declare ptr @PyImport_ImportModule(ptr)

cl/_testrt/alloca/in.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"github.com/goplus/llgo/internal/runtime/c"
+)
+
+func main() {
+	s := c.Str("Hi\n")
+	s2 := c.Alloca(4)
+	c.Memcpy(s2, c.Pointer(s), 4)
+	c.Printf(c.Str("%s"), s2)
+}

cl/_testrt/alloca/out.ll

@@ -0,0 +1,39 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [4 x i8] c"Hi\0A\00", align 1
+@1 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = alloca i8, i64 4, align 1
+  %3 = call ptr @memcpy(ptr %2, ptr @0, i64 4)
+  %4 = call i32 (ptr, ...) @printf(ptr @1, ptr %2)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare ptr @memcpy(ptr, ptr, i64)
+
+declare i32 @printf(ptr, ...)

cl/_testrt/allocstr/in.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"github.com/goplus/llgo/internal/runtime/c"
+)
+
+func hello() string {
+	return "Hello world\n"
+}
+
+func main() {
+	c.Printf(c.AllocaCStr(hello()))
+}

cl/_testrt/allocstr/out.ll

@@ -0,0 +1,51 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%"github.com/goplus/llgo/internal/runtime.String" = type { ptr, i64 }
+
+@"main.init$guard" = global ptr null
+@0 = private unnamed_addr constant [13 x i8] c"Hello world\0A\00", align 1
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+
+define %"github.com/goplus/llgo/internal/runtime.String" @main.hello() {
+_llgo_0:
+  %0 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @0, i64 12)
+  ret %"github.com/goplus/llgo/internal/runtime.String" %0
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call %"github.com/goplus/llgo/internal/runtime.String" @main.hello()
+  %3 = extractvalue %"github.com/goplus/llgo/internal/runtime.String" %2, 1
+  %4 = add i64 %3, 1
+  %5 = alloca i8, i64 %4, align 1
+  %6 = call ptr @"github.com/goplus/llgo/internal/runtime.CStrCopy"(ptr %5, %"github.com/goplus/llgo/internal/runtime.String" %2)
+  %7 = call i32 (ptr, ...) @printf(ptr %6)
+  ret void
+}
+
+declare %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr, i64)
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.CStrCopy"(ptr, %"github.com/goplus/llgo/internal/runtime.String")
+
+declare i32 @printf(ptr, ...)

cl/_testrt/any/in.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"github.com/goplus/llgo/internal/runtime/c"
+)
+
+func incVal(a any) int {
+	return a.(int) + 1
+}
+
+func main() {
+	c.Printf(c.Str("Hello %d\n"), incVal(100))
+}

cl/_testrt/any/out.ll

@@ -0,0 +1,53 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%"github.com/goplus/llgo/internal/runtime.iface" = type { ptr, ptr }
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [10 x i8] c"Hello %d\0A\00", align 1
+
+define i64 @main.incVal(%"github.com/goplus/llgo/internal/runtime.iface" %0) {
+_llgo_0:
+  %1 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 2)
+  %2 = call i64 @"github.com/goplus/llgo/internal/runtime.I2Int"(%"github.com/goplus/llgo/internal/runtime.iface" %0, ptr %1)
+  %3 = add i64 %2, 1
+  ret i64 %3
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64 2)
+  %3 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr %2, i64 100)
+  %4 = call i64 @main.incVal(%"github.com/goplus/llgo/internal/runtime.iface" %3)
+  %5 = call i32 (ptr, ...) @printf(ptr @0, i64 %4)
+  ret void
+}
+
+declare i64 @"github.com/goplus/llgo/internal/runtime.I2Int"(%"github.com/goplus/llgo/internal/runtime.iface", ptr)
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.Basic"(i64)
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyInt"(ptr, i64)
+
+declare i32 @printf(ptr, ...)

cl/_testrt/builtin/in.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"github.com/goplus/llgo/internal/runtime/c"
+)
+
+var a int64 = 1<<63 - 1
+var b int64 = -1 << 63
+var n uint64 = 1<<64 - 1
+
+func main() {
+	var s = []int{1, 2, 3, 4}
+	var a = [...]int{1, 2, 3, 4}
+
+	out(len(s))
+	out(len([]int{1, 2, 3, 4}))
+	out(len(a))
+	out(len(&a))
+	out(len([4]int{1, 2, 3, 4}))
+
+	out(cap(s))
+	out(cap(a))
+	out(cap(&a))
+
+	out(len(s[1:]))
+	out(cap(s[1:]))
+	out(len(s[1:2]))
+	out(cap(s[1:2]))
+	out(len(s[1:2:2]))
+	out(cap(s[1:2:2]))
+
+	out(len(a[1:]))
+	out(cap(a[1:]))
+	out(len(a[1:2]))
+	out(cap(a[1:2]))
+	out(len(a[1:2:2]))
+	out(cap(a[1:2:2]))
+
+	string_len("hello")
+	string_len("hello"[1:])
+	string_len("hello"[1:2])
+	string_len("hello"[5:])
+}
+
+func string_len(s string) {
+	out(len(s))
+}
+
+func out(n int) {
+	c.Printf(c.Str("%d\n"), n)
+}

cl/_testrt/builtin/out.ll

@@ -0,0 +1,176 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%"github.com/goplus/llgo/internal/runtime.Slice" = type { ptr, i64, i64 }
+%"github.com/goplus/llgo/internal/runtime.String" = type { ptr, i64 }
+
+@main.a = global ptr null
+@main.b = global ptr null
+@"main.init$guard" = global ptr null
+@main.n = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [6 x i8] c"hello\00", align 1
+@1 = private unnamed_addr constant [6 x i8] c"hello\00", align 1
+@2 = private unnamed_addr constant [6 x i8] c"hello\00", align 1
+@3 = private unnamed_addr constant [6 x i8] c"hello\00", align 1
+@4 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  store i64 9223372036854775807, ptr @main.a, align 4
+  store i64 -9223372036854775808, ptr @main.b, align 4
+  store i64 -1, ptr @main.n, align 4
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 32)
+  %3 = getelementptr inbounds i64, ptr %2, i64 0
+  store i64 1, ptr %3, align 4
+  %4 = getelementptr inbounds i64, ptr %2, i64 1
+  store i64 2, ptr %4, align 4
+  %5 = getelementptr inbounds i64, ptr %2, i64 2
+  store i64 3, ptr %5, align 4
+  %6 = getelementptr inbounds i64, ptr %2, i64 3
+  store i64 4, ptr %6, align 4
+  %7 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %2, i64 8, i64 4, i64 0, i64 4, i64 4)
+  %8 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 32)
+  %9 = getelementptr inbounds i64, ptr %8, i64 0
+  %10 = getelementptr inbounds i64, ptr %8, i64 1
+  %11 = getelementptr inbounds i64, ptr %8, i64 2
+  %12 = getelementptr inbounds i64, ptr %8, i64 3
+  store i64 1, ptr %9, align 4
+  store i64 2, ptr %10, align 4
+  store i64 3, ptr %11, align 4
+  store i64 4, ptr %12, align 4
+  %13 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  call void @main.out(i64 %13)
+  %14 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 32)
+  %15 = getelementptr inbounds i64, ptr %14, i64 0
+  store i64 1, ptr %15, align 4
+  %16 = getelementptr inbounds i64, ptr %14, i64 1
+  store i64 2, ptr %16, align 4
+  %17 = getelementptr inbounds i64, ptr %14, i64 2
+  store i64 3, ptr %17, align 4
+  %18 = getelementptr inbounds i64, ptr %14, i64 3
+  store i64 4, ptr %18, align 4
+  %19 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %14, i64 8, i64 4, i64 0, i64 4, i64 4)
+  %20 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %19)
+  call void @main.out(i64 %20)
+  call void @main.out(i64 4)
+  call void @main.out(i64 4)
+  call void @main.out(i64 4)
+  %21 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  call void @main.out(i64 %21)
+  call void @main.out(i64 4)
+  call void @main.out(i64 4)
+  %22 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %23 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %24 = call ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %25 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %24, i64 8, i64 %22, i64 1, i64 %23, i64 %22)
+  %26 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %25)
+  call void @main.out(i64 %26)
+  %27 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %28 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %29 = call ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %30 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %29, i64 8, i64 %27, i64 1, i64 %28, i64 %27)
+  %31 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice" %30)
+  call void @main.out(i64 %31)
+  %32 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %33 = call ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %34 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %33, i64 8, i64 %32, i64 1, i64 2, i64 %32)
+  %35 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %34)
+  call void @main.out(i64 %35)
+  %36 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %37 = call ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %38 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %37, i64 8, i64 %36, i64 1, i64 2, i64 %36)
+  %39 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice" %38)
+  call void @main.out(i64 %39)
+  %40 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %41 = call ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %42 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %41, i64 8, i64 %40, i64 1, i64 2, i64 2)
+  %43 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %42)
+  call void @main.out(i64 %43)
+  %44 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %45 = call ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice" %7)
+  %46 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %45, i64 8, i64 %44, i64 1, i64 2, i64 2)
+  %47 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice" %46)
+  call void @main.out(i64 %47)
+  %48 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %8, i64 8, i64 4, i64 1, i64 4, i64 4)
+  %49 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %48)
+  call void @main.out(i64 %49)
+  %50 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %8, i64 8, i64 4, i64 1, i64 4, i64 4)
+  %51 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice" %50)
+  call void @main.out(i64 %51)
+  %52 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %8, i64 8, i64 4, i64 1, i64 2, i64 4)
+  %53 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %52)
+  call void @main.out(i64 %53)
+  %54 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %8, i64 8, i64 4, i64 1, i64 2, i64 4)
+  %55 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice" %54)
+  call void @main.out(i64 %55)
+  %56 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %8, i64 8, i64 4, i64 1, i64 2, i64 2)
+  %57 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %56)
+  call void @main.out(i64 %57)
+  %58 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %8, i64 8, i64 4, i64 1, i64 2, i64 2)
+  %59 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice" %58)
+  call void @main.out(i64 %59)
+  %60 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @0, i64 5)
+  call void @main.string_len(%"github.com/goplus/llgo/internal/runtime.String" %60)
+  %61 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @1, i64 5)
+  %62 = extractvalue %"github.com/goplus/llgo/internal/runtime.String" %61, 1
+  %63 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewStringSlice"(%"github.com/goplus/llgo/internal/runtime.String" %61, i64 1, i64 %62)
+  call void @main.string_len(%"github.com/goplus/llgo/internal/runtime.String" %63)
+  %64 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @2, i64 5)
+  %65 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewStringSlice"(%"github.com/goplus/llgo/internal/runtime.String" %64, i64 1, i64 2)
+  call void @main.string_len(%"github.com/goplus/llgo/internal/runtime.String" %65)
+  %66 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @3, i64 5)
+  %67 = extractvalue %"github.com/goplus/llgo/internal/runtime.String" %66, 1
+  %68 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewStringSlice"(%"github.com/goplus/llgo/internal/runtime.String" %66, i64 5, i64 %67)
+  call void @main.string_len(%"github.com/goplus/llgo/internal/runtime.String" %68)
+  ret void
+}
+
+define void @main.out(i64 %0) {
+_llgo_0:
+  %1 = call i32 (ptr, ...) @printf(ptr @4, i64 %0)
+  ret void
+}
+
+define void @main.string_len(%"github.com/goplus/llgo/internal/runtime.String" %0) {
+_llgo_0:
+  %1 = extractvalue %"github.com/goplus/llgo/internal/runtime.String" %0, 1
+  call void @main.out(i64 %1)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64)
+
+declare %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr, i64, i64, i64, i64, i64)
+
+declare i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice")
+
+declare i64 @"github.com/goplus/llgo/internal/runtime.SliceCap"(%"github.com/goplus/llgo/internal/runtime.Slice")
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice")
+
+declare %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr, i64)
+
+declare %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewStringSlice"(%"github.com/goplus/llgo/internal/runtime.String", i64, i64)
+
+declare i32 @printf(ptr, ...)

cl/_testrt/callback/in.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"github.com/goplus/llgo/internal/runtime/c"
+)
+
+func callback(msg *c.Char, f func(*c.Char)) {
+	f(msg)
+}
+
+func print(msg *c.Char) {
+	c.Printf(msg)
+}
+
+func main() {
+	callback(c.Str("Hello\n"), print)
+	callback(c.Str("callback\n"), print)
+}

cl/_testrt/callback/out.ll

@@ -0,0 +1,68 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [7 x i8] c"Hello\0A\00", align 1
+@1 = private unnamed_addr constant [10 x i8] c"callback\0A\00", align 1
+
+define void @main.callback(ptr %0, { ptr, ptr } %1) {
+_llgo_0:
+  %2 = extractvalue { ptr, ptr } %1, 1
+  %3 = extractvalue { ptr, ptr } %1, 0
+  call void %3(ptr %2, ptr %0)
+  ret void
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = alloca { ptr, ptr }, align 8
+  %3 = getelementptr inbounds { ptr, ptr }, ptr %2, i32 0, i32 0
+  store ptr @__llgo_stub.main.print, ptr %3, align 8
+  %4 = getelementptr inbounds { ptr, ptr }, ptr %2, i32 0, i32 1
+  store ptr null, ptr %4, align 8
+  %5 = load { ptr, ptr }, ptr %2, align 8
+  call void @main.callback(ptr @0, { ptr, ptr } %5)
+  %6 = alloca { ptr, ptr }, align 8
+  %7 = getelementptr inbounds { ptr, ptr }, ptr %6, i32 0, i32 0
+  store ptr @__llgo_stub.main.print, ptr %7, align 8
+  %8 = getelementptr inbounds { ptr, ptr }, ptr %6, i32 0, i32 1
+  store ptr null, ptr %8, align 8
+  %9 = load { ptr, ptr }, ptr %6, align 8
+  call void @main.callback(ptr @1, { ptr, ptr } %9)
+  ret void
+}
+
+define void @main.print(ptr %0) {
+_llgo_0:
+  %1 = call i32 (ptr, ...) @printf(ptr %0)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+define linkonce void @__llgo_stub.main.print(ptr %0, ptr %1) {
+_llgo_0:
+  tail call void @main.print(ptr %1)
+  ret void
+}
+
+declare i32 @printf(ptr, ...)

cl/_testrt/cast/in.go

@@ -0,0 +1,158 @@
+package main
+
+//"github.com/goplus/llgo/internal/runtime/c"
+
+func main() {
+	cvt64to8(0, 0)
+	cvt64to8(127, 127)
+	cvt64to8(128, -128)
+	cvt64to8(-128, -128)
+	cvt64to8(-129, 127)
+	cvt64to8(256, 0)
+
+	cvt64to8U(0, 0)
+	cvt64to8U(255, 255)
+	cvt64to8U(256, 0)
+	cvt64to8U(257, 1)
+	cvt64to8U(-1, 255)
+
+	cvt32Fto8(0.1, 0)
+	cvt32Fto8(127.1, 127)
+	cvt32Fto8(128.1, -128)
+	cvt32Fto8(-128.1, -128)
+	cvt32Fto8(-129.1, 127)
+	cvt32Fto8(256.1, 0)
+
+	cvt32Fto8U(0, 0)
+	cvt32Fto8U(255, 255)
+	cvt32Fto8U(256, 0)
+	cvt32Fto8U(257, 1)
+	cvt32Fto8U(-1, 255)
+
+	// MaxInt32  = 1<<31 - 1           // 2147483647
+	// MinInt32  = -1 << 31            // -2147483648
+	cvt32Fto32(0, 0)
+	cvt32Fto32(1.5, 1)
+	cvt32Fto32(1147483647.1, 1147483648)
+	cvt32Fto32(2147483647.1, -2147483648)
+	cvt32Fto32(4147483647.1, -2147483648)
+	cvt32Fto32(-2147483648.1, -2147483648)
+	cvt32Fto32(-2147482648.1, -2147482624)
+
+	// MaxUint32 = 1<<32 - 1           // 4294967295
+	cvt32Fto32U(0, 0)
+	cvt32Fto32U(1.5, 1)
+	cvt32Fto32U(4294967295.1, 0)
+	cvt32Fto32U(5294967295.1, 1000000000)
+	cvt32Fto32U(-4294967295.1, 0)
+	cvt32Fto32U(-1294967295.1, 3000000000)
+	cvt32Fto32U(-1.1, 4294967295)
+
+	// MaxFloat32             = 0x1p127 * (1 + (1 - 0x1p-23)) // 3.40282346638528859811704183484516925440e+38
+	// SmallestNonzeroFloat32 = 0x1p-126 * 0x1p-23            // 1.401298464324817070923729583289916131280e-45
+	// MaxFloat64             = 0x1p1023 * (1 + (1 - 0x1p-52)) // 1.79769313486231570814527423731704356798070e+308
+	// SmallestNonzeroFloat64 = 0x1p-1022 * 0x1p-52            // 4.9406564584124654417656879286822137236505980e-324
+
+	cvt32Fto64F(0, 0)
+	cvt32Fto64F(1.5, 1.5)
+	cvt32Fto64F(1e10, 1e10)
+	cvt32Fto64F(-1e10, -1e10)
+
+	cvt64Fto32F(0, 0)
+	cvt64Fto32F(1.5, 1.5)
+	cvt64Fto32F(1e10, 1e10)
+	cvt64Fto32F(-1e10, -1e10)
+
+	// MaxInt64  = 1<<63 - 1           // 9223372036854775807
+	// MinInt64  = -1 << 63            // -9223372036854775808
+	cvt64to64F(0, 0)
+	cvt64to64F(1e10, 1e10)
+	cvt64to64F(9223372036854775807, 9223372036854775807)
+	cvt64to64F(-9223372036854775807, -9223372036854775807)
+
+	// MaxUint64 = 1<<64 - 1           // 18446744073709551615
+	cvt64Uto64F(0, 0)
+	cvt64Uto64F(1e10, 1e10)
+	cvt64Uto64F(9223372036854775807, 9223372036854775807)
+	cvt64Uto64F(18446744073709551615, 18446744073709551615)
+
+	cvt32to64(0, 0)
+	cvt32to64(2147483647, 2147483647)
+
+	cvtUinptr(1024, 1024)
+}
+
+func cvtUinptr(a int32, b uintptr) {
+	if uintptr(a) != b {
+		panic("error")
+	}
+	if int32(b) != a {
+		panic("error")
+	}
+}
+
+func cvt32to64(a int32, b int64) {
+	if int64(a) != b {
+		panic("error")
+	}
+}
+
+func cvt64to64F(a int64, b float64) {
+	if float64(a) != b {
+		panic("error")
+	}
+}
+
+func cvt64Uto64F(a uint64, b float64) {
+	if float64(a) != b {
+		panic("error")
+	}
+}
+
+func cvt64Fto32F(a float64, b float32) {
+	if float32(a) != b {
+		panic("error")
+	}
+}
+
+func cvt32Fto64F(a float32, b float64) {
+	if float64(a) != b {
+		panic("error")
+	}
+}
+
+func cvt32Fto32(a float32, b int32) {
+	if int32(a) != b {
+		panic("error")
+	}
+}
+
+func cvt32Fto32U(a float32, b uint32) {
+	if uint32(a) != b {
+		panic("error")
+	}
+}
+
+func cvt32Fto8(a float32, b int8) {
+	if int8(a) != b {
+		panic("error")
+	}
+}
+
+func cvt32Fto8U(a float32, b uint8) {
+	if uint8(a) != b {
+		panic("error")
+	}
+}
+
+func cvt64to8(a int64, b int8) {
+	if int8(a) != b {
+		panic("error")
+	}
+}
+
+func cvt64to8U(a int, b uint8) {
+	if uint8(a) != b {
+		panic("error")
+	}
+}

cl/_testrt/cast/out.ll

@@ -0,0 +1,310 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%"github.com/goplus/llgo/internal/runtime.String" = type { ptr, i64 }
+%"github.com/goplus/llgo/internal/runtime.iface" = type { ptr, ptr }
+
+@"main.init$guard" = global ptr null
+@0 = private unnamed_addr constant [6 x i8] c"error\00", align 1
+@1 = private unnamed_addr constant [6 x i8] c"error\00", align 1
+@2 = private unnamed_addr constant [6 x i8] c"error\00", align 1
+@3 = private unnamed_addr constant [6 x i8] c"error\00", align 1
+@4 = private unnamed_addr constant [6 x i8] c"error\00", align 1
+@5 = private unnamed_addr constant [6 x i8] c"error\00", align 1
+@6 = private unnamed_addr constant [6 x i8] c"error\00", align 1
+@7 = private unnamed_addr constant [6 x i8] c"error\00", align 1
+@8 = private unnamed_addr constant [6 x i8] c"error\00", align 1
+@9 = private unnamed_addr constant [6 x i8] c"error\00", align 1
+@10 = private unnamed_addr constant [6 x i8] c"error\00", align 1
+@11 = private unnamed_addr constant [6 x i8] c"error\00", align 1
+@12 = private unnamed_addr constant [6 x i8] c"error\00", align 1
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+
+define void @main.cvt32Fto32(float %0, i32 %1) {
+_llgo_0:
+  %2 = fptosi float %0 to i32
+  %3 = icmp ne i32 %2, %1
+  br i1 %3, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %4 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @0, i64 5)
+  %5 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %4)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %5)
+  unreachable
+
+_llgo_2:                                          ; preds = %_llgo_0
+  ret void
+}
+
+define void @main.cvt32Fto32U(float %0, i32 %1) {
+_llgo_0:
+  %2 = fptoui float %0 to i32
+  %3 = icmp ne i32 %2, %1
+  br i1 %3, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %4 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @1, i64 5)
+  %5 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %4)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %5)
+  unreachable
+
+_llgo_2:                                          ; preds = %_llgo_0
+  ret void
+}
+
+define void @main.cvt32Fto64F(float %0, double %1) {
+_llgo_0:
+  %2 = fpext float %0 to double
+  %3 = fcmp one double %2, %1
+  br i1 %3, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %4 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @2, i64 5)
+  %5 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %4)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %5)
+  unreachable
+
+_llgo_2:                                          ; preds = %_llgo_0
+  ret void
+}
+
+define void @main.cvt32Fto8(float %0, i8 %1) {
+_llgo_0:
+  %2 = fptosi float %0 to i8
+  %3 = icmp ne i8 %2, %1
+  br i1 %3, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %4 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @3, i64 5)
+  %5 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %4)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %5)
+  unreachable
+
+_llgo_2:                                          ; preds = %_llgo_0
+  ret void
+}
+
+define void @main.cvt32Fto8U(float %0, i8 %1) {
+_llgo_0:
+  %2 = fptoui float %0 to i8
+  %3 = icmp ne i8 %2, %1
+  br i1 %3, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %4 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @4, i64 5)
+  %5 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %4)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %5)
+  unreachable
+
+_llgo_2:                                          ; preds = %_llgo_0
+  ret void
+}
+
+define void @main.cvt32to64(i32 %0, i64 %1) {
+_llgo_0:
+  %2 = sext i32 %0 to i64
+  %3 = icmp ne i64 %2, %1
+  br i1 %3, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %4 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @5, i64 5)
+  %5 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %4)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %5)
+  unreachable
+
+_llgo_2:                                          ; preds = %_llgo_0
+  ret void
+}
+
+define void @main.cvt64Fto32F(double %0, float %1) {
+_llgo_0:
+  %2 = fptrunc double %0 to float
+  %3 = fcmp one float %2, %1
+  br i1 %3, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %4 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @6, i64 5)
+  %5 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %4)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %5)
+  unreachable
+
+_llgo_2:                                          ; preds = %_llgo_0
+  ret void
+}
+
+define void @main.cvt64Uto64F(i64 %0, double %1) {
+_llgo_0:
+  %2 = uitofp i64 %0 to double
+  %3 = fcmp one double %2, %1
+  br i1 %3, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %4 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @7, i64 5)
+  %5 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %4)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %5)
+  unreachable
+
+_llgo_2:                                          ; preds = %_llgo_0
+  ret void
+}
+
+define void @main.cvt64to64F(i64 %0, double %1) {
+_llgo_0:
+  %2 = sitofp i64 %0 to double
+  %3 = fcmp one double %2, %1
+  br i1 %3, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %4 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @8, i64 5)
+  %5 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %4)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %5)
+  unreachable
+
+_llgo_2:                                          ; preds = %_llgo_0
+  ret void
+}
+
+define void @main.cvt64to8(i64 %0, i8 %1) {
+_llgo_0:
+  %2 = trunc i64 %0 to i8
+  %3 = icmp ne i8 %2, %1
+  br i1 %3, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %4 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @9, i64 5)
+  %5 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %4)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %5)
+  unreachable
+
+_llgo_2:                                          ; preds = %_llgo_0
+  ret void
+}
+
+define void @main.cvt64to8U(i64 %0, i8 %1) {
+_llgo_0:
+  %2 = trunc i64 %0 to i8
+  %3 = icmp ne i8 %2, %1
+  br i1 %3, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %4 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @10, i64 5)
+  %5 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %4)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %5)
+  unreachable
+
+_llgo_2:                                          ; preds = %_llgo_0
+  ret void
+}
+
+define void @main.cvtUinptr(i32 %0, i64 %1) {
+_llgo_0:
+  %2 = sext i32 %0 to i64
+  %3 = icmp ne i64 %2, %1
+  br i1 %3, label %_llgo_1, label %_llgo_2
+
+_llgo_1:                                          ; preds = %_llgo_0
+  %4 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @11, i64 5)
+  %5 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %4)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %5)
+  unreachable
+
+_llgo_2:                                          ; preds = %_llgo_0
+  %6 = trunc i64 %1 to i32
+  %7 = icmp ne i32 %6, %0
+  br i1 %7, label %_llgo_3, label %_llgo_4
+
+_llgo_3:                                          ; preds = %_llgo_2
+  %8 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @12, i64 5)
+  %9 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %8)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %9)
+  unreachable
+
+_llgo_4:                                          ; preds = %_llgo_2
+  ret void
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  call void @main.cvt64to8(i64 0, i8 0)
+  call void @main.cvt64to8(i64 127, i8 127)
+  call void @main.cvt64to8(i64 128, i8 -128)
+  call void @main.cvt64to8(i64 -128, i8 -128)
+  call void @main.cvt64to8(i64 -129, i8 127)
+  call void @main.cvt64to8(i64 256, i8 0)
+  call void @main.cvt64to8U(i64 0, i8 0)
+  call void @main.cvt64to8U(i64 255, i8 -1)
+  call void @main.cvt64to8U(i64 256, i8 0)
+  call void @main.cvt64to8U(i64 257, i8 1)
+  call void @main.cvt64to8U(i64 -1, i8 -1)
+  call void @main.cvt32Fto8(float 0x3FB99999A0000000, i8 0)
+  call void @main.cvt32Fto8(float 0x405FC66660000000, i8 127)
+  call void @main.cvt32Fto8(float 0x4060033340000000, i8 -128)
+  call void @main.cvt32Fto8(float 0xC060033340000000, i8 -128)
+  call void @main.cvt32Fto8(float 0xC060233340000000, i8 127)
+  call void @main.cvt32Fto8(float 0x40700199A0000000, i8 0)
+  call void @main.cvt32Fto8U(float 0.000000e+00, i8 0)
+  call void @main.cvt32Fto8U(float 2.550000e+02, i8 -1)
+  call void @main.cvt32Fto8U(float 2.560000e+02, i8 0)
+  call void @main.cvt32Fto8U(float 2.570000e+02, i8 1)
+  call void @main.cvt32Fto8U(float -1.000000e+00, i8 -1)
+  call void @main.cvt32Fto32(float 0.000000e+00, i32 0)
+  call void @main.cvt32Fto32(float 1.500000e+00, i32 1)
+  call void @main.cvt32Fto32(float 0x41D1194D80000000, i32 1147483648)
+  call void @main.cvt32Fto32(float 0x41E0000000000000, i32 -2147483648)
+  call void @main.cvt32Fto32(float 0x41EEE6B280000000, i32 -2147483648)
+  call void @main.cvt32Fto32(float 0xC1E0000000000000, i32 -2147483648)
+  call void @main.cvt32Fto32(float 0xC1DFFFFF00000000, i32 -2147482624)
+  call void @main.cvt32Fto32U(float 0.000000e+00, i32 0)
+  call void @main.cvt32Fto32U(float 1.500000e+00, i32 1)
+  call void @main.cvt32Fto32U(float 0x41F0000000000000, i32 0)
+  call void @main.cvt32Fto32U(float 0x41F3B9ACA0000000, i32 1000000000)
+  call void @main.cvt32Fto32U(float 0xC1F0000000000000, i32 0)
+  call void @main.cvt32Fto32U(float 0xC1D34BE880000000, i32 -1294967296)
+  call void @main.cvt32Fto32U(float 0xBFF19999A0000000, i32 -1)
+  call void @main.cvt32Fto64F(float 0.000000e+00, double 0.000000e+00)
+  call void @main.cvt32Fto64F(float 1.500000e+00, double 1.500000e+00)
+  call void @main.cvt32Fto64F(float 1.000000e+10, double 1.000000e+10)
+  call void @main.cvt32Fto64F(float -1.000000e+10, double -1.000000e+10)
+  call void @main.cvt64Fto32F(double 0.000000e+00, float 0.000000e+00)
+  call void @main.cvt64Fto32F(double 1.500000e+00, float 1.500000e+00)
+  call void @main.cvt64Fto32F(double 1.000000e+10, float 1.000000e+10)
+  call void @main.cvt64Fto32F(double -1.000000e+10, float -1.000000e+10)
+  call void @main.cvt64to64F(i64 0, double 0.000000e+00)
+  call void @main.cvt64to64F(i64 10000000000, double 1.000000e+10)
+  call void @main.cvt64to64F(i64 9223372036854775807, double 0x43E0000000000000)
+  call void @main.cvt64to64F(i64 -9223372036854775807, double 0xC3E0000000000000)
+  call void @main.cvt64Uto64F(i64 0, double 0.000000e+00)
+  call void @main.cvt64Uto64F(i64 10000000000, double 1.000000e+10)
+  call void @main.cvt64Uto64F(i64 9223372036854775807, double 0x43E0000000000000)
+  call void @main.cvt64Uto64F(i64 -1, double 0x43F0000000000000)
+  call void @main.cvt32to64(i32 0, i64 0)
+  call void @main.cvt32to64(i32 2147483647, i64 2147483647)
+  call void @main.cvtUinptr(i32 1024, i64 1024)
+  ret void
+}
+
+declare %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr, i64)
+
+declare %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String")
+
+declare void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface")
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()

cl/_testrt/closure/in.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"github.com/goplus/llgo/internal/runtime/c"
+)
+
+func main() {
+	func(n1, n2 int) {
+		c.Printf(c.Str("%d %d\n"), n1, n2)
+	}(100, 200)
+	fn1 := func(n1, n2 int) {
+		c.Printf(c.Str("%d %d\n"), n1, n2)
+	}
+	fn2 := func() {
+		fn1(100, 200)
+	}
+	fn2()
+}

cl/_testrt/closure/out.ll

@@ -0,0 +1,88 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [7 x i8] c"%d %d\0A\00", align 1
+@1 = private unnamed_addr constant [7 x i8] c"%d %d\0A\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  call void @"main.main$1"(i64 100, i64 200)
+  %2 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 16)
+  %3 = alloca { ptr, ptr }, align 8
+  %4 = getelementptr inbounds { ptr, ptr }, ptr %3, i32 0, i32 0
+  store ptr @"__llgo_stub.main.main$2", ptr %4, align 8
+  %5 = getelementptr inbounds { ptr, ptr }, ptr %3, i32 0, i32 1
+  store ptr null, ptr %5, align 8
+  %6 = load { ptr, ptr }, ptr %3, align 8
+  store { ptr, ptr } %6, ptr %2, align 8
+  %7 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
+  %8 = getelementptr inbounds { ptr }, ptr %7, i32 0, i32 0
+  store ptr %2, ptr %8, align 8
+  %9 = alloca { ptr, ptr }, align 8
+  %10 = getelementptr inbounds { ptr, ptr }, ptr %9, i32 0, i32 0
+  store ptr @"main.main$3", ptr %10, align 8
+  %11 = getelementptr inbounds { ptr, ptr }, ptr %9, i32 0, i32 1
+  store ptr %7, ptr %11, align 8
+  %12 = load { ptr, ptr }, ptr %9, align 8
+  %13 = extractvalue { ptr, ptr } %12, 1
+  %14 = extractvalue { ptr, ptr } %12, 0
+  call void %14(ptr %13)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+define void @"main.main$1"(i64 %0, i64 %1) {
+_llgo_0:
+  %2 = call i32 (ptr, ...) @printf(ptr @0, i64 %0, i64 %1)
+  ret void
+}
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64)
+
+define void @"main.main$2"(i64 %0, i64 %1) {
+_llgo_0:
+  %2 = call i32 (ptr, ...) @printf(ptr @1, i64 %0, i64 %1)
+  ret void
+}
+
+define linkonce void @"__llgo_stub.main.main$2"(ptr %0, i64 %1, i64 %2) {
+_llgo_0:
+  tail call void @"main.main$2"(i64 %1, i64 %2)
+  ret void
+}
+
+define void @"main.main$3"(ptr %0) {
+_llgo_0:
+  %1 = load { ptr }, ptr %0, align 8
+  %2 = extractvalue { ptr } %1, 0
+  %3 = load { ptr, ptr }, ptr %2, align 8
+  %4 = extractvalue { ptr, ptr } %3, 1
+  %5 = extractvalue { ptr, ptr } %3, 0
+  call void %5(ptr %4, i64 100, i64 200)
+  ret void
+}
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64)
+
+declare i32 @printf(ptr, ...)

cl/_testrt/concat/in.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"github.com/goplus/llgo/internal/runtime/c"
+)
+
+func concat(args ...string) (ret string) {
+	for _, v := range args {
+		ret += v
+	}
+	return
+}
+
+func main() {
+	result := concat("Hello", " ", "World")
+	c.Fprintf(c.Stderr, c.Str("Hi, %s\n"), c.AllocaCStr(result))
+}

cl/_testrt/concat/out.ll

@@ -0,0 +1,108 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%"github.com/goplus/llgo/internal/runtime.String" = type { ptr, i64 }
+%"github.com/goplus/llgo/internal/runtime.Slice" = type { ptr, i64, i64 }
+
+@"main.init$guard" = global ptr null
+@0 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@1 = private unnamed_addr constant [6 x i8] c"Hello\00", align 1
+@2 = private unnamed_addr constant [2 x i8] c" \00", align 1
+@3 = private unnamed_addr constant [6 x i8] c"World\00", align 1
+@__stderrp = external global ptr
+@4 = private unnamed_addr constant [8 x i8] c"Hi, %s\0A\00", align 1
+
+define %"github.com/goplus/llgo/internal/runtime.String" @main.concat(%"github.com/goplus/llgo/internal/runtime.Slice" %0) {
+_llgo_0:
+  %1 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %0)
+  %2 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @0, i64 0)
+  %3 = extractvalue %"github.com/goplus/llgo/internal/runtime.String" %2, 0
+  %4 = extractvalue %"github.com/goplus/llgo/internal/runtime.String" %2, 1
+  br label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_2, %_llgo_0
+  %5 = phi ptr [ %3, %_llgo_0 ], [ %18, %_llgo_2 ]
+  %6 = phi i64 [ %4, %_llgo_0 ], [ %19, %_llgo_2 ]
+  %7 = phi i64 [ -1, %_llgo_0 ], [ %12, %_llgo_2 ]
+  %8 = alloca %"github.com/goplus/llgo/internal/runtime.String", align 8
+  %9 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %8, i32 0, i32 0
+  store ptr %5, ptr %9, align 8
+  %10 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %8, i32 0, i32 1
+  store i64 %6, ptr %10, align 4
+  %11 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %8, align 8
+  %12 = add i64 %7, 1
+  %13 = icmp slt i64 %12, %1
+  br i1 %13, label %_llgo_2, label %_llgo_3
+
+_llgo_2:                                          ; preds = %_llgo_1
+  %14 = call ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice" %0)
+  %15 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %14, i64 %12
+  %16 = load %"github.com/goplus/llgo/internal/runtime.String", ptr %15, align 8
+  %17 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.StringCat"(%"github.com/goplus/llgo/internal/runtime.String" %11, %"github.com/goplus/llgo/internal/runtime.String" %16)
+  %18 = extractvalue %"github.com/goplus/llgo/internal/runtime.String" %17, 0
+  %19 = extractvalue %"github.com/goplus/llgo/internal/runtime.String" %17, 1
+  br label %_llgo_1
+
+_llgo_3:                                          ; preds = %_llgo_1
+  ret %"github.com/goplus/llgo/internal/runtime.String" %11
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 48)
+  %3 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %2, i64 0
+  %4 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @1, i64 5)
+  store %"github.com/goplus/llgo/internal/runtime.String" %4, ptr %3, align 8
+  %5 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %2, i64 1
+  %6 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @2, i64 1)
+  store %"github.com/goplus/llgo/internal/runtime.String" %6, ptr %5, align 8
+  %7 = getelementptr inbounds %"github.com/goplus/llgo/internal/runtime.String", ptr %2, i64 2
+  %8 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @3, i64 5)
+  store %"github.com/goplus/llgo/internal/runtime.String" %8, ptr %7, align 8
+  %9 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr %2, i64 16, i64 3, i64 0, i64 3, i64 3)
+  %10 = call %"github.com/goplus/llgo/internal/runtime.String" @main.concat(%"github.com/goplus/llgo/internal/runtime.Slice" %9)
+  %11 = load ptr, ptr @__stderrp, align 8
+  %12 = extractvalue %"github.com/goplus/llgo/internal/runtime.String" %10, 1
+  %13 = add i64 %12, 1
+  %14 = alloca i8, i64 %13, align 1
+  %15 = call ptr @"github.com/goplus/llgo/internal/runtime.CStrCopy"(ptr %14, %"github.com/goplus/llgo/internal/runtime.String" %10)
+  %16 = call i32 (ptr, ptr, ...) @fprintf(ptr %11, ptr @4, ptr %15)
+  ret void
+}
+
+declare i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice")
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice")
+
+declare %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.StringCat"(%"github.com/goplus/llgo/internal/runtime.String", %"github.com/goplus/llgo/internal/runtime.String")
+
+declare %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr, i64)
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64)
+
+declare %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice3"(ptr, i64, i64, i64, i64, i64)
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.CStrCopy"(ptr, %"github.com/goplus/llgo/internal/runtime.String")
+
+declare i32 @fprintf(ptr, ptr, ...)

cl/_testrt/cstr/in.go

@@ -0,0 +1,13 @@
+package main
+
+import _ "unsafe"
+
+//go:linkname cstr llgo.cstr
+func cstr(string) *int8
+
+//go:linkname printf C.printf
+func printf(format *int8, __llgo_va_list ...any)
+
+func main() {
+	printf(cstr("Hello, world\n"))
+}

cl/_testrt/cstr/out.ll

@@ -0,0 +1,34 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [14 x i8] c"Hello, world\0A\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  call void (ptr, ...) @printf(ptr @0)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare void @printf(ptr, ...)

cl/_testrt/cvar/in.go

@@ -0,0 +1,19 @@
+package main
+
+import _ "unsafe"
+
+//go:linkname barX _bar_x
+var barX struct {
+	Arr       [16]int8
+	Callbacks [2]func()
+}
+
+//go:linkname barY _bar_y
+var barY struct {
+	Arr [16]int8
+}
+
+func main() {
+	_ = barX
+	_ = barY
+}

cl/_testrt/cvar/out.ll

@@ -0,0 +1,34 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@_bar_x = external global ptr
+@_bar_y = external global ptr
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = load { [16 x i8], [2 x ptr] }, ptr @_bar_x, align 8
+  %3 = load { [16 x i8] }, ptr @_bar_y, align 1
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()

cl/_testrt/fprintf/in.go

@@ -0,0 +1,16 @@
+package main
+
+import "unsafe"
+
+//go:linkname cstr llgo.cstr
+func cstr(string) *int8
+
+//go:linkname stderr __stderrp
+var stderr unsafe.Pointer
+
+//go:linkname fprintf C.fprintf
+func fprintf(fp unsafe.Pointer, format *int8, __llgo_va_list ...any)
+
+func main() {
+	fprintf(stderr, cstr("Hello %d\n"), 100)
+}

cl/_testrt/fprintf/out.ll

@@ -0,0 +1,36 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@"main.init$guard" = global ptr null
+@__stderrp = external global ptr
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [10 x i8] c"Hello %d\0A\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = load ptr, ptr @__stderrp, align 8
+  call void (ptr, ptr, ...) @fprintf(ptr %2, ptr @0, i64 100)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare void @fprintf(ptr, ptr, ...)

cl/_testrt/gblarray/in.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"github.com/goplus/llgo/internal/abi"
+	"github.com/goplus/llgo/internal/runtime/c"
+)
+
+func Basic(kind abi.Kind) *abi.Type {
+	return basicTypes[kind]
+}
+
+var (
+	basicTypes = [...]*abi.Type{
+		abi.String: basicType(abi.String),
+	}
+	sizeBasicTypes = [...]uintptr{
+		abi.String: 16,
+	}
+)
+
+func basicType(kind abi.Kind) *abi.Type {
+	return &abi.Type{
+		Size_: sizeBasicTypes[kind],
+		Hash:  uint32(kind),
+		Kind_: uint8(kind),
+	}
+}
+
+func main() {
+	t := Basic(abi.String)
+	c.Printf(c.Str("Kind: %d, Size: %d\n"), int(t.Kind_), t.Size_)
+}

cl/_testrt/gblarray/out.ll

@@ -0,0 +1,75 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%"github.com/goplus/llgo/internal/abi.Type" = type { i64, i64, i32, i8, i8, i8, i8, { ptr, ptr }, ptr, i32, i32 }
+
+@main.basicTypes = global ptr null
+@"main.init$guard" = global ptr null
+@main.sizeBasicTypes = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [20 x i8] c"Kind: %d, Size: %d\0A\00", align 1
+
+define ptr @main.Basic(i64 %0) {
+_llgo_0:
+  %1 = getelementptr inbounds ptr, ptr @main.basicTypes, i64 %0
+  %2 = load ptr, ptr %1, align 8
+  ret ptr %2
+}
+
+define ptr @main.basicType(i64 %0) {
+_llgo_0:
+  %1 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 56)
+  %2 = getelementptr inbounds %"github.com/goplus/llgo/internal/abi.Type", ptr %1, i32 0, i32 0
+  %3 = getelementptr inbounds i64, ptr @main.sizeBasicTypes, i64 %0
+  %4 = load i64, ptr %3, align 4
+  %5 = getelementptr inbounds %"github.com/goplus/llgo/internal/abi.Type", ptr %1, i32 0, i32 2
+  %6 = trunc i64 %0 to i32
+  %7 = getelementptr inbounds %"github.com/goplus/llgo/internal/abi.Type", ptr %1, i32 0, i32 6
+  %8 = trunc i64 %0 to i8
+  store i64 %4, ptr %2, align 4
+  store i32 %6, ptr %5, align 4
+  store i8 %8, ptr %7, align 1
+  ret ptr %1
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  call void @"github.com/goplus/llgo/internal/abi.init"()
+  store i64 16, ptr getelementptr inbounds (i64, ptr @main.sizeBasicTypes, i64 24), align 4
+  %1 = call ptr @main.basicType(i64 24)
+  store ptr %1, ptr getelementptr inbounds (ptr, ptr @main.basicTypes, i64 24), align 8
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call ptr @main.Basic(i64 24)
+  %3 = getelementptr inbounds %"github.com/goplus/llgo/internal/abi.Type", ptr %2, i32 0, i32 6
+  %4 = load i8, ptr %3, align 1
+  %5 = sext i8 %4 to i64
+  %6 = getelementptr inbounds %"github.com/goplus/llgo/internal/abi.Type", ptr %2, i32 0, i32 0
+  %7 = load i64, ptr %6, align 4
+  %8 = call i32 (ptr, ...) @printf(ptr @0, i64 %5, i64 %7)
+  ret void
+}
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64)
+
+declare void @"github.com/goplus/llgo/internal/abi.init"()
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare i32 @printf(ptr, ...)

cl/_testrt/gotypes/in.go

@@ -0,0 +1,17 @@
+package main
+
+type base interface {
+	f(m map[string]func())
+}
+
+type bar interface {
+	base
+	g(c chan func())
+}
+
+func foo(bar) {
+}
+
+func main() {
+	foo(nil)
+}

cl/_testrt/gotypes/out.ll

@@ -0,0 +1,38 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%"github.com/goplus/llgo/internal/runtime.iface" = type { ptr, ptr }
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+
+define void @main.foo(%"github.com/goplus/llgo/internal/runtime.iface" %0) {
+_llgo_0:
+  ret void
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  call void @main.foo(%"github.com/goplus/llgo/internal/runtime.iface" zeroinitializer)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()

cl/_testrt/hello/in.go

@@ -0,0 +1,10 @@
+package main
+
+import "github.com/goplus/llgo/cl/internal/libc"
+
+var format = [...]int8{'H', 'e', 'l', 'l', 'o', ' ', '%', 'd', '\n', 0}
+
+func main() {
+	sfmt := &format[0]
+	libc.Printf(sfmt, libc.Strlen(sfmt))
+}

cl/_testrt/hello/out.ll

@@ -0,0 +1,47 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@main.format = global ptr null
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  store i8 72, ptr @main.format, align 1
+  store i8 101, ptr getelementptr inbounds (i8, ptr @main.format, i64 1), align 1
+  store i8 108, ptr getelementptr inbounds (i8, ptr @main.format, i64 2), align 1
+  store i8 108, ptr getelementptr inbounds (i8, ptr @main.format, i64 3), align 1
+  store i8 111, ptr getelementptr inbounds (i8, ptr @main.format, i64 4), align 1
+  store i8 32, ptr getelementptr inbounds (i8, ptr @main.format, i64 5), align 1
+  store i8 37, ptr getelementptr inbounds (i8, ptr @main.format, i64 6), align 1
+  store i8 100, ptr getelementptr inbounds (i8, ptr @main.format, i64 7), align 1
+  store i8 10, ptr getelementptr inbounds (i8, ptr @main.format, i64 8), align 1
+  store i8 0, ptr getelementptr inbounds (i8, ptr @main.format, i64 9), align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call i32 @strlen(ptr @main.format)
+  call void (ptr, ...) @printf(ptr @main.format, i32 %2)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare i32 @strlen(ptr)
+
+declare void @printf(ptr, ...)

cl/_testrt/index/in.go

@@ -0,0 +1,25 @@
+package main
+
+import "github.com/goplus/llgo/internal/runtime/c"
+
+type point struct {
+	x int
+	y int
+}
+
+func main() {
+	a := [...]point{{1, 2}, {3, 4}, {5, 6}}[2]
+	c.Printf(c.Str("%d %d\n"), a.x, a.y)
+
+	b := [...][2]int{[2]int{1, 2}, [2]int{3, 4}}[1]
+	c.Printf(c.Str("%d %d\n"), b[0], b[1])
+
+	var i int = 2
+	n := [...]int{1, 2, 3, 4, 5}[i]
+	c.Printf(c.Str("%d\n"), n)
+	c.Printf(c.Str("%d\n"), [...]int{1, 2, 3, 4, 5}[i])
+
+	s := "123456"
+	c.Printf(c.Str("%c\n"), s[i])
+	c.Printf(c.Str("%c\n"), "123456"[1])
+}

cl/_testrt/index/out.ll

@@ -0,0 +1,140 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%main.point = type { i64, i64 }
+%"github.com/goplus/llgo/internal/runtime.String" = type { ptr, i64 }
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [7 x i8] c"%d %d\0A\00", align 1
+@1 = private unnamed_addr constant [7 x i8] c"%d %d\0A\00", align 1
+@2 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
+@3 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
+@4 = private unnamed_addr constant [4 x i8] c"%c\0A\00", align 1
+@5 = private unnamed_addr constant [7 x i8] c"123456\00", align 1
+@6 = private unnamed_addr constant [4 x i8] c"%c\0A\00", align 1
+@7 = private unnamed_addr constant [7 x i8] c"123456\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = alloca %main.point, align 8
+  %3 = call ptr @"github.com/goplus/llgo/internal/runtime.Zeroinit"(ptr %2, i64 16)
+  %4 = alloca [3 x %main.point], align 8
+  %5 = call ptr @"github.com/goplus/llgo/internal/runtime.Zeroinit"(ptr %4, i64 48)
+  %6 = getelementptr inbounds %main.point, ptr %5, i64 0
+  %7 = getelementptr inbounds %main.point, ptr %6, i32 0, i32 0
+  %8 = getelementptr inbounds %main.point, ptr %6, i32 0, i32 1
+  %9 = getelementptr inbounds %main.point, ptr %5, i64 1
+  %10 = getelementptr inbounds %main.point, ptr %9, i32 0, i32 0
+  %11 = getelementptr inbounds %main.point, ptr %9, i32 0, i32 1
+  %12 = getelementptr inbounds %main.point, ptr %5, i64 2
+  %13 = getelementptr inbounds %main.point, ptr %12, i32 0, i32 0
+  %14 = getelementptr inbounds %main.point, ptr %12, i32 0, i32 1
+  store i64 1, ptr %7, align 4
+  store i64 2, ptr %8, align 4
+  store i64 3, ptr %10, align 4
+  store i64 4, ptr %11, align 4
+  store i64 5, ptr %13, align 4
+  store i64 6, ptr %14, align 4
+  %15 = load [3 x %main.point], ptr %5, align 4
+  %16 = getelementptr inbounds %main.point, ptr %5, i64 2
+  %17 = load %main.point, ptr %16, align 4
+  store %main.point %17, ptr %3, align 4
+  %18 = getelementptr inbounds %main.point, ptr %3, i32 0, i32 0
+  %19 = load i64, ptr %18, align 4
+  %20 = getelementptr inbounds %main.point, ptr %3, i32 0, i32 1
+  %21 = load i64, ptr %20, align 4
+  %22 = call i32 (ptr, ...) @printf(ptr @0, i64 %19, i64 %21)
+  %23 = alloca [2 x i64], align 8
+  %24 = call ptr @"github.com/goplus/llgo/internal/runtime.Zeroinit"(ptr %23, i64 16)
+  %25 = alloca [2 x [2 x i64]], align 8
+  %26 = call ptr @"github.com/goplus/llgo/internal/runtime.Zeroinit"(ptr %25, i64 32)
+  %27 = getelementptr inbounds [2 x i64], ptr %26, i64 0
+  %28 = getelementptr inbounds i64, ptr %27, i64 0
+  %29 = getelementptr inbounds i64, ptr %27, i64 1
+  %30 = getelementptr inbounds [2 x i64], ptr %26, i64 1
+  %31 = getelementptr inbounds i64, ptr %30, i64 0
+  %32 = getelementptr inbounds i64, ptr %30, i64 1
+  store i64 1, ptr %28, align 4
+  store i64 2, ptr %29, align 4
+  store i64 3, ptr %31, align 4
+  store i64 4, ptr %32, align 4
+  %33 = load [2 x [2 x i64]], ptr %26, align 4
+  %34 = getelementptr inbounds [2 x i64], ptr %26, i64 1
+  %35 = load [2 x i64], ptr %34, align 4
+  store [2 x i64] %35, ptr %24, align 4
+  %36 = getelementptr inbounds i64, ptr %24, i64 0
+  %37 = load i64, ptr %36, align 4
+  %38 = getelementptr inbounds i64, ptr %24, i64 1
+  %39 = load i64, ptr %38, align 4
+  %40 = call i32 (ptr, ...) @printf(ptr @1, i64 %37, i64 %39)
+  %41 = alloca [5 x i64], align 8
+  %42 = call ptr @"github.com/goplus/llgo/internal/runtime.Zeroinit"(ptr %41, i64 40)
+  %43 = getelementptr inbounds i64, ptr %42, i64 0
+  %44 = getelementptr inbounds i64, ptr %42, i64 1
+  %45 = getelementptr inbounds i64, ptr %42, i64 2
+  %46 = getelementptr inbounds i64, ptr %42, i64 3
+  %47 = getelementptr inbounds i64, ptr %42, i64 4
+  store i64 1, ptr %43, align 4
+  store i64 2, ptr %44, align 4
+  store i64 3, ptr %45, align 4
+  store i64 4, ptr %46, align 4
+  store i64 5, ptr %47, align 4
+  %48 = load [5 x i64], ptr %42, align 4
+  %49 = getelementptr inbounds i64, ptr %42, i64 2
+  %50 = load i64, ptr %49, align 4
+  %51 = call i32 (ptr, ...) @printf(ptr @2, i64 %50)
+  %52 = alloca [5 x i64], align 8
+  %53 = call ptr @"github.com/goplus/llgo/internal/runtime.Zeroinit"(ptr %52, i64 40)
+  %54 = getelementptr inbounds i64, ptr %53, i64 0
+  %55 = getelementptr inbounds i64, ptr %53, i64 1
+  %56 = getelementptr inbounds i64, ptr %53, i64 2
+  %57 = getelementptr inbounds i64, ptr %53, i64 3
+  %58 = getelementptr inbounds i64, ptr %53, i64 4
+  store i64 1, ptr %54, align 4
+  store i64 2, ptr %55, align 4
+  store i64 3, ptr %56, align 4
+  store i64 4, ptr %57, align 4
+  store i64 5, ptr %58, align 4
+  %59 = load [5 x i64], ptr %53, align 4
+  %60 = getelementptr inbounds i64, ptr %53, i64 2
+  %61 = load i64, ptr %60, align 4
+  %62 = call i32 (ptr, ...) @printf(ptr @3, i64 %61)
+  %63 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @5, i64 6)
+  %64 = extractvalue %"github.com/goplus/llgo/internal/runtime.String" %63, 0
+  %65 = getelementptr inbounds i8, ptr %64, i64 2
+  %66 = load i8, ptr %65, align 1
+  %67 = call i32 (ptr, ...) @printf(ptr @4, i8 %66)
+  %68 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @7, i64 6)
+  %69 = extractvalue %"github.com/goplus/llgo/internal/runtime.String" %68, 0
+  %70 = getelementptr inbounds i8, ptr %69, i64 1
+  %71 = load i8, ptr %70, align 1
+  %72 = call i32 (ptr, ...) @printf(ptr @6, i8 %71)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.Zeroinit"(ptr, i64)
+
+declare i32 @printf(ptr, ...)
+
+declare %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr, i64)

cl/_testrt/intgen/in.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"github.com/goplus/llgo/internal/runtime/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() {
+	for _, v := range genInts(5, c.Rand) {
+		c.Printf(c.Str("%d\n"), v)
+	}
+
+	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)
+	}
+
+	g := &generator{val: 1}
+	for _, v := range genInts(5, g.next) {
+		c.Printf(c.Str("%d\n"), v)
+	}
+}

cl/_testrt/intgen/out.ll

@@ -0,0 +1,199 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%"github.com/goplus/llgo/internal/runtime.Slice" = type { ptr, i64, i64 }
+%main.generator = type { i32 }
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
+@1 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
+@2 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
+
+define %"github.com/goplus/llgo/internal/runtime.Slice" @main.genInts(i64 %0, { ptr, ptr } %1) {
+_llgo_0:
+  %2 = mul i64 %0, 4
+  %3 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 %2)
+  %4 = call %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice"(ptr %3, i64 %0, i64 %0)
+  %5 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %4)
+  br label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_2, %_llgo_0
+  %6 = phi i64 [ -1, %_llgo_0 ], [ %7, %_llgo_2 ]
+  %7 = add i64 %6, 1
+  %8 = icmp slt i64 %7, %5
+  br i1 %8, label %_llgo_2, label %_llgo_3
+
+_llgo_2:                                          ; preds = %_llgo_1
+  %9 = extractvalue { ptr, ptr } %1, 1
+  %10 = extractvalue { ptr, ptr } %1, 0
+  %11 = call i32 %10(ptr %9)
+  %12 = call ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice" %4)
+  %13 = getelementptr inbounds i32, ptr %12, i64 %7
+  store i32 %11, ptr %13, align 4
+  br label %_llgo_1
+
+_llgo_3:                                          ; preds = %_llgo_1
+  ret %"github.com/goplus/llgo/internal/runtime.Slice" %4
+}
+
+define i32 @"(*main.generator).next"(ptr %0) {
+_llgo_0:
+  %1 = getelementptr inbounds %main.generator, ptr %0, i32 0, i32 0
+  %2 = load i32, ptr %1, align 4
+  %3 = add i32 %2, 1
+  %4 = getelementptr inbounds %main.generator, ptr %0, i32 0, i32 0
+  store i32 %3, ptr %4, align 4
+  %5 = getelementptr inbounds %main.generator, ptr %0, i32 0, i32 0
+  %6 = load i32, ptr %5, align 4
+  ret i32 %6
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = alloca { ptr, ptr }, align 8
+  %3 = getelementptr inbounds { ptr, ptr }, ptr %2, i32 0, i32 0
+  store ptr @__llgo_stub.rand, ptr %3, align 8
+  %4 = getelementptr inbounds { ptr, ptr }, ptr %2, i32 0, i32 1
+  store ptr null, ptr %4, align 8
+  %5 = load { ptr, ptr }, ptr %2, align 8
+  %6 = call %"github.com/goplus/llgo/internal/runtime.Slice" @main.genInts(i64 5, { ptr, ptr } %5)
+  %7 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %6)
+  br label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_2, %_llgo_0
+  %8 = phi i64 [ -1, %_llgo_0 ], [ %9, %_llgo_2 ]
+  %9 = add i64 %8, 1
+  %10 = icmp slt i64 %9, %7
+  br i1 %10, label %_llgo_2, label %_llgo_3
+
+_llgo_2:                                          ; preds = %_llgo_1
+  %11 = call ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice" %6)
+  %12 = getelementptr inbounds i32, ptr %11, i64 %9
+  %13 = load i32, ptr %12, align 4
+  %14 = call i32 (ptr, ...) @printf(ptr @0, i32 %13)
+  br label %_llgo_1
+
+_llgo_3:                                          ; preds = %_llgo_1
+  %15 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 4)
+  store i32 1, ptr %15, align 4
+  %16 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
+  %17 = getelementptr inbounds { ptr }, ptr %16, i32 0, i32 0
+  store ptr %15, ptr %17, align 8
+  %18 = alloca { ptr, ptr }, align 8
+  %19 = getelementptr inbounds { ptr, ptr }, ptr %18, i32 0, i32 0
+  store ptr @"main.main$1", ptr %19, align 8
+  %20 = getelementptr inbounds { ptr, ptr }, ptr %18, i32 0, i32 1
+  store ptr %16, ptr %20, align 8
+  %21 = load { ptr, ptr }, ptr %18, align 8
+  %22 = call %"github.com/goplus/llgo/internal/runtime.Slice" @main.genInts(i64 5, { ptr, ptr } %21)
+  %23 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %22)
+  br label %_llgo_4
+
+_llgo_4:                                          ; preds = %_llgo_5, %_llgo_3
+  %24 = phi i64 [ -1, %_llgo_3 ], [ %25, %_llgo_5 ]
+  %25 = add i64 %24, 1
+  %26 = icmp slt i64 %25, %23
+  br i1 %26, label %_llgo_5, label %_llgo_6
+
+_llgo_5:                                          ; preds = %_llgo_4
+  %27 = call ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice" %22)
+  %28 = getelementptr inbounds i32, ptr %27, i64 %25
+  %29 = load i32, ptr %28, align 4
+  %30 = call i32 (ptr, ...) @printf(ptr @1, i32 %29)
+  br label %_llgo_4
+
+_llgo_6:                                          ; preds = %_llgo_4
+  %31 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 4)
+  %32 = getelementptr inbounds %main.generator, ptr %31, i32 0, i32 0
+  store i32 1, ptr %32, align 4
+  %33 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
+  %34 = getelementptr inbounds { ptr }, ptr %33, i32 0, i32 0
+  store ptr %31, ptr %34, align 8
+  %35 = alloca { ptr, ptr }, align 8
+  %36 = getelementptr inbounds { ptr, ptr }, ptr %35, i32 0, i32 0
+  store ptr @"main.next$bound", ptr %36, align 8
+  %37 = getelementptr inbounds { ptr, ptr }, ptr %35, i32 0, i32 1
+  store ptr %33, ptr %37, align 8
+  %38 = load { ptr, ptr }, ptr %35, align 8
+  %39 = call %"github.com/goplus/llgo/internal/runtime.Slice" @main.genInts(i64 5, { ptr, ptr } %38)
+  %40 = call i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice" %39)
+  br label %_llgo_7
+
+_llgo_7:                                          ; preds = %_llgo_8, %_llgo_6
+  %41 = phi i64 [ -1, %_llgo_6 ], [ %42, %_llgo_8 ]
+  %42 = add i64 %41, 1
+  %43 = icmp slt i64 %42, %40
+  br i1 %43, label %_llgo_8, label %_llgo_9
+
+_llgo_8:                                          ; preds = %_llgo_7
+  %44 = call ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice" %39)
+  %45 = getelementptr inbounds i32, ptr %44, i64 %42
+  %46 = load i32, ptr %45, align 4
+  %47 = call i32 (ptr, ...) @printf(ptr @2, i32 %46)
+  br label %_llgo_7
+
+_llgo_9:                                          ; preds = %_llgo_7
+  ret void
+}
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64)
+
+declare %"github.com/goplus/llgo/internal/runtime.Slice" @"github.com/goplus/llgo/internal/runtime.NewSlice"(ptr, i64, i64)
+
+declare i64 @"github.com/goplus/llgo/internal/runtime.SliceLen"(%"github.com/goplus/llgo/internal/runtime.Slice")
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.SliceData"(%"github.com/goplus/llgo/internal/runtime.Slice")
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare i32 @rand()
+
+define linkonce i32 @__llgo_stub.rand(ptr %0) {
+_llgo_0:
+  %1 = tail call i32 @rand()
+  ret i32 %1
+}
+
+declare i32 @printf(ptr, ...)
+
+define i32 @"main.main$1"(ptr %0) {
+_llgo_0:
+  %1 = load { ptr }, ptr %0, align 8
+  %2 = extractvalue { ptr } %1, 0
+  %3 = load i32, ptr %2, align 4
+  %4 = mul i32 %3, 2
+  %5 = extractvalue { ptr } %1, 0
+  store i32 %4, ptr %5, align 4
+  %6 = extractvalue { ptr } %1, 0
+  %7 = load i32, ptr %6, align 4
+  ret i32 %7
+}
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64)
+
+define i32 @"main.next$bound"(ptr %0) {
+_llgo_0:
+  %1 = load { ptr }, ptr %0, align 8
+  %2 = extractvalue { ptr } %1, 0
+  %3 = call i32 @"(*main.generator).next"(ptr %2)
+  ret i32 %3
+}

cl/_testrt/linkname/in.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/internal/runtime/c"
+)
+
+//go:linkname print github.com/goplus/llgo/cl/internal/linktarget.F
+func print(a, b, c, d *c.Char)
+
+func main() {
+	print(c.Str("a"), c.Str("b"), c.Str("c"), c.Str("d"))
+	print(c.Str("1"), c.Str("2"), c.Str("3"), c.Str("4"))
+}

cl/_testrt/linkname/out.ll

@@ -0,0 +1,42 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [2 x i8] c"a\00", align 1
+@1 = private unnamed_addr constant [2 x i8] c"b\00", align 1
+@2 = private unnamed_addr constant [2 x i8] c"c\00", align 1
+@3 = private unnamed_addr constant [2 x i8] c"d\00", align 1
+@4 = private unnamed_addr constant [2 x i8] c"1\00", align 1
+@5 = private unnamed_addr constant [2 x i8] c"2\00", align 1
+@6 = private unnamed_addr constant [2 x i8] c"3\00", align 1
+@7 = private unnamed_addr constant [2 x i8] c"4\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  call void @"github.com/goplus/llgo/cl/internal/linktarget.F"(ptr @0, ptr @1, ptr @2, ptr @3)
+  call void @"github.com/goplus/llgo/cl/internal/linktarget.F"(ptr @4, ptr @5, ptr @6, ptr @7)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/cl/internal/linktarget.F"(ptr, ptr, ptr, ptr)
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()

cl/_testrt/map/in.go

@@ -0,0 +1,10 @@
+package main
+
+import (
+	"github.com/goplus/llgo/internal/runtime/c"
+)
+
+func main() {
+	a := map[int]int{23: 100, 7: 29}
+	c.Printf(c.Str("Hello %d\n"), a[23])
+}

cl/_testrt/map/out.ll

@@ -0,0 +1,37 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [10 x i8] c"Hello %d\0A\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call ptr @"github.com/goplus/llgo/internal/runtime.MakeSmallMap"()
+  %3 = call i32 (ptr, ...) @printf(ptr @0, <null operand!>)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.MakeSmallMap"()
+
+declare i32 @printf(ptr, ...)

cl/_testrt/named/in.go

@@ -0,0 +1,39 @@
+package main
+
+import "github.com/goplus/llgo/internal/runtime/c"
+
+type mSpanList struct {
+	first *mspan
+	last  *mspan
+}
+
+type minfo struct {
+	span *mspan
+	info int
+}
+
+type mspan struct {
+	next  *mspan
+	prev  *mspan
+	list  *mSpanList
+	info  minfo
+	value int
+	check func(int) int
+}
+
+func main() {
+	m := &mspan{}
+	m.value = 100
+	m.next = &mspan{}
+	m.next.value = 200
+	m.list = &mSpanList{}
+	m.list.last = &mspan{}
+	m.list.last.value = 300
+	m.info.info = 10
+	m.info.span = m
+	m.check = func(n int) int {
+		return m.value * n
+	}
+	c.Printf(c.Str("%d %d %d %d %d %d\n"), m.next.value, m.list.last.value, m.info.info,
+		m.info.span.value, m.check(-2), m.info.span.check(-3))
+}

cl/_testrt/named/out.ll

@@ -0,0 +1,143 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%main.mspan = type { ptr, ptr, ptr, %main.minfo, i64, { ptr, ptr } }
+%main.minfo = type { ptr, i64 }
+%main.mSpanList = type { ptr, ptr }
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [19 x i8] c"%d %d %d %d %d %d\0A\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 8)
+  %3 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 64)
+  store ptr %3, ptr %2, align 8
+  %4 = load ptr, ptr %2, align 8
+  %5 = getelementptr inbounds %main.mspan, ptr %4, i32 0, i32 4
+  store i64 100, ptr %5, align 4
+  %6 = load ptr, ptr %2, align 8
+  %7 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 64)
+  %8 = getelementptr inbounds %main.mspan, ptr %6, i32 0, i32 0
+  store ptr %7, ptr %8, align 8
+  %9 = load ptr, ptr %2, align 8
+  %10 = getelementptr inbounds %main.mspan, ptr %9, i32 0, i32 0
+  %11 = load ptr, ptr %10, align 8
+  %12 = getelementptr inbounds %main.mspan, ptr %11, i32 0, i32 4
+  store i64 200, ptr %12, align 4
+  %13 = load ptr, ptr %2, align 8
+  %14 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 16)
+  %15 = getelementptr inbounds %main.mspan, ptr %13, i32 0, i32 2
+  store ptr %14, ptr %15, align 8
+  %16 = load ptr, ptr %2, align 8
+  %17 = getelementptr inbounds %main.mspan, ptr %16, i32 0, i32 2
+  %18 = load ptr, ptr %17, align 8
+  %19 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 64)
+  %20 = getelementptr inbounds %main.mSpanList, ptr %18, i32 0, i32 1
+  store ptr %19, ptr %20, align 8
+  %21 = load ptr, ptr %2, align 8
+  %22 = getelementptr inbounds %main.mspan, ptr %21, i32 0, i32 2
+  %23 = load ptr, ptr %22, align 8
+  %24 = getelementptr inbounds %main.mSpanList, ptr %23, i32 0, i32 1
+  %25 = load ptr, ptr %24, align 8
+  %26 = getelementptr inbounds %main.mspan, ptr %25, i32 0, i32 4
+  store i64 300, ptr %26, align 4
+  %27 = load ptr, ptr %2, align 8
+  %28 = getelementptr inbounds %main.mspan, ptr %27, i32 0, i32 3
+  %29 = getelementptr inbounds %main.minfo, ptr %28, i32 0, i32 1
+  store i64 10, ptr %29, align 4
+  %30 = load ptr, ptr %2, align 8
+  %31 = getelementptr inbounds %main.mspan, ptr %30, i32 0, i32 3
+  %32 = load ptr, ptr %2, align 8
+  %33 = getelementptr inbounds %main.minfo, ptr %31, i32 0, i32 0
+  store ptr %32, ptr %33, align 8
+  %34 = load ptr, ptr %2, align 8
+  %35 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64 8)
+  %36 = getelementptr inbounds { ptr }, ptr %35, i32 0, i32 0
+  store ptr %2, ptr %36, align 8
+  %37 = alloca { ptr, ptr }, align 8
+  %38 = getelementptr inbounds { ptr, ptr }, ptr %37, i32 0, i32 0
+  store ptr @"main.main$1", ptr %38, align 8
+  %39 = getelementptr inbounds { ptr, ptr }, ptr %37, i32 0, i32 1
+  store ptr %35, ptr %39, align 8
+  %40 = load { ptr, ptr }, ptr %37, align 8
+  %41 = getelementptr inbounds %main.mspan, ptr %34, i32 0, i32 5
+  store { ptr, ptr } %40, ptr %41, align 8
+  %42 = load ptr, ptr %2, align 8
+  %43 = getelementptr inbounds %main.mspan, ptr %42, i32 0, i32 0
+  %44 = load ptr, ptr %43, align 8
+  %45 = getelementptr inbounds %main.mspan, ptr %44, i32 0, i32 4
+  %46 = load i64, ptr %45, align 4
+  %47 = load ptr, ptr %2, align 8
+  %48 = getelementptr inbounds %main.mspan, ptr %47, i32 0, i32 2
+  %49 = load ptr, ptr %48, align 8
+  %50 = getelementptr inbounds %main.mSpanList, ptr %49, i32 0, i32 1
+  %51 = load ptr, ptr %50, align 8
+  %52 = getelementptr inbounds %main.mspan, ptr %51, i32 0, i32 4
+  %53 = load i64, ptr %52, align 4
+  %54 = load ptr, ptr %2, align 8
+  %55 = getelementptr inbounds %main.mspan, ptr %54, i32 0, i32 3
+  %56 = getelementptr inbounds %main.minfo, ptr %55, i32 0, i32 1
+  %57 = load i64, ptr %56, align 4
+  %58 = load ptr, ptr %2, align 8
+  %59 = getelementptr inbounds %main.mspan, ptr %58, i32 0, i32 3
+  %60 = getelementptr inbounds %main.minfo, ptr %59, i32 0, i32 0
+  %61 = load ptr, ptr %60, align 8
+  %62 = getelementptr inbounds %main.mspan, ptr %61, i32 0, i32 4
+  %63 = load i64, ptr %62, align 4
+  %64 = load ptr, ptr %2, align 8
+  %65 = getelementptr inbounds %main.mspan, ptr %64, i32 0, i32 5
+  %66 = load { ptr, ptr }, ptr %65, align 8
+  %67 = extractvalue { ptr, ptr } %66, 1
+  %68 = extractvalue { ptr, ptr } %66, 0
+  %69 = call i64 %68(ptr %67, i64 -2)
+  %70 = load ptr, ptr %2, align 8
+  %71 = getelementptr inbounds %main.mspan, ptr %70, i32 0, i32 3
+  %72 = getelementptr inbounds %main.minfo, ptr %71, i32 0, i32 0
+  %73 = load ptr, ptr %72, align 8
+  %74 = getelementptr inbounds %main.mspan, ptr %73, i32 0, i32 5
+  %75 = load { ptr, ptr }, ptr %74, align 8
+  %76 = extractvalue { ptr, ptr } %75, 1
+  %77 = extractvalue { ptr, ptr } %75, 0
+  %78 = call i64 %77(ptr %76, i64 -3)
+  %79 = call i32 (ptr, ...) @printf(ptr @0, i64 %46, i64 %53, i64 %57, i64 %63, i64 %69, i64 %78)
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64)
+
+define i64 @"main.main$1"(ptr %0, i64 %1) {
+_llgo_0:
+  %2 = load { ptr }, ptr %0, align 8
+  %3 = extractvalue { ptr } %2, 0
+  %4 = load ptr, ptr %3, align 8
+  %5 = getelementptr inbounds %main.mspan, ptr %4, i32 0, i32 4
+  %6 = load i64, ptr %5, align 4
+  %7 = mul i64 %6, %1
+  ret i64 %7
+}
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocU"(i64)
+
+declare i32 @printf(ptr, ...)

cl/_testrt/panic/in.go

@@ -0,0 +1,5 @@
+package main
+
+func main() {
+	panic("panic message")
+}

cl/_testrt/panic/out.ll

@@ -0,0 +1,43 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+%"github.com/goplus/llgo/internal/runtime.String" = type { ptr, i64 }
+%"github.com/goplus/llgo/internal/runtime.iface" = type { ptr, ptr }
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [14 x i8] c"panic message\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr @0, i64 13)
+  %3 = call %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String" %2)
+  call void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface" %3)
+  unreachable
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare %"github.com/goplus/llgo/internal/runtime.String" @"github.com/goplus/llgo/internal/runtime.NewString"(ptr, i64)
+
+declare %"github.com/goplus/llgo/internal/runtime.iface" @"github.com/goplus/llgo/internal/runtime.MakeAnyString"(%"github.com/goplus/llgo/internal/runtime.String")
+
+declare void @"github.com/goplus/llgo/internal/runtime.TracePanic"(%"github.com/goplus/llgo/internal/runtime.iface")

cl/_testrt/qsort/in.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/internal/runtime/c"
+)
+
+//go:linkname qsort C.qsort
+func qsort(base c.Pointer, count, elem uintptr, compar func(a, b c.Pointer) c.Int)
+
+func main() {
+	a := [...]int{100, 8, 23, 2, 7}
+	qsort(c.Pointer(&a[0]), 5, unsafe.Sizeof(0), func(a, b c.Pointer) c.Int {
+		return c.Int(*(*int)(a) - *(*int)(b))
+	})
+	for _, v := range a {
+		c.Printf(c.Str("%d\n"), v)
+	}
+}

cl/_testrt/qsort/out.ll

@@ -0,0 +1,75 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64 40)
+  %3 = getelementptr inbounds i64, ptr %2, i64 0
+  %4 = getelementptr inbounds i64, ptr %2, i64 1
+  %5 = getelementptr inbounds i64, ptr %2, i64 2
+  %6 = getelementptr inbounds i64, ptr %2, i64 3
+  %7 = getelementptr inbounds i64, ptr %2, i64 4
+  store i64 100, ptr %3, align 4
+  store i64 8, ptr %4, align 4
+  store i64 23, ptr %5, align 4
+  store i64 2, ptr %6, align 4
+  store i64 7, ptr %7, align 4
+  %8 = getelementptr inbounds i64, ptr %2, i64 0
+  call void @qsort(ptr %8, i64 5, i64 8, ptr @"main.main$1")
+  %9 = load [5 x i64], ptr %2, align 4
+  br label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_2, %_llgo_0
+  %10 = phi i64 [ -1, %_llgo_0 ], [ %11, %_llgo_2 ]
+  %11 = add i64 %10, 1
+  %12 = icmp slt i64 %11, 5
+  br i1 %12, label %_llgo_2, label %_llgo_3
+
+_llgo_2:                                          ; preds = %_llgo_1
+  %13 = getelementptr inbounds i64, ptr %2, i64 %11
+  %14 = load i64, ptr %13, align 4
+  %15 = call i32 (ptr, ...) @printf(ptr @0, i64 %14)
+  br label %_llgo_1
+
+_llgo_3:                                          ; preds = %_llgo_1
+  ret void
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+declare ptr @"github.com/goplus/llgo/internal/runtime.AllocZ"(i64)
+
+declare void @qsort(ptr, i64, i64, ptr)
+
+define i32 @"main.main$1"(ptr %0, ptr %1) {
+_llgo_0:
+  %2 = load i64, ptr %0, align 4
+  %3 = load i64, ptr %1, align 4
+  %4 = sub i64 %2, %3
+  %5 = trunc i64 %4 to i32
+  ret i32 %5
+}
+
+declare i32 @printf(ptr, ...)

cl/_testrt/result/in.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"github.com/goplus/llgo/internal/runtime/c"
+)
+
+func main() {
+	fn := func() func(int, int) int {
+		return func(x, y int) int {
+			return x + y
+		}
+	}()
+	c.Printf(c.Str("%d\n"), fn(100, 200))
+	c.Printf(c.Str("%d\n"), add()(100, 200))
+	fn, n := add2()
+	c.Printf(c.Str("%d %d\n"), add()(100, 200), n)
+}
+
+func add() func(int, int) int {
+	return func(x, y int) int {
+		return x + y
+	}
+}
+
+func add2() (func(int, int) int, int) {
+	return func(x, y int) int {
+		return x + y
+	}, 1
+}

cl/_testrt/result/out.ll

@@ -0,0 +1,124 @@
+; ModuleID = 'main'
+source_filename = "main"
+
+@"main.init$guard" = global ptr null
+@__llgo_argc = global ptr null
+@__llgo_argv = global ptr null
+@0 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
+@1 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
+@2 = private unnamed_addr constant [7 x i8] c"%d %d\0A\00", align 1
+
+define { ptr, ptr } @main.add() {
+_llgo_0:
+  %0 = alloca { ptr, ptr }, align 8
+  %1 = getelementptr inbounds { ptr, ptr }, ptr %0, i32 0, i32 0
+  store ptr @"__llgo_stub.main.add$1", ptr %1, align 8
+  %2 = getelementptr inbounds { ptr, ptr }, ptr %0, i32 0, i32 1
+  store ptr null, ptr %2, align 8
+  %3 = load { ptr, ptr }, ptr %0, align 8
+  ret { ptr, ptr } %3
+}
+
+define { { ptr, ptr }, i64 } @main.add2() {
+_llgo_0:
+  %0 = alloca { ptr, ptr }, align 8
+  %1 = getelementptr inbounds { ptr, ptr }, ptr %0, i32 0, i32 0
+  store ptr @"__llgo_stub.main.add2$1", ptr %1, align 8
+  %2 = getelementptr inbounds { ptr, ptr }, ptr %0, i32 0, i32 1
+  store ptr null, ptr %2, align 8
+  %3 = load { ptr, ptr }, ptr %0, align 8
+  %mrv = insertvalue { { ptr, ptr }, i64 } poison, { ptr, ptr } %3, 0
+  %mrv1 = insertvalue { { ptr, ptr }, i64 } %mrv, i64 1, 1
+  ret { { ptr, ptr }, i64 } %mrv1
+}
+
+define void @main.init() {
+_llgo_0:
+  %0 = load i1, ptr @"main.init$guard", align 1
+  br i1 %0, label %_llgo_2, label %_llgo_1
+
+_llgo_1:                                          ; preds = %_llgo_0
+  store i1 true, ptr @"main.init$guard", align 1
+  br label %_llgo_2
+
+_llgo_2:                                          ; preds = %_llgo_1, %_llgo_0
+  ret void
+}
+
+define void @main(i32 %0, ptr %1) {
+_llgo_0:
+  store i32 %0, ptr @__llgo_argc, align 4
+  store ptr %1, ptr @__llgo_argv, align 8
+  call void @"github.com/goplus/llgo/internal/runtime.init"()
+  call void @main.init()
+  %2 = call { ptr, ptr } @"main.main$1"()
+  %3 = extractvalue { ptr, ptr } %2, 1
+  %4 = extractvalue { ptr, ptr } %2, 0
+  %5 = call i64 %4(ptr %3, i64 100, i64 200)
+  %6 = call i32 (ptr, ...) @printf(ptr @0, i64 %5)
+  %7 = call { ptr, ptr } @main.add()
+  %8 = extractvalue { ptr, ptr } %7, 1
+  %9 = extractvalue { ptr, ptr } %7, 0
+  %10 = call i64 %9(ptr %8, i64 100, i64 200)
+  %11 = call i32 (ptr, ...) @printf(ptr @1, i64 %10)
+  %12 = call { { ptr, ptr }, i64 } @main.add2()
+  %13 = extractvalue { { ptr, ptr }, i64 } %12, 0
+  %14 = extractvalue { { ptr, ptr }, i64 } %12, 1
+  %15 = call { ptr, ptr } @main.add()
+  %16 = extractvalue { ptr, ptr } %15, 1
+  %17 = extractvalue { ptr, ptr } %15, 0
+  %18 = call i64 %17(ptr %16, i64 100, i64 200)
+  %19 = call i32 (ptr, ...) @printf(ptr @2, i64 %18, i64 %14)
+  ret void
+}
+
+define i64 @"main.add$1"(i64 %0, i64 %1) {
+_llgo_0:
+  %2 = add i64 %0, %1
+  ret i64 %2
+}
+
+define linkonce i64 @"__llgo_stub.main.add$1"(ptr %0, i64 %1, i64 %2) {
+_llgo_0:
+  %3 = tail call i64 @"main.add$1"(i64 %1, i64 %2)
+  ret i64 %3
+}
+
+define i64 @"main.add2$1"(i64 %0, i64 %1) {
+_llgo_0:
+  %2 = add i64 %0, %1
+  ret i64 %2
+}
+
+define linkonce i64 @"__llgo_stub.main.add2$1"(ptr %0, i64 %1, i64 %2) {
+_llgo_0:
+  %3 = tail call i64 @"main.add2$1"(i64 %1, i64 %2)
+  ret i64 %3
+}
+
+declare void @"github.com/goplus/llgo/internal/runtime.init"()
+
+define { ptr, ptr } @"main.main$1"() {
+_llgo_0:
+  %0 = alloca { ptr, ptr }, align 8
+  %1 = getelementptr inbounds { ptr, ptr }, ptr %0, i32 0, i32 0
+  store ptr @"__llgo_stub.main.main$1$1", ptr %1, align 8
+  %2 = getelementptr inbounds { ptr, ptr }, ptr %0, i32 0, i32 1
+  store ptr null, ptr %2, align 8
+  %3 = load { ptr, ptr }, ptr %0, align 8
+  ret { ptr, ptr } %3
+}
+
+declare i32 @printf(ptr, ...)
+
+define i64 @"main.main$1$1"(i64 %0, i64 %1) {
+_llgo_0:
+  %2 = add i64 %0, %1
+  ret i64 %2
+}
+
+define linkonce i64 @"__llgo_stub.main.main$1$1"(ptr %0, i64 %1, i64 %2) {
+_llgo_0:
+  %3 = tail call i64 @"main.main$1$1"(i64 %1, i64 %2)
+  ret i64 %3
+}

cl/_testrt/strlen/in.go

@@ -0,0 +1,17 @@
+package main
+
+import "C"
+import _ "unsafe"
+
+//go:linkname printf C.printf
+func printf(format *int8, __llgo_va_list ...any)
+
+//go:linkname strlen C.strlen
+func strlen(str *int8) C.int
+
+var format = [...]int8{'H', 'e', 'l', 'l', 'o', ' ', '%', 'd', '\n', 0}
+
+func main() {
+	sfmt := &format[0]
+	printf(sfmt, strlen(sfmt))
+}