build: remove incorrect TODO comment

Remove TODO(lijie) comment as requested - the syscall.init weak stub is intentional.

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

cl/_testgo/rewrite/dep/dep.go

@@ -1,11 +0,0 @@
-package dep
-
-import "fmt"
-
-var VarName = "dep-default"
-var VarPlain string
-
-func PrintVar() {
-	fmt.Printf("dep.VarName: %s\n", VarName)
-	fmt.Printf("dep.VarPlain: %s\n", VarPlain)
-}

cl/_testgo/rewrite/main.go

@@ -1,23 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"runtime"
-
-	dep "github.com/goplus/llgo/cl/_testgo/rewrite/dep"
-)
-
-var VarName = "main-default"
-var VarPlain string
-
-func printLine(label, value string) {
-	fmt.Printf("%s: %s\n", label, value)
-}
-
-func main() {
-	printLine("main.VarName", VarName)
-	printLine("main.VarPlain", VarPlain)
-	dep.PrintVar()
-	printLine("runtime.GOROOT()", runtime.GOROOT())
-	printLine("runtime.Version()", runtime.Version())
-}

cl/_testgo/rewrite/out.ll

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

cl/compile.go

@@ -127,58 +127,6 @@ type context struct {
 	cgoArgs    []llssa.Expr
 	cgoRet     llssa.Expr
 	cgoSymbols []string
-	rewrites   map[string]string
-}
-
-func (p *context) rewriteValue(name string) (string, bool) {
-	if p.rewrites == nil {
-		return "", false
-	}
-	dot := strings.LastIndex(name, ".")
-	if dot < 0 || dot == len(name)-1 {
-		return "", false
-	}
-	varName := name[dot+1:]
-	val, ok := p.rewrites[varName]
-	return val, ok
-}
-
-// isStringPtrType checks if typ is a pointer to the basic string type (*string).
-// This is used to validate that -ldflags -X can only rewrite variables of type *string,
-// not derived string types like "type T string".
-func (p *context) isStringPtrType(typ types.Type) bool {
-	ptr, ok := typ.(*types.Pointer)
-	if !ok {
-		return false
-	}
-	basic, ok := ptr.Elem().(*types.Basic)
-	return ok && basic.Kind() == types.String
-}
-
-func (p *context) globalFullName(g *ssa.Global) string {
-	name, _, _ := p.varName(g.Pkg.Pkg, g)
-	return name
-}
-
-func (p *context) rewriteInitStore(store *ssa.Store, g *ssa.Global) (string, bool) {
-	if p.rewrites == nil {
-		return "", false
-	}
-	fn := store.Block().Parent()
-	if fn == nil || fn.Synthetic != "package initializer" {
-		return "", false
-	}
-	if _, ok := store.Val.(*ssa.Const); !ok {
-		return "", false
-	}
-	if !p.isStringPtrType(g.Type()) {
-		return "", false
-	}
-	value, ok := p.rewriteValue(p.globalFullName(g))
-	if !ok {
-		return "", false
-	}
-	return value, true
 }
 
 type pkgState byte
@@ -228,16 +176,7 @@ func (p *context) compileGlobal(pkg llssa.Package, gbl *ssa.Global) {
 		log.Println("==> NewVar", name, typ)
 	}
 	g := pkg.NewVar(name, typ, llssa.Background(vtype))
-	if value, ok := p.rewriteValue(name); ok {
-		if p.isStringPtrType(gbl.Type()) {
-			g.Init(pkg.ConstString(value))
-		} else {
-			log.Printf("warning: ignoring rewrite for non-string variable %s (type: %v)", name, gbl.Type())
-			if define {
-				g.InitNil()
-			}
-		}
-	} else if define {
+	if define {
 		g.InitNil()
 	}
 }
@@ -877,13 +816,6 @@ func (p *context) compileInstr(b llssa.Builder, instr ssa.Instruction) {
 				return
 			}
 		}
-		if p.rewrites != nil {
-			if g, ok := va.(*ssa.Global); ok {
-				if _, ok := p.rewriteInitStore(v, g); ok {
-					return
-				}
-			}
-		}
 		ptr := p.compileValue(b, va)
 		val := p.compileValue(b, v.Val)
 		b.Store(ptr, val)
@@ -1048,22 +980,12 @@ type Patches = map[string]Patch
 
 // NewPackage compiles a Go package to LLVM IR package.
 func NewPackage(prog llssa.Program, pkg *ssa.Package, files []*ast.File) (ret llssa.Package, err error) {
-	ret, _, err = NewPackageEx(prog, nil, nil, pkg, files)
+	ret, _, err = NewPackageEx(prog, nil, pkg, files)
 	return
 }
 
 // NewPackageEx compiles a Go package to LLVM IR package.
-//
-// Parameters:
-//   - prog: target LLVM SSA program context
-//   - patches: optional package patches applied during compilation
-//   - rewrites: per-package string initializers rewritten at compile time
-//   - pkg: SSA package to compile
-//   - files: parsed AST files that belong to the package
-//
-// The rewrites map uses short variable names (without package qualifier) and
-// only affects string-typed globals defined in the current package.
-func NewPackageEx(prog llssa.Program, patches Patches, rewrites map[string]string, pkg *ssa.Package, files []*ast.File) (ret llssa.Package, externs []string, err error) {
+func NewPackageEx(prog llssa.Program, patches Patches, pkg *ssa.Package, files []*ast.File) (ret llssa.Package, externs []string, err error) {
 	pkgProg := pkg.Prog
 	pkgTypes := pkg.Pkg
 	oldTypes := pkgTypes
@@ -1096,7 +1018,6 @@ func NewPackageEx(prog llssa.Program, patches Patches, rewrites map[string]strin
 			types.Unsafe: {kind: PkgDeclOnly}, // TODO(xsw): PkgNoInit or PkgDeclOnly?
 		},
 		cgoSymbols: make([]string, 0, 128),
-		rewrites:   rewrites,
 	}
 	ctx.initPyModule()
 	ctx.initFiles(pkgPath, files, pkgName == "C")

cl/rewrite_internal_test.go

@@ -1,169 +0,0 @@
-//go:build !llgo
-// +build !llgo
-
-package cl
-
-import (
-	"go/ast"
-	"go/parser"
-	"go/token"
-	"go/types"
-	"runtime"
-	"strings"
-	"testing"
-
-	gpackages "github.com/goplus/gogen/packages"
-	llssa "github.com/goplus/llgo/ssa"
-	"github.com/goplus/llgo/ssa/ssatest"
-	"golang.org/x/tools/go/ssa"
-	"golang.org/x/tools/go/ssa/ssautil"
-)
-
-func init() {
-	llssa.Initialize(llssa.InitAll | llssa.InitNative)
-}
-
-func compileWithRewrites(t *testing.T, src string, rewrites map[string]string) string {
-	t.Helper()
-	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "rewrite.go", src, 0)
-	if err != nil {
-		t.Fatalf("parse failed: %v", err)
-	}
-	importer := gpackages.NewImporter(fset)
-	mode := ssa.SanityCheckFunctions | ssa.InstantiateGenerics
-	pkg, _, err := ssautil.BuildPackage(&types.Config{Importer: importer}, fset,
-		types.NewPackage(file.Name.Name, file.Name.Name), []*ast.File{file}, mode)
-	if err != nil {
-		t.Fatalf("build package failed: %v", err)
-	}
-	prog := ssatest.NewProgramEx(t, nil, importer)
-	prog.TypeSizes(types.SizesFor("gc", runtime.GOARCH))
-	ret, _, err := NewPackageEx(prog, nil, rewrites, pkg, []*ast.File{file})
-	if err != nil {
-		t.Fatalf("NewPackageEx failed: %v", err)
-	}
-	return ret.String()
-}
-
-func TestRewriteGlobalStrings(t *testing.T) {
-	const src = `package rewritepkg
-var VarInit = "original_value"
-var VarPlain string
-func Use() string { return VarInit + VarPlain }
-`
-	ir := compileWithRewrites(t, src, map[string]string{
-		"VarInit":  "rewrite_init",
-		"VarPlain": "rewrite_plain",
-	})
-	if strings.Contains(ir, "original_value") {
-		t.Fatalf("original initializer still present:\n%s", ir)
-	}
-	for _, want := range []string{`c"rewrite_init"`, `c"rewrite_plain"`} {
-		if !strings.Contains(ir, want) {
-			t.Fatalf("missing %s in IR:\n%s", want, ir)
-		}
-	}
-}
-
-func TestRewriteSkipsNonConstStores(t *testing.T) {
-	const src = `package rewritepkg
-import "strings"
-var VarInit = strings.ToUpper("original_value")
-var VarPlain string
-func Use() string { return VarInit + VarPlain }
-`
-	ir := compileWithRewrites(t, src, map[string]string{
-		"VarInit":  "rewrite_init",
-		"VarPlain": "rewrite_plain",
-	})
-	if !strings.Contains(ir, `c"rewrite_init"`) {
-		t.Fatalf("expected rewrite_init constant to remain:\n%s", ir)
-	}
-	if !strings.Contains(ir, "strings.ToUpper") {
-		t.Fatalf("expected call to strings.ToUpper in IR:\n%s", ir)
-	}
-}
-
-func TestRewriteValueNoDot(t *testing.T) {
-	ctx := &context{rewrites: map[string]string{"VarInit": "rewrite_init"}}
-	if _, ok := ctx.rewriteValue("VarInit"); ok {
-		t.Fatalf("rewriteValue should skip names without package prefix")
-	}
-	if _, ok := ctx.rewriteValue("pkg."); ok {
-		t.Fatalf("rewriteValue should skip trailing dot names")
-	}
-}
-
-func TestIsStringPtrTypeDefault(t *testing.T) {
-	ctx := &context{}
-	if ctx.isStringPtrType(types.NewPointer(types.Typ[types.Int])) {
-		t.Fatalf("expected non-string pointer to return false")
-	}
-}
-
-func TestIsStringPtrTypeBranches(t *testing.T) {
-	ctx := &context{}
-	if ctx.isStringPtrType(types.NewSlice(types.Typ[types.String])) {
-		t.Fatalf("slice should trigger default branch and return false")
-	}
-	if ctx.isStringPtrType(nil) {
-		t.Fatalf("nil type should return false")
-	}
-	if !ctx.isStringPtrType(types.NewPointer(types.Typ[types.String])) {
-		t.Fatalf("*string should return true")
-	}
-}
-
-func TestRewriteIgnoredInNonInitStore(t *testing.T) {
-	const src = `package rewritepkg
-var VarInit = "original_value"
-func Override() { VarInit = "override_value" }
-`
-	ir := compileWithRewrites(t, src, map[string]string{"VarInit": "rewrite_init"})
-	if !strings.Contains(ir, `c"override_value"`) {
-		t.Fatalf("override store should retain original literal:\n%s", ir)
-	}
-	if !strings.Contains(ir, `c"rewrite_init"`) {
-		t.Fatalf("global initializer should still be rewritten:\n%s", ir)
-	}
-}
-
-func TestRewriteMissingEntry(t *testing.T) {
-	const src = `package rewritepkg
-var VarInit = "original_value"
-var VarOther = "other_value"
-`
-	ir := compileWithRewrites(t, src, map[string]string{"VarInit": "rewrite_init"})
-	if !strings.Contains(ir, `c"other_value"`) {
-		t.Fatalf("VarOther should keep original initializer:\n%s", ir)
-	}
-	if !strings.Contains(ir, `c"rewrite_init"`) {
-		t.Fatalf("VarInit should still be rewritten:\n%s", ir)
-	}
-}
-
-func TestRewriteIgnoresNonStringVar(t *testing.T) {
-	const src = `package rewritepkg
-type wrapper struct{ v int }
-var VarStruct = wrapper{v: 1}
-`
-	ir := compileWithRewrites(t, src, map[string]string{"VarStruct": "rewrite_struct"})
-	if strings.Contains(ir, `c"rewrite_struct"`) {
-		t.Fatalf("non-string variables must not be rewritten:\n%s", ir)
-	}
-}
-
-func TestRewriteIgnoresStringAlias(t *testing.T) {
-	const src = `package rewritepkg
-type T string
-var VarAlias T = "original_value"
-`
-	ir := compileWithRewrites(t, src, map[string]string{"VarAlias": "rewrite_alias"})
-	if strings.Contains(ir, `c"rewrite_alias"`) {
-		t.Fatalf("string alias types must not be rewritten:\n%s", ir)
-	}
-	if !strings.Contains(ir, `c"original_value"`) {
-		t.Fatalf("original value should remain for alias type:\n%s", ir)
-	}
-}

internal/build/build.go

@@ -132,16 +132,10 @@ type Config struct {
 	CheckLinkArgs bool // check linkargs valid
 	ForceEspClang bool // force to use esp-clang
 	Tags          string
-	// GlobalRewrites specifies compile-time overrides for global string variables.
-	// Keys are fully qualified package paths (e.g. "main" or "github.com/user/pkg").
-	// Each Rewrites entry maps variable names to replacement string values. Only
-	// string-typed globals are supported and "main" applies to all root main
-	// packages in the current build.
-	GlobalRewrites map[string]Rewrites
+	GlobalNames   map[string][]string // pkg => names
+	GlobalDatas   map[string]string   // pkg.name => data
 }
 
-type Rewrites map[string]string
-
 func NewDefaultConf(mode Mode) *Config {
 	bin := os.Getenv("GOBIN")
 	if bin == "" {
@@ -341,10 +335,6 @@ func Do(args []string, conf *Config) ([]Package, error) {
 		crossCompile: export,
 		cTransformer: cabi.NewTransformer(prog, export.LLVMTarget, export.TargetABI, conf.AbiMode, cabiOptimize),
 	}
-
-	// default runtime globals must be registered before packages are built
-	addGlobalString(conf, "runtime.defaultGOROOT="+runtime.GOROOT(), nil)
-	addGlobalString(conf, "runtime.buildVersion="+runtime.Version(), nil)
 	pkgs, err := buildAllPkgs(ctx, initial, verbose)
 	check(err)
 	if mode == ModeGen {
@@ -355,11 +345,19 @@ func Do(args []string, conf *Config) ([]Package, error) {
 		}
 		return nil, fmt.Errorf("initial package not found")
 	}
+
 	dpkg, err := buildAllPkgs(ctx, altPkgs[noRt:], verbose)
 	check(err)
 	allPkgs := append([]*aPackage{}, pkgs...)
 	allPkgs = append(allPkgs, dpkg...)
 
+	// update globals importpath.name=value
+	addGlobalString(conf, "runtime.defaultGOROOT="+runtime.GOROOT(), nil)
+	addGlobalString(conf, "runtime.buildVersion="+runtime.Version(), nil)
+
+	global, err := createGlobals(ctx, ctx.prog, pkgs)
+	check(err)
+
 	for _, pkg := range initial {
 		if needLink(pkg, mode) {
 			name := path.Base(pkg.PkgPath)
@@ -371,7 +369,7 @@ func Do(args []string, conf *Config) ([]Package, error) {
 			}
 
 			// Link main package using the output path from buildOutFmts
-			err = linkMainPkg(ctx, pkg, allPkgs, outFmts.Out, verbose)
+			err = linkMainPkg(ctx, pkg, allPkgs, global, outFmts.Out, verbose)
 			if err != nil {
 				return nil, err
 			}
@@ -631,59 +629,58 @@ var (
 	errXflags = errors.New("-X flag requires argument of the form importpath.name=value")
 )
 
-// maxRewriteValueLength limits the size of rewrite values to prevent
-// excessive memory usage and potential resource exhaustion during compilation.
-const maxRewriteValueLength = 1 << 20 // 1 MiB cap per rewrite value
-
 func addGlobalString(conf *Config, arg string, mainPkgs []string) {
-	addGlobalStringWith(conf, arg, mainPkgs, true)
-}
-
-func addGlobalStringWith(conf *Config, arg string, mainPkgs []string, skipIfExists bool) {
 	eq := strings.Index(arg, "=")
 	dot := strings.LastIndex(arg[:eq+1], ".")
 	if eq < 0 || dot < 0 {
 		panic(errXflags)
 	}
 	pkg := arg[:dot]
-	varName := arg[dot+1 : eq]
-	value := arg[eq+1:]
-	validateRewriteInput(pkg, varName, value)
 	pkgs := []string{pkg}
 	if pkg == "main" {
 		pkgs = mainPkgs
 	}
-	if len(pkgs) == 0 {
-		return
+	if conf.GlobalNames == nil {
+		conf.GlobalNames = make(map[string][]string)
 	}
-	if conf.GlobalRewrites == nil {
-		conf.GlobalRewrites = make(map[string]Rewrites)
+	if conf.GlobalDatas == nil {
+		conf.GlobalDatas = make(map[string]string)
 	}
-	for _, realPkg := range pkgs {
-		vars := conf.GlobalRewrites[realPkg]
-		if vars == nil {
-			vars = make(Rewrites)
-			conf.GlobalRewrites[realPkg] = vars
+	for _, pkg := range pkgs {
+		name := pkg + arg[dot:eq]
+		value := arg[eq+1:]
+		if _, ok := conf.GlobalDatas[name]; !ok {
+			conf.GlobalNames[pkg] = append(conf.GlobalNames[pkg], name)
 		}
-		if skipIfExists {
-			if _, exists := vars[varName]; exists {
-				continue
-			}
-		}
-		vars[varName] = value
+		conf.GlobalDatas[name] = value
 	}
 }
 
-func validateRewriteInput(pkg, varName, value string) {
-	if pkg == "" || strings.ContainsAny(pkg, " \t\r\n") {
-		panic(fmt.Errorf("invalid package path for rewrite: %q", pkg))
+func createGlobals(ctx *context, prog llssa.Program, pkgs []*aPackage) (llssa.Package, error) {
+	if len(ctx.buildConf.GlobalDatas) == 0 {
+		return nil, nil
 	}
-	if !token.IsIdentifier(varName) {
-		panic(fmt.Errorf("invalid variable name for rewrite: %q", varName))
+	for _, pkg := range pkgs {
+		if pkg.ExportFile == "" {
+			continue
+		}
+		if names, ok := ctx.buildConf.GlobalNames[pkg.PkgPath]; ok {
+			err := pkg.LPkg.Undefined(names...)
+			if err != nil {
+				return nil, err
+			}
+			pkg.ExportFile += "-global"
+			pkg.ExportFile, err = exportObject(ctx, pkg.PkgPath+".global", pkg.ExportFile, []byte(pkg.LPkg.String()))
+			if err != nil {
+				return nil, err
+			}
+		}
 	}
-	if len(value) > maxRewriteValueLength {
-		panic(fmt.Errorf("rewrite value too large: %d bytes", len(value)))
+	global := prog.NewPackage("", "global")
+	for name, value := range ctx.buildConf.GlobalDatas {
+		global.AddGlobalString(name, value)
 	}
+	return global, nil
 }
 
 // compileExtraFiles compiles extra files (.s/.c) from target configuration and returns object files
@@ -755,7 +752,7 @@ func compileExtraFiles(ctx *context, verbose bool) ([]string, error) {
 	return objFiles, nil
 }
 
-func linkMainPkg(ctx *context, pkg *packages.Package, pkgs []*aPackage, outputPath string, verbose bool) error {
+func linkMainPkg(ctx *context, pkg *packages.Package, pkgs []*aPackage, global llssa.Package, outputPath string, verbose bool) error {
 
 	needRuntime := false
 	needPyInit := false
@@ -772,6 +769,7 @@ func linkMainPkg(ctx *context, pkg *packages.Package, pkgs []*aPackage, outputPa
 		if p.ExportFile != "" && aPkg != nil { // skip packages that only contain declarations
 			linkArgs = append(linkArgs, aPkg.LinkArgs...)
 			objFiles = append(objFiles, aPkg.LLFiles...)
+			objFiles = append(objFiles, aPkg.ExportFile)
 			need1, need2 := isNeedRuntimeOrPyInit(ctx, p)
 			if !needRuntime {
 				needRuntime = need1
@@ -782,11 +780,11 @@ func linkMainPkg(ctx *context, pkg *packages.Package, pkgs []*aPackage, outputPa
 		}
 	})
 	// Generate main module file (needed for global variables even in library modes)
-	entryObjFile, err := genMainModuleFile(ctx, llssa.PkgRuntime, pkg, needRuntime, needPyInit)
+	entryPkg := genMainModule(ctx, llssa.PkgRuntime, pkg, needRuntime, needPyInit)
+	entryObjFile, err := exportObject(ctx, entryPkg.PkgPath, entryPkg.ExportFile, []byte(entryPkg.LPkg.String()))
 	if err != nil {
 		return err
 	}
-	// defer os.Remove(entryLLFile)
 	objFiles = append(objFiles, entryObjFile)
 
 	// Compile extra files from target configuration
@@ -796,6 +794,14 @@ func linkMainPkg(ctx *context, pkg *packages.Package, pkgs []*aPackage, outputPa
 	}
 	objFiles = append(objFiles, extraObjFiles...)
 
+	if global != nil {
+		export, err := exportObject(ctx, pkg.PkgPath+".global", pkg.ExportFile+"-global", []byte(global.String()))
+		if err != nil {
+			return err
+		}
+		objFiles = append(objFiles, export)
+	}
+
 	if IsFullRpathEnabled() {
 		// Treat every link-time library search path, specified by the -L parameter, as a runtime search path as well.
 		// This is to ensure the final executable can locate libraries with a relocatable install_name
@@ -908,118 +914,6 @@ func needStart(ctx *context) bool {
 	}
 }
 
-func genMainModuleFile(ctx *context, rtPkgPath string, pkg *packages.Package, needRuntime, needPyInit bool) (path string, err error) {
-	var (
-		pyInitDecl string
-		pyInit     string
-		rtInitDecl string
-		rtInit     string
-	)
-	mainPkgPath := pkg.PkgPath
-	if needRuntime {
-		rtInit = "call void @\"" + rtPkgPath + ".init\"()"
-		rtInitDecl = "declare void @\"" + rtPkgPath + ".init\"()"
-	}
-	if needPyInit {
-		pyInit = "call void @Py_Initialize()"
-		pyInitDecl = "declare void @Py_Initialize()"
-	}
-	declSizeT := "%size_t = type i64"
-	if is32Bits(ctx.buildConf.Goarch) {
-		declSizeT = "%size_t = type i32"
-	}
-	stdioDecl := ""
-	stdioNobuf := ""
-	if IsStdioNobuf() {
-		stdioDecl = `
-@stdout = external global ptr
-@stderr = external global ptr
-@__stdout = external global ptr
-@__stderr = external global ptr
-declare i32 @setvbuf(ptr, ptr, i32, %size_t)
-	`
-		stdioNobuf = `
-; Set stdout with no buffer
-%stdout_is_null = icmp eq ptr @stdout, null
-%stdout_ptr = select i1 %stdout_is_null, ptr @__stdout, ptr @stdout
-call i32 @setvbuf(ptr %stdout_ptr, ptr null, i32 2, %size_t 0)
-; Set stderr with no buffer
-%stderr_ptr = select i1 %stdout_is_null, ptr @__stderr, ptr @stderr
-call i32 @setvbuf(ptr %stderr_ptr, ptr null, i32 2, %size_t 0)
-	`
-	}
-	// TODO(lijie): workaround for libc-free
-	// Remove main/_start when -buildmode and libc are ready
-	startDefine := `
-define weak void @_start() {
-  ; argc = 0
-  %argc = add i32 0, 0
-  ; argv = null
-  %argv = inttoptr i64 0 to i8**
-  call i32 @main(i32 %argc, i8** %argv)
-  ret void
-}
-`
-	mainDefine := "define i32 @main(i32 noundef %0, ptr nocapture noundef readnone %1) local_unnamed_addr"
-	if !needStart(ctx) && isWasmTarget(ctx.buildConf.Goos) {
-		mainDefine = "define hidden noundef i32 @__main_argc_argv(i32 noundef %0, ptr nocapture noundef readnone %1) local_unnamed_addr"
-	}
-	if !needStart(ctx) {
-		startDefine = ""
-	}
-
-	var mainCode string
-	// For library modes (c-archive, c-shared), only generate global variables
-	if ctx.buildConf.BuildMode != BuildModeExe {
-		mainCode = `; ModuleID = 'main'
-source_filename = "main"
-@__llgo_argc = global i32 0, align 4
-@__llgo_argv = global ptr null, align 8
-`
-	} else {
-		// For executable mode, generate full main function
-		mainCode = fmt.Sprintf(`; ModuleID = 'main'
-source_filename = "main"
-%s
-@__llgo_argc = global i32 0, align 4
-@__llgo_argv = global ptr null, align 8
-%s
-%s
-%s
-declare void @"%s.init"()
-declare void @"%s.main"()
-define weak void @runtime.init() {
-  ret void
-}
-
-; TODO(lijie): workaround for syscall patch
-define weak void @"syscall.init"() {
-  ret void
-}
-
-%s
-
-%s {
-_llgo_0:
-  store i32 %%0, ptr @__llgo_argc, align 4
-  store ptr %%1, ptr @__llgo_argv, align 8
-  %s
-  %s
-  %s
-  call void @runtime.init()
-  call void @"%s.init"()
-  call void @"%s.main"()
-  ret i32 0
-}
-`, declSizeT, stdioDecl,
-			pyInitDecl, rtInitDecl, mainPkgPath, mainPkgPath,
-			startDefine, mainDefine, stdioNobuf,
-			pyInit, rtInit, mainPkgPath, mainPkgPath)
-	}
-
-	return exportObject(ctx, pkg.PkgPath+".main", pkg.ExportFile+"-main", []byte(mainCode))
-}
-
 func is32Bits(goarch string) bool {
 	return goarch == "386" || goarch == "arm" || goarch == "mips" || goarch == "wasm"
 }
@@ -1044,7 +938,7 @@ func buildPkg(ctx *context, aPkg *aPackage, verbose bool) error {
 		cl.SetDebug(cl.DbgFlagAll)
 	}
 
-	ret, externs, err := cl.NewPackageEx(ctx.prog, ctx.patches, aPkg.rewriteVars, aPkg.SSA, syntax)
+	ret, externs, err := cl.NewPackageEx(ctx.prog, ctx.patches, aPkg.SSA, syntax)
 	if showDetail {
 		llssa.SetDebug(0)
 		cl.SetDebug(0)
@@ -1071,11 +965,10 @@ func buildPkg(ctx *context, aPkg *aPackage, verbose bool) error {
 		aPkg.LinkArgs = append(aPkg.LinkArgs, altLdflags...)
 	}
 	if pkg.ExportFile != "" {
-		exportFile, err := exportObject(ctx, pkg.PkgPath, pkg.ExportFile, []byte(ret.String()))
+		pkg.ExportFile, err = exportObject(ctx, pkg.PkgPath, pkg.ExportFile, []byte(ret.String()))
 		if err != nil {
 			return fmt.Errorf("export object of %v failed: %v", pkgPath, err)
 		}
-		aPkg.LLFiles = append(aPkg.LLFiles, exportFile)
 		if debugBuild || verbose {
 			fmt.Fprintf(os.Stderr, "==> Export %s: %s\n", aPkg.PkgPath, pkg.ExportFile)
 		}
@@ -1084,15 +977,11 @@ func buildPkg(ctx *context, aPkg *aPackage, verbose bool) error {
 }
 
 func exportObject(ctx *context, pkgPath string, exportFile string, data []byte) (string, error) {
-	base := filepath.Base(exportFile)
-	f, err := os.CreateTemp("", base+"-*.ll")
+	f, err := os.CreateTemp("", "llgo-*.ll")
 	if err != nil {
 		return "", err
 	}
-	if _, err := f.Write(data); err != nil {
-		f.Close()
-		return "", err
-	}
+	f.Write(data)
 	err = f.Close()
 	if err != nil {
 		return exportFile, err
@@ -1110,17 +999,13 @@ func exportObject(ctx *context, pkgPath string, exportFile string, data []byte)
 		}
 		return exportFile, os.Rename(f.Name(), exportFile)
 	}
-	objFile, err := os.CreateTemp("", base+"-*.o")
-	if err != nil {
-		return "", err
-	}
-	objFile.Close()
-	args := []string{"-o", objFile.Name(), "-c", f.Name(), "-Wno-override-module"}
+	exportFile += ".o"
+	args := []string{"-o", exportFile, "-c", f.Name(), "-Wno-override-module"}
 	if ctx.buildConf.Verbose {
 		fmt.Fprintln(os.Stderr, "clang", args)
 	}
 	cmd := ctx.compiler()
-	return objFile.Name(), cmd.Compile(args...)
+	return exportFile, cmd.Compile(args...)
 }
 
 func llcCheck(env *llvm.Env, exportFile string) (msg string, err error) {
@@ -1174,9 +1059,8 @@ type aPackage struct {
 	AltPkg *packages.Cached
 	LPkg   llssa.Package
 
-	LinkArgs    []string
-	LLFiles     []string
-	rewriteVars map[string]string
+	LinkArgs []string
+	LLFiles  []string
 }
 
 type Package = *aPackage
@@ -1197,8 +1081,7 @@ func allPkgs(ctx *context, initial []*packages.Package, verbose bool) (all []*aP
 					return
 				}
 			}
-			rewrites := collectRewriteVars(ctx, pkgPath)
-			all = append(all, &aPackage{p, ssaPkg, altPkg, nil, nil, nil, rewrites})
+			all = append(all, &aPackage{p, ssaPkg, altPkg, nil, nil, nil})
 		} else {
 			errs = append(errs, p)
 		}
@@ -1206,32 +1089,6 @@ func allPkgs(ctx *context, initial []*packages.Package, verbose bool) (all []*aP
 	return
 }
 
-func collectRewriteVars(ctx *context, pkgPath string) map[string]string {
-	data := ctx.buildConf.GlobalRewrites
-	if len(data) == 0 {
-		return nil
-	}
-	basePath := strings.TrimPrefix(pkgPath, altPkgPathPrefix)
-	if vars := data[basePath]; vars != nil {
-		return cloneRewrites(vars)
-	}
-	if vars := data[pkgPath]; vars != nil {
-		return cloneRewrites(vars)
-	}
-	return nil
-}
-
-func cloneRewrites(src Rewrites) map[string]string {
-	if len(src) == 0 {
-		return nil
-	}
-	dup := make(map[string]string, len(src))
-	for k, v := range src {
-		dup[k] = v
-	}
-	return dup
-}
-
 func createSSAPkg(prog *ssa.Program, p *packages.Package, verbose bool) *ssa.Package {
 	pkgSSA := prog.ImportedPackage(p.ID)
 	if pkgSSA == nil {

internal/build/build_test.go

@@ -8,9 +8,6 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
 	"testing"
 
 	"github.com/goplus/llgo/internal/mockable"
@@ -97,65 +94,4 @@ func TestCmpTest(t *testing.T) {
 	mockRun([]string{"../../cl/_testgo/runtest"}, &Config{Mode: ModeCmpTest})
 }
 
-const (
-	rewriteMainPkg = "github.com/goplus/llgo/cl/_testgo/rewrite"
-	rewriteDepPkg  = rewriteMainPkg + "/dep"
-	rewriteDirPath = "../../cl/_testgo/rewrite"
-)
-
-func TestLdFlagsRewriteVars(t *testing.T) {
-	buildRewriteBinary(t, false, "build-main", "build-pkg")
-	buildRewriteBinary(t, false, "rerun-main", "rerun-pkg")
-}
-
-func TestLdFlagsRewriteVarsMainAlias(t *testing.T) {
-	buildRewriteBinary(t, true, "alias-main", "alias-pkg")
-}
-
-func buildRewriteBinary(t *testing.T, useMainAlias bool, mainVal, depVal string) {
-	t.Helper()
-	binPath := filepath.Join(t.TempDir(), "rewrite")
-	if runtime.GOOS == "windows" {
-		binPath += ".exe"
-	}
-
-	cfg := &Config{Mode: ModeBuild, OutFile: binPath}
-	mainKey := rewriteMainPkg
-	var mainPkgs []string
-	if useMainAlias {
-		mainKey = "main"
-		mainPkgs = []string{rewriteMainPkg}
-	}
-	mainPlain := mainVal + "-plain"
-	depPlain := depVal + "-plain"
-	gorootVal := "goroot-" + mainVal
-	versionVal := "version-" + mainVal
-	addGlobalString(cfg, mainKey+".VarName="+mainVal, mainPkgs)
-	addGlobalString(cfg, mainKey+".VarPlain="+mainPlain, mainPkgs)
-	addGlobalString(cfg, rewriteDepPkg+".VarName="+depVal, nil)
-	addGlobalString(cfg, rewriteDepPkg+".VarPlain="+depPlain, nil)
-	addGlobalString(cfg, "runtime.defaultGOROOT="+gorootVal, nil)
-	addGlobalString(cfg, "runtime.buildVersion="+versionVal, nil)
-
-	if _, err := Do([]string{rewriteDirPath}, cfg); err != nil {
-		t.Fatalf("ModeBuild failed: %v", err)
-	}
-	got := runBinary(t, binPath)
-	want := fmt.Sprintf(
-		"main.VarName: %s\nmain.VarPlain: %s\ndep.VarName: %s\ndep.VarPlain: %s\nruntime.GOROOT(): %s\nruntime.Version(): %s\n",
-		mainVal, mainPlain, depVal, depPlain, gorootVal, versionVal,
-	)
-	if got != want {
-		t.Fatalf("unexpected binary output:\nwant %q\ngot  %q", want, got)
-	}
-}
-
-func runBinary(t *testing.T, path string, args ...string) string {
-	t.Helper()
-	cmd := exec.Command(path, args...)
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("failed to run %s: %v\n%s", path, err, output)
-	}
-	return string(output)
-}
+// TestGenerateOutputFilenames removed - functionality moved to filename_test.go

internal/build/main_module.go

@@ -0,0 +1,213 @@
+//go:build !llgo
+// +build !llgo
+
+/*
+ * 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 build
+
+import (
+	"go/token"
+	"go/types"
+
+	"github.com/goplus/llgo/internal/packages"
+	llvm "github.com/goplus/llvm"
+
+	llssa "github.com/goplus/llgo/ssa"
+)
+
+func genMainModule(ctx *context, rtPkgPath string, pkg *packages.Package, needRuntime, needPyInit bool) Package {
+	prog := ctx.prog
+	mainPkg := prog.NewPackage("", pkg.ID+".main")
+
+	argcVar := mainPkg.NewVarEx("__llgo_argc", prog.Pointer(prog.Int32()))
+	argcVar.Init(prog.Zero(prog.Int32()))
+
+	argvValueType := prog.Pointer(prog.CStr())
+	argvVar := mainPkg.NewVarEx("__llgo_argv", prog.Pointer(argvValueType))
+	argvVar.InitNil()
+
+	exportFile := pkg.ExportFile
+	if exportFile == "" {
+		exportFile = pkg.PkgPath
+	}
+	mainAPkg := &aPackage{
+		Package: &packages.Package{
+			PkgPath:    pkg.PkgPath + ".main",
+			ExportFile: exportFile + "-main",
+		},
+		LPkg: mainPkg,
+	}
+
+	if ctx.buildConf.BuildMode != BuildModeExe {
+		return mainAPkg
+	}
+
+	runtimeStub := defineWeakNoArgStub(mainPkg, "runtime.init")
+	// Define syscall.init as a weak stub to allow linking even when syscall package is not imported
+	defineWeakNoArgStub(mainPkg, "syscall.init")
+
+	var pyInit llssa.Function
+	if needPyInit {
+		pyInit = declareNoArgFunc(mainPkg, "Py_Initialize")
+	}
+
+	var rtInit llssa.Function
+	if needRuntime {
+		rtInit = declareNoArgFunc(mainPkg, rtPkgPath+".init")
+	}
+
+	mainInit := declareNoArgFunc(mainPkg, pkg.PkgPath+".init")
+	mainMain := declareNoArgFunc(mainPkg, pkg.PkgPath+".main")
+
+	entryFn := defineEntryFunction(ctx, mainPkg, argcVar, argvVar, argvValueType, runtimeStub, mainInit, mainMain, pyInit, rtInit)
+
+	if needStart(ctx) {
+		defineStart(mainPkg, entryFn, argvValueType)
+	}
+
+	return mainAPkg
+}
+
+func defineEntryFunction(ctx *context, pkg llssa.Package, argcVar, argvVar llssa.Global, argvType llssa.Type, runtimeStub, mainInit, mainMain llssa.Function, pyInit, rtInit llssa.Function) llssa.Function {
+	prog := pkg.Prog
+	entryName := "main"
+	if !needStart(ctx) && isWasmTarget(ctx.buildConf.Goos) {
+		entryName = "__main_argc_argv"
+	}
+	sig := newEntrySignature(argvType.RawType())
+	fn := pkg.NewFunc(entryName, sig, llssa.InC)
+	fnVal := pkg.Module().NamedFunction(entryName)
+	if entryName != "main" {
+		fnVal.SetVisibility(llvm.HiddenVisibility)
+		fnVal.SetUnnamedAddr(true)
+	}
+	b := fn.MakeBody(1)
+	b.Store(argcVar.Expr, fn.Param(0))
+	b.Store(argvVar.Expr, fn.Param(1))
+	if IsStdioNobuf() {
+		emitStdioNobuf(b, pkg, ctx.buildConf.Goarch)
+	}
+	if pyInit != nil {
+		b.Call(pyInit.Expr)
+	}
+	if rtInit != nil {
+		b.Call(rtInit.Expr)
+	}
+	b.Call(runtimeStub.Expr)
+	b.Call(mainInit.Expr)
+	b.Call(mainMain.Expr)
+	b.Return(prog.IntVal(0, prog.Int32()))
+	return fn
+}
+
+func defineStart(pkg llssa.Package, entry llssa.Function, argvType llssa.Type) {
+	fn := pkg.NewFunc("_start", llssa.NoArgsNoRet, llssa.InC)
+	pkg.Module().NamedFunction("_start").SetLinkage(llvm.WeakAnyLinkage)
+	b := fn.MakeBody(1)
+	prog := pkg.Prog
+	b.Call(entry.Expr, prog.IntVal(0, prog.Int32()), prog.Nil(argvType))
+	b.Return()
+}
+
+func declareNoArgFunc(pkg llssa.Package, name string) llssa.Function {
+	return pkg.NewFunc(name, llssa.NoArgsNoRet, llssa.InC)
+}
+
+func defineWeakNoArgStub(pkg llssa.Package, name string) llssa.Function {
+	fn := pkg.NewFunc(name, llssa.NoArgsNoRet, llssa.InC)
+	pkg.Module().NamedFunction(name).SetLinkage(llvm.WeakAnyLinkage)
+	b := fn.MakeBody(1)
+	b.Return()
+	return fn
+}
+
+func emitStdioNobuf(b llssa.Builder, pkg llssa.Package, goarch string) {
+	prog := pkg.Prog
+	streamType := prog.VoidPtr()
+	streamPtrType := prog.Pointer(streamType)
+	stdout := declareExternalPtrGlobal(pkg, "stdout", streamType)
+	stderr := declareExternalPtrGlobal(pkg, "stderr", streamType)
+	stdoutAlt := declareExternalPtrGlobal(pkg, "__stdout", streamType)
+	stderrAlt := declareExternalPtrGlobal(pkg, "__stderr", streamType)
+	sizeType := prog.Uintptr()
+	setvbuf := declareSetvbuf(pkg, streamPtrType, prog.CStr(), prog.Int32(), sizeType)
+
+	stdoutSlot := b.AllocaT(streamPtrType)
+	b.Store(stdoutSlot, stdout)
+	condOut := b.BinOp(token.EQL, stdout, prog.Nil(streamPtrType))
+	b.IfThen(condOut, func() {
+		b.Store(stdoutSlot, stdoutAlt)
+	})
+	stdoutPtr := b.Load(stdoutSlot)
+
+	stderrSlot := b.AllocaT(streamPtrType)
+	b.Store(stderrSlot, stderr)
+	condErr := b.BinOp(token.EQL, stderr, prog.Nil(streamPtrType))
+	b.IfThen(condErr, func() {
+		b.Store(stderrSlot, stderrAlt)
+	})
+	stderrPtr := b.Load(stderrSlot)
+
+	mode := prog.IntVal(2, prog.Int32())
+	zeroSize := prog.Zero(sizeType)
+	nullBuf := prog.Nil(prog.CStr())
+
+	b.Call(setvbuf.Expr, stdoutPtr, nullBuf, mode, zeroSize)
+	b.Call(setvbuf.Expr, stderrPtr, nullBuf, mode, zeroSize)
+}
+
+func declareExternalPtrGlobal(pkg llssa.Package, name string, valueType llssa.Type) llssa.Expr {
+	ptrType := pkg.Prog.Pointer(valueType)
+	global := pkg.NewVarEx(name, ptrType)
+	pkg.Module().NamedGlobal(name).SetLinkage(llvm.ExternalLinkage)
+	return global.Expr
+}
+
+func declareSetvbuf(pkg llssa.Package, streamPtrType, bufPtrType, intType, sizeType llssa.Type) llssa.Function {
+	sig := newSignature(
+		[]types.Type{
+			streamPtrType.RawType(),
+			bufPtrType.RawType(),
+			intType.RawType(),
+			sizeType.RawType(),
+		},
+		[]types.Type{intType.RawType()},
+	)
+	return pkg.NewFunc("setvbuf", sig, llssa.InC)
+}
+
+func tupleOf(tys ...types.Type) *types.Tuple {
+	if len(tys) == 0 {
+		return types.NewTuple()
+	}
+	vars := make([]*types.Var, len(tys))
+	for i, t := range tys {
+		vars[i] = types.NewParam(token.NoPos, nil, "", t)
+	}
+	return types.NewTuple(vars...)
+}
+
+func newSignature(params []types.Type, results []types.Type) *types.Signature {
+	return types.NewSignatureType(nil, nil, nil, tupleOf(params...), tupleOf(results...), false)
+}
+
+func newEntrySignature(argvType types.Type) *types.Signature {
+	return newSignature(
+		[]types.Type{types.Typ[types.Int32], argvType},
+		[]types.Type{types.Typ[types.Int32]},
+	)
+}

internal/build/main_module_test.go

@@ -0,0 +1,70 @@
+//go:build !llgo
+// +build !llgo
+
+package build
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/goplus/llvm"
+
+	"github.com/goplus/llgo/internal/packages"
+	llssa "github.com/goplus/llgo/ssa"
+)
+
+func init() {
+	llssa.Initialize(llssa.InitAll)
+}
+
+func TestGenMainModuleExecutable(t *testing.T) {
+	llvm.InitializeAllTargets()
+	t.Setenv(llgoStdioNobuf, "")
+	ctx := &context{
+		prog: llssa.NewProgram(nil),
+		buildConf: &Config{
+			BuildMode: BuildModeExe,
+			Goos:      "linux",
+			Goarch:    "amd64",
+		},
+	}
+	pkg := &packages.Package{PkgPath: "example.com/foo", ExportFile: "foo.a"}
+	mod := genMainModule(ctx, llssa.PkgRuntime, pkg, true, true)
+	if mod.ExportFile != "foo.a-main" {
+		t.Fatalf("unexpected export file: %s", mod.ExportFile)
+	}
+	ir := mod.LPkg.String()
+	checks := []string{
+		"define i32 @main(",
+		"call void @Py_Initialize()",
+		"call void @\"example.com/foo.init\"()",
+		"define weak void @_start()",
+	}
+	for _, want := range checks {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("main module IR missing %q:\n%s", want, ir)
+		}
+	}
+}
+
+func TestGenMainModuleLibrary(t *testing.T) {
+	llvm.InitializeAllTargets()
+	t.Setenv(llgoStdioNobuf, "")
+	ctx := &context{
+		prog: llssa.NewProgram(nil),
+		buildConf: &Config{
+			BuildMode: BuildModeCArchive,
+			Goos:      "linux",
+			Goarch:    "amd64",
+		},
+	}
+	pkg := &packages.Package{PkgPath: "example.com/foo", ExportFile: "foo.a"}
+	mod := genMainModule(ctx, llssa.PkgRuntime, pkg, false, false)
+	ir := mod.LPkg.String()
+	if strings.Contains(ir, "define i32 @main") {
+		t.Fatalf("library mode should not emit main function:\n%s", ir)
+	}
+	if !strings.Contains(ir, "@__llgo_argc = global i32 0") {
+		t.Fatalf("library mode missing argc global:\n%s", ir)
+	}
+}

ssa/globals.go

@@ -31,19 +31,6 @@ func (pkg Package) AddGlobalString(name string, value string) {
 	pkg.NewVarEx(name, prog.Pointer(styp)).Init(Expr{cv, styp})
 }
 
-// ConstString creates an SSA expression representing a Go string literal. The
-// returned value is backed by an anonymous global constant and can be used to
-// initialize package-level variables or other constant contexts that expect a
-// Go string value.
-func (pkg Package) ConstString(value string) Expr {
-	prog := pkg.Prog
-	styp := prog.String()
-	data := pkg.createGlobalStr(value)
-	length := prog.IntVal(uint64(len(value)), prog.Uintptr())
-	cv := llvm.ConstNamedStruct(styp.ll, []llvm.Value{data, length.impl})
-	return Expr{cv, styp}
-}
-
 // Undefined global string var by names
 func (pkg Package) Undefined(names ...string) error {
 	prog := pkg.Prog