...
Run Format

Source file src/cmd/link/internal/ld/config.go

Documentation: cmd/link/internal/ld

  // Copyright 2016 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 ld
  
  import (
  	"cmd/internal/objabi"
  	"cmd/internal/sys"
  	"fmt"
  	"log"
  )
  
  var (
  	Linkmode  LinkMode
  	Buildmode BuildMode
  )
  
  // A BuildMode indicates the sort of object we are building.
  //
  // Possible build modes are the same as those for the -buildmode flag
  // in cmd/go, and are documented in 'go help buildmode'.
  type BuildMode uint8
  
  const (
  	BuildmodeUnset BuildMode = iota
  	BuildmodeExe
  	BuildmodePIE
  	BuildmodeCArchive
  	BuildmodeCShared
  	BuildmodeShared
  	BuildmodePlugin
  )
  
  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)
  	}
  	switch s {
  	default:
  		return fmt.Errorf("invalid buildmode: %q", s)
  	case "exe":
  		*mode = BuildmodeExe
  	case "pie":
  		switch objabi.GOOS {
  		case "android", "linux":
  		default:
  			return badmode()
  		}
  		*mode = BuildmodePIE
  	case "c-archive":
  		switch objabi.GOOS {
  		case "darwin", "linux":
  		case "windows":
  			switch objabi.GOARCH {
  			case "amd64", "386":
  			default:
  				return badmode()
  			}
  		default:
  			return badmode()
  		}
  		*mode = BuildmodeCArchive
  	case "c-shared":
  		switch objabi.GOARCH {
  		case "386", "amd64", "arm", "arm64":
  		default:
  			return badmode()
  		}
  		*mode = BuildmodeCShared
  	case "shared":
  		switch objabi.GOOS {
  		case "linux":
  			switch objabi.GOARCH {
  			case "386", "amd64", "arm", "arm64", "ppc64le", "s390x":
  			default:
  				return badmode()
  			}
  		default:
  			return badmode()
  		}
  		*mode = BuildmodeShared
  	case "plugin":
  		switch objabi.GOOS {
  		case "linux":
  			switch objabi.GOARCH {
  			case "386", "amd64", "arm", "arm64", "s390x":
  			default:
  				return badmode()
  			}
  		case "darwin":
  			switch objabi.GOARCH {
  			case "amd64":
  			default:
  				return badmode()
  			}
  		default:
  			return badmode()
  		}
  		*mode = BuildmodePlugin
  	}
  	return nil
  }
  
  func (mode *BuildMode) String() string {
  	switch *mode {
  	case BuildmodeUnset:
  		return "" // avoid showing a default in usage message
  	case BuildmodeExe:
  		return "exe"
  	case BuildmodePIE:
  		return "pie"
  	case BuildmodeCArchive:
  		return "c-archive"
  	case BuildmodeCShared:
  		return "c-shared"
  	case BuildmodeShared:
  		return "shared"
  	case BuildmodePlugin:
  		return "plugin"
  	}
  	return fmt.Sprintf("BuildMode(%d)", uint8(*mode))
  }
  
  // LinkMode indicates whether an external linker is used for the final link.
  type LinkMode uint8
  
  const (
  	LinkAuto LinkMode = iota
  	LinkInternal
  	LinkExternal
  )
  
  func (mode *LinkMode) Set(s string) error {
  	switch s {
  	default:
  		return fmt.Errorf("invalid linkmode: %q", s)
  	case "auto":
  		*mode = LinkAuto
  	case "internal":
  		*mode = LinkInternal
  	case "external":
  		*mode = LinkExternal
  	}
  	return nil
  }
  
  func (mode *LinkMode) String() string {
  	switch *mode {
  	case LinkAuto:
  		return "auto"
  	case LinkInternal:
  		return "internal"
  	case LinkExternal:
  		return "external"
  	}
  	return fmt.Sprintf("LinkMode(%d)", uint8(*mode))
  }
  
  // mustLinkExternal reports whether the program being linked requires
  // the external linker be used to complete the link.
  func mustLinkExternal(ctxt *Link) (res bool, reason string) {
  	if ctxt.Debugvlog > 1 {
  		defer func() {
  			if res {
  				log.Printf("external linking is forced by: %s\n", reason)
  			}
  		}()
  	}
  
  	switch objabi.GOOS {
  	case "android":
  		return true, "android"
  	case "darwin":
  		if SysArch.InFamily(sys.ARM, sys.ARM64) {
  			return true, "iOS"
  		}
  	}
  
  	if *flagMsan {
  		return true, "msan"
  	}
  
  	// Internally linking cgo is incomplete on some architectures.
  	// https://golang.org/issue/10373
  	// https://golang.org/issue/14449
  	if iscgo && SysArch.InFamily(sys.ARM64, sys.MIPS64, sys.MIPS) {
  		return true, objabi.GOARCH + " does not support internal cgo"
  	}
  
  	// Some build modes require work the internal linker cannot do (yet).
  	switch Buildmode {
  	case BuildmodeCArchive:
  		return true, "buildmode=c-archive"
  	case BuildmodeCShared:
  		return true, "buildmode=c-shared"
  	case BuildmodePIE:
  		switch objabi.GOOS + "/" + objabi.GOARCH {
  		case "linux/amd64":
  		default:
  			// Internal linking does not support TLS_IE.
  			return true, "buildmode=pie"
  		}
  	case BuildmodePlugin:
  		return true, "buildmode=plugin"
  	case BuildmodeShared:
  		return true, "buildmode=shared"
  	}
  	if *FlagLinkshared {
  		return true, "dynamically linking with a shared library"
  	}
  
  	return false, ""
  }
  
  // determineLinkMode sets Linkmode.
  //
  // It is called after flags are processed and inputs are processed,
  // so the Linkmode variable has an initial value from the -linkmode
  // flag and the iscgo externalobj variables are set.
  func determineLinkMode(ctxt *Link) {
  	switch Linkmode {
  	case LinkAuto:
  		// The environment variable GO_EXTLINK_ENABLED controls the
  		// 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() {
  		case "0":
  			if needed, reason := mustLinkExternal(ctxt); needed {
  				Exitf("internal linking requested via GO_EXTLINK_ENABLED, but external linking required: %s", reason)
  			}
  			Linkmode = LinkInternal
  		case "1":
  			Linkmode = LinkExternal
  		default:
  			if needed, _ := mustLinkExternal(ctxt); needed {
  				Linkmode = LinkExternal
  			} else if iscgo && externalobj {
  				Linkmode = LinkExternal
  			} else if Buildmode == BuildmodePIE {
  				Linkmode = LinkExternal // https://golang.org/issue/18968
  			} else {
  				Linkmode = LinkInternal
  			}
  		}
  	case LinkInternal:
  		if needed, reason := mustLinkExternal(ctxt); needed {
  			Exitf("internal linking requested but external linking required: %s", reason)
  		}
  	}
  }
  

View as plain text