build: use LLVM memcpyopt pass to replace cabi load/store optimization

- Add targetInfo() to return TargetData and TargetMachine
- Add TargetMachine() and DataLayout() methods to Program
- Set data layout and target triple before running LLVM passes
- Run memcpyopt pass after IR generation to convert load/store to memcpy

This replaces the manual optimization in cabi with LLVM's built-in
memcpyopt pass, which handles more cases and is more robust.

Fixes #1605

Author: luoliwoshang

internal/build/build.go

@@ -54,6 +54,7 @@ import (
 	"github.com/goplus/llgo/ssa/abi"
 	xenv "github.com/goplus/llgo/xtool/env"
 	"github.com/goplus/llgo/xtool/env/llvm"
+	gollvm "github.com/goplus/llvm"
 
 	llruntime "github.com/goplus/llgo/runtime"
 	llssa "github.com/goplus/llgo/ssa"
@@ -142,6 +143,7 @@ type Config struct {
 	SizeFormat    string // size report format: text,json (default text)
 	SizeLevel     string // size aggregation level: full,module,package (default module)
 	CompilerHash  string // metadata hash for the running compiler (development builds only)
+	SkipTargetInfo bool  // skip setting data layout and target triple (for test generation)
 	// 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
@@ -1158,6 +1160,19 @@ func buildPkg(ctx *context, aPkg *aPackage, verbose bool) error {
 
 	ctx.cTransformer.TransformModule(ret.Path(), ret.Module())
 
+	// Run LLVM optimization passes (memcpyopt converts load/store to memcpy)
+	// Skip when SkipTargetInfo is set (for test generation to avoid target-specific output)
+	if !ctx.buildConf.SkipTargetInfo {
+		mod := ret.Module()
+		mod.SetDataLayout(ctx.prog.DataLayout())
+		mod.SetTarget(ctx.prog.Target().Spec().Triple)
+		pbo := gollvm.NewPassBuilderOptions()
+		defer pbo.Dispose()
+		if err := mod.RunPasses("memcpyopt", ctx.prog.TargetMachine(), pbo); err != nil {
+			return fmt.Errorf("run LLVM passes failed for %v: %v", pkgPath, err)
+		}
+	}
+
 	printCmds := ctx.shouldPrintCommands(verbose)
 	cgoLLFiles, cgoLdflags, err := buildCgo(ctx, aPkg, aPkg.Package.Syntax, externs, printCmds)
 	if err != nil {

internal/llgen/llgenf.go

@@ -45,8 +45,9 @@ func genFrom(pkgPath string, abiMode build.AbiMode) (build.Package, error) {
 	}()
 
 	conf := &build.Config{
-		Mode:    build.ModeGen,
-		AbiMode: abiMode,
+		Mode:           build.ModeGen,
+		AbiMode:        abiMode,
+		SkipTargetInfo: true,
 	}
 	pkgs, err := build.Do([]string{pkgPath}, conf)
 	if err != nil {

ssa/package.go

@@ -22,6 +22,7 @@ import (
 	"go/types"
 	"runtime"
 	"strconv"
+	"testing"
 	"unsafe"
 
 	"github.com/goplus/llgo/internal/env"
@@ -117,9 +118,9 @@ type aProgram struct {
 	py    *types.Package
 	pyget func() *types.Package
 
-	target *Target
-	td     llvm.TargetData
-	// tm  llvm.TargetMachine
+	target  *Target
+	td      llvm.TargetData
+	tm      llvm.TargetMachine
 	named   map[string]Type
 	fnnamed map[string]int
 
@@ -247,7 +248,7 @@ func NewProgram(target *Target) Program {
 		}
 	}
 	ctx := llvm.NewContext()
-	td := target.targetData() // TODO(xsw): target config
+	td, tm := target.targetInfo()
 	/*
 		arch := target.GOARCH
 		if arch == "" {
@@ -261,7 +262,7 @@ func NewProgram(target *Target) Program {
 	is32Bits := (td.PointerSize() == 4 || is32Bits(target.GOARCH))
 	return &aProgram{
 		ctx: ctx, gocvt: newGoTypes(),
-		target: target, td: td, is32Bits: is32Bits,
+		target: target, td: td, tm: tm, is32Bits: is32Bits,
 		ptrSize: td.PointerSize(), named: make(map[string]Type), fnnamed: make(map[string]int),
 		linkname: make(map[string]string), abiSymbol: make(map[string]Type),
 	}
@@ -275,6 +276,14 @@ func (p Program) TargetData() llvm.TargetData {
 	return p.td
 }
 
+func (p Program) TargetMachine() llvm.TargetMachine {
+	return p.tm
+}
+
+func (p Program) DataLayout() string {
+	return p.td.String()
+}
+
 func (p Program) SetPatch(patchType func(types.Type) types.Type) {
 	p.patchType = patchType
 }
@@ -413,6 +422,7 @@ func (p Program) NewPackage(name, pkgPath string) Package {
 	// if p.target.GOARCH != runtime.GOARCH && p.target.GOOS != runtime.GOOS {
 	// 	mod.SetTarget(p.target.Spec().Triple)
 	// }
+	testing.Testing()
 
 	// TODO(xsw): Finalize may cause panic, so comment it.
 	// mod.Finalize()

ssa/target.go

@@ -62,7 +62,7 @@ func (t *Target) CtxRegister() CtxRegister {
 	return CtxRegister{Name: info.Name, Constraint: info.Constraint}
 }
 
-func (p *Target) targetData() llvm.TargetData {
+func (p *Target) targetInfo() (llvm.TargetData, llvm.TargetMachine) {
 	spec := p.Spec()
 	if spec.Triple == "" {
 		spec.Triple = llvm.DefaultTargetTriple()
@@ -72,30 +72,9 @@ func (p *Target) targetData() llvm.TargetData {
 		panic(err)
 	}
 	machine := t.CreateTargetMachine(spec.Triple, spec.CPU, spec.Features, llvm.CodeGenLevelDefault, llvm.RelocDefault, llvm.CodeModelDefault)
-	return machine.CreateTargetData()
+	return machine.CreateTargetData(), machine
 }
 
-/*
-func (p *Program) targetMachine() llvm.TargetMachine {
-	if p.tm.C == nil {
-		spec := p.target.toSpec()
-		target, err := llvm.GetTargetFromTriple(spec.triple)
-		if err != nil {
-			panic(err)
-		}
-		p.tm = target.CreateTargetMachine(
-			spec.triple,
-			spec.cpu,
-			spec.features,
-			llvm.CodeGenLevelDefault,
-			llvm.RelocDefault,
-			llvm.CodeModelDefault,
-		)
-	}
-	return p.tm
-}
-*/
-
 type TargetSpec struct {
 	Triple   string
 	CPU      string