jiri-profile-v23/go_profile/darwin_xcompile.go - release.go.x.devtools - Git at Google

 // Copyright 2015 The Vanadium 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 go_profile

 import (
 	"bytes"
 	"fmt"
 	"net/url"
 	"os"
 	"path"
 	"path/filepath"
 	"strings"
 	"text/template"

 	"v.io/jiri"
 	"v.io/jiri/profiles"
 	"v.io/jiri/profiles/profilesutil"
 )

 type absoluteLink struct {
 	source, target string
 }

 const (
 	// TODO(cnicolaou): have these version controlled - i.e. the
 	// version specified in the target will be used to chose the
 	// clang/llvm etc versions.
 	clangSrc    = "cfe-3.6.2.src"
 	llvmSrc     = "llvm-3.6.2.src"
 	binutilsSrc = "binutils-2.25"
 	binutilsURL = "http://ftp.gnu.org/gnu/binutils/" + binutilsSrc + ".tar.gz"
 	clangURL    = "http://llvm.org/releases/3.6.2/" + clangSrc + ".tar.xz"
 	llvmURL     = "http://llvm.org/releases/3.6.2/" + llvmSrc + ".tar.xz"
 )

 const compilerTemplate = `#!/bin/bash
 JIRI_ROOT=${JIRI_ROOT:={{.JiriRoot}}}
 compiler={{.Compiler}}
 export PATH={{.ClangBin}}:$PATH:
 exec $compiler --target={{.Target}} -B{{.BinutilsBin}} --sysroot={{.Sysroot}}  -isysroot {{.ISysroot}}  "$@"
 `

 type compilerInfo struct {
 	JiriRoot string
 	Compiler string
 	ClangBin string
 	Target   string
 	// Sysroot applies to libraries and is specified using --sysroot=<dir>
 	Sysroot string
 	// ISysroot applies to header files and is specified using -isysroot <dir>
 	ISysroot    string
 	BinutilsBin string
 }

 func useLLVM(jirix *jiri.X, m *Manager, root jiri.RelPath, target profiles.Target, action profiles.Action) (bindir string, env []string, e error) {
 	targetABI := ""
 	targetDir := target.TargetSpecificDirname()
 	switch target.Arch() {
 	case "arm":
 		targetABI = "arm-linux-gnueabi"
 	default:
 		return "", nil, fmt.Errorf("Arch %q is not yet supported for llvm", target.Arch())
 	}

 	// Directory structure is a follows:
 	// - profiles/llvm contains the llvm source and build.<llvm source> directories
 	// - profiles/cout/<target>/llvm contains the installed binaries
 	//   and configured copy of the sysroot.
 	// The detailed directory structure underneath these is constructed to
 	// support AtomicActions on the expensive operations, in particular,
 	// each unique sysroot argument gets a directory to itself.

 	src := m.root.Join("llvm")
 	inst := m.root.Join("cout", targetDir, "llvm")

 	if action == profiles.Uninstall {
 		err := jirix.NewSeq().
 			RemoveAll(src.Abs(jirix)).
 			RemoveAll(inst.Abs(jirix)).Done()
 		return "", nil, err
 	}

 	if len(goSysrootFlag) == 0 {
 		return "", nil, fmt.Errorf("sysroot argument is missing")
 	}

 	sysrootImage := filepath.Base(goSysrootFlag)
 	// The following are all AtomicAction directories.
 	binutilsBin := inst.Join(binutilsSrc)
 	clangBuildSrc := src.Join("build." + llvmSrc)
 	// Copy the tarball into here.
 	sysrootTarballDir := inst.Join(filepath.Join("sysroot", sysrootImage))
 	// Unpack and configure the tarball into here, it's nested under the
 	// tarball directory since it makes no sense to keep it around if
 	// the tarball has changed.
 	sysrootDir := sysrootTarballDir.Join("root")

 	absSrc := src.Abs(jirix)
 	for _, url := range []string{binutilsURL, llvmURL, clangURL} {
 		if err := downloadAndUnpackFile(jirix, url, absSrc); err != nil {
 			return "", nil, err
 		}
 	}

 	absBinutilsBin := binutilsBin.Abs(jirix)
 	binutilsFn := func() error {
 		return jirix.NewSeq().Pushd(src.Abs(jirix)).
 			Pushd(binutilsSrc).
 			MkdirAll(absBinutilsBin, profilesutil.DefaultDirPerm).
 			Run("./configure", "--target="+targetABI, "--program-prefix=",
 				"--prefix="+absBinutilsBin, "--with-sysroot=yes").
 			Run("make", "-j8").
 			Last("make", "install")
 	}
 	if err := profilesutil.AtomicAction(jirix, binutilsFn, absBinutilsBin, "Build and install binutils"); err != nil {
 		return "", nil, err
 	}

 	absClangBuildSrc := clangBuildSrc.Abs(jirix)
 	absClangSrc := src.Join(clangSrc).Abs(jirix)
 	absLLVMSrc := src.Join(llvmSrc).Abs(jirix)
 	clangFn := func() error {
 		return jirix.NewSeq().MkdirAll(absClangBuildSrc, profilesutil.DefaultDirPerm).
 			Pushd(absClangBuildSrc).
 			Run("cmake", "-GUnix Makefiles", "-DCMAKE_INSTALL_PREFIX="+inst.Abs(jirix),
 				"-DLLVM_TARGETS_TO_BUILD=ARM",
 				"-DLLVM_EXTERNAL_CLANG_SOURCE_DIR="+absClangSrc, absLLVMSrc).
 			Run("make", "-j8").
 			Last("make", "install")
 	}
 	if err := profilesutil.AtomicAction(jirix, clangFn, absClangBuildSrc, "Build and install clang"); err != nil {
 		return "", nil, err
 	}

 	s := jirix.NewSeq()

 	absClangBin := inst.Join("bin").Abs(jirix)
 	// Write out helper scripts to run clang with the appropriate PATH etc.
 	ci := &compilerInfo{
 		JiriRoot:    jirix.Root,
 		ClangBin:    inst.Join("bin").Symbolic(),
 		Target:      targetABI + "hf",
 		Sysroot:     sysrootDir.Symbolic(),
 		BinutilsBin: binutilsBin.Join("bin").Symbolic(),
 	}
 	ci.ISysroot = filepath.Join(sysrootDir.Symbolic(), "usr", "lib", "gcc", ci.Target)
 	tmpl := template.New("compiler scripts")
 	tmpl, err := tmpl.Parse(compilerTemplate)
 	if err != nil {
 		return "", nil, fmt.Errorf("Failed to parse template %v\n", err)
 	}

 	for _, compiler := range []string{"clang", "clang++"} {
 		ci.Compiler = filepath.Join(ci.ClangBin, compiler)
 		var out bytes.Buffer
 		if err := tmpl.Execute(&out, &ci); err != nil {
 			return "", nil, fmt.Errorf("Failed to execute template for %s: %v\n", compiler, err)
 		}
 		ofile := filepath.Join(absClangBin, "go-"+targetABI+"-"+compiler)
 		if err := s.RemoveAll(ofile).WriteFile(ofile, out.Bytes(), os.FileMode(0755)).Done(); err != nil {
 			return "", nil, fmt.Errorf("Failed to write: %s: %v", ofile, err)
 		}
 	}

 	absSysrootTarballDir := sysrootTarballDir.Abs(jirix)
 	sysrootTGZ := filepath.Join(absSysrootTarballDir, "sysroot.tar.gz")
 	tarArgs := []string{"czf", sysrootTGZ}
 	for _, k := range strings.Split(goSysrootDirs, ":") {
 		if filepath.IsAbs(k) {
 			k, _ = filepath.Rel(string(filepath.Separator), k)
 		}
 		tarArgs = append(tarArgs, k)
 	}
 	sysrootCopyFn := func() error {
 		return jirix.NewSeq().
 			MkdirAll(absSysrootTarballDir, profilesutil.DefaultDirPerm).
 			Pushd(goSysrootFlag).
 			Last("tar", tarArgs...)
 	}
 	if err := profilesutil.AtomicAction(jirix, sysrootCopyFn, absSysrootTarballDir, "Copy sysroot"); err != nil {
 		return "", nil, err
 	}

 	absSysroot := filepath.Join(absSysrootTarballDir, "root")

 	sysrootConfigFn := func() error {
 		s := jirix.NewSeq()
 		sysrootRoot := filepath.Join(absSysrootTarballDir, "root")
 		if err := s.Pushd(absSysrootTarballDir).
 			RemoveAll("root").
 			MkdirAll("root", profilesutil.DefaultDirPerm).
 			Pushd("root").
 			Last("tar", "zxf", sysrootTGZ); err != nil {
 			return err
 		}
 		return rewriteSysroot(jirix, sysrootRoot)
 	}
 	if err := profilesutil.AtomicAction(jirix, sysrootConfigFn, absSysroot, "Configure sysroot"); err != nil {
 		return "", nil, err
 	}

 	vars := []string{
 		"CC=" + filepath.Join(ci.ClangBin, "go-"+targetABI+"-clang"),
 		"CXX=" + filepath.Join(ci.ClangBin, "go-"+targetABI+"-clang++"),
 		"CLANG_BIN=" + filepath.Join(ci.ClangBin),
 		"BINUTILS_BIN=" + filepath.Join(ci.BinutilsBin, "bin"),
 		"CLANG=" + filepath.Join(ci.ClangBin, "go-"+targetABI+"-clang"),
 		"CLANG++=" + filepath.Join(ci.ClangBin, "go-"+targetABI+"-clang++"),
 		"LDFLAGS=" + "-lm",
 		"AR=" + filepath.Join(ci.BinutilsBin, "ar"),
 		"RANLIB=" + filepath.Join(ci.BinutilsBin, "ranlib"),
 		"TARGET=" + ci.Target,
 	}
 	return ci.ClangBin, vars, nil
 }

 func unpackCommand(file string) (string, []string, error) {
 	compressed := false
 	compressionOpt := ""
 	tar := false
 	dirname := filepath.Base(file)
 	ext := filepath.Ext(dirname)
 	switch ext {
 	case ".gz", ".xz":
 		compressed = true
 		compressionOpt = "z"
 		dirname = strings.TrimSuffix(dirname, ext)
 	}
 	if ext := filepath.Ext(dirname); ext == ".tar" {
 		tar = true
 		dirname = strings.TrimSuffix(dirname, ".tar")
 	}
 	if !tar {
 		if compressed {
 			return file, []string{"unzip", file}, nil
 		} else {
 			return file, []string{"echo", "it looks like ", file, " is already unpacked and uncompressed"}, nil
 		}
 	}
 	opts := "xf"
 	if compressed {
 		opts = compressionOpt + opts
 	}
 	return dirname, []string{"tar", "-" + opts, file}, nil
 }

 func downloadCmd(uri string) (string, []string, error) {
 	u, err := url.Parse(uri)
 	if err != nil {
 		return "", nil, err
 	}
 	switch u.Scheme {
 	case "gs":
 		return path.Base(u.Path), []string{"gsutil", "cp", uri}, nil
 	case "http", "https":
 		return path.Base(u.Path), []string{"curl", "-LO", uri}, nil
 	}
 	return "", nil, fmt.Errorf("%v is an unsupported uri:", uri)
 }

 func downloadAndUnpackFile(jirix *jiri.X, uri, toRoot string) error {
 	filename, downloadCmd, err := downloadCmd(uri)
 	if err != nil {
 		return err
 	}
 	dirname, unpackCmd, err := unpackCommand(filename)
 	if err != nil {
 		return err
 	}
 	toDir := filepath.Join(toRoot, dirname)
 	fn := func() error {
 		s := jirix.NewSeq()
 		tmpDir, err := s.TempDir("", "")
 		if err != nil {
 			return err
 		}
 		defer jirix.NewSeq().RemoveAll(tmpDir)
 		return s.Pushd(tmpDir).
 			Run(downloadCmd[0], downloadCmd[1:]...).
 			Run(unpackCmd[0], unpackCmd[1:]...).
 			MkdirAll(toRoot, profilesutil.DefaultDirPerm).
 			Rename(filepath.Join(tmpDir, dirname), toDir).
 			Done()
 	}
 	return profilesutil.AtomicAction(jirix, fn, toDir, "Download and unpack: "+uri)
 }

 func rewriteSysroot(jirix *jiri.X, sysroot string) error {
 	ch := make(chan *absoluteLink, 100)
 	errch := make(chan error, 1)
 	go func() {
 		findAbsoluteLinks(ch, errch, sysroot)
 		close(ch)
 	}()
 	for {
 		select {
 		case err := <-errch:
 			return err
 		case al := <-ch:
 			if al == nil {
 				return nil
 			}
 			rewriteLinks(jirix, al.source, al.target, sysroot)
 		}
 	}
 	return nil
 }

 func rewriteLinks(jirix *jiri.X, pathname, target, sysroot string) error {
 	newTarget := filepath.Join(sysroot, target)
 	os.Remove(pathname)
 	if err := os.Symlink(newTarget, pathname); err != nil {
 		return fmt.Errorf("Symlink: %q -> %q: %s\n", pathname, newTarget, err)
 	}
 	return nil
 }

 func findAbsoluteLinks(ch chan *absoluteLink, errch chan error, root string) {
 	di, err := os.Open(root)
 	if err != nil {
 		errch <- err
 		return
 	}
 	files, err := di.Readdir(-1)
 	if err != nil {
 		errch <- err
 		return
 	}
 	di.Close()
 	for _, file := range files {
 		pathname := filepath.Join(root, file.Name())
 		if file.IsDir() {
 			findAbsoluteLinks(ch, errch, pathname)
 			continue
 		}
 		if (file.Mode() & os.ModeSymlink) != 0 {
 			target, err := os.Readlink(pathname)
 			if err != nil {
 				errch <- err
 				return
 			}
 			if filepath.IsAbs(target) && !filepath.HasPrefix(target, root) {
 				ch <- &absoluteLink{pathname, target}
 			}
 		}
 	}
 }
	// Copyright 2015 The Vanadium 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 go_profile

	import (
	"bytes"
	"fmt"
	"net/url"
	"os"
	"path"
	"path/filepath"
	"strings"
	"text/template"

	"v.io/jiri"
	"v.io/jiri/profiles"
	"v.io/jiri/profiles/profilesutil"
	)

	type absoluteLink struct {
	source, target string
	}

	const (
	// TODO(cnicolaou): have these version controlled - i.e. the
	// version specified in the target will be used to chose the
	// clang/llvm etc versions.
	clangSrc = "cfe-3.6.2.src"
	llvmSrc = "llvm-3.6.2.src"
	binutilsSrc = "binutils-2.25"
	binutilsURL = "http://ftp.gnu.org/gnu/binutils/" + binutilsSrc + ".tar.gz"
	clangURL = "http://llvm.org/releases/3.6.2/" + clangSrc + ".tar.xz"
	llvmURL = "http://llvm.org/releases/3.6.2/" + llvmSrc + ".tar.xz"
	)

	const compilerTemplate = `#!/bin/bash
	JIRI_ROOT=${JIRI_ROOT:={{.JiriRoot}}}
	compiler={{.Compiler}}
	export PATH={{.ClangBin}}:$PATH:
	exec $compiler --target={{.Target}} -B{{.BinutilsBin}} --sysroot={{.Sysroot}} -isysroot {{.ISysroot}} "$@"
	`

	type compilerInfo struct {
	JiriRoot string
	Compiler string
	ClangBin string
	Target string
	// Sysroot applies to libraries and is specified using --sysroot=<dir>
	Sysroot string
	// ISysroot applies to header files and is specified using -isysroot <dir>
	ISysroot string
	BinutilsBin string
	}

	func useLLVM(jirix jiri.X, m Manager, root jiri.RelPath, target profiles.Target, action profiles.Action) (bindir string, env []string, e error) {
	targetABI := ""
	targetDir := target.TargetSpecificDirname()
	switch target.Arch() {
	case "arm":
	targetABI = "arm-linux-gnueabi"
	default:
	return "", nil, fmt.Errorf("Arch %q is not yet supported for llvm", target.Arch())
	}

	// Directory structure is a follows:
	// - profiles/llvm contains the llvm source and build.<llvm source> directories
	// - profiles/cout/<target>/llvm contains the installed binaries
	// and configured copy of the sysroot.
	// The detailed directory structure underneath these is constructed to
	// support AtomicActions on the expensive operations, in particular,
	// each unique sysroot argument gets a directory to itself.

	src := m.root.Join("llvm")
	inst := m.root.Join("cout", targetDir, "llvm")

	if action == profiles.Uninstall {
	err := jirix.NewSeq().
	RemoveAll(src.Abs(jirix)).
	RemoveAll(inst.Abs(jirix)).Done()
	return "", nil, err
	}

	if len(goSysrootFlag) == 0 {
	return "", nil, fmt.Errorf("sysroot argument is missing")
	}

	sysrootImage := filepath.Base(goSysrootFlag)
	// The following are all AtomicAction directories.
	binutilsBin := inst.Join(binutilsSrc)
	clangBuildSrc := src.Join("build." + llvmSrc)
	// Copy the tarball into here.
	sysrootTarballDir := inst.Join(filepath.Join("sysroot", sysrootImage))
	// Unpack and configure the tarball into here, it's nested under the
	// tarball directory since it makes no sense to keep it around if
	// the tarball has changed.
	sysrootDir := sysrootTarballDir.Join("root")

	absSrc := src.Abs(jirix)
	for _, url := range []string{binutilsURL, llvmURL, clangURL} {
	if err := downloadAndUnpackFile(jirix, url, absSrc); err != nil {
	return "", nil, err
	}
	}

	absBinutilsBin := binutilsBin.Abs(jirix)
	binutilsFn := func() error {
	return jirix.NewSeq().Pushd(src.Abs(jirix)).
	Pushd(binutilsSrc).
	MkdirAll(absBinutilsBin, profilesutil.DefaultDirPerm).
	Run("./configure", "--target="+targetABI, "--program-prefix=",
	"--prefix="+absBinutilsBin, "--with-sysroot=yes").
	Run("make", "-j8").
	Last("make", "install")
	}
	if err := profilesutil.AtomicAction(jirix, binutilsFn, absBinutilsBin, "Build and install binutils"); err != nil {
	return "", nil, err
	}

	absClangBuildSrc := clangBuildSrc.Abs(jirix)
	absClangSrc := src.Join(clangSrc).Abs(jirix)
	absLLVMSrc := src.Join(llvmSrc).Abs(jirix)
	clangFn := func() error {
	return jirix.NewSeq().MkdirAll(absClangBuildSrc, profilesutil.DefaultDirPerm).
	Pushd(absClangBuildSrc).
	Run("cmake", "-GUnix Makefiles", "-DCMAKE_INSTALL_PREFIX="+inst.Abs(jirix),
	"-DLLVM_TARGETS_TO_BUILD=ARM",
	"-DLLVM_EXTERNAL_CLANG_SOURCE_DIR="+absClangSrc, absLLVMSrc).
	Run("make", "-j8").
	Last("make", "install")
	}
	if err := profilesutil.AtomicAction(jirix, clangFn, absClangBuildSrc, "Build and install clang"); err != nil {
	return "", nil, err
	}

	s := jirix.NewSeq()

	absClangBin := inst.Join("bin").Abs(jirix)
	// Write out helper scripts to run clang with the appropriate PATH etc.
	ci := &compilerInfo{
	JiriRoot: jirix.Root,
	ClangBin: inst.Join("bin").Symbolic(),
	Target: targetABI + "hf",
	Sysroot: sysrootDir.Symbolic(),
	BinutilsBin: binutilsBin.Join("bin").Symbolic(),
	}
	ci.ISysroot = filepath.Join(sysrootDir.Symbolic(), "usr", "lib", "gcc", ci.Target)
	tmpl := template.New("compiler scripts")
	tmpl, err := tmpl.Parse(compilerTemplate)
	if err != nil {
	return "", nil, fmt.Errorf("Failed to parse template %v\n", err)
	}

	for _, compiler := range []string{"clang", "clang++"} {
	ci.Compiler = filepath.Join(ci.ClangBin, compiler)
	var out bytes.Buffer
	if err := tmpl.Execute(&out, &ci); err != nil {
	return "", nil, fmt.Errorf("Failed to execute template for %s: %v\n", compiler, err)
	}
	ofile := filepath.Join(absClangBin, "go-"+targetABI+"-"+compiler)
	if err := s.RemoveAll(ofile).WriteFile(ofile, out.Bytes(), os.FileMode(0755)).Done(); err != nil {
	return "", nil, fmt.Errorf("Failed to write: %s: %v", ofile, err)
	}
	}

	absSysrootTarballDir := sysrootTarballDir.Abs(jirix)
	sysrootTGZ := filepath.Join(absSysrootTarballDir, "sysroot.tar.gz")
	tarArgs := []string{"czf", sysrootTGZ}
	for _, k := range strings.Split(goSysrootDirs, ":") {
	if filepath.IsAbs(k) {
	k, _ = filepath.Rel(string(filepath.Separator), k)
	}
	tarArgs = append(tarArgs, k)
	}
	sysrootCopyFn := func() error {
	return jirix.NewSeq().
	MkdirAll(absSysrootTarballDir, profilesutil.DefaultDirPerm).
	Pushd(goSysrootFlag).
	Last("tar", tarArgs...)
	}
	if err := profilesutil.AtomicAction(jirix, sysrootCopyFn, absSysrootTarballDir, "Copy sysroot"); err != nil {
	return "", nil, err
	}

	absSysroot := filepath.Join(absSysrootTarballDir, "root")

	sysrootConfigFn := func() error {
	s := jirix.NewSeq()
	sysrootRoot := filepath.Join(absSysrootTarballDir, "root")
	if err := s.Pushd(absSysrootTarballDir).
	RemoveAll("root").
	MkdirAll("root", profilesutil.DefaultDirPerm).
	Pushd("root").
	Last("tar", "zxf", sysrootTGZ); err != nil {
	return err
	}
	return rewriteSysroot(jirix, sysrootRoot)
	}
	if err := profilesutil.AtomicAction(jirix, sysrootConfigFn, absSysroot, "Configure sysroot"); err != nil {
	return "", nil, err
	}

	vars := []string{
	"CC=" + filepath.Join(ci.ClangBin, "go-"+targetABI+"-clang"),
	"CXX=" + filepath.Join(ci.ClangBin, "go-"+targetABI+"-clang++"),
	"CLANG_BIN=" + filepath.Join(ci.ClangBin),
	"BINUTILS_BIN=" + filepath.Join(ci.BinutilsBin, "bin"),
	"CLANG=" + filepath.Join(ci.ClangBin, "go-"+targetABI+"-clang"),
	"CLANG++=" + filepath.Join(ci.ClangBin, "go-"+targetABI+"-clang++"),
	"LDFLAGS=" + "-lm",
	"AR=" + filepath.Join(ci.BinutilsBin, "ar"),
	"RANLIB=" + filepath.Join(ci.BinutilsBin, "ranlib"),
	"TARGET=" + ci.Target,
	}
	return ci.ClangBin, vars, nil
	}

	func unpackCommand(file string) (string, []string, error) {
	compressed := false
	compressionOpt := ""
	tar := false
	dirname := filepath.Base(file)
	ext := filepath.Ext(dirname)
	switch ext {
	case ".gz", ".xz":
	compressed = true
	compressionOpt = "z"
	dirname = strings.TrimSuffix(dirname, ext)
	}
	if ext := filepath.Ext(dirname); ext == ".tar" {
	tar = true
	dirname = strings.TrimSuffix(dirname, ".tar")
	}
	if !tar {
	if compressed {
	return file, []string{"unzip", file}, nil
	} else {
	return file, []string{"echo", "it looks like ", file, " is already unpacked and uncompressed"}, nil
	}
	}
	opts := "xf"
	if compressed {
	opts = compressionOpt + opts
	}
	return dirname, []string{"tar", "-" + opts, file}, nil
	}

	func downloadCmd(uri string) (string, []string, error) {
	u, err := url.Parse(uri)
	if err != nil {
	return "", nil, err
	}
	switch u.Scheme {
	case "gs":
	return path.Base(u.Path), []string{"gsutil", "cp", uri}, nil
	case "http", "https":
	return path.Base(u.Path), []string{"curl", "-LO", uri}, nil
	}
	return "", nil, fmt.Errorf("%v is an unsupported uri:", uri)
	}

	func downloadAndUnpackFile(jirix *jiri.X, uri, toRoot string) error {
	filename, downloadCmd, err := downloadCmd(uri)
	if err != nil {
	return err
	}
	dirname, unpackCmd, err := unpackCommand(filename)
	if err != nil {
	return err
	}
	toDir := filepath.Join(toRoot, dirname)
	fn := func() error {
	s := jirix.NewSeq()
	tmpDir, err := s.TempDir("", "")
	if err != nil {
	return err
	}
	defer jirix.NewSeq().RemoveAll(tmpDir)
	return s.Pushd(tmpDir).
	Run(downloadCmd[0], downloadCmd[1:]...).
	Run(unpackCmd[0], unpackCmd[1:]...).
	MkdirAll(toRoot, profilesutil.DefaultDirPerm).
	Rename(filepath.Join(tmpDir, dirname), toDir).
	Done()
	}
	return profilesutil.AtomicAction(jirix, fn, toDir, "Download and unpack: "+uri)
	}

	func rewriteSysroot(jirix *jiri.X, sysroot string) error {
	ch := make(chan *absoluteLink, 100)
	errch := make(chan error, 1)
	go func() {
	findAbsoluteLinks(ch, errch, sysroot)
	close(ch)
	}()
	for {
	select {
	case err := <-errch:
	return err
	case al := <-ch:
	if al == nil {
	return nil
	}
	rewriteLinks(jirix, al.source, al.target, sysroot)
	}
	}
	return nil
	}

	func rewriteLinks(jirix *jiri.X, pathname, target, sysroot string) error {
	newTarget := filepath.Join(sysroot, target)
	os.Remove(pathname)
	if err := os.Symlink(newTarget, pathname); err != nil {
	return fmt.Errorf("Symlink: %q -> %q: %s\n", pathname, newTarget, err)
	}
	return nil
	}

	func findAbsoluteLinks(ch chan *absoluteLink, errch chan error, root string) {
	di, err := os.Open(root)
	if err != nil {
	errch <- err
	return
	}
	files, err := di.Readdir(-1)
	if err != nil {
	errch <- err
	return
	}
	di.Close()
	for _, file := range files {
	pathname := filepath.Join(root, file.Name())
	if file.IsDir() {
	findAbsoluteLinks(ch, errch, pathname)
	continue
	}
	if (file.Mode() & os.ModeSymlink) != 0 {
	target, err := os.Readlink(pathname)
	if err != nil {
	errch <- err
	return
	}
	if filepath.IsAbs(target) && !filepath.HasPrefix(target, root) {
	ch <- &absoluteLink{pathname, target}
	}
	}
	}
	}