build: refactor main module generation
This commit is contained in:
Li Jie
221
internal/build/main_module.go
Normal file
221
internal/build/main_module.go
Normal file
@@ -0,0 +1,221 @@
|
||||
//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"
|
||||
"runtime"
|
||||
|
||||
"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, error) {
|
||||
prog := ctx.prog
|
||||
mainPkg := prog.NewPackage("", pkg.PkgPath+".main")
|
||||
|
||||
argcVar := mainPkg.NewVarEx("__llgo_argc", prog.Pointer(prog.Int32()))
|
||||
argcVar.Init(prog.Zero(prog.Int32()))
|
||||
|
||||
charPtrType := prog.Pointer(prog.Byte())
|
||||
argvValueType := prog.Pointer(charPtrType)
|
||||
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, nil
|
||||
}
|
||||
|
||||
runtimeStub := defineWeakNoArgStub(mainPkg, "runtime.init")
|
||||
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, nil
|
||||
}
|
||||
|
||||
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 := sizeTypeForArch(prog, goarch)
|
||||
charPtrType := prog.Pointer(prog.Byte())
|
||||
setvbuf := declareSetvbuf(pkg, streamPtrType, charPtrType, prog.Int32(), sizeType)
|
||||
|
||||
stdoutSlot := b.AllocaT(streamPtrType)
|
||||
b.Store(stdoutSlot, stdout)
|
||||
stderrSlot := b.AllocaT(streamPtrType)
|
||||
b.Store(stderrSlot, stderr)
|
||||
cond := b.BinOp(token.EQL, stdout, prog.Nil(streamPtrType))
|
||||
b.IfThen(cond, func() {
|
||||
b.Store(stdoutSlot, stdoutAlt)
|
||||
b.Store(stderrSlot, stderrAlt)
|
||||
})
|
||||
stdoutPtr := b.Load(stdoutSlot)
|
||||
stderrPtr := b.Load(stderrSlot)
|
||||
|
||||
mode := prog.IntVal(2, prog.Int32())
|
||||
zeroSize := prog.Zero(sizeType)
|
||||
nullBuf := prog.Nil(charPtrType)
|
||||
|
||||
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]},
|
||||
)
|
||||
}
|
||||
|
||||
func sizeTypeForArch(prog llssa.Program, arch string) llssa.Type {
|
||||
if arch == "" {
|
||||
arch = runtime.GOARCH
|
||||
}
|
||||
if is32Bits(arch) {
|
||||
return prog.Uint32()
|
||||
}
|
||||
return prog.Uint64()
|
||||
}
|
||||
Reference in New Issue
Block a user