/src/cmd/internal/objabi/zbootstrap.go
/src/go/build/zcgo.go
/src/go/doc/headscan
+/src/internal/buildcfg/zbootstrap.go
/src/runtime/internal/sys/zversion.go
/src/unicode/maketables
/test.out
"bufio"
"bytes"
"fmt"
+ "internal/buildcfg"
"io/ioutil"
"os"
"path/filepath"
"cmd/asm/internal/lex"
"cmd/internal/obj"
- "cmd/internal/objabi"
)
// An end-to-end test for the assembler: Do we print what we parse?
}
func TestARMEndToEnd(t *testing.T) {
- defer func(old int) { objabi.GOARM = old }(objabi.GOARM)
+ defer func(old int) { buildcfg.GOARM = old }(buildcfg.GOARM)
for _, goarm := range []int{5, 6, 7} {
t.Logf("GOARM=%d", goarm)
- objabi.GOARM = goarm
+ buildcfg.GOARM = goarm
testEndToEnd(t, "arm", "arm")
if goarm == 6 {
testEndToEnd(t, "arm", "armv6")
package asm
import (
+ "internal/buildcfg"
"strings"
"testing"
"cmd/asm/internal/arch"
"cmd/asm/internal/lex"
"cmd/internal/obj"
- "cmd/internal/objabi"
)
// A simple in-out test: Do we print what we parse?
func setArch(goarch string) (*arch.Arch, *obj.Link) {
- objabi.GOOS = "linux" // obj can handle this OS for all architectures.
- objabi.GOARCH = goarch
+ buildcfg.GOOS = "linux" // obj can handle this OS for all architectures.
+ buildcfg.GOARCH = goarch
architecture := arch.Set(goarch)
if architecture == nil {
panic("asm: unrecognized architecture " + goarch)
import (
"fmt"
+ "internal/buildcfg"
"os"
"path/filepath"
"strconv"
// Set macros for GOEXPERIMENTs so we can easily switch
// runtime assembly code based on them.
if *flags.CompilingRuntime {
- for _, exp := range objabi.EnabledExperiments() {
+ for _, exp := range buildcfg.EnabledExperiments() {
// Define macro.
name := "GOEXPERIMENT_" + exp
macros[name] = &Macro{
"bufio"
"flag"
"fmt"
+ "internal/buildcfg"
"log"
"os"
"cmd/internal/bio"
"cmd/internal/obj"
- "cmd/internal/objabi"
)
func main() {
log.SetFlags(0)
log.SetPrefix("asm: ")
- GOARCH := objabi.GOARCH
+ buildcfg.Check()
+ GOARCH := buildcfg.GOARCH
architecture := arch.Set(GOARCH)
if architecture == nil {
defer buf.Close()
if !*flags.SymABIs {
- fmt.Fprintf(buf, "go object %s %s %s\n", objabi.GOOS, objabi.GOARCH, objabi.Version)
+ fmt.Fprintf(buf, "go object %s %s %s\n", buildcfg.GOOS, buildcfg.GOARCH, buildcfg.Version)
fmt.Fprintf(buf, "!\n")
}
"go/ast"
"go/printer"
"go/token"
+ "internal/buildcfg"
"io"
"io/ioutil"
"os"
if s := os.Getenv("GOOS"); s != "" {
goos = s
}
- gomips = objabi.GOMIPS
- gomips64 = objabi.GOMIPS64
+ buildcfg.Check()
+ gomips = buildcfg.GOMIPS
+ gomips64 = buildcfg.GOMIPS64
ptrSize := ptrSizeMap[goarch]
if ptrSize == 0 {
fatalf("unknown ptrSize for $GOARCH %q", goarch)
"cmd/compile/internal/types"
"cmd/internal/obj"
"cmd/internal/obj/x86"
- "cmd/internal/objabi"
+ "internal/buildcfg"
)
// no floating point in note handlers on Plan 9
-var isPlan9 = objabi.GOOS == "plan9"
+var isPlan9 = buildcfg.GOOS == "plan9"
// DUFFZERO consists of repeated blocks of 4 MOVUPSs + LEAQ,
// See runtime/mkduff.go.
}
p = pp.Append(p, x86.AMOVQ, obj.TYPE_REG, x86.REG_R13, 0, obj.TYPE_MEM, x86.REG_SP, off)
} else if !isPlan9 && cnt <= int64(8*types.RegSize) {
- if !objabi.Experiment.RegabiG && *state&x15 == 0 {
+ if !buildcfg.Experiment.RegabiG && *state&x15 == 0 {
p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_REG, x86.REG_X15, 0)
*state |= x15
}
p = pp.Append(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_MEM, x86.REG_SP, off+cnt-int64(16))
}
} else if !isPlan9 && (cnt <= int64(128*types.RegSize)) {
- if !objabi.Experiment.RegabiG && *state&x15 == 0 {
+ if !buildcfg.Experiment.RegabiG && *state&x15 == 0 {
p = pp.Append(p, x86.AXORPS, obj.TYPE_REG, x86.REG_X15, 0, obj.TYPE_REG, x86.REG_X15, 0)
*state |= x15
}
import (
"fmt"
+ "internal/buildcfg"
"math"
"cmd/compile/internal/base"
"cmd/compile/internal/types"
"cmd/internal/obj"
"cmd/internal/obj/x86"
- "cmd/internal/objabi"
)
// markMoves marks any MOVXconst ops that need to avoid clobbering flags.
p.To.Reg = v.Args[0].Reg()
ssagen.AddAux2(&p.To, v, sc.Off64())
case ssa.OpAMD64MOVOstorezero:
- if !objabi.Experiment.RegabiG || s.ABI != obj.ABIInternal {
+ if !buildcfg.Experiment.RegabiG || s.ABI != obj.ABIInternal {
// zero X15 manually
opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
}
p.To.Type = obj.TYPE_REG
p.To.Reg = v.Reg()
case ssa.OpAMD64DUFFZERO:
- if !objabi.Experiment.RegabiG || s.ABI != obj.ABIInternal {
+ if !buildcfg.Experiment.RegabiG || s.ABI != obj.ABIInternal {
// zero X15 manually
opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
}
// Closure pointer is DX.
ssagen.CheckLoweredGetClosurePtr(v)
case ssa.OpAMD64LoweredGetG:
- if objabi.Experiment.RegabiG && s.ABI == obj.ABIInternal {
+ if buildcfg.Experiment.RegabiG && s.ABI == obj.ABIInternal {
v.Fatalf("LoweredGetG should not appear in ABIInternal")
}
r := v.Reg()
getgFromTLS(s, r)
case ssa.OpAMD64CALLstatic:
- if objabi.Experiment.RegabiG && s.ABI == obj.ABI0 && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABIInternal {
+ if buildcfg.Experiment.RegabiG && s.ABI == obj.ABI0 && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABIInternal {
// zeroing X15 when entering ABIInternal from ABI0
opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
// set G register from TLS
getgFromTLS(s, x86.REG_R14)
}
s.Call(v)
- if objabi.Experiment.RegabiG && s.ABI == obj.ABIInternal && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABI0 {
+ if buildcfg.Experiment.RegabiG && s.ABI == obj.ABIInternal && v.Aux.(*ssa.AuxCall).Fn.ABI() == obj.ABI0 {
// zeroing X15 when entering ABIInternal from ABI0
opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
// set G register from TLS
case ssa.BlockRet:
s.Prog(obj.ARET)
case ssa.BlockRetJmp:
- if objabi.Experiment.RegabiG && s.ABI == obj.ABI0 && b.Aux.(*obj.LSym).ABI() == obj.ABIInternal {
+ if buildcfg.Experiment.RegabiG && s.ABI == obj.ABI0 && b.Aux.(*obj.LSym).ABI() == obj.ABIInternal {
// zeroing X15 when entering ABIInternal from ABI0
opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
// set G register from TLS
"cmd/compile/internal/ssa"
"cmd/compile/internal/ssagen"
"cmd/internal/obj/arm"
- "cmd/internal/objabi"
+ "internal/buildcfg"
)
func Init(arch *ssagen.ArchInfo) {
arch.LinkArch = &arm.Linkarm
arch.REGSP = arm.REGSP
arch.MAXWIDTH = (1 << 32) - 1
- arch.SoftFloat = objabi.GOARM == 5
+ arch.SoftFloat = buildcfg.GOARM == 5
arch.ZeroRange = zerorange
arch.Ginsnop = ginsnop
arch.Ginsnopdefer = ginsnop
import (
"fmt"
+ "internal/buildcfg"
"math"
"math/bits"
"cmd/compile/internal/types"
"cmd/internal/obj"
"cmd/internal/obj/arm"
- "cmd/internal/objabi"
)
// loadByType returns the load instruction of the given type.
case ssa.OpARMANDconst, ssa.OpARMBICconst:
// try to optimize ANDconst and BICconst to BFC, which saves bytes and ticks
// BFC is only available on ARMv7, and its result and source are in the same register
- if objabi.GOARM == 7 && v.Reg() == v.Args[0].Reg() {
+ if buildcfg.GOARM == 7 && v.Reg() == v.Args[0].Reg() {
var val uint32
if v.Op == ssa.OpARMANDconst {
val = ^uint32(v.AuxInt)
default:
}
}
- if objabi.GOARM >= 6 {
+ if buildcfg.GOARM >= 6 {
// generate more efficient "MOVB/MOVBU/MOVH/MOVHU Reg@>0, Reg" on ARMv6 & ARMv7
genshift(s, v.Op.Asm(), 0, v.Args[0].Reg(), v.Reg(), arm.SHIFT_RR, 0)
return
"cmd/compile/internal/types"
"cmd/internal/obj"
"cmd/internal/obj/arm64"
- "cmd/internal/objabi"
+ "internal/buildcfg"
)
-var darwin = objabi.GOOS == "darwin" || objabi.GOOS == "ios"
+var darwin = buildcfg.GOOS == "darwin" || buildcfg.GOOS == "ios"
func padframe(frame int64) int64 {
// arm64 requires that the frame size (not counting saved FP&LR)
"encoding/json"
"flag"
"fmt"
+ "internal/buildcfg"
"io/ioutil"
"log"
"os"
Flag.LowerP = &Ctxt.Pkgpath
Flag.LowerV = &Ctxt.Debugvlog
- Flag.Dwarf = objabi.GOARCH != "wasm"
+ Flag.Dwarf = buildcfg.GOARCH != "wasm"
Flag.DwarfBASEntries = &Ctxt.UseBASEntries
Flag.DwarfLocationLists = &Ctxt.Flag_locationlists
*Flag.DwarfLocationLists = true
registerFlags()
objabi.Flagparse(usage)
- if Flag.MSan && !sys.MSanSupported(objabi.GOOS, objabi.GOARCH) {
- log.Fatalf("%s/%s does not support -msan", objabi.GOOS, objabi.GOARCH)
+ if Flag.MSan && !sys.MSanSupported(buildcfg.GOOS, buildcfg.GOARCH) {
+ log.Fatalf("%s/%s does not support -msan", buildcfg.GOOS, buildcfg.GOARCH)
}
- if Flag.Race && !sys.RaceDetectorSupported(objabi.GOOS, objabi.GOARCH) {
- log.Fatalf("%s/%s does not support -race", objabi.GOOS, objabi.GOARCH)
+ if Flag.Race && !sys.RaceDetectorSupported(buildcfg.GOOS, buildcfg.GOARCH) {
+ log.Fatalf("%s/%s does not support -race", buildcfg.GOOS, buildcfg.GOARCH)
}
if (*Flag.Shared || *Flag.Dynlink || *Flag.LinkShared) && !Ctxt.Arch.InFamily(sys.AMD64, sys.ARM, sys.ARM64, sys.I386, sys.PPC64, sys.RISCV64, sys.S390X) {
- log.Fatalf("%s/%s does not support -shared", objabi.GOOS, objabi.GOARCH)
+ log.Fatalf("%s/%s does not support -shared", buildcfg.GOOS, buildcfg.GOARCH)
}
parseSpectre(Flag.Spectre) // left as string for RecordFlags
return false
}
// TODO: Test and delete this condition.
- if objabi.Experiment.FieldTrack {
+ if buildcfg.Experiment.FieldTrack {
return false
}
// TODO: fix races and enable the following flags
}
if Flag.Cfg.SpectreIndex {
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
case "amd64":
// ok
default:
- log.Fatalf("GOARCH=%s does not support -spectre=index", objabi.GOARCH)
+ log.Fatalf("GOARCH=%s does not support -spectre=index", buildcfg.GOARCH)
}
}
}
import (
"fmt"
+ "internal/buildcfg"
"os"
"runtime/debug"
"sort"
"strings"
- "cmd/internal/objabi"
"cmd/internal/src"
)
fmt.Printf("\n")
// If this is a released compiler version, ask for a bug report.
- if strings.HasPrefix(objabi.Version, "go") {
+ if strings.HasPrefix(buildcfg.Version, "go") {
fmt.Printf("\n")
fmt.Printf("Please file a bug report including a short program that triggers the error.\n")
fmt.Printf("https://golang.org/issue/new\n")
"bytes"
"flag"
"fmt"
+ "internal/buildcfg"
"sort"
"cmd/compile/internal/base"
if base.Ctxt.FixedFrameSize() == 0 {
offs -= int64(types.PtrSize)
}
- if objabi.FramePointerEnabled {
+ if buildcfg.FramePointerEnabled {
offs -= int64(types.PtrSize)
}
"cmd/internal/src"
"flag"
"fmt"
+ "internal/buildcfg"
"log"
"os"
"runtime"
dwarf.EnableLogging(base.Debug.DwarfInl != 0)
}
if base.Debug.SoftFloat != 0 {
- if objabi.Experiment.RegabiArgs {
+ if buildcfg.Experiment.RegabiArgs {
log.Fatalf("softfloat mode with GOEXPERIMENT=regabiargs not implemented ")
}
ssagen.Arch.SoftFloat = true
}
var buf bytes.Buffer
- fmt.Fprintln(&buf, "commit:", objabi.Version)
+ fmt.Fprintln(&buf, "commit:", buildcfg.Version)
fmt.Fprintln(&buf, "goos:", runtime.GOOS)
fmt.Fprintln(&buf, "goarch:", runtime.GOARCH)
base.Timer.Write(&buf, "BenchmarkCompile:"+base.Ctxt.Pkgpath+":")
import (
"cmd/internal/obj"
- "cmd/internal/objabi"
"cmd/internal/src"
"encoding/json"
"fmt"
+ "internal/buildcfg"
"io"
"log"
"net/url"
if !strings.HasPrefix(filename, "$GOROOT/") {
return filename
}
- return objabi.GOROOT + filename[len("$GOROOT"):]
+ return buildcfg.GOROOT + filename[len("$GOROOT"):]
}
// FlushLoggedOpts flushes all the accumulated optimization log entries.
currentFile = p0f
w = writerForLSP(subdirpath, currentFile)
encoder = json.NewEncoder(w)
- encoder.Encode(VersionHeader{Version: 0, Package: slashPkgPath, Goos: objabi.GOOS, Goarch: objabi.GOARCH, GcVersion: objabi.Version, File: currentFile})
+ encoder.Encode(VersionHeader{Version: 0, Package: slashPkgPath, Goos: buildcfg.GOOS, Goarch: buildcfg.GOARCH, GcVersion: buildcfg.Version, File: currentFile})
}
// The first "target" is the most important one.
"cmd/compile/internal/ssa"
"cmd/compile/internal/ssagen"
"cmd/internal/obj/mips"
- "cmd/internal/objabi"
+ "internal/buildcfg"
)
func Init(arch *ssagen.ArchInfo) {
arch.LinkArch = &mips.Linkmips
- if objabi.GOARCH == "mipsle" {
+ if buildcfg.GOARCH == "mipsle" {
arch.LinkArch = &mips.Linkmipsle
}
arch.REGSP = mips.REGSP
arch.MAXWIDTH = (1 << 31) - 1
- arch.SoftFloat = (objabi.GOMIPS == "softfloat")
+ arch.SoftFloat = (buildcfg.GOMIPS == "softfloat")
arch.ZeroRange = zerorange
arch.Ginsnop = ginsnop
arch.Ginsnopdefer = ginsnop
"cmd/compile/internal/ssa"
"cmd/compile/internal/ssagen"
"cmd/internal/obj/mips"
- "cmd/internal/objabi"
+ "internal/buildcfg"
)
func Init(arch *ssagen.ArchInfo) {
arch.LinkArch = &mips.Linkmips64
- if objabi.GOARCH == "mips64le" {
+ if buildcfg.GOARCH == "mips64le" {
arch.LinkArch = &mips.Linkmips64le
}
arch.REGSP = mips.REGSP
arch.MAXWIDTH = 1 << 50
- arch.SoftFloat = objabi.GOMIPS64 == "softfloat"
+ arch.SoftFloat = buildcfg.GOMIPS64 == "softfloat"
arch.ZeroRange = zerorange
arch.Ginsnop = ginsnop
arch.Ginsnopdefer = ginsnop
import (
"errors"
"fmt"
+ "internal/buildcfg"
"io"
"os"
pathpkg "path"
}
}
- if objabi.GOROOT != "" {
+ if buildcfg.GOROOT != "" {
suffix := ""
if base.Flag.InstallSuffix != "" {
suffix = "_" + base.Flag.InstallSuffix
suffix = "_msan"
}
- if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.a", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffix, path)); err == nil {
+ if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.a", buildcfg.GOROOT, buildcfg.GOOS, buildcfg.GOARCH, suffix, path)); err == nil {
return file, nil
}
- if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.o", objabi.GOROOT, objabi.GOOS, objabi.GOARCH, suffix, path)); err == nil {
+ if file, err := os.Open(fmt.Sprintf("%s/pkg/%s_%s%s/%s.o", buildcfg.GOROOT, buildcfg.GOOS, buildcfg.GOARCH, suffix, path)); err == nil {
return file, nil
}
}
import (
"fmt"
+ "internal/buildcfg"
"strings"
"cmd/compile/internal/ir"
"cmd/compile/internal/syntax"
- "cmd/internal/objabi"
)
func isSpace(c rune) bool {
case "go:build":
return ir.GoBuildPragma
case "go:nointerface":
- if objabi.Experiment.FieldTrack {
+ if buildcfg.Experiment.FieldTrack {
return ir.Nointerface
}
case "go:noescape":
case len(f) == 3 && !isQuoted(f[1]) && !isQuoted(f[2]):
case len(f) == 4 && !isQuoted(f[1]) && !isQuoted(f[2]) && isQuoted(f[3]):
f[3] = strings.Trim(f[3], `"`)
- if objabi.GOOS == "aix" && f[3] != "" {
+ if buildcfg.GOOS == "aix" && f[3] != "" {
// On Aix, library pattern must be "lib.a/object.o"
// or "lib.a/libname.so.X"
n := strings.Split(f[3], "/")
import (
"cmd/compile/internal/ssagen"
"cmd/internal/obj/ppc64"
- "cmd/internal/objabi"
+ "internal/buildcfg"
)
func Init(arch *ssagen.ArchInfo) {
arch.LinkArch = &ppc64.Linkppc64
- if objabi.GOARCH == "ppc64le" {
+ if buildcfg.GOARCH == "ppc64le" {
arch.LinkArch = &ppc64.Linkppc64le
}
arch.REGSP = ppc64.REGSP
"cmd/compile/internal/types"
"cmd/internal/obj"
"cmd/internal/obj/ppc64"
- "cmd/internal/objabi"
+ "internal/buildcfg"
"math"
"strings"
)
s.UseArgs(16) // space used in callee args area by assembly stubs
case ssa.OpPPC64LoweredNilCheck:
- if objabi.GOOS == "aix" {
+ if buildcfg.GOOS == "aix" {
// CMP Rarg0, R0
// BNE 2(PC)
// STW R0, 0(R0)
import (
"fmt"
+ "internal/buildcfg"
"os"
"sort"
"strings"
// Disable tailcall for RegabiArgs for now. The IR does not connect the
// arguments with the OTAILCALL node, and the arguments are not marshaled
// correctly.
- if !base.Flag.Cfg.Instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !types.IsInterfaceMethod(method.Type) && !(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) && !objabi.Experiment.RegabiArgs {
+ if !base.Flag.Cfg.Instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !types.IsInterfaceMethod(method.Type) && !(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) && !buildcfg.Experiment.RegabiArgs {
// generate tail call: adjust pointer receiver and jump to embedded method.
left := dot.X // skip final .M
if !left.Type().IsPtr() {
import (
"bytes"
- "cmd/internal/objabi"
"cmd/internal/src"
"fmt"
"hash/crc32"
+ "internal/buildcfg"
"log"
"math/rand"
"os"
{name: "dse", fn: dse},
{name: "writebarrier", fn: writebarrier, required: true}, // expand write barrier ops
{name: "insert resched checks", fn: insertLoopReschedChecks,
- disabled: !objabi.Experiment.PreemptibleLoops}, // insert resched checks in loops.
+ disabled: !buildcfg.Experiment.PreemptibleLoops}, // insert resched checks in loops.
{name: "lower", fn: lower, required: true},
{name: "addressing modes", fn: addressingModes, required: false},
{name: "lowered deadcode for cse", fn: deadcode}, // deadcode immediately before CSE avoids CSE making dead values live again
"cmd/compile/internal/ir"
"cmd/compile/internal/types"
"cmd/internal/obj"
- "cmd/internal/objabi"
"cmd/internal/src"
+ "internal/buildcfg"
)
// A Config holds readonly compilation information.
c.floatParamRegs = paramFloatRegAMD64
c.FPReg = framepointerRegAMD64
c.LinkReg = linkRegAMD64
- c.hasGReg = objabi.Experiment.RegabiG
+ c.hasGReg = buildcfg.Experiment.RegabiG
case "386":
c.PtrSize = 4
c.RegSize = 4
c.FPReg = framepointerRegARM64
c.LinkReg = linkRegARM64
c.hasGReg = true
- c.noDuffDevice = objabi.GOOS == "darwin" || objabi.GOOS == "ios" // darwin linker cannot handle BR26 reloc with non-zero addend
+ c.noDuffDevice = buildcfg.GOOS == "darwin" || buildcfg.GOOS == "ios" // darwin linker cannot handle BR26 reloc with non-zero addend
case "ppc64":
c.BigEndian = true
fallthrough
c.ABI1 = abi.NewABIConfig(len(c.intParamRegs), len(c.floatParamRegs), ctxt.FixedFrameSize())
// On Plan 9, floating point operations are not allowed in note handler.
- if objabi.GOOS == "plan9" {
+ if buildcfg.GOOS == "plan9" {
// Don't use FMA on Plan 9
c.UseFMA = false
(IsInBounds idx len) => (SETB (CMPQ idx len))
(IsSliceInBounds idx len) => (SETBE (CMPQ idx len))
(NilCheck ...) => (LoweredNilCheck ...)
-(GetG mem) && !(objabi.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal) => (LoweredGetG mem) // only lower in old ABI. in new ABI we have a G register.
+(GetG mem) && !(buildcfg.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal) => (LoweredGetG mem) // only lower in old ABI. in new ABI we have a G register.
(GetClosurePtr ...) => (LoweredGetClosurePtr ...)
(GetCallerPC ...) => (LoweredGetCallerPC ...)
(GetCallerSP ...) => (LoweredGetCallerSP ...)
// count trailing zero for ARMv5 and ARMv6
// 32 - CLZ(x&-x - 1)
-(Ctz32 <t> x) && objabi.GOARM<=6 =>
+(Ctz32 <t> x) && buildcfg.GOARM<=6 =>
(RSBconst [32] (CLZ <t> (SUBconst <t> (AND <t> x (RSBconst <t> [0] x)) [1])))
-(Ctz16 <t> x) && objabi.GOARM<=6 =>
+(Ctz16 <t> x) && buildcfg.GOARM<=6 =>
(RSBconst [32] (CLZ <t> (SUBconst <typ.UInt32> (AND <typ.UInt32> (ORconst <typ.UInt32> [0x10000] x) (RSBconst <typ.UInt32> [0] (ORconst <typ.UInt32> [0x10000] x))) [1])))
-(Ctz8 <t> x) && objabi.GOARM<=6 =>
+(Ctz8 <t> x) && buildcfg.GOARM<=6 =>
(RSBconst [32] (CLZ <t> (SUBconst <typ.UInt32> (AND <typ.UInt32> (ORconst <typ.UInt32> [0x100] x) (RSBconst <typ.UInt32> [0] (ORconst <typ.UInt32> [0x100] x))) [1])))
// count trailing zero for ARMv7
-(Ctz32 <t> x) && objabi.GOARM==7 => (CLZ <t> (RBIT <t> x))
-(Ctz16 <t> x) && objabi.GOARM==7 => (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x10000] x)))
-(Ctz8 <t> x) && objabi.GOARM==7 => (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x100] x)))
+(Ctz32 <t> x) && buildcfg.GOARM==7 => (CLZ <t> (RBIT <t> x))
+(Ctz16 <t> x) && buildcfg.GOARM==7 => (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x10000] x)))
+(Ctz8 <t> x) && buildcfg.GOARM==7 => (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x100] x)))
// bit length
(BitLen32 <t> x) => (RSBconst [32] (CLZ <t> x))
// t5 = x right rotate 8 bits -- (d, a, b, c )
// result = t4 ^ t5 -- (d, c, b, a )
// using shifted ops this can be done in 4 instructions.
-(Bswap32 <t> x) && objabi.GOARM==5 =>
+(Bswap32 <t> x) && buildcfg.GOARM==5 =>
(XOR <t>
(SRLconst <t> (BICconst <t> (XOR <t> x (SRRconst <t> [16] x)) [0xff0000]) [8])
(SRRconst <t> x [8]))
// byte swap for ARMv6 and above
-(Bswap32 x) && objabi.GOARM>=6 => (REV x)
+(Bswap32 x) && buildcfg.GOARM>=6 => (REV x)
// boolean ops -- booleans are represented with 0=false, 1=true
(AndB ...) => (AND ...)
(SUBconst [c] x) && !isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c)) => (ADDconst [-c] x)
(ANDconst [c] x) && !isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c)) => (BICconst [int32(^uint32(c))] x)
(BICconst [c] x) && !isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c)) => (ANDconst [int32(^uint32(c))] x)
-(ADDconst [c] x) && objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff => (SUBconst [-c] x)
-(SUBconst [c] x) && objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff => (ADDconst [-c] x)
-(ANDconst [c] x) && objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff => (BICconst [int32(^uint32(c))] x)
-(BICconst [c] x) && objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff => (ANDconst [int32(^uint32(c))] x)
+(ADDconst [c] x) && buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff => (SUBconst [-c] x)
+(SUBconst [c] x) && buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff => (ADDconst [-c] x)
+(ANDconst [c] x) && buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff => (BICconst [int32(^uint32(c))] x)
+(BICconst [c] x) && buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff => (ANDconst [int32(^uint32(c))] x)
(ADDconst [c] (MOVWconst [d])) => (MOVWconst [c+d])
(ADDconst [c] (ADDconst [d] x)) => (ADDconst [c+d] x)
(ADDconst [c] (SUBconst [d] x)) => (ADDconst [c-d] x)
// UBFX instruction is supported by ARMv6T2, ARMv7 and above versions, REV16 is supported by
// ARMv6 and above versions. So for ARMv6, we need to match SLLconst, SRLconst and ORshiftLL.
((ADDshiftLL|ORshiftLL|XORshiftLL) <typ.UInt16> [8] (BFXU <typ.UInt16> [int32(armBFAuxInt(8, 8))] x) x) => (REV16 x)
-((ADDshiftLL|ORshiftLL|XORshiftLL) <typ.UInt16> [8] (SRLconst <typ.UInt16> [24] (SLLconst [16] x)) x) && objabi.GOARM>=6 => (REV16 x)
+((ADDshiftLL|ORshiftLL|XORshiftLL) <typ.UInt16> [8] (SRLconst <typ.UInt16> [24] (SLLconst [16] x)) x) && buildcfg.GOARM>=6 => (REV16 x)
// use indexed loads and stores
(MOVWload [0] {sym} (ADD ptr idx) mem) && sym == nil => (MOVWloadidx ptr idx mem)
(BIC x x) => (MOVWconst [0])
(ADD (MUL x y) a) => (MULA x y a)
-(SUB a (MUL x y)) && objabi.GOARM == 7 => (MULS x y a)
-(RSB (MUL x y) a) && objabi.GOARM == 7 => (MULS x y a)
+(SUB a (MUL x y)) && buildcfg.GOARM == 7 => (MULS x y a)
+(RSB (MUL x y) a) && buildcfg.GOARM == 7 => (MULS x y a)
-(NEGF (MULF x y)) && objabi.GOARM >= 6 => (NMULF x y)
-(NEGD (MULD x y)) && objabi.GOARM >= 6 => (NMULD x y)
-(MULF (NEGF x) y) && objabi.GOARM >= 6 => (NMULF x y)
-(MULD (NEGD x) y) && objabi.GOARM >= 6 => (NMULD x y)
+(NEGF (MULF x y)) && buildcfg.GOARM >= 6 => (NMULF x y)
+(NEGD (MULD x y)) && buildcfg.GOARM >= 6 => (NMULD x y)
+(MULF (NEGF x) y) && buildcfg.GOARM >= 6 => (NMULF x y)
+(MULD (NEGD x) y) && buildcfg.GOARM >= 6 => (NMULD x y)
(NMULF (NEGF x) y) => (MULF x y)
(NMULD (NEGD x) y) => (MULD x y)
// the result will overwrite the addend, since they are in the same register
-(ADDF a (MULF x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULAF a x y)
-(ADDF a (NMULF x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULSF a x y)
-(ADDD a (MULD x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULAD a x y)
-(ADDD a (NMULD x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULSD a x y)
-(SUBF a (MULF x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULSF a x y)
-(SUBF a (NMULF x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULAF a x y)
-(SUBD a (MULD x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULSD a x y)
-(SUBD a (NMULD x y)) && a.Uses == 1 && objabi.GOARM >= 6 => (MULAD a x y)
+(ADDF a (MULF x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULAF a x y)
+(ADDF a (NMULF x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULSF a x y)
+(ADDD a (MULD x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULAD a x y)
+(ADDD a (NMULD x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULSD a x y)
+(SUBF a (MULF x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULSF a x y)
+(SUBF a (NMULF x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULAF a x y)
+(SUBD a (MULD x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULSD a x y)
+(SUBD a (NMULD x y)) && a.Uses == 1 && buildcfg.GOARM >= 6 => (MULAD a x y)
(AND x (MVN y)) => (BIC x y)
(CMPD x (MOVDconst [0])) => (CMPD0 x)
// bit extraction
-(SRAconst (SLLconst x [c]) [d]) && objabi.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31 => (BFX [(d-c)|(32-d)<<8] x)
-(SRLconst (SLLconst x [c]) [d]) && objabi.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31 => (BFXU [(d-c)|(32-d)<<8] x)
+(SRAconst (SLLconst x [c]) [d]) && buildcfg.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31 => (BFX [(d-c)|(32-d)<<8] x)
+(SRLconst (SLLconst x [c]) [d]) && buildcfg.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31 => (BFXU [(d-c)|(32-d)<<8] x)
// comparison simplification
((LT|LE|EQ|NE|GE|GT) (CMP x (RSBconst [0] y))) => ((LT|LE|EQ|NE|GE|GT) (CMN x y)) // sense of carry bit not preserved
(Sub64F ...) => (FSUB ...)
// Combine 64 bit integer multiply and adds
-(ADD l:(MULLD x y) z) && objabi.GOPPC64 >= 9 && l.Uses == 1 && clobber(l) => (MADDLD x y z)
+(ADD l:(MULLD x y) z) && buildcfg.GOPPC64 >= 9 && l.Uses == 1 && clobber(l) => (MADDLD x y z)
(Mod16 x y) => (Mod32 (SignExt16to32 x) (SignExt16to32 y))
(Mod16u x y) => (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y))
(Mod8 x y) => (Mod32 (SignExt8to32 x) (SignExt8to32 y))
(Mod8u x y) => (Mod32u (ZeroExt8to32 x) (ZeroExt8to32 y))
-(Mod64 x y) && objabi.GOPPC64 >=9 => (MODSD x y)
-(Mod64 x y) && objabi.GOPPC64 <=8 => (SUB x (MULLD y (DIVD x y)))
-(Mod64u x y) && objabi.GOPPC64 >= 9 => (MODUD x y)
-(Mod64u x y) && objabi.GOPPC64 <= 8 => (SUB x (MULLD y (DIVDU x y)))
-(Mod32 x y) && objabi.GOPPC64 >= 9 => (MODSW x y)
-(Mod32 x y) && objabi.GOPPC64 <= 8 => (SUB x (MULLW y (DIVW x y)))
-(Mod32u x y) && objabi.GOPPC64 >= 9 => (MODUW x y)
-(Mod32u x y) && objabi.GOPPC64 <= 8 => (SUB x (MULLW y (DIVWU x y)))
+(Mod64 x y) && buildcfg.GOPPC64 >=9 => (MODSD x y)
+(Mod64 x y) && buildcfg.GOPPC64 <=8 => (SUB x (MULLD y (DIVD x y)))
+(Mod64u x y) && buildcfg.GOPPC64 >= 9 => (MODUD x y)
+(Mod64u x y) && buildcfg.GOPPC64 <= 8 => (SUB x (MULLD y (DIVDU x y)))
+(Mod32 x y) && buildcfg.GOPPC64 >= 9 => (MODSW x y)
+(Mod32 x y) && buildcfg.GOPPC64 <= 8 => (SUB x (MULLW y (DIVW x y)))
+(Mod32u x y) && buildcfg.GOPPC64 >= 9 => (MODUW x y)
+(Mod32u x y) && buildcfg.GOPPC64 <= 8 => (SUB x (MULLW y (DIVWU x y)))
// (x + y) / 2 with x>=y => (x - y) / 2 + y
(Avg64u <t> x y) => (ADD (SRDconst <t> (SUB <t> x y) [1]) y)
(Ctz32NonZero ...) => (Ctz32 ...)
(Ctz64NonZero ...) => (Ctz64 ...)
-(Ctz64 x) && objabi.GOPPC64<=8 => (POPCNTD (ANDN <typ.Int64> (ADDconst <typ.Int64> [-1] x) x))
+(Ctz64 x) && buildcfg.GOPPC64<=8 => (POPCNTD (ANDN <typ.Int64> (ADDconst <typ.Int64> [-1] x) x))
(Ctz64 x) => (CNTTZD x)
-(Ctz32 x) && objabi.GOPPC64<=8 => (POPCNTW (MOVWZreg (ANDN <typ.Int> (ADDconst <typ.Int> [-1] x) x)))
+(Ctz32 x) && buildcfg.GOPPC64<=8 => (POPCNTW (MOVWZreg (ANDN <typ.Int> (ADDconst <typ.Int> [-1] x) x)))
(Ctz32 x) => (CNTTZW (MOVWZreg x))
(Ctz16 x) => (POPCNTW (MOVHZreg (ANDN <typ.Int16> (ADDconst <typ.Int16> [-1] x) x)))
(Ctz8 x) => (POPCNTB (MOVBZreg (ANDN <typ.UInt8> (ADDconst <typ.UInt8> [-1] x) x)))
// Handle cases not handled above
// Lowered Short cases do not generate loops, and as a result don't clobber
// the address registers or flags.
-(Zero [s] ptr mem) && objabi.GOPPC64 <= 8 && s < 64 => (LoweredZeroShort [s] ptr mem)
-(Zero [s] ptr mem) && objabi.GOPPC64 <= 8 => (LoweredZero [s] ptr mem)
-(Zero [s] ptr mem) && s < 128 && objabi.GOPPC64 >= 9 => (LoweredQuadZeroShort [s] ptr mem)
-(Zero [s] ptr mem) && objabi.GOPPC64 >= 9 => (LoweredQuadZero [s] ptr mem)
+(Zero [s] ptr mem) && buildcfg.GOPPC64 <= 8 && s < 64 => (LoweredZeroShort [s] ptr mem)
+(Zero [s] ptr mem) && buildcfg.GOPPC64 <= 8 => (LoweredZero [s] ptr mem)
+(Zero [s] ptr mem) && s < 128 && buildcfg.GOPPC64 >= 9 => (LoweredQuadZeroShort [s] ptr mem)
+(Zero [s] ptr mem) && buildcfg.GOPPC64 >= 9 => (LoweredQuadZero [s] ptr mem)
// moves
(Move [0] _ _ mem) => mem
// Large move uses a loop. Since the address is computed and the
// offset is zero, any alignment can be used.
-(Move [s] dst src mem) && s > 8 && objabi.GOPPC64 <= 8 && logLargeCopy(v, s) =>
+(Move [s] dst src mem) && s > 8 && buildcfg.GOPPC64 <= 8 && logLargeCopy(v, s) =>
(LoweredMove [s] dst src mem)
-(Move [s] dst src mem) && s > 8 && s <= 64 && objabi.GOPPC64 >= 9 =>
+(Move [s] dst src mem) && s > 8 && s <= 64 && buildcfg.GOPPC64 >= 9 =>
(LoweredQuadMoveShort [s] dst src mem)
-(Move [s] dst src mem) && s > 8 && objabi.GOPPC64 >= 9 && logLargeCopy(v, s) =>
+(Move [s] dst src mem) && s > 8 && buildcfg.GOPPC64 >= 9 && logLargeCopy(v, s) =>
(LoweredQuadMove [s] dst src mem)
// Calls
(SLWconst [c] z:(ANDconst [d] x)) && z.Uses == 1 && isPPC64ValidShiftMask(d) && c<=(32-getPPC64ShiftMaskLength(d)) => (CLRLSLWI [newPPC64ShiftAuxInt(c,32-getPPC64ShiftMaskLength(d),31,32)] x)
(SLWconst [c] z:(AND (MOVDconst [d]) x)) && z.Uses == 1 && isPPC64ValidShiftMask(d) && c<=(32-getPPC64ShiftMaskLength(d)) => (CLRLSLWI [newPPC64ShiftAuxInt(c,32-getPPC64ShiftMaskLength(d),31,32)] x)
// special case for power9
-(SL(W|D)const [c] z:(MOVWreg x)) && c < 32 && objabi.GOPPC64 >= 9 => (EXTSWSLconst [c] x)
+(SL(W|D)const [c] z:(MOVWreg x)) && c < 32 && buildcfg.GOPPC64 >= 9 => (EXTSWSLconst [c] x)
// Lose widening ops fed to stores
(MOVBstore [off] {sym} ptr (MOV(B|BZ|H|HZ|W|WZ)reg x) mem) => (MOVBstore [off] {sym} ptr x mem)
(ZeroExt32to64 x:(I64Load32U _ _)) => x
(ZeroExt16to(64|32) x:(I64Load16U _ _)) => x
(ZeroExt8to(64|32|16) x:(I64Load8U _ _)) => x
-(SignExt32to64 x) && objabi.GOWASM.SignExt => (I64Extend32S x)
-(SignExt8to(64|32|16) x) && objabi.GOWASM.SignExt => (I64Extend8S x)
-(SignExt16to(64|32) x) && objabi.GOWASM.SignExt => (I64Extend16S x)
+(SignExt32to64 x) && buildcfg.GOWASM.SignExt => (I64Extend32S x)
+(SignExt8to(64|32|16) x) && buildcfg.GOWASM.SignExt => (I64Extend8S x)
+(SignExt16to(64|32) x) && buildcfg.GOWASM.SignExt => (I64Extend16S x)
(SignExt32to64 x) => (I64ShrS (I64Shl x (I64Const [32])) (I64Const [32]))
(SignExt16to(64|32) x) => (I64ShrS (I64Shl x (I64Const [48])) (I64Const [48]))
(SignExt8to(64|32|16) x) => (I64ShrS (I64Shl x (I64Const [56])) (I64Const [56]))
fmt.Fprintf(w, "\npackage ssa\n")
for _, path := range append([]string{
"fmt",
+ "internal/buildcfg",
"math",
"cmd/internal/obj",
- "cmd/internal/objabi",
"cmd/compile/internal/base",
"cmd/compile/internal/types",
}, n.Arch.imports...) {
import (
"cmd/compile/internal/ir"
- "cmd/internal/objabi"
"cmd/internal/src"
+ "internal/buildcfg"
)
// nilcheckelim eliminates unnecessary nil checks.
const minZeroPage = 4096
// faultOnLoad is true if a load to an address below minZeroPage will trigger a SIGSEGV.
-var faultOnLoad = objabi.GOOS != "aix"
+var faultOnLoad = buildcfg.GOOS != "aix"
// nilcheckelim2 eliminates unnecessary nil checks.
// Runs after lowering and scheduling.
"cmd/compile/internal/base"
"cmd/compile/internal/ir"
"cmd/compile/internal/types"
- "cmd/internal/objabi"
"cmd/internal/src"
"cmd/internal/sys"
"fmt"
+ "internal/buildcfg"
"math/bits"
"unsafe"
)
if s.f.Config.hasGReg {
s.allocatable &^= 1 << s.GReg
}
- if objabi.FramePointerEnabled && s.f.Config.FPReg >= 0 {
+ if buildcfg.FramePointerEnabled && s.f.Config.FPReg >= 0 {
s.allocatable &^= 1 << uint(s.f.Config.FPReg)
}
if s.f.Config.LinkReg != -1 {
package ssa
-import "math"
-import "cmd/compile/internal/types"
+import (
+ "cmd/compile/internal/types"
+ "math"
+)
func rewriteValue386(v *Value) bool {
switch v.Op {
package ssa
-import "math"
-import "cmd/internal/obj"
-import "cmd/internal/objabi"
-import "cmd/compile/internal/types"
+import (
+ "cmd/compile/internal/types"
+ "cmd/internal/obj"
+ "internal/buildcfg"
+ "math"
+)
func rewriteValueAMD64(v *Value) bool {
switch v.Op {
func rewriteValueAMD64_OpGetG(v *Value) bool {
v_0 := v.Args[0]
// match: (GetG mem)
- // cond: !(objabi.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal)
+ // cond: !(buildcfg.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal)
// result: (LoweredGetG mem)
for {
mem := v_0
- if !(!(objabi.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal)) {
+ if !(!(buildcfg.Experiment.RegabiG && v.Block.Func.OwnAux.Fn.ABI() == obj.ABIInternal)) {
break
}
v.reset(OpAMD64LoweredGetG)
package ssa
-import "cmd/internal/objabi"
-import "cmd/compile/internal/types"
+import (
+ "cmd/compile/internal/types"
+ "internal/buildcfg"
+)
func rewriteValueARM(v *Value) bool {
switch v.Op {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDD a (MULD x y))
- // cond: a.Uses == 1 && objabi.GOARM >= 6
+ // cond: a.Uses == 1 && buildcfg.GOARM >= 6
// result: (MULAD a x y)
for {
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
}
y := v_1.Args[1]
x := v_1.Args[0]
- if !(a.Uses == 1 && objabi.GOARM >= 6) {
+ if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
continue
}
v.reset(OpARMMULAD)
break
}
// match: (ADDD a (NMULD x y))
- // cond: a.Uses == 1 && objabi.GOARM >= 6
+ // cond: a.Uses == 1 && buildcfg.GOARM >= 6
// result: (MULSD a x y)
for {
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
}
y := v_1.Args[1]
x := v_1.Args[0]
- if !(a.Uses == 1 && objabi.GOARM >= 6) {
+ if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
continue
}
v.reset(OpARMMULSD)
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDF a (MULF x y))
- // cond: a.Uses == 1 && objabi.GOARM >= 6
+ // cond: a.Uses == 1 && buildcfg.GOARM >= 6
// result: (MULAF a x y)
for {
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
}
y := v_1.Args[1]
x := v_1.Args[0]
- if !(a.Uses == 1 && objabi.GOARM >= 6) {
+ if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
continue
}
v.reset(OpARMMULAF)
break
}
// match: (ADDF a (NMULF x y))
- // cond: a.Uses == 1 && objabi.GOARM >= 6
+ // cond: a.Uses == 1 && buildcfg.GOARM >= 6
// result: (MULSF a x y)
for {
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
}
y := v_1.Args[1]
x := v_1.Args[0]
- if !(a.Uses == 1 && objabi.GOARM >= 6) {
+ if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
continue
}
v.reset(OpARMMULSF)
return true
}
// match: (ADDconst [c] x)
- // cond: objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff
+ // cond: buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff
// result: (SUBconst [-c] x)
for {
c := auxIntToInt32(v.AuxInt)
x := v_0
- if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) {
+ if !(buildcfg.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) {
break
}
v.reset(OpARMSUBconst)
return true
}
// match: (ADDshiftLL <typ.UInt16> [8] (SRLconst <typ.UInt16> [24] (SLLconst [16] x)) x)
- // cond: objabi.GOARM>=6
+ // cond: buildcfg.GOARM>=6
// result: (REV16 x)
for {
if v.Type != typ.UInt16 || auxIntToInt32(v.AuxInt) != 8 || v_0.Op != OpARMSRLconst || v_0.Type != typ.UInt16 || auxIntToInt32(v_0.AuxInt) != 24 {
break
}
x := v_0_0.Args[0]
- if x != v_1 || !(objabi.GOARM >= 6) {
+ if x != v_1 || !(buildcfg.GOARM >= 6) {
break
}
v.reset(OpARMREV16)
return true
}
// match: (ANDconst [c] x)
- // cond: objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff
+ // cond: buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff
// result: (BICconst [int32(^uint32(c))] x)
for {
c := auxIntToInt32(v.AuxInt)
x := v_0
- if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) {
+ if !(buildcfg.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) {
break
}
v.reset(OpARMBICconst)
return true
}
// match: (BICconst [c] x)
- // cond: objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff
+ // cond: buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff
// result: (ANDconst [int32(^uint32(c))] x)
for {
c := auxIntToInt32(v.AuxInt)
x := v_0
- if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) {
+ if !(buildcfg.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) {
break
}
v.reset(OpARMANDconst)
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULD (NEGD x) y)
- // cond: objabi.GOARM >= 6
+ // cond: buildcfg.GOARM >= 6
// result: (NMULD x y)
for {
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
}
x := v_0.Args[0]
y := v_1
- if !(objabi.GOARM >= 6) {
+ if !(buildcfg.GOARM >= 6) {
continue
}
v.reset(OpARMNMULD)
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULF (NEGF x) y)
- // cond: objabi.GOARM >= 6
+ // cond: buildcfg.GOARM >= 6
// result: (NMULF x y)
for {
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
}
x := v_0.Args[0]
y := v_1
- if !(objabi.GOARM >= 6) {
+ if !(buildcfg.GOARM >= 6) {
continue
}
v.reset(OpARMNMULF)
func rewriteValueARM_OpARMNEGD(v *Value) bool {
v_0 := v.Args[0]
// match: (NEGD (MULD x y))
- // cond: objabi.GOARM >= 6
+ // cond: buildcfg.GOARM >= 6
// result: (NMULD x y)
for {
if v_0.Op != OpARMMULD {
}
y := v_0.Args[1]
x := v_0.Args[0]
- if !(objabi.GOARM >= 6) {
+ if !(buildcfg.GOARM >= 6) {
break
}
v.reset(OpARMNMULD)
func rewriteValueARM_OpARMNEGF(v *Value) bool {
v_0 := v.Args[0]
// match: (NEGF (MULF x y))
- // cond: objabi.GOARM >= 6
+ // cond: buildcfg.GOARM >= 6
// result: (NMULF x y)
for {
if v_0.Op != OpARMMULF {
}
y := v_0.Args[1]
x := v_0.Args[0]
- if !(objabi.GOARM >= 6) {
+ if !(buildcfg.GOARM >= 6) {
break
}
v.reset(OpARMNMULF)
return true
}
// match: (ORshiftLL <typ.UInt16> [8] (SRLconst <typ.UInt16> [24] (SLLconst [16] x)) x)
- // cond: objabi.GOARM>=6
+ // cond: buildcfg.GOARM>=6
// result: (REV16 x)
for {
if v.Type != typ.UInt16 || auxIntToInt32(v.AuxInt) != 8 || v_0.Op != OpARMSRLconst || v_0.Type != typ.UInt16 || auxIntToInt32(v_0.AuxInt) != 24 {
break
}
x := v_0_0.Args[0]
- if x != v_1 || !(objabi.GOARM >= 6) {
+ if x != v_1 || !(buildcfg.GOARM >= 6) {
break
}
v.reset(OpARMREV16)
return true
}
// match: (RSB (MUL x y) a)
- // cond: objabi.GOARM == 7
+ // cond: buildcfg.GOARM == 7
// result: (MULS x y a)
for {
if v_0.Op != OpARMMUL {
y := v_0.Args[1]
x := v_0.Args[0]
a := v_1
- if !(objabi.GOARM == 7) {
+ if !(buildcfg.GOARM == 7) {
break
}
v.reset(OpARMMULS)
return true
}
// match: (SRAconst (SLLconst x [c]) [d])
- // cond: objabi.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31
+ // cond: buildcfg.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31
// result: (BFX [(d-c)|(32-d)<<8] x)
for {
d := auxIntToInt32(v.AuxInt)
}
c := auxIntToInt32(v_0.AuxInt)
x := v_0.Args[0]
- if !(objabi.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) {
+ if !(buildcfg.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) {
break
}
v.reset(OpARMBFX)
return true
}
// match: (SRLconst (SLLconst x [c]) [d])
- // cond: objabi.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31
+ // cond: buildcfg.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31
// result: (BFXU [(d-c)|(32-d)<<8] x)
for {
d := auxIntToInt32(v.AuxInt)
}
c := auxIntToInt32(v_0.AuxInt)
x := v_0.Args[0]
- if !(objabi.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) {
+ if !(buildcfg.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) {
break
}
v.reset(OpARMBFXU)
return true
}
// match: (SUB a (MUL x y))
- // cond: objabi.GOARM == 7
+ // cond: buildcfg.GOARM == 7
// result: (MULS x y a)
for {
a := v_0
}
y := v_1.Args[1]
x := v_1.Args[0]
- if !(objabi.GOARM == 7) {
+ if !(buildcfg.GOARM == 7) {
break
}
v.reset(OpARMMULS)
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBD a (MULD x y))
- // cond: a.Uses == 1 && objabi.GOARM >= 6
+ // cond: a.Uses == 1 && buildcfg.GOARM >= 6
// result: (MULSD a x y)
for {
a := v_0
}
y := v_1.Args[1]
x := v_1.Args[0]
- if !(a.Uses == 1 && objabi.GOARM >= 6) {
+ if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
break
}
v.reset(OpARMMULSD)
return true
}
// match: (SUBD a (NMULD x y))
- // cond: a.Uses == 1 && objabi.GOARM >= 6
+ // cond: a.Uses == 1 && buildcfg.GOARM >= 6
// result: (MULAD a x y)
for {
a := v_0
}
y := v_1.Args[1]
x := v_1.Args[0]
- if !(a.Uses == 1 && objabi.GOARM >= 6) {
+ if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
break
}
v.reset(OpARMMULAD)
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBF a (MULF x y))
- // cond: a.Uses == 1 && objabi.GOARM >= 6
+ // cond: a.Uses == 1 && buildcfg.GOARM >= 6
// result: (MULSF a x y)
for {
a := v_0
}
y := v_1.Args[1]
x := v_1.Args[0]
- if !(a.Uses == 1 && objabi.GOARM >= 6) {
+ if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
break
}
v.reset(OpARMMULSF)
return true
}
// match: (SUBF a (NMULF x y))
- // cond: a.Uses == 1 && objabi.GOARM >= 6
+ // cond: a.Uses == 1 && buildcfg.GOARM >= 6
// result: (MULAF a x y)
for {
a := v_0
}
y := v_1.Args[1]
x := v_1.Args[0]
- if !(a.Uses == 1 && objabi.GOARM >= 6) {
+ if !(a.Uses == 1 && buildcfg.GOARM >= 6) {
break
}
v.reset(OpARMMULAF)
return true
}
// match: (SUBconst [c] x)
- // cond: objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff
+ // cond: buildcfg.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff
// result: (ADDconst [-c] x)
for {
c := auxIntToInt32(v.AuxInt)
x := v_0
- if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) {
+ if !(buildcfg.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) {
break
}
v.reset(OpARMADDconst)
return true
}
// match: (XORshiftLL <typ.UInt16> [8] (SRLconst <typ.UInt16> [24] (SLLconst [16] x)) x)
- // cond: objabi.GOARM>=6
+ // cond: buildcfg.GOARM>=6
// result: (REV16 x)
for {
if v.Type != typ.UInt16 || auxIntToInt32(v.AuxInt) != 8 || v_0.Op != OpARMSRLconst || v_0.Type != typ.UInt16 || auxIntToInt32(v_0.AuxInt) != 24 {
break
}
x := v_0_0.Args[0]
- if x != v_1 || !(objabi.GOARM >= 6) {
+ if x != v_1 || !(buildcfg.GOARM >= 6) {
break
}
v.reset(OpARMREV16)
v_0 := v.Args[0]
b := v.Block
// match: (Bswap32 <t> x)
- // cond: objabi.GOARM==5
+ // cond: buildcfg.GOARM==5
// result: (XOR <t> (SRLconst <t> (BICconst <t> (XOR <t> x (SRRconst <t> [16] x)) [0xff0000]) [8]) (SRRconst <t> x [8]))
for {
t := v.Type
x := v_0
- if !(objabi.GOARM == 5) {
+ if !(buildcfg.GOARM == 5) {
break
}
v.reset(OpARMXOR)
return true
}
// match: (Bswap32 x)
- // cond: objabi.GOARM>=6
+ // cond: buildcfg.GOARM>=6
// result: (REV x)
for {
x := v_0
- if !(objabi.GOARM >= 6) {
+ if !(buildcfg.GOARM >= 6) {
break
}
v.reset(OpARMREV)
b := v.Block
typ := &b.Func.Config.Types
// match: (Ctz16 <t> x)
- // cond: objabi.GOARM<=6
+ // cond: buildcfg.GOARM<=6
// result: (RSBconst [32] (CLZ <t> (SUBconst <typ.UInt32> (AND <typ.UInt32> (ORconst <typ.UInt32> [0x10000] x) (RSBconst <typ.UInt32> [0] (ORconst <typ.UInt32> [0x10000] x))) [1])))
for {
t := v.Type
x := v_0
- if !(objabi.GOARM <= 6) {
+ if !(buildcfg.GOARM <= 6) {
break
}
v.reset(OpARMRSBconst)
return true
}
// match: (Ctz16 <t> x)
- // cond: objabi.GOARM==7
+ // cond: buildcfg.GOARM==7
// result: (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x10000] x)))
for {
t := v.Type
x := v_0
- if !(objabi.GOARM == 7) {
+ if !(buildcfg.GOARM == 7) {
break
}
v.reset(OpARMCLZ)
v_0 := v.Args[0]
b := v.Block
// match: (Ctz32 <t> x)
- // cond: objabi.GOARM<=6
+ // cond: buildcfg.GOARM<=6
// result: (RSBconst [32] (CLZ <t> (SUBconst <t> (AND <t> x (RSBconst <t> [0] x)) [1])))
for {
t := v.Type
x := v_0
- if !(objabi.GOARM <= 6) {
+ if !(buildcfg.GOARM <= 6) {
break
}
v.reset(OpARMRSBconst)
return true
}
// match: (Ctz32 <t> x)
- // cond: objabi.GOARM==7
+ // cond: buildcfg.GOARM==7
// result: (CLZ <t> (RBIT <t> x))
for {
t := v.Type
x := v_0
- if !(objabi.GOARM == 7) {
+ if !(buildcfg.GOARM == 7) {
break
}
v.reset(OpARMCLZ)
b := v.Block
typ := &b.Func.Config.Types
// match: (Ctz8 <t> x)
- // cond: objabi.GOARM<=6
+ // cond: buildcfg.GOARM<=6
// result: (RSBconst [32] (CLZ <t> (SUBconst <typ.UInt32> (AND <typ.UInt32> (ORconst <typ.UInt32> [0x100] x) (RSBconst <typ.UInt32> [0] (ORconst <typ.UInt32> [0x100] x))) [1])))
for {
t := v.Type
x := v_0
- if !(objabi.GOARM <= 6) {
+ if !(buildcfg.GOARM <= 6) {
break
}
v.reset(OpARMRSBconst)
return true
}
// match: (Ctz8 <t> x)
- // cond: objabi.GOARM==7
+ // cond: buildcfg.GOARM==7
// result: (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x100] x)))
for {
t := v.Type
x := v_0
- if !(objabi.GOARM == 7) {
+ if !(buildcfg.GOARM == 7) {
break
}
v.reset(OpARMCLZ)
package ssa
-import "math"
-import "cmd/internal/objabi"
-import "cmd/compile/internal/types"
+import (
+ "cmd/compile/internal/types"
+ "internal/buildcfg"
+ "math"
+)
func rewriteValuePPC64(v *Value) bool {
switch v.Op {
b := v.Block
typ := &b.Func.Config.Types
// match: (Ctz32 x)
- // cond: objabi.GOPPC64<=8
+ // cond: buildcfg.GOPPC64<=8
// result: (POPCNTW (MOVWZreg (ANDN <typ.Int> (ADDconst <typ.Int> [-1] x) x)))
for {
x := v_0
- if !(objabi.GOPPC64 <= 8) {
+ if !(buildcfg.GOPPC64 <= 8) {
break
}
v.reset(OpPPC64POPCNTW)
b := v.Block
typ := &b.Func.Config.Types
// match: (Ctz64 x)
- // cond: objabi.GOPPC64<=8
+ // cond: buildcfg.GOPPC64<=8
// result: (POPCNTD (ANDN <typ.Int64> (ADDconst <typ.Int64> [-1] x) x))
for {
x := v_0
- if !(objabi.GOPPC64 <= 8) {
+ if !(buildcfg.GOPPC64 <= 8) {
break
}
v.reset(OpPPC64POPCNTD)
b := v.Block
typ := &b.Func.Config.Types
// match: (Mod32 x y)
- // cond: objabi.GOPPC64 >= 9
+ // cond: buildcfg.GOPPC64 >= 9
// result: (MODSW x y)
for {
x := v_0
y := v_1
- if !(objabi.GOPPC64 >= 9) {
+ if !(buildcfg.GOPPC64 >= 9) {
break
}
v.reset(OpPPC64MODSW)
return true
}
// match: (Mod32 x y)
- // cond: objabi.GOPPC64 <= 8
+ // cond: buildcfg.GOPPC64 <= 8
// result: (SUB x (MULLW y (DIVW x y)))
for {
x := v_0
y := v_1
- if !(objabi.GOPPC64 <= 8) {
+ if !(buildcfg.GOPPC64 <= 8) {
break
}
v.reset(OpPPC64SUB)
b := v.Block
typ := &b.Func.Config.Types
// match: (Mod32u x y)
- // cond: objabi.GOPPC64 >= 9
+ // cond: buildcfg.GOPPC64 >= 9
// result: (MODUW x y)
for {
x := v_0
y := v_1
- if !(objabi.GOPPC64 >= 9) {
+ if !(buildcfg.GOPPC64 >= 9) {
break
}
v.reset(OpPPC64MODUW)
return true
}
// match: (Mod32u x y)
- // cond: objabi.GOPPC64 <= 8
+ // cond: buildcfg.GOPPC64 <= 8
// result: (SUB x (MULLW y (DIVWU x y)))
for {
x := v_0
y := v_1
- if !(objabi.GOPPC64 <= 8) {
+ if !(buildcfg.GOPPC64 <= 8) {
break
}
v.reset(OpPPC64SUB)
b := v.Block
typ := &b.Func.Config.Types
// match: (Mod64 x y)
- // cond: objabi.GOPPC64 >=9
+ // cond: buildcfg.GOPPC64 >=9
// result: (MODSD x y)
for {
x := v_0
y := v_1
- if !(objabi.GOPPC64 >= 9) {
+ if !(buildcfg.GOPPC64 >= 9) {
break
}
v.reset(OpPPC64MODSD)
return true
}
// match: (Mod64 x y)
- // cond: objabi.GOPPC64 <=8
+ // cond: buildcfg.GOPPC64 <=8
// result: (SUB x (MULLD y (DIVD x y)))
for {
x := v_0
y := v_1
- if !(objabi.GOPPC64 <= 8) {
+ if !(buildcfg.GOPPC64 <= 8) {
break
}
v.reset(OpPPC64SUB)
b := v.Block
typ := &b.Func.Config.Types
// match: (Mod64u x y)
- // cond: objabi.GOPPC64 >= 9
+ // cond: buildcfg.GOPPC64 >= 9
// result: (MODUD x y)
for {
x := v_0
y := v_1
- if !(objabi.GOPPC64 >= 9) {
+ if !(buildcfg.GOPPC64 >= 9) {
break
}
v.reset(OpPPC64MODUD)
return true
}
// match: (Mod64u x y)
- // cond: objabi.GOPPC64 <= 8
+ // cond: buildcfg.GOPPC64 <= 8
// result: (SUB x (MULLD y (DIVDU x y)))
for {
x := v_0
y := v_1
- if !(objabi.GOPPC64 <= 8) {
+ if !(buildcfg.GOPPC64 <= 8) {
break
}
v.reset(OpPPC64SUB)
return true
}
// match: (Move [s] dst src mem)
- // cond: s > 8 && objabi.GOPPC64 <= 8 && logLargeCopy(v, s)
+ // cond: s > 8 && buildcfg.GOPPC64 <= 8 && logLargeCopy(v, s)
// result: (LoweredMove [s] dst src mem)
for {
s := auxIntToInt64(v.AuxInt)
dst := v_0
src := v_1
mem := v_2
- if !(s > 8 && objabi.GOPPC64 <= 8 && logLargeCopy(v, s)) {
+ if !(s > 8 && buildcfg.GOPPC64 <= 8 && logLargeCopy(v, s)) {
break
}
v.reset(OpPPC64LoweredMove)
return true
}
// match: (Move [s] dst src mem)
- // cond: s > 8 && s <= 64 && objabi.GOPPC64 >= 9
+ // cond: s > 8 && s <= 64 && buildcfg.GOPPC64 >= 9
// result: (LoweredQuadMoveShort [s] dst src mem)
for {
s := auxIntToInt64(v.AuxInt)
dst := v_0
src := v_1
mem := v_2
- if !(s > 8 && s <= 64 && objabi.GOPPC64 >= 9) {
+ if !(s > 8 && s <= 64 && buildcfg.GOPPC64 >= 9) {
break
}
v.reset(OpPPC64LoweredQuadMoveShort)
return true
}
// match: (Move [s] dst src mem)
- // cond: s > 8 && objabi.GOPPC64 >= 9 && logLargeCopy(v, s)
+ // cond: s > 8 && buildcfg.GOPPC64 >= 9 && logLargeCopy(v, s)
// result: (LoweredQuadMove [s] dst src mem)
for {
s := auxIntToInt64(v.AuxInt)
dst := v_0
src := v_1
mem := v_2
- if !(s > 8 && objabi.GOPPC64 >= 9 && logLargeCopy(v, s)) {
+ if !(s > 8 && buildcfg.GOPPC64 >= 9 && logLargeCopy(v, s)) {
break
}
v.reset(OpPPC64LoweredQuadMove)
b := v.Block
typ := &b.Func.Config.Types
// match: (ADD l:(MULLD x y) z)
- // cond: objabi.GOPPC64 >= 9 && l.Uses == 1 && clobber(l)
+ // cond: buildcfg.GOPPC64 >= 9 && l.Uses == 1 && clobber(l)
// result: (MADDLD x y z)
for {
for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
y := l.Args[1]
x := l.Args[0]
z := v_1
- if !(objabi.GOPPC64 >= 9 && l.Uses == 1 && clobber(l)) {
+ if !(buildcfg.GOPPC64 >= 9 && l.Uses == 1 && clobber(l)) {
continue
}
v.reset(OpPPC64MADDLD)
break
}
// match: (SLDconst [c] z:(MOVWreg x))
- // cond: c < 32 && objabi.GOPPC64 >= 9
+ // cond: c < 32 && buildcfg.GOPPC64 >= 9
// result: (EXTSWSLconst [c] x)
for {
c := auxIntToInt64(v.AuxInt)
break
}
x := z.Args[0]
- if !(c < 32 && objabi.GOPPC64 >= 9) {
+ if !(c < 32 && buildcfg.GOPPC64 >= 9) {
break
}
v.reset(OpPPC64EXTSWSLconst)
break
}
// match: (SLWconst [c] z:(MOVWreg x))
- // cond: c < 32 && objabi.GOPPC64 >= 9
+ // cond: c < 32 && buildcfg.GOPPC64 >= 9
// result: (EXTSWSLconst [c] x)
for {
c := auxIntToInt64(v.AuxInt)
break
}
x := z.Args[0]
- if !(c < 32 && objabi.GOPPC64 >= 9) {
+ if !(c < 32 && buildcfg.GOPPC64 >= 9) {
break
}
v.reset(OpPPC64EXTSWSLconst)
return true
}
// match: (Zero [s] ptr mem)
- // cond: objabi.GOPPC64 <= 8 && s < 64
+ // cond: buildcfg.GOPPC64 <= 8 && s < 64
// result: (LoweredZeroShort [s] ptr mem)
for {
s := auxIntToInt64(v.AuxInt)
ptr := v_0
mem := v_1
- if !(objabi.GOPPC64 <= 8 && s < 64) {
+ if !(buildcfg.GOPPC64 <= 8 && s < 64) {
break
}
v.reset(OpPPC64LoweredZeroShort)
return true
}
// match: (Zero [s] ptr mem)
- // cond: objabi.GOPPC64 <= 8
+ // cond: buildcfg.GOPPC64 <= 8
// result: (LoweredZero [s] ptr mem)
for {
s := auxIntToInt64(v.AuxInt)
ptr := v_0
mem := v_1
- if !(objabi.GOPPC64 <= 8) {
+ if !(buildcfg.GOPPC64 <= 8) {
break
}
v.reset(OpPPC64LoweredZero)
return true
}
// match: (Zero [s] ptr mem)
- // cond: s < 128 && objabi.GOPPC64 >= 9
+ // cond: s < 128 && buildcfg.GOPPC64 >= 9
// result: (LoweredQuadZeroShort [s] ptr mem)
for {
s := auxIntToInt64(v.AuxInt)
ptr := v_0
mem := v_1
- if !(s < 128 && objabi.GOPPC64 >= 9) {
+ if !(s < 128 && buildcfg.GOPPC64 >= 9) {
break
}
v.reset(OpPPC64LoweredQuadZeroShort)
return true
}
// match: (Zero [s] ptr mem)
- // cond: objabi.GOPPC64 >= 9
+ // cond: buildcfg.GOPPC64 >= 9
// result: (LoweredQuadZero [s] ptr mem)
for {
s := auxIntToInt64(v.AuxInt)
ptr := v_0
mem := v_1
- if !(objabi.GOPPC64 >= 9) {
+ if !(buildcfg.GOPPC64 >= 9) {
break
}
v.reset(OpPPC64LoweredQuadZero)
package ssa
-import "math"
-import "cmd/compile/internal/types"
+import (
+ "cmd/compile/internal/types"
+ "math"
+)
func rewriteValueRISCV64(v *Value) bool {
switch v.Op {
package ssa
-import "math"
-import "cmd/compile/internal/types"
-import "cmd/internal/obj/s390x"
+import (
+ "cmd/compile/internal/types"
+ "cmd/internal/obj/s390x"
+ "math"
+)
func rewriteValueS390X(v *Value) bool {
switch v.Op {
package ssa
-import "math"
-import "cmd/internal/objabi"
-import "cmd/compile/internal/types"
+import (
+ "cmd/compile/internal/types"
+ "internal/buildcfg"
+ "math"
+)
func rewriteValueWasm(v *Value) bool {
switch v.Op {
return true
}
// match: (SignExt16to32 x)
- // cond: objabi.GOWASM.SignExt
+ // cond: buildcfg.GOWASM.SignExt
// result: (I64Extend16S x)
for {
x := v_0
- if !(objabi.GOWASM.SignExt) {
+ if !(buildcfg.GOWASM.SignExt) {
break
}
v.reset(OpWasmI64Extend16S)
return true
}
// match: (SignExt16to64 x)
- // cond: objabi.GOWASM.SignExt
+ // cond: buildcfg.GOWASM.SignExt
// result: (I64Extend16S x)
for {
x := v_0
- if !(objabi.GOWASM.SignExt) {
+ if !(buildcfg.GOWASM.SignExt) {
break
}
v.reset(OpWasmI64Extend16S)
return true
}
// match: (SignExt32to64 x)
- // cond: objabi.GOWASM.SignExt
+ // cond: buildcfg.GOWASM.SignExt
// result: (I64Extend32S x)
for {
x := v_0
- if !(objabi.GOWASM.SignExt) {
+ if !(buildcfg.GOWASM.SignExt) {
break
}
v.reset(OpWasmI64Extend32S)
return true
}
// match: (SignExt8to16 x)
- // cond: objabi.GOWASM.SignExt
+ // cond: buildcfg.GOWASM.SignExt
// result: (I64Extend8S x)
for {
x := v_0
- if !(objabi.GOWASM.SignExt) {
+ if !(buildcfg.GOWASM.SignExt) {
break
}
v.reset(OpWasmI64Extend8S)
return true
}
// match: (SignExt8to32 x)
- // cond: objabi.GOWASM.SignExt
+ // cond: buildcfg.GOWASM.SignExt
// result: (I64Extend8S x)
for {
x := v_0
- if !(objabi.GOWASM.SignExt) {
+ if !(buildcfg.GOWASM.SignExt) {
break
}
v.reset(OpWasmI64Extend8S)
return true
}
// match: (SignExt8to64 x)
- // cond: objabi.GOWASM.SignExt
+ // cond: buildcfg.GOWASM.SignExt
// result: (I64Extend8S x)
for {
x := v_0
- if !(objabi.GOWASM.SignExt) {
+ if !(buildcfg.GOWASM.SignExt) {
break
}
v.reset(OpWasmI64Extend8S)
package ssa
-import "math"
-import "cmd/compile/internal/types"
+import (
+ "cmd/compile/internal/types"
+ "math"
+)
func rewriteValuegeneric(v *Value) bool {
switch v.Op {
import (
"fmt"
+ "internal/buildcfg"
"io/ioutil"
"log"
"os"
base.Fatalf("cgo exported function %s cannot have ABI wrappers", fn)
}
- if !objabi.Experiment.RegabiWrappers {
+ if !buildcfg.Experiment.RegabiWrappers {
// We'll generate ABI aliases instead of
// wrappers once we have LSyms in InitLSym.
continue
if f.Pragma&ir.Systemstack != 0 {
f.LSym.Set(obj.AttrCFunc, true)
}
- if f.ABI == obj.ABIInternal || !objabi.Experiment.RegabiWrappers {
+ if f.ABI == obj.ABIInternal || !buildcfg.Experiment.RegabiWrappers {
// Function values can only point to
// ABIInternal entry points. This will create
// the funcsym for either the defining
// when we see that.
staticdata.NeedFuncSym(f)
}
- if !objabi.Experiment.RegabiWrappers {
+ if !buildcfg.Experiment.RegabiWrappers {
// Create ABI aliases instead of wrappers.
forEachWrapperABI(f, makeABIAlias)
}
package ssagen
import (
+ "internal/buildcfg"
"internal/race"
"math/rand"
"sort"
if base.Ctxt.FixedFrameSize() == 0 {
off -= int64(types.PtrSize)
}
- if objabi.FramePointerEnabled {
+ if buildcfg.FramePointerEnabled {
off -= int64(types.PtrSize)
}
}
if fnsym == nil {
return
}
- if !objabi.Experiment.FieldTrack || len(tracked) == 0 {
+ if !buildcfg.Experiment.FieldTrack || len(tracked) == 0 {
return
}
"fmt"
"go/constant"
"html"
+ "internal/buildcfg"
"os"
"path/filepath"
"sort"
// abiForFunc implements ABI policy for a function, but does not return a copy of the ABI.
// Passing a nil function returns the default ABI based on experiment configuration.
func abiForFunc(fn *ir.Func, abi0, abi1 *abi.ABIConfig) *abi.ABIConfig {
- if objabi.Experiment.RegabiArgs {
+ if buildcfg.Experiment.RegabiArgs {
// Select the ABI based on the function's defining ABI.
if fn == nil {
return abi1
var args []*ssa.Value
var argNodes []*ir.Name
- if objabi.Experiment.RegabiDefer && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER || n.X.Type().NumResults() != 0) {
+ if buildcfg.Experiment.RegabiDefer && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER || n.X.Type().NumResults() != 0) {
s.Fatalf("defer call with arguments or results: %v", n)
}
callABI := s.f.ABIDefault
- if !objabi.Experiment.RegabiArgs {
+ if !buildcfg.Experiment.RegabiArgs {
var magicFnNameSym *types.Sym
if fn.Name() != nil {
magicFnNameSym = fn.Name().Sym()
}
}
- if objabi.Experiment.RegabiDefer && k != callNormal && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER || n.X.Type().NumResults() != 0) {
+ if buildcfg.Experiment.RegabiDefer && k != callNormal && (len(n.Args) != 0 || n.Op() == ir.OCALLINTER || n.X.Type().NumResults() != 0) {
s.Fatalf("go/defer call with arguments: %v", n)
}
if k == callNormal && fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC {
fn := fn.(*ir.Name)
callee = fn
- if objabi.Experiment.RegabiArgs {
+ if buildcfg.Experiment.RegabiArgs {
// This is a static call, so it may be
// a direct call to a non-ABIInternal
// function. fn.Func may be nil for
}
}
- if !objabi.Experiment.RegabiArgs {
+ if !buildcfg.Experiment.RegabiArgs {
if regAbiForFuncType(n.X.Type().FuncType()) {
// Magic last type in input args to call
callABI = s.f.ABI1
// maybeNilCheckClosure checks if a nil check of a closure is needed in some
// architecture-dependent situations and, if so, emits the nil check.
func (s *state) maybeNilCheckClosure(closure *ssa.Value, k callKind) {
- if Arch.LinkArch.Family == sys.Wasm || objabi.GOOS == "aix" && k != callGo {
+ if Arch.LinkArch.Family == sys.Wasm || buildcfg.GOOS == "aix" && k != callGo {
// On AIX, the closure needs to be verified as fn can be nil, except if it's a call go. This needs to be handled by the runtime to have the "go of nil func value" error.
// TODO(neelance): On other architectures this should be eliminated by the optimization steps
s.nilCheck(closure)
// and not address-taken (for non-SSA-able or address-taken arguments we always
// spill upfront).
// TODO(register args) Make liveness more fine-grained to that partial spilling is okay.
- if objabi.Experiment.RegabiArgs {
+ if buildcfg.Experiment.RegabiArgs {
// First, see if it is already spilled before it may be live. Look for a spill
// in the entry block up to the first safepoint.
type nameOff struct {
"crypto/sha256"
"fmt"
"go/constant"
+ "internal/buildcfg"
"io"
"io/ioutil"
"os"
// funcsymsmu, like in FuncSym.
base.Fatalf("NeedFuncSym must be called in serial")
}
- if fn.ABI != obj.ABIInternal && objabi.Experiment.RegabiWrappers {
+ if fn.ABI != obj.ABIInternal && buildcfg.Experiment.RegabiWrappers {
// Function values must always reference ABIInternal
// entry points, so it doesn't make sense to create a
// funcsym for other ABIs.
import (
"fmt"
"go/constant"
+ "internal/buildcfg"
"strings"
"cmd/compile/internal/base"
"cmd/compile/internal/typecheck"
"cmd/compile/internal/types"
"cmd/internal/obj"
- "cmd/internal/objabi"
)
// The result of walkExpr MUST be assigned back to n, e.g.
}
func usefield(n *ir.SelectorExpr) {
- if !objabi.Experiment.FieldTrack {
+ if !buildcfg.Experiment.FieldTrack {
return
}
import (
"fmt"
"go/constant"
+ "internal/buildcfg"
"cmd/compile/internal/base"
"cmd/compile/internal/escape"
"cmd/compile/internal/staticinit"
"cmd/compile/internal/typecheck"
"cmd/compile/internal/types"
- "cmd/internal/objabi"
"cmd/internal/src"
)
n.Call = walkRecover(n.Call.(*ir.CallExpr), &init)
o.stmtList(init)
}
- if objabi.Experiment.RegabiDefer {
+ if buildcfg.Experiment.RegabiDefer {
o.wrapGoDefer(n)
}
o.out = append(o.out, n)
th := hit.Type()
// depends on layout of iterator struct.
// See cmd/compile/internal/reflectdata/reflect.go:MapIterType
- keysym := th.Field(0).Sym
+ keysym := th.Field(0).Sym
elemsym := th.Field(1).Sym // ditto
fn := typecheck.LookupRuntime("mapiterinit")
"cmd/compile/internal/types"
"cmd/internal/obj"
"cmd/internal/obj/wasm"
- "cmd/internal/objabi"
+ "internal/buildcfg"
)
func Init(arch *ssagen.ArchInfo) {
case ssa.OpWasmI64TruncSatF32S, ssa.OpWasmI64TruncSatF64S:
getValue64(s, v.Args[0])
- if objabi.GOWASM.SatConv {
+ if buildcfg.GOWASM.SatConv {
s.Prog(v.Op.Asm())
} else {
if v.Op == ssa.OpWasmI64TruncSatF32S {
case ssa.OpWasmI64TruncSatF32U, ssa.OpWasmI64TruncSatF64U:
getValue64(s, v.Args[0])
- if objabi.GOWASM.SatConv {
+ if buildcfg.GOWASM.SatConv {
s.Prog(v.Op.Asm())
} else {
if v.Op == ssa.OpWasmI64TruncSatF32U {
"cmd/compile/internal/base"
"cmd/compile/internal/ssagen"
"cmd/internal/obj/x86"
- "cmd/internal/objabi"
"fmt"
+ "internal/buildcfg"
"os"
)
arch.SSAGenValue = ssaGenValue
arch.SSAGenBlock = ssaGenBlock
arch.MAXWIDTH = (1 << 32) - 1
- switch v := objabi.GO386; v {
+ switch v := buildcfg.GO386; v {
case "sse2":
case "softfloat":
arch.SoftFloat = true
"cmd/compile/internal/ssagen"
"cmd/compile/internal/wasm"
"cmd/compile/internal/x86"
- "cmd/internal/objabi"
"fmt"
+ "internal/buildcfg"
"log"
"os"
)
log.SetFlags(0)
log.SetPrefix("compile: ")
- archInit, ok := archInits[objabi.GOARCH]
+ buildcfg.Check()
+ archInit, ok := archInits[buildcfg.GOARCH]
if !ok {
- fmt.Fprintf(os.Stderr, "compile: unknown architecture %q\n", objabi.GOARCH)
+ fmt.Fprintf(os.Stderr, "compile: unknown architecture %q\n", buildcfg.GOARCH)
os.Exit(2)
}
writefile(buf.String(), file, writeSkipSame)
}
-// mkzbootstrap writes cmd/internal/objabi/zbootstrap.go:
+// mkbuildcfg writes internal/buildcfg/zbootstrap.go:
//
-// package objabi
+// package buildcfg
//
// const defaultGOROOT = <goroot>
// const defaultGO386 = <go386>
-// const defaultGOARM = <goarm>
-// const defaultGOMIPS = <gomips>
-// const defaultGOMIPS64 = <gomips64>
-// const defaultGOPPC64 = <goppc64>
+// ...
// const defaultGOOS = runtime.GOOS
// const defaultGOARCH = runtime.GOARCH
-// const defaultGOEXPERIMENT = <goexperiment>
-// const defaultGO_EXTLINK_ENABLED = <goextlinkenabled>
-// const version = <version>
-// const stackGuardMultiplierDefault = <multiplier value>
//
// The use of runtime.GOOS and runtime.GOARCH makes sure that
// a cross-compiled compiler expects to compile for its own target
// the resulting compiler will default to generating linux/ppc64 object files.
// This is more useful than having it default to generating objects for the
// original target (in this example, a Mac).
-func mkzbootstrap(file string) {
+func mkbuildcfg(file string) {
var buf bytes.Buffer
fmt.Fprintf(&buf, "// Code generated by go tool dist; DO NOT EDIT.\n")
fmt.Fprintln(&buf)
- fmt.Fprintf(&buf, "package objabi\n")
+ fmt.Fprintf(&buf, "package buildcfg\n")
fmt.Fprintln(&buf)
fmt.Fprintf(&buf, "import \"runtime\"\n")
fmt.Fprintln(&buf)
fmt.Fprintf(&buf, "const defaultGOMIPS = `%s`\n", gomips)
fmt.Fprintf(&buf, "const defaultGOMIPS64 = `%s`\n", gomips64)
fmt.Fprintf(&buf, "const defaultGOPPC64 = `%s`\n", goppc64)
- fmt.Fprintf(&buf, "const defaultGOOS = runtime.GOOS\n")
- fmt.Fprintf(&buf, "const defaultGOARCH = runtime.GOARCH\n")
fmt.Fprintf(&buf, "const defaultGOEXPERIMENT = `%s`\n", goexperiment)
fmt.Fprintf(&buf, "const defaultGO_EXTLINK_ENABLED = `%s`\n", goextlinkenabled)
fmt.Fprintf(&buf, "const defaultGO_LDSO = `%s`\n", defaultldso)
fmt.Fprintf(&buf, "const version = `%s`\n", findgoversion())
+ fmt.Fprintf(&buf, "const defaultGOOS = runtime.GOOS\n")
+ fmt.Fprintf(&buf, "const defaultGOARCH = runtime.GOARCH\n")
+
+ writefile(buf.String(), file, writeSkipSame)
+}
+
+// mkobjabi writes cmd/internal/objabi/zbootstrap.go:
+//
+// package objabi
+//
+// const stackGuardMultiplierDefault = <multiplier value>
+//
+func mkobjabi(file string) {
+ var buf bytes.Buffer
+ fmt.Fprintf(&buf, "// Code generated by go tool dist; DO NOT EDIT.\n")
+ fmt.Fprintln(&buf)
+ fmt.Fprintf(&buf, "package objabi\n")
+ fmt.Fprintln(&buf)
fmt.Fprintf(&buf, "const stackGuardMultiplierDefault = %d\n", stackGuardMultiplierDefault())
writefile(buf.String(), file, writeSkipSame)
"debug/macho",
"debug/pe",
"go/constant",
+ "internal/buildcfg",
"internal/goexperiment",
"internal/goversion",
"internal/race",
}
xprintf("Building Go toolchain1 using %s.\n", goroot_bootstrap)
- mkzbootstrap(pathf("%s/src/cmd/internal/objabi/zbootstrap.go", goroot))
+ mkbuildcfg(pathf("%s/src/internal/buildcfg/zbootstrap.go", goroot))
+ mkobjabi(pathf("%s/src/cmd/internal/objabi/zbootstrap.go", goroot))
// Use $GOROOT/pkg/bootstrap as the bootstrap workspace root.
// We use a subdirectory of $GOROOT/pkg because that's the
"bytes"
"fmt"
"go/build"
+ "internal/buildcfg"
"internal/cfg"
"io"
"os"
"sync"
"cmd/go/internal/fsys"
-
- "cmd/internal/objabi"
)
// These are general "build flags" used by build and other commands.
GOMODCACHE = envOr("GOMODCACHE", gopathDir("pkg/mod"))
// Used in envcmd.MkEnv and build ID computations.
- GOARM = envOr("GOARM", fmt.Sprint(objabi.GOARM))
- GO386 = envOr("GO386", objabi.GO386)
- GOMIPS = envOr("GOMIPS", objabi.GOMIPS)
- GOMIPS64 = envOr("GOMIPS64", objabi.GOMIPS64)
- GOPPC64 = envOr("GOPPC64", fmt.Sprintf("%s%d", "power", objabi.GOPPC64))
- GOWASM = envOr("GOWASM", fmt.Sprint(objabi.GOWASM))
+ GOARM = envOr("GOARM", fmt.Sprint(buildcfg.GOARM))
+ GO386 = envOr("GO386", buildcfg.GO386)
+ GOMIPS = envOr("GOMIPS", buildcfg.GOMIPS)
+ GOMIPS64 = envOr("GOMIPS64", buildcfg.GOMIPS64)
+ GOPPC64 = envOr("GOPPC64", fmt.Sprintf("%s%d", "power", buildcfg.GOPPC64))
+ GOWASM = envOr("GOWASM", fmt.Sprint(buildcfg.GOWASM))
GOPROXY = envOr("GOPROXY", "https://proxy.golang.org,direct")
GOSUMDB = envOr("GOSUMDB", "sum.golang.org")
"encoding/json"
"errors"
"fmt"
+ "internal/buildcfg"
exec "internal/execabs"
"internal/lazyregexp"
"io"
"cmd/go/internal/modload"
"cmd/go/internal/str"
"cmd/go/internal/trace"
- "cmd/internal/objabi"
)
// actionList returns the list of actions in the dag rooted at root
key, val := cfg.GetArchEnv()
fmt.Fprintf(h, "%s=%s\n", key, val)
- if goexperiment := objabi.GOEXPERIMENT(); goexperiment != "" {
+ if goexperiment := buildcfg.GOEXPERIMENT(); goexperiment != "" {
fmt.Fprintf(h, "GOEXPERIMENT=%q\n", goexperiment)
}
key, val := cfg.GetArchEnv()
fmt.Fprintf(h, "%s=%s\n", key, val)
- if goexperiment := objabi.GOEXPERIMENT(); goexperiment != "" {
+ if goexperiment := buildcfg.GOEXPERIMENT(); goexperiment != "" {
fmt.Fprintf(h, "GOEXPERIMENT=%q\n", goexperiment)
}
"bufio"
"bytes"
"fmt"
+ "internal/buildcfg"
"io"
"log"
"os"
}
// TODO: Test and delete these conditions.
- if objabi.Experiment.FieldTrack || objabi.Experiment.PreemptibleLoops {
+ if buildcfg.Experiment.FieldTrack || buildcfg.Experiment.PreemptibleLoops {
canDashC = false
}
"cmd/go/internal/cfg"
"cmd/go/internal/fsys"
"cmd/go/internal/modload"
- "cmd/internal/objabi"
"cmd/internal/sys"
"flag"
"fmt"
+ "internal/buildcfg"
"os"
"path/filepath"
"runtime"
// used for compiling alternative files for the experiment. This allows
// changes for the experiment, like extra struct fields in the runtime,
// without affecting the base non-experiment code at all.
- for _, expt := range objabi.EnabledExperiments() {
+ for _, expt := range buildcfg.EnabledExperiments() {
cfg.BuildContext.BuildTags = append(cfg.BuildContext.BuildTags, "goexperiment."+expt)
}
}
"context"
"flag"
"fmt"
+ "internal/buildcfg"
"log"
"os"
"path/filepath"
os.Exit(2)
}
+ if err := buildcfg.Error; err != nil {
+ fmt.Fprintf(os.Stderr, "go: %v\n", buildcfg.Error)
+ os.Exit(2)
+ }
+
// Set environment (GOOS, GOARCH, etc) explicitly.
// In theory all the commands we invoke should have
// the same default computation of these as we do,
"errors"
"fmt"
"go/build"
+ "internal/buildcfg"
"internal/testenv"
"io/fs"
"os"
"cmd/go/internal/robustio"
"cmd/go/internal/txtar"
"cmd/go/internal/work"
- "cmd/internal/objabi"
"cmd/internal/sys"
)
"GOCACHE=" + testGOCACHE,
"GODEBUG=" + os.Getenv("GODEBUG"),
"GOEXE=" + cfg.ExeSuffix,
- "GOEXPERIMENT=" + objabi.GOEXPERIMENT(),
+ "GOEXPERIMENT=" + buildcfg.GOEXPERIMENT(),
"GOOS=" + runtime.GOOS,
"GOPATH=" + filepath.Join(ts.workdir, "gopath"),
"GOPROXY=" + proxyURL,
import (
"bytes"
- "cmd/internal/objabi"
"errors"
"fmt"
+ "internal/buildcfg"
exec "internal/execabs"
"sort"
"strconv"
"strings"
+
+ "cmd/internal/objabi"
)
// InfoPrefix is the prefix for all the symbols containing DWARF info entries.
return form
}
expandedForm := DW_FORM_udata
- if objabi.GOOS == "darwin" || objabi.GOOS == "ios" {
+ if buildcfg.GOOS == "darwin" || buildcfg.GOOS == "ios" {
expandedForm = DW_FORM_data4
}
return uint8(expandedForm)
"cmd/internal/bio"
"cmd/internal/objabi"
"fmt"
+ "internal/buildcfg"
"internal/testenv"
"io/ioutil"
"os"
`
func TestIssue41621LargeNumberOfRelocations(t *testing.T) {
- if testing.Short() || (objabi.GOARCH != "amd64") {
- t.Skipf("Skipping large number of relocations test in short mode or on %s", objabi.GOARCH)
+ if testing.Short() || (buildcfg.GOARCH != "amd64") {
+ t.Skipf("Skipping large number of relocations test in short mode or on %s", buildcfg.GOARCH)
}
testenv.MustHaveGoBuild(t)
"cmd/internal/obj"
"cmd/internal/objabi"
"fmt"
+ "internal/buildcfg"
"log"
"math"
"sort"
if immrot(^uint32(c.instoffset)) != 0 {
return C_NCON
}
- if uint32(c.instoffset) <= 0xffff && objabi.GOARM == 7 {
+ if uint32(c.instoffset) <= 0xffff && buildcfg.GOARM == 7 {
return C_SCON
}
if x, y := immrot2a(uint32(c.instoffset)); x != 0 && y != 0 {
func (c *ctxt5) chipzero5(e float64) int {
// We use GOARM=7 to gate the use of VFPv3 vmov (imm) instructions.
- if objabi.GOARM < 7 || math.Float64bits(e) != 0 {
+ if buildcfg.GOARM < 7 || math.Float64bits(e) != 0 {
return -1
}
return 0
func (c *ctxt5) chipfloat5(e float64) int {
// We use GOARM=7 to gate the use of VFPv3 vmov (imm) instructions.
- if objabi.GOARM < 7 {
+ if buildcfg.GOARM < 7 {
return -1
}
"cmd/internal/obj"
"cmd/internal/objabi"
"cmd/internal/sys"
+ "internal/buildcfg"
"log"
)
ctxt.Diag("%v: TLS MRC instruction must write to R0 as it might get translated into a BL instruction", p.Line())
}
- if objabi.GOARM < 7 {
+ if buildcfg.GOARM < 7 {
// Replace it with BL runtime.read_tls_fallback(SB) for ARM CPUs that lack the tls extension.
if progedit_tlsfallback == nil {
progedit_tlsfallback = ctxt.Lookup("runtime.read_tls_fallback")
"cmd/internal/objabi"
"cmd/internal/src"
"cmd/internal/sys"
+ "internal/buildcfg"
"log"
"math"
)
q1.To.Reg = REGSP
q1.Spadj = c.autosize
- if objabi.GOOS == "ios" {
+ if buildcfg.GOOS == "ios" {
// iOS does not support SA_ONSTACK. We will run the signal handler
// on the G stack. If we write below SP, it may be clobbered by
// the signal handler. So we save LR after decrementing SP.
"cmd/internal/goobj"
"cmd/internal/objabi"
"fmt"
+ "internal/buildcfg"
"log"
"math"
"sort"
ctxt.Arch = arch
ctxt.Pathname = objabi.WorkingDir()
- if err := ctxt.Headtype.Set(objabi.GOOS); err != nil {
- log.Fatalf("unknown goos %s", objabi.GOOS)
+ if err := ctxt.Headtype.Set(buildcfg.GOOS); err != nil {
+ log.Fatalf("unknown goos %s", buildcfg.GOOS)
}
ctxt.Flag_optimize = true
"bytes"
"cmd/internal/objabi"
"fmt"
+ "internal/buildcfg"
"io"
"strings"
)
}
for i := range opSuffixSpace {
sset := &opSuffixSpace[i]
- if sset.arch == objabi.GOARCH {
+ if sset.arch == buildcfg.GOARCH {
return sset.cconv(s)
}
}
case TYPE_SHIFT:
v := int(a.Offset)
ops := "<<>>->@>"
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
case "arm":
op := ops[((v>>5)&3)<<1:]
if v&(1<<4) != 0 {
r := (v >> 16) & 31
fmt.Fprintf(w, "%s%c%c%d", Rconv(r+RBaseARM64), op[0], op[1], (v>>10)&63)
default:
- panic("TYPE_SHIFT is not supported on " + objabi.GOARCH)
+ panic("TYPE_SHIFT is not supported on " + buildcfg.GOARCH)
}
case TYPE_REGREG:
"cmd/internal/sys"
"encoding/binary"
"fmt"
+ "internal/buildcfg"
"log"
"strings"
)
}
}
-var isAndroid = objabi.GOOS == "android"
+var isAndroid = buildcfg.GOOS == "android"
func prefixof(ctxt *obj.Link, a *obj.Addr) int {
if a.Reg < REG_CS && a.Index < REG_CS { // fast path
"cmd/internal/objabi"
"cmd/internal/src"
"cmd/internal/sys"
+ "internal/buildcfg"
"log"
"math"
"path"
var regg int16
if !p.From.Sym.NoSplit() || p.From.Sym.Wrapper() {
- if ctxt.Arch.Family == sys.AMD64 && objabi.Experiment.RegabiG && cursym.ABI() == obj.ABIInternal {
+ if ctxt.Arch.Family == sys.AMD64 && buildcfg.Experiment.RegabiG && cursym.ABI() == obj.ABIInternal {
regg = REGG // use the g register directly in ABIInternal
} else {
p = obj.Appendp(p, newprog)
regg = REG_CX
if ctxt.Arch.Family == sys.AMD64 {
- // Using this register means that stacksplit works w/ //go:registerparams even when !objabi.Experiment.RegabiG
+ // Using this register means that stacksplit works w/ //go:registerparams even when !buildcfg.Experiment.RegabiG
regg = REGG // == REG_R14
}
p = load_g(ctxt, p, newprog, regg) // load g into regg
"bytes"
"flag"
"fmt"
+ "internal/buildcfg"
"io"
"io/ioutil"
"log"
if s == "goexperiment" {
// test/run.go uses this to discover the full set of
// experiment tags. Report everything.
- p = " X:" + strings.Join(expList(&Experiment, nil, true), ",")
+ p = " X:" + strings.Join(buildcfg.AllExperiments(), ",")
} else {
// If the enabled experiments differ from the defaults,
// include that difference.
- if goexperiment := GOEXPERIMENT(); goexperiment != "" {
+ if goexperiment := buildcfg.GOEXPERIMENT(); goexperiment != "" {
p = " X:" + goexperiment
}
}
// build ID of the binary, so that if the compiler is changed and
// rebuilt, we notice and rebuild all packages.
if s == "full" {
- if strings.HasPrefix(Version, "devel") {
+ if strings.HasPrefix(buildcfg.Version, "devel") {
p += " buildID=" + buildID
}
}
- fmt.Printf("%s version %s%s\n", name, Version, p)
+ fmt.Printf("%s version %s%s\n", name, buildcfg.Version, p)
os.Exit(0)
return nil
}
package objabi
import (
+ "internal/buildcfg"
"os"
"path/filepath"
"strings"
}
abs, rewritten := ApplyRewrites(abs, rewrites)
- if !rewritten && hasPathPrefix(abs, GOROOT) {
- abs = "$GOROOT" + abs[len(GOROOT):]
+ if !rewritten && hasPathPrefix(abs, buildcfg.GOROOT) {
+ abs = "$GOROOT" + abs[len(buildcfg.GOROOT):]
}
if abs == "" {
package objabi
+import "internal/buildcfg"
+
// For the linkers. Must match Go definitions.
const (
// builds that have larger stack frames or for specific targets.
func stackGuardMultiplier() int {
// On AIX, a larger stack is needed for syscalls.
- if GOOS == "aix" {
+ if buildcfg.GOOS == "aix" {
return 2
}
return stackGuardMultiplierDefault
import (
"fmt"
- "log"
- "os"
"strings"
-)
-
-func envOr(key, value string) string {
- if x := os.Getenv(key); x != "" {
- return x
- }
- return value
-}
-var (
- defaultGOROOT string // set by linker
-
- GOROOT = envOr("GOROOT", defaultGOROOT)
- GOARCH = envOr("GOARCH", defaultGOARCH)
- GOOS = envOr("GOOS", defaultGOOS)
- GO386 = envOr("GO386", defaultGO386)
- GOARM = goarm()
- GOMIPS = gomips()
- GOMIPS64 = gomips64()
- GOPPC64 = goppc64()
- GOWASM = gowasm()
- GO_LDSO = defaultGO_LDSO
- Version = version
+ "internal/buildcfg"
)
const (
MachoRelocOffset = 2048 // reserve enough space for ELF relocations
)
-func goarm() int {
- def := defaultGOARM
- if GOOS == "android" && GOARCH == "arm" {
- // Android arm devices always support GOARM=7.
- def = "7"
- }
- switch v := envOr("GOARM", def); v {
- case "5":
- return 5
- case "6":
- return 6
- case "7":
- return 7
- }
- // Fail here, rather than validate at multiple call sites.
- log.Fatalf("Invalid GOARM value. Must be 5, 6, or 7.")
- panic("unreachable")
-}
-
-func gomips() string {
- switch v := envOr("GOMIPS", defaultGOMIPS); v {
- case "hardfloat", "softfloat":
- return v
- }
- log.Fatalf("Invalid GOMIPS value. Must be hardfloat or softfloat.")
- panic("unreachable")
-}
-
-func gomips64() string {
- switch v := envOr("GOMIPS64", defaultGOMIPS64); v {
- case "hardfloat", "softfloat":
- return v
- }
- log.Fatalf("Invalid GOMIPS64 value. Must be hardfloat or softfloat.")
- panic("unreachable")
-}
-
-func goppc64() int {
- switch v := envOr("GOPPC64", defaultGOPPC64); v {
- case "power8":
- return 8
- case "power9":
- return 9
- }
- log.Fatalf("Invalid GOPPC64 value. Must be power8 or power9.")
- panic("unreachable")
-}
-
-type gowasmFeatures struct {
- SignExt bool
- SatConv bool
-}
-
-func (f gowasmFeatures) String() string {
- var flags []string
- if f.SatConv {
- flags = append(flags, "satconv")
- }
- if f.SignExt {
- flags = append(flags, "signext")
- }
- return strings.Join(flags, ",")
-}
-
-func gowasm() (f gowasmFeatures) {
- for _, opt := range strings.Split(envOr("GOWASM", ""), ",") {
- switch opt {
- case "satconv":
- f.SatConv = true
- case "signext":
- f.SignExt = true
- case "":
- // ignore
- default:
- log.Fatalf("Invalid GOWASM value. No such feature: " + opt)
- }
- }
- return
-}
-
-func Getgoextlinkenabled() string {
- return envOr("GO_EXTLINK_ENABLED", defaultGO_EXTLINK_ENABLED)
-}
-
// HeaderString returns the toolchain configuration string written in
// Go object headers. This string ensures we don't attempt to import
// or link object files that are incompatible with each other. This
// string always starts with "go object ".
func HeaderString() string {
- return fmt.Sprintf("go object %s %s %s X:%s\n", GOOS, GOARCH, Version, strings.Join(EnabledExperiments(), ","))
+ return fmt.Sprintf("go object %s %s %s X:%s\n", buildcfg.GOOS, buildcfg.GOARCH, buildcfg.Version, strings.Join(buildcfg.EnabledExperiments(), ","))
}
import (
"cmd/internal/bio"
- "cmd/internal/objabi"
"cmd/link/internal/sym"
"encoding/binary"
"fmt"
+ "internal/buildcfg"
"io"
"os"
)
// For Mach-O and PE/386 files we strip a leading
// underscore from the symbol name.
- if objabi.GOOS == "darwin" || objabi.GOOS == "ios" || (objabi.GOOS == "windows" && objabi.GOARCH == "386") {
+ if buildcfg.GOOS == "darwin" || buildcfg.GOOS == "ios" || (buildcfg.GOOS == "windows" && buildcfg.GOARCH == "386") {
if name[0] == '_' && len(name) > 1 {
name = name[1:]
}
package ld
import (
- "cmd/internal/objabi"
"cmd/internal/sys"
"fmt"
+ "internal/buildcfg"
)
// A BuildMode indicates the sort of object we are building.
func (mode *BuildMode) Set(s string) error {
badmode := func() error {
- return fmt.Errorf("buildmode %s not supported on %s/%s", s, objabi.GOOS, objabi.GOARCH)
+ return fmt.Errorf("buildmode %s not supported on %s/%s", s, buildcfg.GOOS, buildcfg.GOARCH)
}
switch s {
default:
return fmt.Errorf("invalid buildmode: %q", s)
case "exe":
- switch objabi.GOOS + "/" + objabi.GOARCH {
+ switch buildcfg.GOOS + "/" + buildcfg.GOARCH {
case "darwin/arm64", "windows/arm", "windows/arm64": // On these platforms, everything is PIE
*mode = BuildModePIE
default:
*mode = BuildModeExe
}
case "pie":
- switch objabi.GOOS {
+ switch buildcfg.GOOS {
case "aix", "android", "linux", "windows", "darwin", "ios":
case "freebsd":
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
case "amd64":
default:
return badmode()
}
*mode = BuildModePIE
case "c-archive":
- switch objabi.GOOS {
+ switch buildcfg.GOOS {
case "aix", "darwin", "ios", "linux":
case "freebsd":
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
case "amd64":
default:
return badmode()
}
case "windows":
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
case "amd64", "386", "arm", "arm64":
default:
return badmode()
}
*mode = BuildModeCArchive
case "c-shared":
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
case "386", "amd64", "arm", "arm64", "ppc64le", "s390x":
default:
return badmode()
}
*mode = BuildModeCShared
case "shared":
- switch objabi.GOOS {
+ switch buildcfg.GOOS {
case "linux":
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
case "386", "amd64", "arm", "arm64", "ppc64le", "s390x":
default:
return badmode()
}
*mode = BuildModeShared
case "plugin":
- switch objabi.GOOS {
+ switch buildcfg.GOOS {
case "linux":
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
case "386", "amd64", "arm", "arm64", "s390x", "ppc64le":
default:
return badmode()
}
case "darwin":
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
case "amd64", "arm64":
default:
return badmode()
}
case "freebsd":
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
case "amd64":
default:
return badmode()
}()
}
- if sys.MustLinkExternal(objabi.GOOS, objabi.GOARCH) {
- return true, fmt.Sprintf("%s/%s requires external linking", objabi.GOOS, objabi.GOARCH)
+ if sys.MustLinkExternal(buildcfg.GOOS, buildcfg.GOARCH) {
+ return true, fmt.Sprintf("%s/%s requires external linking", buildcfg.GOOS, buildcfg.GOARCH)
}
if *flagMsan {
// https://golang.org/issue/14449
// https://golang.org/issue/21961
if iscgo && ctxt.Arch.InFamily(sys.MIPS64, sys.MIPS, sys.PPC64, sys.RISCV64) {
- return true, objabi.GOARCH + " does not support internal cgo"
+ return true, buildcfg.GOARCH + " does not support internal cgo"
}
- if iscgo && (objabi.GOOS == "android" || objabi.GOOS == "dragonfly") {
+ if iscgo && (buildcfg.GOOS == "android" || buildcfg.GOOS == "dragonfly") {
// It seems that on Dragonfly thread local storage is
// set up by the dynamic linker, so internal cgo linking
// doesn't work. Test case is "go test runtime/cgo".
- return true, objabi.GOOS + " does not support internal cgo"
+ return true, buildcfg.GOOS + " does not support internal cgo"
}
// When the race flag is set, the LLVM tsan relocatable file is linked
// into the final binary, which means external linking is required because
// internal linking does not support it.
if *flagRace && ctxt.Arch.InFamily(sys.PPC64) {
- return true, "race on " + objabi.GOARCH
+ return true, "race on " + buildcfg.GOARCH
}
// Some build modes require work the internal linker cannot do (yet).
case BuildModeCShared:
return true, "buildmode=c-shared"
case BuildModePIE:
- switch objabi.GOOS + "/" + objabi.GOARCH {
+ switch buildcfg.GOOS + "/" + buildcfg.GOARCH {
case "linux/amd64", "linux/arm64", "android/arm64":
case "windows/386", "windows/amd64", "windows/arm", "windows/arm64":
case "darwin/amd64", "darwin/arm64":
// default value of -linkmode. If it is not set when the
// linker is called we take the value it was set to when
// cmd/link was compiled. (See make.bash.)
- switch objabi.Getgoextlinkenabled() {
+ switch buildcfg.Getgoextlinkenabled() {
case "0":
ctxt.LinkMode = LinkInternal
via = "via GO_EXTLINK_ENABLED "
}
case LinkExternal:
switch {
- case objabi.GOARCH == "ppc64" && objabi.GOOS != "aix":
- Exitf("external linking not supported for %s/ppc64", objabi.GOOS)
+ case buildcfg.GOARCH == "ppc64" && buildcfg.GOOS != "aix":
+ Exitf("external linking not supported for %s/ppc64", buildcfg.GOOS)
}
}
}
"cmd/internal/objabi"
"cmd/internal/sys"
"cmd/link/internal/loader"
+ "internal/buildcfg"
"testing"
)
}
// Save the architecture as we're going to set it on each test run.
- origArch := objabi.GOARCH
+ origArch := buildcfg.GOARCH
defer func() {
- objabi.GOARCH = origArch
+ buildcfg.GOARCH = origArch
}()
for i, test := range tests {
iself := len(test.rel) != 0
- objabi.GOARCH = test.arch.Name
+ buildcfg.GOARCH = test.arch.Name
ctxt := setUpContext(test.arch, iself, test.ht, test.bm, test.lm)
foo := ctxt.loader.CreateSymForUpdate("foo", 0)
ctxt.loader.CreateExtSym("bar", 0)
"cmd/link/internal/loader"
"cmd/link/internal/sym"
"fmt"
+ "internal/buildcfg"
"unicode"
)
func (d *deadcodePass) init() {
d.ldr.InitReachable()
d.ifaceMethod = make(map[methodsig]bool)
- if objabi.Experiment.FieldTrack {
+ if buildcfg.Experiment.FieldTrack {
d.ldr.Reachparent = make([]loader.Sym, d.ldr.NSym())
}
d.dynlink = d.ctxt.DynlinkingGo()
if symIdx != 0 && !d.ldr.AttrReachable(symIdx) {
d.wq.push(symIdx)
d.ldr.SetAttrReachable(symIdx, true)
- if objabi.Experiment.FieldTrack && d.ldr.Reachparent[symIdx] == 0 {
+ if buildcfg.Experiment.FieldTrack && d.ldr.Reachparent[symIdx] == 0 {
d.ldr.Reachparent[symIdx] = parent
}
if *flagDumpDep {
"cmd/link/internal/loader"
"cmd/link/internal/sym"
"fmt"
+ "internal/buildcfg"
"log"
"path"
"runtime"
if producerExtra := d.ldr.Lookup(dwarf.CUInfoPrefix+"producer."+unit.Lib.Pkg, 0); producerExtra != 0 {
peData = d.ldr.Data(producerExtra)
}
- producer := "Go cmd/compile " + objabi.Version
+ producer := "Go cmd/compile " + buildcfg.Version
if len(peData) > 0 {
// We put a semicolon before the flags to clearly
// separate them from the version, which can be long
"encoding/binary"
"encoding/hex"
"fmt"
+ "internal/buildcfg"
"path/filepath"
"sort"
"strings"
ctxt.Out.Write8(1) // gprSize
ctxt.Out.Write8(1) // cpr1Size
ctxt.Out.Write8(0) // cpr2Size
- if objabi.GOMIPS == "softfloat" {
+ if buildcfg.GOMIPS == "softfloat" {
ctxt.Out.Write8(MIPS_FPABI_SOFT) // fpAbi
} else {
// Go cannot make sure non odd-number-fpr is used (ie, in load a double from memory).
gnuattributes.AddUint8(1) // 1:file, 2: section, 3: symbol, 1 here
gnuattributes.AddUint32(ctxt.Arch, 7) // tag length, including tag, 7 here
gnuattributes.AddUint8(4) // 4 for FP, 8 for MSA
- if objabi.GOMIPS == "softfloat" {
+ if buildcfg.GOMIPS == "softfloat" {
gnuattributes.AddUint8(MIPS_FPABI_SOFT)
} else {
// Note: MIPS_FPABI_ANY is bad naming: in fact it is MIPS I style FPR usage.
sh.Flags = uint64(elf.SHF_ALLOC)
sh.Addralign = 1
- if interpreter == "" && objabi.GO_LDSO != "" {
- interpreter = objabi.GO_LDSO
+ if interpreter == "" && buildcfg.GO_LDSO != "" {
+ interpreter = buildcfg.GO_LDSO
}
if interpreter == "" {
switch ctxt.HeadType {
case objabi.Hlinux:
- if objabi.GOOS == "android" {
+ if buildcfg.GOOS == "android" {
interpreter = thearch.Androiddynld
if interpreter == "" {
Exitf("ELF interpreter not set")
"encoding/base64"
"encoding/binary"
"fmt"
+ "internal/buildcfg"
exec "internal/execabs"
"io"
"io/ioutil"
suffix = "msan"
}
- Lflag(ctxt, filepath.Join(objabi.GOROOT, "pkg", fmt.Sprintf("%s_%s%s%s", objabi.GOOS, objabi.GOARCH, suffixsep, suffix)))
+ Lflag(ctxt, filepath.Join(buildcfg.GOROOT, "pkg", fmt.Sprintf("%s_%s%s%s", buildcfg.GOOS, buildcfg.GOARCH, suffixsep, suffix)))
mayberemoveoutfile()
if *flagEntrySymbol == "" {
switch ctxt.BuildMode {
case BuildModeCShared, BuildModeCArchive:
- *flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s_lib", objabi.GOARCH, objabi.GOOS)
+ *flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s_lib", buildcfg.GOARCH, buildcfg.GOOS)
case BuildModeExe, BuildModePIE:
- *flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s", objabi.GOARCH, objabi.GOOS)
+ *flagEntrySymbol = fmt.Sprintf("_rt0_%s_%s", buildcfg.GOARCH, buildcfg.GOOS)
case BuildModeShared, BuildModePlugin:
// No *flagEntrySymbol for -buildmode=shared and plugin
default:
default:
log.Fatalf("invalid -strictdups flag value %d", *FlagStrictDups)
}
- if !objabi.Experiment.RegabiWrappers || ctxt.linkShared {
+ if !buildcfg.Experiment.RegabiWrappers || ctxt.linkShared {
// Use ABI aliases if ABI wrappers are not used.
// TODO: for now we still use ABI aliases in shared linkage, even if
// the wrapper is enabled.
// We now have enough information to determine the link mode.
determineLinkMode(ctxt)
- if ctxt.LinkMode == LinkExternal && !iscgo && !(objabi.GOOS == "darwin" && ctxt.BuildMode != BuildModePlugin && ctxt.Arch.Family == sys.AMD64) {
+ if ctxt.LinkMode == LinkExternal && !iscgo && !(buildcfg.GOOS == "darwin" && ctxt.BuildMode != BuildModePlugin && ctxt.Arch.Family == sys.AMD64) {
// This indicates a user requested -linkmode=external.
// The startup code uses an import of runtime/cgo to decide
// whether to initialize the TLS. So give it one. This could
}
}
- if ctxt.LinkMode == LinkExternal && ctxt.Arch.Family == sys.PPC64 && objabi.GOOS != "aix" {
+ if ctxt.LinkMode == LinkExternal && ctxt.Arch.Family == sys.PPC64 && buildcfg.GOOS != "aix" {
toc := ctxt.loader.LookupOrCreateSym(".TOC.", 0)
sb := ctxt.loader.MakeSymbolUpdater(toc)
sb.SetType(sym.SDYNIMPORT)
// The Android Q linker started to complain about underalignment of the our TLS
// section. We don't actually use the section on android, so don't
// generate it.
- if objabi.GOOS != "android" {
+ if buildcfg.GOOS != "android" {
tlsg := ctxt.loader.LookupOrCreateSym("runtime.tlsg", 0)
sb := ctxt.loader.MakeSymbolUpdater(tlsg)
sb := ctxt.loader.MakeSymbolUpdater(goarm)
sb.SetType(sym.SDATA)
sb.SetSize(0)
- sb.AddUint8(uint8(objabi.GOARM))
+ sb.AddUint8(uint8(buildcfg.GOARM))
}
// Set runtime.disableMemoryProfiling bool if
// -headerpad is incompatible with -fembed-bitcode.
argv = append(argv, "-Wl,-headerpad,1144")
}
- if ctxt.DynlinkingGo() && objabi.GOOS != "ios" {
+ if ctxt.DynlinkingGo() && buildcfg.GOOS != "ios" {
// -flat_namespace is deprecated on iOS.
// It is useful for supporting plugins. We don't support plugins on iOS.
argv = append(argv, "-Wl,-flat_namespace")
// from the beginning of the section (like sym.STYPE).
argv = append(argv, "-Wl,-znocopyreloc")
- if objabi.GOOS == "android" {
+ if buildcfg.GOOS == "android" {
// Use lld to avoid errors from default linker (issue #38838)
altLinker = "lld"
}
- if ctxt.Arch.InFamily(sys.ARM, sys.ARM64) && objabi.GOOS == "linux" {
+ if ctxt.Arch.InFamily(sys.ARM, sys.ARM64) && buildcfg.GOOS == "linux" {
// On ARM, the GNU linker will generate COPY relocations
// even with -znocopyreloc set.
// https://sourceware.org/bugzilla/show_bug.cgi?id=19962
}
}
}
- if ctxt.Arch.Family == sys.ARM64 && objabi.GOOS == "freebsd" {
+ if ctxt.Arch.Family == sys.ARM64 && buildcfg.GOOS == "freebsd" {
// Switch to ld.bfd on freebsd/arm64.
altLinker = "bfd"
// only want to do this when producing a Windows output file
// on a Windows host.
outopt := *flagOutfile
- if objabi.GOOS == "windows" && runtime.GOOS == "windows" && filepath.Ext(outopt) == "" {
+ if buildcfg.GOOS == "windows" && runtime.GOOS == "windows" && filepath.Ext(outopt) == "" {
outopt += "."
}
argv = append(argv, "-o")
case sys.I386:
return []string{"-m32"}
case sys.AMD64:
- if objabi.GOOS == "darwin" {
+ if buildcfg.GOOS == "darwin" {
return []string{"-arch", "x86_64", "-m64"}
}
return []string{"-m64"}
case sys.ARM:
return []string{"-marm"}
case sys.ARM64:
- if objabi.GOOS == "darwin" {
+ if buildcfg.GOOS == "darwin" {
return []string{"-arch", "arm64"}
}
case sys.MIPS64:
case sys.MIPS:
return []string{"-mabi=32"}
case sys.PPC64:
- if objabi.GOOS == "aix" {
+ if buildcfg.GOOS == "aix" {
return []string{"-maix64"}
} else {
return []string{"-m64"}
}
// First, check that the basic GOOS, GOARCH, and Version match.
- t := fmt.Sprintf("%s %s %s ", objabi.GOOS, objabi.GOARCH, objabi.Version)
+ t := fmt.Sprintf("%s %s %s ", buildcfg.GOOS, buildcfg.GOARCH, buildcfg.Version)
line = strings.TrimRight(line, "\n")
if !strings.HasPrefix(line[10:]+" ", t) && !*flagF {
// collect text symbol ABI versions.
symabi := make(map[string]int) // map (unmangled) symbol name to version
- if objabi.Experiment.RegabiWrappers {
+ if buildcfg.Experiment.RegabiWrappers {
for _, elfsym := range syms {
if elf.ST_TYPE(elfsym.Info) != elf.STT_FUNC {
continue
symname := elfsym.Name // (unmangled) symbol name
if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && strings.HasPrefix(elfsym.Name, "type.") {
ver = sym.SymVerABIInternal
- } else if objabi.Experiment.RegabiWrappers && elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC {
+ } else if buildcfg.Experiment.RegabiWrappers && elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC {
if strings.HasSuffix(elfsym.Name, ".abiinternal") {
ver = sym.SymVerABIInternal
symname = strings.TrimSuffix(elfsym.Name, ".abiinternal")
// mangle Go function names in the .so to include the
// ABI.
if elf.ST_TYPE(elfsym.Info) == elf.STT_FUNC && ver == 0 {
- if objabi.Experiment.RegabiWrappers {
+ if buildcfg.Experiment.RegabiWrappers {
if _, ok := symabi[symname]; ok {
continue // only use alias for functions w/o ABI wrappers
}
// of non-splitting functions.
var ch chain
ch.limit = objabi.StackLimit - callsize(ctxt)
- if objabi.GOARCH == "arm64" {
+ if buildcfg.GOARCH == "arm64" {
// need extra 8 bytes below SP to save FP
ch.limit -= 8
}
"debug/macho"
"encoding/binary"
"fmt"
+ "internal/buildcfg"
"io"
"os"
"sort"
if machoPlatform == PLATFORM_MACOS {
switch n := ldr.SymExtname(s); n {
case "fdopendir":
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
case "amd64":
ldr.SetSymExtname(s, n+"$INODE64")
}
case "readdir_r", "getfsstat":
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
case "amd64":
ldr.SetSymExtname(s, n+"$INODE64")
}
"cmd/internal/sys"
"cmd/link/internal/benchmark"
"flag"
+ "internal/buildcfg"
"log"
"os"
"runtime"
addstrdata1(ctxt, "runtime.defaultGOROOT="+final)
addstrdata1(ctxt, "cmd/internal/objabi.defaultGOROOT="+final)
- buildVersion := objabi.Version
- if goexperiment := objabi.GOEXPERIMENT(); goexperiment != "" {
+ buildVersion := buildcfg.Version
+ if goexperiment := buildcfg.GOEXPERIMENT(); goexperiment != "" {
buildVersion += " X:" + goexperiment
}
addstrdata1(ctxt, "runtime.buildVersion="+buildVersion)
// TODO(matloob): define these above and then check flag values here
- if ctxt.Arch.Family == sys.AMD64 && objabi.GOOS == "plan9" {
+ if ctxt.Arch.Family == sys.AMD64 && buildcfg.GOOS == "plan9" {
flag.BoolVar(&flag8, "8", false, "use 64-bit addresses in symbol table")
}
flagHeadType := flag.String("H", "", "set header `type`")
}
}
if ctxt.HeadType == objabi.Hunknown {
- ctxt.HeadType.Set(objabi.GOOS)
+ ctxt.HeadType.Set(buildcfg.GOOS)
}
if !*flagAslr && ctxt.BuildMode != BuildModeCShared {
bench.Start("dostrdata")
ctxt.dostrdata()
- if objabi.Experiment.FieldTrack {
+ if buildcfg.Experiment.FieldTrack {
bench.Start("fieldtrack")
fieldtrack(ctxt.Arch, ctxt.loader)
}
"cmd/link/internal/loader"
"cmd/link/internal/sym"
"fmt"
+ "internal/buildcfg"
"os"
"path/filepath"
)
}
func gorootFinal() string {
- root := objabi.GOROOT
+ root := buildcfg.GOROOT
if final := os.Getenv("GOROOT_FINAL"); final != "" {
root = final
}
"debug/pe"
"encoding/binary"
"fmt"
+ "internal/buildcfg"
"sort"
"strconv"
"strings"
// that this will need to grow in the future.
var size int
var alignment uint32
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
default:
- Exitf("peFile.addInitArray: unsupported GOARCH=%q\n", objabi.GOARCH)
+ Exitf("peFile.addInitArray: unsupported GOARCH=%q\n", buildcfg.GOARCH)
case "386", "arm":
size = 4
alignment = IMAGE_SCN_ALIGN_4BYTES
init_entry := ctxt.loader.Lookup(*flagEntrySymbol, 0)
addr := uint64(ctxt.loader.SymValue(init_entry)) - ctxt.loader.SymSect(init_entry).Vaddr
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
case "386", "arm":
ctxt.Out.Write32(uint32(addr))
case "amd64", "arm64":
dottext := ldr.Lookup(".text", 0)
ctxt.Out.Write32(0)
ctxt.Out.Write32(uint32(ldr.SymDynid(dottext)))
- switch objabi.GOARCH {
+ switch buildcfg.GOARCH {
default:
- ctxt.Errorf(dottext, "unknown architecture for PE: %q\n", objabi.GOARCH)
+ ctxt.Errorf(dottext, "unknown architecture for PE: %q\n", buildcfg.GOARCH)
case "386":
ctxt.Out.Write16(IMAGE_REL_I386_DIR32)
case "amd64":
"cmd/internal/sys"
"cmd/link/internal/loader"
"cmd/link/internal/sym"
+ "internal/buildcfg"
"log"
"runtime"
)
generatorSyms: make(map[loader.Sym]generatorFunc),
}
- if objabi.GOARCH != arch.Name {
- log.Fatalf("invalid objabi.GOARCH %s (want %s)", objabi.GOARCH, arch.Name)
+ if buildcfg.GOARCH != arch.Name {
+ log.Fatalf("invalid buildcfg.GOARCH %s (want %s)", buildcfg.GOARCH, arch.Name)
}
AtExit(func() {
"cmd/link/internal/sym"
"debug/elf"
"fmt"
+ "internal/buildcfg"
"path/filepath"
"strings"
)
// TODO: avoid the ldr.Lookup calls below by instead using an aux
// sym or marker relocation to associate the wrapper with the
// wrapped function.
- if !objabi.Experiment.RegabiWrappers {
+ if !buildcfg.Experiment.RegabiWrappers {
return name
}
"cmd/internal/objabi"
"cmd/internal/sys"
"cmd/link/internal/ld"
+ "internal/buildcfg"
)
func Init() (*sys.Arch, ld.Arch) {
arch := sys.ArchMIPS
- if objabi.GOARCH == "mipsle" {
+ if buildcfg.GOARCH == "mipsle" {
arch = sys.ArchMIPSLE
}
"cmd/internal/objabi"
"cmd/internal/sys"
"cmd/link/internal/ld"
+ "internal/buildcfg"
)
func Init() (*sys.Arch, ld.Arch) {
arch := sys.ArchMIPS64
- if objabi.GOARCH == "mips64le" {
+ if buildcfg.GOARCH == "mips64le" {
arch = sys.ArchMIPS64LE
}
"cmd/internal/objabi"
"cmd/internal/sys"
"cmd/link/internal/ld"
+ "internal/buildcfg"
)
func Init() (*sys.Arch, ld.Arch) {
arch := sys.ArchPPC64
- if objabi.GOARCH == "ppc64le" {
+ if buildcfg.GOARCH == "ppc64le" {
arch = sys.ArchPPC64LE
}
"cmd/link/internal/ld"
"cmd/link/internal/loader"
"cmd/link/internal/sym"
+ "internal/buildcfg"
"io"
"regexp"
)
writeUleb128(ctxt.Out, 2) // number of fields
- writeName(ctxt.Out, "language") // field name
- writeUleb128(ctxt.Out, 1) // number of values
- writeName(ctxt.Out, "Go") // value: name
- writeName(ctxt.Out, objabi.Version) // value: version
+ writeName(ctxt.Out, "language") // field name
+ writeUleb128(ctxt.Out, 1) // number of values
+ writeName(ctxt.Out, "Go") // value: name
+ writeName(ctxt.Out, buildcfg.Version) // value: version
writeName(ctxt.Out, "processed-by") // field name
writeUleb128(ctxt.Out, 1) // number of values
writeName(ctxt.Out, "Go cmd/compile") // value: name
- writeName(ctxt.Out, objabi.Version) // value: version
+ writeName(ctxt.Out, buildcfg.Version) // value: version
writeSecSize(ctxt, sizeOffset)
}
import (
"bytes"
- "cmd/internal/objabi"
"fmt"
+ "internal/buildcfg"
"internal/testenv"
"io/ioutil"
"os/exec"
)
func TestLargeText(t *testing.T) {
- if testing.Short() || (objabi.GOARCH != "ppc64le" && objabi.GOARCH != "ppc64" && objabi.GOARCH != "arm") {
- t.Skipf("Skipping large text section test in short mode or on %s", objabi.GOARCH)
+ if testing.Short() || (buildcfg.GOARCH != "ppc64le" && buildcfg.GOARCH != "ppc64" && buildcfg.GOARCH != "arm") {
+ t.Skipf("Skipping large text section test in short mode or on %s", buildcfg.GOARCH)
}
testenv.MustHaveGoBuild(t)
"ppc64le": "\tMOVD\tR0,R3\n",
"arm": "\tMOVW\tR0,R1\n",
}
- inst := instOnArch[objabi.GOARCH]
+ inst := instOnArch[buildcfg.GOARCH]
for j := 0; j < FN; j++ {
testname := fmt.Sprintf("bigfn%d", j)
fmt.Fprintf(&w, "TEXT ยท%s(SB),$0\n", testname)
package main
import (
- "cmd/internal/objabi"
"cmd/internal/sys"
"cmd/link/internal/amd64"
"cmd/link/internal/arm"
"cmd/link/internal/wasm"
"cmd/link/internal/x86"
"fmt"
+ "internal/buildcfg"
"os"
)
var arch *sys.Arch
var theArch ld.Arch
- switch objabi.GOARCH {
+ buildcfg.Check()
+ switch buildcfg.GOARCH {
default:
- fmt.Fprintf(os.Stderr, "link: unknown architecture %q\n", objabi.GOARCH)
+ fmt.Fprintf(os.Stderr, "link: unknown architecture %q\n", buildcfg.GOARCH)
os.Exit(2)
case "386":
arch, theArch = x86.Init()
container/heap, go/constant, go/parser, regexp
< go/types;
- go/build/constraint, go/doc, go/parser, internal/goroot, internal/goversion
+ FMT, internal/goexperiment
+ < internal/buildcfg;
+
+ go/build/constraint, go/doc, go/parser, internal/buildcfg, internal/goroot, internal/goversion
< go/build;
DEBUG, go/build, go/types, text/scanner
--- /dev/null
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package buildcfg provides access to the build configuration
+// described by the current environment. It is for use by build tools
+// such as cmd/go or cmd/compile and for setting up go/build's Default context.
+//
+// Note that it does NOT provide access to the build configuration used to
+// build the currently-running binary. For that, use runtime.GOOS etc
+// as well as internal/goexperiment.
+package buildcfg
+
+import (
+ "fmt"
+ "os"
+ "path/filepath"
+ "strings"
+)
+
+var (
+ defaultGOROOT string // set by linker
+
+ GOROOT = envOr("GOROOT", defaultGOROOT)
+ GOARCH = envOr("GOARCH", defaultGOARCH)
+ GOOS = envOr("GOOS", defaultGOOS)
+ GO386 = envOr("GO386", defaultGO386)
+ GOARM = goarm()
+ GOMIPS = gomips()
+ GOMIPS64 = gomips64()
+ GOPPC64 = goppc64()
+ GOWASM = gowasm()
+ GO_LDSO = defaultGO_LDSO
+ Version = version
+)
+
+// Error is one of the errors found (if any) in the build configuration.
+var Error error
+
+// Check exits the program with a fatal error if Error is non-nil.
+func Check() {
+ if Error != nil {
+ fmt.Fprintf(os.Stderr, "%s: %v\n", filepath.Base(os.Args[0]), Error)
+ os.Exit(2)
+ }
+}
+
+func envOr(key, value string) string {
+ if x := os.Getenv(key); x != "" {
+ return x
+ }
+ return value
+}
+
+func goarm() int {
+ def := defaultGOARM
+ if GOOS == "android" && GOARCH == "arm" {
+ // Android arm devices always support GOARM=7.
+ def = "7"
+ }
+ switch v := envOr("GOARM", def); v {
+ case "5":
+ return 5
+ case "6":
+ return 6
+ case "7":
+ return 7
+ }
+ Error = fmt.Errorf("invalid GOARM: must be 5, 6, 7")
+ return int(def[0] - '0')
+}
+
+func gomips() string {
+ switch v := envOr("GOMIPS", defaultGOMIPS); v {
+ case "hardfloat", "softfloat":
+ return v
+ }
+ Error = fmt.Errorf("invalid GOMIPS: must be hardfloat, softfloat")
+ return defaultGOMIPS
+}
+
+func gomips64() string {
+ switch v := envOr("GOMIPS64", defaultGOMIPS64); v {
+ case "hardfloat", "softfloat":
+ return v
+ }
+ Error = fmt.Errorf("invalid GOMIPS64: must be hardfloat, softfloat")
+ return defaultGOMIPS64
+}
+
+func goppc64() int {
+ switch v := envOr("GOPPC64", defaultGOPPC64); v {
+ case "power8":
+ return 8
+ case "power9":
+ return 9
+ }
+ Error = fmt.Errorf("invalid GOPPC64: must be power8, power9")
+ return int(defaultGOPPC64[len("power")] - '0')
+}
+
+type gowasmFeatures struct {
+ SignExt bool
+ SatConv bool
+}
+
+func (f gowasmFeatures) String() string {
+ var flags []string
+ if f.SatConv {
+ flags = append(flags, "satconv")
+ }
+ if f.SignExt {
+ flags = append(flags, "signext")
+ }
+ return strings.Join(flags, ",")
+}
+
+func gowasm() (f gowasmFeatures) {
+ for _, opt := range strings.Split(envOr("GOWASM", ""), ",") {
+ switch opt {
+ case "satconv":
+ f.SatConv = true
+ case "signext":
+ f.SignExt = true
+ case "":
+ // ignore
+ default:
+ Error = fmt.Errorf("invalid GOWASM: no such feature %q", opt)
+ }
+ }
+ return
+}
+
+func Getgoextlinkenabled() string {
+ return envOr("GO_EXTLINK_ENABLED", defaultGO_EXTLINK_ENABLED)
+}
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package objabi
+package buildcfg
import (
"fmt"
// experimentBaseline specifies the experiment flags that are enabled by
// default in the current toolchain. This is, in effect, the "control"
// configuration and any variation from this is an experiment.
-var experimentBaseline goexperiment.Flags
+var experimentBaseline = goexperiment.Flags{}
// FramePointerEnabled enables the use of platform conventions for
// saving frame pointers.
func EnabledExperiments() []string {
return expList(&Experiment, nil, false)
}
+
+// AllExperiments returns a list of all experiment settings.
+// Disabled experiments appear in the list prefixed by "no".
+func AllExperiments() []string {
+ return expList(&Experiment, nil, true)
+}
// and "go version <binary>" if it differs from the default experiments.
//
// For the set of experiments supported by the current toolchain, see
-// go doc internal/experiment.Flags.
+// "go doc goexperiment.Flags".
+//
+// Note that this package defines the set of experiments (in Flags)
+// and records the experiments that were enabled when the package
+// was compiled (as boolean and integer constants).
+//
+// Note especially that this package does not itself change behavior
+// at run time based on the GOEXPERIMENT variable.
+// The code used in builds to interpret the GOEXPERIMENT variable
+// is in the separate package internal/buildcfg.
package goexperiment
//go:generate go run mkconsts.go