src/librustc_back/target/x86_64_unknown_linux_musl.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use target::Target;
  12
  13 pub fn target() -> Target {
  14     let mut base = super::linux_base::opts();
  15     base.cpu = "x86-64".to_string();
  16     base.pre_link_args.push("-m64".to_string());
  17
  18     // Make sure that the linker/gcc really don't pull in anything, including
  19     // default objects, libs, etc.
  20     base.pre_link_args.push("-nostdlib".to_string());
  21     base.pre_link_args.push("-static".to_string());
  22
  23     // At least when this was tested, the linker would not add the
  24     // `GNU_EH_FRAME` program header to executables generated, which is required
  25     // when unwinding to locate the unwinding information. I'm not sure why this
  26     // argument is *not* necessary for normal builds, but it can't hurt!
  27     base.pre_link_args.push("-Wl,--eh-frame-hdr".to_string());
  28
  29     // There's a whole bunch of circular dependencies when dealing with MUSL
  30     // unfortunately. To put this in perspective libc is statically linked to
  31     // liblibc and libunwind is statically linked to libstd:
  32     //
  33     // * libcore depends on `fmod` which is in libc (transitively in liblibc).
  34     //   liblibc, however, depends on libcore.
  35     // * compiler-rt has personality symbols that depend on libunwind, but
  36     //   libunwind is in libstd which depends on compiler-rt.
  37     //
  38     // Recall that linkers discard libraries and object files as much as
  39     // possible, and with all the static linking and archives flying around with
  40     // MUSL the linker is super aggressively stripping out objects. For example
  41     // the first case has fmod stripped from liblibc (it's in its own object
  42     // file) so it's not there when libcore needs it. In the second example all
  43     // the unused symbols from libunwind are stripped (each is in its own object
  44     // file in libstd) before we end up linking compiler-rt which depends on
  45     // those symbols.
  46     //
  47     // To deal with these circular dependencies we just force the compiler to
  48     // link everything as a group, not stripping anything out until everything
  49     // is processed. The linker will still perform a pass to strip out object
  50     // files but it won't do so until all objects/archives have been processed.
  51     base.pre_link_args.push("-Wl,-(".to_string());
  52     base.post_link_args.push("-Wl,-)".to_string());
  53
  54     // When generating a statically linked executable there's generally some
  55     // small setup needed which is listed in these files. These are provided by
  56     // a musl toolchain and are linked by default by the `musl-gcc` script. Note
  57     // that `gcc` also does this by default, it just uses some different files.
  58     //
  59     // Each target directory for musl has these object files included in it so
  60     // they'll be included from there.
  61     base.pre_link_objects_exe.push("crt1.o".to_string());
  62     base.pre_link_objects_exe.push("crti.o".to_string());
  63     base.post_link_objects.push("crtn.o".to_string());
  64
  65     // MUSL support doesn't currently include dynamic linking, so there's no
  66     // need for dylibs or rpath business. Additionally `-pie` is incompatible
  67     // with `-static`, so we can't pass `-pie`.
  68     base.dynamic_linking = false;
  69     base.has_rpath = false;
  70     base.position_independent_executables = false;
  71
  72     Target {
  73         llvm_target: "x86_64-unknown-linux-musl".to_string(),
  74         target_endian: "little".to_string(),
  75         target_pointer_width: "64".to_string(),
  76         data_layout: "e-m:e-i64:64-f80:128-n8:16:32:64-S128".to_string(),
  77         arch: "x86_64".to_string(),
  78         target_os: "linux".to_string(),
  79         target_env: "musl".to_string(),
  80         target_vendor: "unknown".to_string(),
  81         options: base,
  82     }
  83 }