build: gen pkg to object

Author: visualfc

internal/build/build.go

@@ -77,6 +77,7 @@ type Config struct {
 	Mode        Mode
 	GenExpect   bool // only valid for ModeCmpTest
 	Verbose     bool
+	GenLL       bool // generate pkg .ll files
 	Tags        string
 	GlobalNames map[string][]string // pkg => names
 	GlobalDatas map[string]string   // pkg.name => data
@@ -252,7 +253,17 @@ func Do(args []string, conf *Config) ([]Package, error) {
 	output := conf.OutFile != ""
 	export, err := crosscompile.Use(conf.Goos, conf.Goarch, IsWasiThreadsEnabled(), IsRpathChangeEnabled())
 	check(err)
-	ctx := &context{env, cfg, progSSA, prog, dedup, patches, make(map[string]none), initial, mode, 0, output, make(map[*packages.Package]bool), make(map[*packages.Package]bool), conf, export}
+	ctx := &context{env: env, conf: cfg, progSSA: progSSA, prog: prog, dedup: dedup,
+		patches: patches, built: make(map[string]none), initial: initial, mode: mode,
+		output:           output,
+		needRt:           make(map[*packages.Package]bool),
+		needPyInit:       make(map[*packages.Package]bool),
+		buildConf:        conf,
+		crossCompile:     export,
+		isDbgEnabled:     IsDbgEnabled(),
+		isDbgSymsEnabled: IsDbgSymsEnabled(),
+		isCheckEnable:    IsCheckEnable(),
+	}
 	pkgs, err := buildAllPkgs(ctx, initial, verbose)
 	check(err)
 	if mode == ModeGen {
@@ -337,6 +348,10 @@ type context struct {
 	nLibdir int
 	output  bool
 
+	isDbgEnabled     bool
+	isDbgSymsEnabled bool
+	isCheckEnable    bool
+
 	needRt     map[*packages.Package]bool
 	needPyInit map[*packages.Package]bool
 
@@ -797,20 +812,56 @@ func buildPkg(ctx *context, aPkg *aPackage, verbose bool) error {
 		aPkg.LinkArgs = append(aPkg.LinkArgs, altLdflags...)
 	}
 	if pkg.ExportFile != "" {
-		pkg.ExportFile += ".ll"
-		os.WriteFile(pkg.ExportFile, []byte(ret.String()), 0644)
+		err := exportObject(ctx, pkg, ret, verbose)
+		if err != nil {
+			return fmt.Errorf("export object of %v failed: %v", pkgPath, err)
+		}
 		if debugBuild || verbose {
 			fmt.Fprintf(os.Stderr, "==> Export %s: %s\n", aPkg.PkgPath, pkg.ExportFile)
 		}
-		if IsCheckEnable() {
-			if msg, err := llcCheck(ctx.env, pkg.ExportFile); err != nil {
-				fmt.Fprintf(os.Stderr, "==> lcc %v: %v\n%v\n", pkg.PkgPath, pkg.ExportFile, msg)
-			}
-		}
 	}
 	return nil
 }
 
+func exportObject(ctx *context, pkg *packages.Package, ret llssa.Package, verbose bool) error {
+	f, err := os.CreateTemp("", "llgo-*.ll")
+	if err != nil {
+		return err
+	}
+	f.Write([]byte(ret.String()))
+	err = f.Close()
+	if err != nil {
+		return err
+	}
+	if ctx.isCheckEnable {
+		if msg, err := llcCheck(ctx.env, f.Name()); err != nil {
+			fmt.Fprintf(os.Stderr, "==> lcc %v: %v\n%v\n", pkg.PkgPath, f.Name(), msg)
+		}
+	}
+	var llfile string
+	if ctx.buildConf.GenLL {
+		llfile = pkg.ExportFile + ".ll"
+		err = os.Chmod(llfile, 0644)
+		if err != nil {
+			return err
+		}
+		err = os.Rename(f.Name(), llfile)
+		if err != nil {
+			return err
+		}
+	} else {
+		llfile = f.Name()
+	}
+	pkg.ExportFile += ".o"
+	args := []string{"-o", pkg.ExportFile, "-c", llfile, "-Wno-override-module"}
+	args = append(args, ctx.crossCompile.CCFLAGS...)
+	if verbose {
+		fmt.Fprintln(os.Stderr, "clang", args)
+	}
+	cmd := ctx.compiler()
+	return cmd.Compile(args...)
+}
+
 func llcCheck(env *llvm.Env, exportFile string) (msg string, err error) {
 	bin := filepath.Join(env.BinDir(), "llc")
 	cmd := exec.Command(bin, "-filetype=null", exportFile)
@@ -1026,15 +1077,20 @@ func clFiles(ctx *context, files string, pkg *packages.Package, procFile func(li
 }
 
 func clFile(ctx *context, args []string, cFile, expFile string, procFile func(linkFile string), verbose bool) {
-	llFile := expFile + filepath.Base(cFile) + ".ll"
+	llFile := expFile + filepath.Base(cFile)
 	ext := filepath.Ext(cFile)
 
 	// default clang++ will use c++ to compile c file,will cause symbol be mangled
 	if ext == ".c" {
 		args = append(args, "-x", "c")
 	}
-
-	args = append(args, "-emit-llvm", "-S", "-o", llFile, "-c", cFile)
+	if ctx.buildConf.GenLL {
+		llFile += ".ll"
+		args = append(args, "-emit-llvm", "-S", "-o", llFile, "-c", cFile)
+	} else {
+		llFile += ".o"
+		args = append(args, "-o", llFile, "-c", cFile)
+	}
 	args = append(args, ctx.crossCompile.CCFLAGS...)
 	args = append(args, ctx.crossCompile.CFLAGS...)
 	if verbose {

internal/crosscompile/cosscompile.go

@@ -36,7 +36,6 @@ func Use(goos, goarch string, wasiThreads, changeRpath bool) (export Export, err
 			"-Wno-override-module",
 			"-Wl,--error-limit=0",
 			"-fuse-ld=lld",
-			"-Wno-override-module",
 		}
 
 		// Add OS-specific flags
@@ -56,6 +55,11 @@ func Use(goos, goarch string, wasiThreads, changeRpath bool) (export Export, err
 		case "windows": // lld-link (Windows)
 			// TODO(lijie): Add options for Windows.
 		default: // ld.lld (Unix)
+			export.CCFLAGS = append(
+				export.CCFLAGS,
+				"-fdata-sections",
+				"-ffunction-sections",
+			)
 			export.LDFLAGS = append(
 				export.LDFLAGS,
 				"-fdata-sections",
@@ -105,6 +109,8 @@ func Use(goos, goarch string, wasiThreads, changeRpath bool) (export Export, err
 			"-target", targetTriple,
 			"--sysroot=" + sysrootDir,
 			"-resource-dir=" + libclangDir,
+			"-matomics",
+			"-mbulk-memory",
 		}
 		export.CFLAGS = []string{
 			"-I" + includeDir,
@@ -138,6 +144,10 @@ func Use(goos, goarch string, wasiThreads, changeRpath bool) (export Export, err
 		}
 		// Add thread support if enabled
 		if wasiThreads {
+			export.CCFLAGS = append(
+				export.CCFLAGS,
+				"-pthread",
+			)
 			export.LDFLAGS = append(
 				export.LDFLAGS,
 				"-lwasi-emulated-pthread",

internal/crosscompile/crosscompile_test.go

@@ -146,7 +146,7 @@ func TestUseCrossCompileSDK(t *testing.T) {
 					}
 				}
 			} else {
-				if len(export.CCFLAGS) != 0 || len(export.CFLAGS) != 0 {
+				if /*len(export.CCFLAGS) != 0 ||*/ len(export.CFLAGS) != 0 {
 					t.Errorf("Expected empty export, got CCFLAGS=%v, CFLAGS=%v, LDFLAGS=%v",
 						export.CCFLAGS, export.CFLAGS, export.LDFLAGS)
 				}