compiler/rustc_session/src/output.rs

   1 //! Related to out filenames of compilation (e.g. save analysis, binaries).
   2 use crate::config::{CrateType, Input, OutputFilenames, OutputType};
   3 use crate::Session;
   4 use rustc_ast as ast;
   5 use rustc_span::symbol::sym;
   6 use rustc_span::Span;
   7 use std::path::{Path, PathBuf};
   8
   9 pub fn out_filename(
  10     sess: &Session,
  11     crate_type: CrateType,
  12     outputs: &OutputFilenames,
  13     crate_name: &str,
  14 ) -> PathBuf {
  15     let default_filename = filename_for_input(sess, crate_type, crate_name, outputs);
  16     let out_filename = outputs
  17         .outputs
  18         .get(&OutputType::Exe)
  19         .and_then(|s| s.to_owned())
  20         .or_else(|| outputs.single_output_file.clone())
  21         .unwrap_or(default_filename);
  22
  23     check_file_is_writeable(&out_filename, sess);
  24
  25     out_filename
  26 }
  27
  28 /// Make sure files are writeable.  Mac, FreeBSD, and Windows system linkers
  29 /// check this already -- however, the Linux linker will happily overwrite a
  30 /// read-only file.  We should be consistent.
  31 pub fn check_file_is_writeable(file: &Path, sess: &Session) {
  32     if !is_writeable(file) {
  33         sess.fatal(&format!(
  34             "output file {} is not writeable -- check its \
  35                             permissions",
  36             file.display()
  37         ));
  38     }
  39 }
  40
  41 fn is_writeable(p: &Path) -> bool {
  42     match p.metadata() {
  43         Err(..) => true,
  44         Ok(m) => !m.permissions().readonly(),
  45     }
  46 }
  47
  48 pub fn find_crate_name(sess: &Session, attrs: &[ast::Attribute], input: &Input) -> String {
  49     let validate = |s: String, span: Option<Span>| {
  50         validate_crate_name(sess, &s, span);
  51         s
  52     };
  53
  54     // Look in attributes 100% of the time to make sure the attribute is marked
  55     // as used. After doing this, however, we still prioritize a crate name from
  56     // the command line over one found in the #[crate_name] attribute. If we
  57     // find both we ensure that they're the same later on as well.
  58     let attr_crate_name =
  59         sess.find_by_name(attrs, sym::crate_name).and_then(|at| at.value_str().map(|s| (at, s)));
  60
  61     if let Some(ref s) = sess.opts.crate_name {
  62         if let Some((attr, name)) = attr_crate_name {
  63             if name.as_str() != s {
  64                 let msg = format!(
  65                     "`--crate-name` and `#[crate_name]` are \
  66                                    required to match, but `{}` != `{}`",
  67                     s, name
  68                 );
  69                 sess.span_err(attr.span, &msg);
  70             }
  71         }
  72         return validate(s.clone(), None);
  73     }
  74
  75     if let Some((attr, s)) = attr_crate_name {
  76         return validate(s.to_string(), Some(attr.span));
  77     }
  78     if let Input::File(ref path) = *input {
  79         if let Some(s) = path.file_stem().and_then(|s| s.to_str()) {
  80             if s.starts_with('-') {
  81                 let msg = format!(
  82                     "crate names cannot start with a `-`, but \
  83                                    `{}` has a leading hyphen",
  84                     s
  85                 );
  86                 sess.err(&msg);
  87             } else {
  88                 return validate(s.replace('-', "_"), None);
  89             }
  90         }
  91     }
  92
  93     "rust_out".to_string()
  94 }
  95
  96 pub fn validate_crate_name(sess: &Session, s: &str, sp: Option<Span>) {
  97     let mut err_count = 0;
  98     {
  99         let mut say = |s: &str| {
 100             match sp {
 101                 Some(sp) => sess.span_err(sp, s),
 102                 None => sess.err(s),
 103             };
 104             err_count += 1;
 105         };
 106         if s.is_empty() {
 107             say("crate name must not be empty");
 108         }
 109         for c in s.chars() {
 110             if c.is_alphanumeric() {
 111                 continue;
 112             }
 113             if c == '_' {
 114                 continue;
 115             }
 116             say(&format!("invalid character `{}` in crate name: `{}`", c, s));
 117         }
 118     }
 119
 120     if err_count > 0 {
 121         sess.abort_if_errors();
 122     }
 123 }
 124
 125 pub fn filename_for_metadata(
 126     sess: &Session,
 127     crate_name: &str,
 128     outputs: &OutputFilenames,
 129 ) -> PathBuf {
 130     // If the command-line specified the path, use that directly.
 131     if let Some(Some(out_filename)) = sess.opts.output_types.get(&OutputType::Metadata) {
 132         return out_filename.clone();
 133     }
 134
 135     let libname = format!("{}{}", crate_name, sess.opts.cg.extra_filename);
 136
 137     let out_filename = outputs
 138         .single_output_file
 139         .clone()
 140         .unwrap_or_else(|| outputs.out_directory.join(&format!("lib{}.rmeta", libname)));
 141
 142     check_file_is_writeable(&out_filename, sess);
 143
 144     out_filename
 145 }
 146
 147 pub fn filename_for_input(
 148     sess: &Session,
 149     crate_type: CrateType,
 150     crate_name: &str,
 151     outputs: &OutputFilenames,
 152 ) -> PathBuf {
 153     let libname = format!("{}{}", crate_name, sess.opts.cg.extra_filename);
 154
 155     match crate_type {
 156         CrateType::Rlib => outputs.out_directory.join(&format!("lib{}.rlib", libname)),
 157         CrateType::Cdylib | CrateType::ProcMacro | CrateType::Dylib => {
 158             let (prefix, suffix) = (&sess.target.dll_prefix, &sess.target.dll_suffix);
 159             outputs.out_directory.join(&format!("{}{}{}", prefix, libname, suffix))
 160         }
 161         CrateType::Staticlib => {
 162             let (prefix, suffix) = (&sess.target.staticlib_prefix, &sess.target.staticlib_suffix);
 163             outputs.out_directory.join(&format!("{}{}{}", prefix, libname, suffix))
 164         }
 165         CrateType::Executable => {
 166             let suffix = &sess.target.exe_suffix;
 167             let out_filename = outputs.path(OutputType::Exe);
 168             if suffix.is_empty() { out_filename } else { out_filename.with_extension(&suffix[1..]) }
 169         }
 170     }
 171 }
 172
 173 /// Returns default crate type for target
 174 ///
 175 /// Default crate type is used when crate type isn't provided neither
 176 /// through cmd line arguments nor through crate attributes
 177 ///
 178 /// It is CrateType::Executable for all platforms but iOS as there is no
 179 /// way to run iOS binaries anyway without jailbreaking and
 180 /// interaction with Rust code through static library is the only
 181 /// option for now
 182 pub fn default_output_for_target(sess: &Session) -> CrateType {
 183     if !sess.target.executables { CrateType::Staticlib } else { CrateType::Executable }
 184 }
 185
 186 /// Checks if target supports crate_type as output
 187 pub fn invalid_output_for_target(sess: &Session, crate_type: CrateType) -> bool {
 188     match crate_type {
 189         CrateType::Cdylib | CrateType::Dylib | CrateType::ProcMacro => {
 190             if !sess.target.dynamic_linking {
 191                 return true;
 192             }
 193             if sess.crt_static(Some(crate_type)) && !sess.target.crt_static_allows_dylibs {
 194                 return true;
 195             }
 196         }
 197         _ => {}
 198     }
 199     if sess.target.only_cdylib {
 200         match crate_type {
 201             CrateType::ProcMacro | CrateType::Dylib => return true,
 202             _ => {}
 203         }
 204     }
 205     if !sess.target.executables && crate_type == CrateType::Executable {
 206         return true;
 207     }
 208
 209     false
 210 }