Source file src/cmd/internal/objabi/util.go

     1	// Copyright 2015 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package objabi
     6	
     7	import (
     8		"fmt"
     9		"log"
    10		"os"
    11		"strings"
    12	)
    13	
    14	func envOr(key, value string) string {
    15		if x := os.Getenv(key); x != "" {
    16			return x
    17		}
    18		return value
    19	}
    20	
    21	var (
    22		defaultGOROOT string // set by linker
    23	
    24		GOROOT   = envOr("GOROOT", defaultGOROOT)
    25		GOARCH   = envOr("GOARCH", defaultGOARCH)
    26		GOOS     = envOr("GOOS", defaultGOOS)
    27		GO386    = envOr("GO386", defaultGO386)
    28		GOARM    = goarm()
    29		GOMIPS   = gomips()
    30		GOMIPS64 = gomips64()
    31		GOPPC64  = goppc64()
    32		GOWASM   = gowasm()
    33		GO_LDSO  = defaultGO_LDSO
    34		Version  = version
    35	)
    36	
    37	const (
    38		ElfRelocOffset   = 256
    39		MachoRelocOffset = 2048 // reserve enough space for ELF relocations
    40	)
    41	
    42	func goarm() int {
    43		switch v := envOr("GOARM", defaultGOARM); v {
    44		case "5":
    45			return 5
    46		case "6":
    47			return 6
    48		case "7":
    49			return 7
    50		}
    51		// Fail here, rather than validate at multiple call sites.
    52		log.Fatalf("Invalid GOARM value. Must be 5, 6, or 7.")
    53		panic("unreachable")
    54	}
    55	
    56	func gomips() string {
    57		switch v := envOr("GOMIPS", defaultGOMIPS); v {
    58		case "hardfloat", "softfloat":
    59			return v
    60		}
    61		log.Fatalf("Invalid GOMIPS value. Must be hardfloat or softfloat.")
    62		panic("unreachable")
    63	}
    64	
    65	func gomips64() string {
    66		switch v := envOr("GOMIPS64", defaultGOMIPS64); v {
    67		case "hardfloat", "softfloat":
    68			return v
    69		}
    70		log.Fatalf("Invalid GOMIPS64 value. Must be hardfloat or softfloat.")
    71		panic("unreachable")
    72	}
    73	
    74	func goppc64() int {
    75		switch v := envOr("GOPPC64", defaultGOPPC64); v {
    76		case "power8":
    77			return 8
    78		case "power9":
    79			return 9
    80		}
    81		log.Fatalf("Invalid GOPPC64 value. Must be power8 or power9.")
    82		panic("unreachable")
    83	}
    84	
    85	type gowasmFeatures struct {
    86		SignExt bool
    87		SatConv bool
    88	}
    89	
    90	func (f gowasmFeatures) String() string {
    91		var flags []string
    92		if f.SatConv {
    93			flags = append(flags, "satconv")
    94		}
    95		if f.SignExt {
    96			flags = append(flags, "signext")
    97		}
    98		return strings.Join(flags, ",")
    99	}
   100	
   101	func gowasm() (f gowasmFeatures) {
   102		for _, opt := range strings.Split(envOr("GOWASM", ""), ",") {
   103			switch opt {
   104			case "satconv":
   105				f.SatConv = true
   106			case "signext":
   107				f.SignExt = true
   108			case "":
   109				// ignore
   110			default:
   111				log.Fatalf("Invalid GOWASM value. No such feature: " + opt)
   112			}
   113		}
   114		return
   115	}
   116	
   117	func Getgoextlinkenabled() string {
   118		return envOr("GO_EXTLINK_ENABLED", defaultGO_EXTLINK_ENABLED)
   119	}
   120	
   121	func init() {
   122		for _, f := range strings.Split(goexperiment, ",") {
   123			if f != "" {
   124				addexp(f)
   125			}
   126		}
   127	}
   128	
   129	func Framepointer_enabled(goos, goarch string) bool {
   130		return framepointer_enabled != 0 && (goarch == "amd64" && goos != "nacl" || goarch == "arm64" && goos == "linux")
   131	}
   132	
   133	func addexp(s string) {
   134		// Could do general integer parsing here, but the runtime copy doesn't yet.
   135		v := 1
   136		name := s
   137		if len(name) > 2 && name[:2] == "no" {
   138			v = 0
   139			name = name[2:]
   140		}
   141		for i := 0; i < len(exper); i++ {
   142			if exper[i].name == name {
   143				if exper[i].val != nil {
   144					*exper[i].val = v
   145				}
   146				return
   147			}
   148		}
   149	
   150		fmt.Printf("unknown experiment %s\n", s)
   151		os.Exit(2)
   152	}
   153	
   154	var (
   155		framepointer_enabled     int = 1
   156		Fieldtrack_enabled       int
   157		Preemptibleloops_enabled int
   158	)
   159	
   160	// Toolchain experiments.
   161	// These are controlled by the GOEXPERIMENT environment
   162	// variable recorded when the toolchain is built.
   163	// This list is also known to cmd/gc.
   164	var exper = []struct {
   165		name string
   166		val  *int
   167	}{
   168		{"fieldtrack", &Fieldtrack_enabled},
   169		{"framepointer", &framepointer_enabled},
   170		{"preemptibleloops", &Preemptibleloops_enabled},
   171	}
   172	
   173	var defaultExpstring = Expstring()
   174	
   175	func DefaultExpstring() string {
   176		return defaultExpstring
   177	}
   178	
   179	func Expstring() string {
   180		buf := "X"
   181		for i := range exper {
   182			if *exper[i].val != 0 {
   183				buf += "," + exper[i].name
   184			}
   185		}
   186		if buf == "X" {
   187			buf += ",none"
   188		}
   189		return "X:" + buf[2:]
   190	}
   191	

View as plain text