admin/llgo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

build: link globals importpath.name=value

Browse Source
This commit is contained in:
visualfc
2025-05-24 19:11:18 +08:00
parent e68355d94f
commit 4726e824a0
6 changed files with 230 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
internal/build/build.go
View File

@@ -19,6 +19,7 @@ package build
import (
"bytes"
"debug/macho"
"errors"
"fmt"
"go/ast"
"go/constant"
@@ -67,16 +68,18 @@ const (
)
type Config struct {
Goos string
Goarch string
BinPath string
AppExt string // ".exe" on Windows, empty on Unix
OutFile string // only valid for ModeBuild when len(pkgs) == 1
RunArgs []string // only valid for ModeRun
Mode Mode
GenExpect bool // only valid for ModeCmpTest
Verbose bool
Tags string
Goos string
Goarch string
BinPath string
AppExt string // ".exe" on Windows, empty on Unix
OutFile string // only valid for ModeBuild when len(pkgs) == 1
RunArgs []string // only valid for ModeRun
Mode Mode
GenExpect bool // only valid for ModeCmpTest
Verbose bool
Tags string
GlobalNames map[string][]string // pkg => names
GlobalDatas map[string]string // pkg.name => data
}
func NewDefaultConf(mode Mode) *Config {
@@ -266,9 +269,16 @@ func Do(args []string, conf *Config) ([]Package, error) {
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(conf, ctx.prog, pkgs)
check(err)
for _, pkg := range initial {
if needLink(pkg, mode) {
linkMainPkg(ctx, pkg, allPkgs, conf, mode, verbose)
linkMainPkg(ctx, pkg, allPkgs, global, conf, mode, verbose)
}
}
@@ -429,7 +439,62 @@ func buildAllPkgs(ctx *context, initial []*packages.Package, verbose bool) (pkgs
return
}
func linkMainPkg(ctx *context, pkg *packages.Package, pkgs []*aPackage, conf *Config, mode Mode, verbose bool) {
var (
errXflags = errors.New("-X flag requires argument of the form importpath.name=value")
)
func addGlobalString(conf *Config, arg string, mainPkgs []string) {
eq := strings.Index(arg, "=")
dot := strings.LastIndex(arg[:eq+1], ".")
if eq < 0 || dot < 0 {
panic(errXflags)
}
pkg := arg[:dot]
pkgs := []string{pkg}
if pkg == "main" {
pkgs = mainPkgs
}
if conf.GlobalNames == nil {
conf.GlobalNames = make(map[string][]string)
}
if conf.GlobalDatas == nil {
conf.GlobalDatas = make(map[string]string)
}
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)
}
conf.GlobalDatas[name] = value
}
}
func createGlobals(conf *Config, prog llssa.Program, pkgs []*aPackage) (llssa.Package, error) {
if len(conf.GlobalDatas) == 0 {
return nil, nil
}
for _, pkg := range pkgs {
if pkg.ExportFile == "" {
continue
}
if names, ok := conf.GlobalNames[pkg.PkgPath]; ok {
err := pkg.LPkg.Undefined(names...)
if err != nil {
return nil, err
}
pkg.ExportFile = pkg.ExportFile + "-global.ll"
os.WriteFile(pkg.ExportFile, []byte(pkg.LPkg.String()), 0644)
}
}
global := prog.NewPackage("", "global")
for name, value := range conf.GlobalDatas {
global.AddGlobalString(name, value)
}
return global, nil
}
func linkMainPkg(ctx *context, pkg *packages.Package, pkgs []*aPackage, global llssa.Package, conf *Config, mode Mode, verbose bool) {
pkgPath := pkg.PkgPath
name := path.Base(pkgPath)
app := conf.OutFile
@@ -462,6 +527,7 @@ func linkMainPkg(ctx *context, pkg *packages.Package, pkgs []*aPackage, conf *Co
if p.ExportFile != "" && aPkg != nil { // skip packages that only contain declarations
linkArgs = append(linkArgs, aPkg.LinkArgs...)
llFiles = append(llFiles, aPkg.LLFiles...)
llFiles = append(llFiles, aPkg.ExportFile)
need1, need2 := isNeedRuntimeOrPyInit(ctx, p)
if !needRuntime {
needRuntime = need1
@@ -476,6 +542,12 @@ func linkMainPkg(ctx *context, pkg *packages.Package, pkgs []*aPackage, conf *Co
// defer os.Remove(entryLLFile)
llFiles = append(llFiles, entryLLFile)
if global != nil {
export := pkg.ExportFile + "-global.ll"
os.WriteFile(export, []byte(global.String()), 0666)
llFiles = append(llFiles, export)
}
// add rpath and find libs
exargs := make([]string, 0, ctx.nLibdir<<1)
libs := make([]string, 0, ctx.nLibdir*3)
@@ -726,7 +798,6 @@ func buildPkg(ctx *context, aPkg *aPackage, verbose bool) error {
if pkg.ExportFile != "" {
pkg.ExportFile += ".ll"
os.WriteFile(pkg.ExportFile, []byte(ret.String()), 0644)
aPkg.LLFiles = append(aPkg.LLFiles, pkg.ExportFile)
if debugBuild || verbose {
fmt.Fprintf(os.Stderr, "==> Export %s: %s\n", aPkg.PkgPath, pkg.ExportFile)
}

13
runtime/internal/lib/runtime/runtime.go
View File

@@ -31,11 +31,16 @@ const (
LLGoFiles = "_wrap/runtime.c"
)
// GOROOT returns the root of the Go tree. It uses the
// GOROOT environment variable, if set at process start,
// or else the root used during the Go build.
var defaultGOROOT string // set by cmd/link
func GOROOT() string {
return ""
return defaultGOROOT
}
var buildVersion string
func Version() string {
return buildVersion
}
//go:linkname c_maxprocs C.llgo_maxprocs

23
ssa/expr.go
View File

@@ -301,32 +301,11 @@ func (b Builder) CMalloc(n Expr) Expr {
// Str returns a Go string constant expression.
func (b Builder) Str(v string) Expr {
prog := b.Prog
data := b.createGlobalStr(v)
data := b.Pkg.createGlobalStr(v)
size := llvm.ConstInt(prog.tyInt(), uint64(len(v)), false)
return Expr{aggregateValue(b.impl, prog.rtString(), data, size), prog.String()}
}
func (b Builder) createGlobalStr(v string) (ret llvm.Value) {
if ret, ok := b.Pkg.strs[v]; ok {
return ret
}
prog := b.Prog
if v != "" {
typ := llvm.ArrayType(prog.tyInt8(), len(v))
global := llvm.AddGlobal(b.Pkg.mod, typ, "")
global.SetInitializer(b.Prog.ctx.ConstString(v, false))
global.SetLinkage(llvm.PrivateLinkage)
global.SetGlobalConstant(true)
global.SetUnnamedAddr(true)
global.SetAlignment(1)
ret = llvm.ConstInBoundsGEP(typ, global, []llvm.Value{prog.Val(0).impl})
} else {
ret = llvm.ConstNull(prog.CStr().ll)
}
b.Pkg.strs[v] = ret
return
}
// unsafeString(data *byte, size int) string
func (b Builder) unsafeString(data, size llvm.Value) Expr {
prog := b.Prog

53
ssa/globals.go Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright (c) 2025 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 ssa
import (
"fmt"
"github.com/goplus/llvm"
)
func (pkg Package) AddGlobalString(name string, value string) {
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})
pkg.NewVarEx(name, prog.Pointer(styp)).Init(Expr{cv, styp})
}
// Undefined global string var by names
func (pkg Package) Undefined(names ...string) error {
prog := pkg.Prog
styp := prog.rtString()
for _, name := range names {
global := pkg.VarOf(name)
if global == nil {
continue
}
typ := prog.Elem(global.Type)
if typ.ll != styp {
return fmt.Errorf("%s: not a var of type string (type:%v)", name, typ.RawType())
}
newGlobal := llvm.AddGlobal(pkg.mod, styp, "")
global.impl.ReplaceAllUsesWith(newGlobal)
global.impl.EraseFromParentAsGlobal()
newGlobal.SetName(name)
}
return nil
}

21
ssa/package.go
View File

@@ -788,6 +788,27 @@ func (p Package) InitDebug(name, pkgPath string, positioner Positioner) {
p.cu = p.di.createCompileUnit(name, pkgPath)
}
func (p Package) createGlobalStr(v string) (ret llvm.Value) {
if ret, ok := p.strs[v]; ok {
return ret
}
prog := p.Prog
if v != "" {
typ := llvm.ArrayType(prog.tyInt8(), len(v))
global := llvm.AddGlobal(p.mod, typ, "")
global.SetInitializer(prog.ctx.ConstString(v, false))
global.SetLinkage(llvm.PrivateLinkage)
global.SetGlobalConstant(true)
global.SetUnnamedAddr(true)
global.SetAlignment(1)
ret = llvm.ConstInBoundsGEP(typ, global, []llvm.Value{prog.Val(0).impl})
} else {
ret = llvm.ConstNull(prog.CStr().ll)
}
p.strs[v] = ret
return
}
// -----------------------------------------------------------------------------
/*

62
ssa/ssa_test.go
View File

@@ -557,3 +557,65 @@ _llgo_0:
}
`)
}
func TestGlobalStrings(t *testing.T) {
prog := NewProgram(nil)
prog.SetRuntime(func() *types.Package {
fset := token.NewFileSet()
imp := packages.NewImporter(fset)
pkg, _ := imp.Import(PkgRuntime)
return pkg
})
pkg := prog.NewPackage("bar", "foo/bar")
typ := types.NewPointer(types.Typ[types.String])
a := pkg.NewVar("foo/bar.a", typ, InGo)
if pkg.NewVar("foo/bar.a", typ, InGo) != a {
t.Fatal("NewVar(a) failed")
}
a.InitNil()
pkg.NewVarEx("foo/bar.a", prog.Type(typ, InGo))
b := pkg.NewVar("foo/bar.b", typ, InGo)
b.InitNil()
c := pkg.NewVar("foo/bar.c", types.NewPointer(types.Typ[types.Int]), InGo)
c.Init(prog.Val(100))
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
source_filename = "foo/bar"
%"github.com/goplus/llgo/runtime/internal/runtime.String" = type { ptr, i64 }
@"foo/bar.a" = global %"github.com/goplus/llgo/runtime/internal/runtime.String" zeroinitializer, align 8
@"foo/bar.b" = global %"github.com/goplus/llgo/runtime/internal/runtime.String" zeroinitializer, align 8
@"foo/bar.c" = global i64 100, align 8
`)
err := pkg.Undefined("foo/bar.a", "foo/bar.b")
if err != nil {
t.Fatal(err)
}
pkg.Undefined("foo.bar.d")
err = pkg.Undefined("foo/bar.c")
if err == nil {
t.Fatal("must err")
}
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
source_filename = "foo/bar"
%"github.com/goplus/llgo/runtime/internal/runtime.String" = type { ptr, i64 }
@"foo/bar.c" = global i64 100, align 8
@"foo/bar.a" = external global %"github.com/goplus/llgo/runtime/internal/runtime.String"
@"foo/bar.b" = external global %"github.com/goplus/llgo/runtime/internal/runtime.String"
`)
global := prog.NewPackage("", "global")
global.AddGlobalString("foo/bar.a", "1.0")
global.AddGlobalString("foo/bar.b", "info")
assertPkg(t, global, `; ModuleID = 'global'
source_filename = "global"
%"github.com/goplus/llgo/runtime/internal/runtime.String" = type { ptr, i64 }
@0 = private unnamed_addr constant [3 x i8] c"1.0", align 1
@"foo/bar.a" = global %"github.com/goplus/llgo/runtime/internal/runtime.String" { ptr @0, i64 3 }, align 8
@1 = private unnamed_addr constant [4 x i8] c"info", align 1
@"foo/bar.b" = global %"github.com/goplus/llgo/runtime/internal/runtime.String" { ptr @1, i64 4 }, align 8
`)
}