]>
Commit | Line | Data |
---|---|---|
29967ef6 XL |
1 | //! Creation of ar archives like for the lib and staticlib crate type |
2 | ||
3 | use std::collections::BTreeMap; | |
4 | use std::fs::File; | |
c295e0f8 | 5 | use std::io::{self, Read, Seek}; |
29967ef6 XL |
6 | use std::path::{Path, PathBuf}; |
7 | ||
064997fb | 8 | use rustc_codegen_ssa::back::archive::{ArchiveBuilder, ArchiveBuilderBuilder}; |
29967ef6 XL |
9 | use rustc_session::Session; |
10 | ||
c295e0f8 | 11 | use object::read::archive::ArchiveFile; |
a2a8927a | 12 | use object::{Object, ObjectSymbol, ReadCache}; |
29967ef6 XL |
13 | |
14 | #[derive(Debug)] | |
15 | enum ArchiveEntry { | |
c295e0f8 | 16 | FromArchive { archive_index: usize, file_range: (u64, u64) }, |
29967ef6 XL |
17 | File(PathBuf), |
18 | } | |
19 | ||
064997fb FG |
20 | pub(crate) struct ArArchiveBuilderBuilder; |
21 | ||
22 | impl ArchiveBuilderBuilder for ArArchiveBuilderBuilder { | |
23 | fn new_archive_builder<'a>(&self, sess: &'a Session) -> Box<dyn ArchiveBuilder<'a> + 'a> { | |
24 | Box::new(ArArchiveBuilder { | |
25 | sess, | |
26 | use_gnu_style_archive: sess.target.archive_format == "gnu", | |
27 | // FIXME fix builtin ranlib on macOS | |
28 | no_builtin_ranlib: sess.target.is_like_osx, | |
29 | ||
30 | src_archives: vec![], | |
31 | entries: vec![], | |
32 | }) | |
33 | } | |
34 | ||
35 | fn create_dll_import_lib( | |
36 | &self, | |
37 | _sess: &Session, | |
38 | _lib_name: &str, | |
39 | _dll_imports: &[rustc_session::cstore::DllImport], | |
40 | _tmpdir: &Path, | |
f2b60f7d | 41 | _is_direct_dependency: bool, |
064997fb FG |
42 | ) -> PathBuf { |
43 | bug!("creating dll imports is not supported"); | |
44 | } | |
45 | } | |
46 | ||
29967ef6 XL |
47 | pub(crate) struct ArArchiveBuilder<'a> { |
48 | sess: &'a Session, | |
29967ef6 XL |
49 | use_gnu_style_archive: bool, |
50 | no_builtin_ranlib: bool, | |
51 | ||
c295e0f8 | 52 | src_archives: Vec<File>, |
29967ef6 XL |
53 | // Don't use `HashMap` here, as the order is important. `rust.metadata.bin` must always be at |
54 | // the end of an archive for linkers to not get confused. | |
c295e0f8 | 55 | entries: Vec<(Vec<u8>, ArchiveEntry)>, |
29967ef6 XL |
56 | } |
57 | ||
58 | impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> { | |
29967ef6 XL |
59 | fn add_file(&mut self, file: &Path) { |
60 | self.entries.push(( | |
c295e0f8 | 61 | file.file_name().unwrap().to_str().unwrap().to_string().into_bytes(), |
29967ef6 XL |
62 | ArchiveEntry::File(file.to_owned()), |
63 | )); | |
64 | } | |
65 | ||
064997fb FG |
66 | fn add_archive( |
67 | &mut self, | |
68 | archive_path: &Path, | |
69 | mut skip: Box<dyn FnMut(&str) -> bool + 'static>, | |
70 | ) -> std::io::Result<()> { | |
c295e0f8 XL |
71 | let read_cache = ReadCache::new(std::fs::File::open(&archive_path)?); |
72 | let archive = ArchiveFile::parse(&read_cache).unwrap(); | |
73 | let archive_index = self.src_archives.len(); | |
29967ef6 | 74 | |
c295e0f8 XL |
75 | for entry in archive.members() { |
76 | let entry = entry.map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?; | |
77 | let file_name = String::from_utf8(entry.name().to_vec()) | |
78 | .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?; | |
79 | if !skip(&file_name) { | |
80 | self.entries.push(( | |
81 | file_name.into_bytes(), | |
82 | ArchiveEntry::FromArchive { archive_index, file_range: entry.file_range() }, | |
83 | )); | |
29967ef6 | 84 | } |
c295e0f8 | 85 | } |
29967ef6 | 86 | |
c295e0f8 XL |
87 | self.src_archives.push(read_cache.into_inner()); |
88 | Ok(()) | |
29967ef6 XL |
89 | } |
90 | ||
064997fb | 91 | fn build(mut self: Box<Self>, output: &Path) -> bool { |
29967ef6 XL |
92 | enum BuilderKind { |
93 | Bsd(ar::Builder<File>), | |
94 | Gnu(ar::GnuBuilder<File>), | |
95 | } | |
96 | ||
97 | let sess = self.sess; | |
98 | ||
99 | let mut symbol_table = BTreeMap::new(); | |
100 | ||
101 | let mut entries = Vec::new(); | |
102 | ||
064997fb | 103 | for (mut entry_name, entry) in self.entries { |
29967ef6 XL |
104 | // FIXME only read the symbol table of the object files to avoid having to keep all |
105 | // object files in memory at once, or read them twice. | |
106 | let data = match entry { | |
c295e0f8 | 107 | ArchiveEntry::FromArchive { archive_index, file_range } => { |
29967ef6 | 108 | // FIXME read symbols from symtab |
c295e0f8 XL |
109 | let src_read_cache = &mut self.src_archives[archive_index]; |
110 | ||
111 | src_read_cache.seek(io::SeekFrom::Start(file_range.0)).unwrap(); | |
112 | let mut data = std::vec::from_elem(0, usize::try_from(file_range.1).unwrap()); | |
113 | src_read_cache.read_exact(&mut data).unwrap(); | |
114 | ||
29967ef6 XL |
115 | data |
116 | } | |
117 | ArchiveEntry::File(file) => std::fs::read(file).unwrap_or_else(|err| { | |
118 | sess.fatal(&format!( | |
119 | "error while reading object file during archive building: {}", | |
120 | err | |
121 | )); | |
122 | }), | |
123 | }; | |
124 | ||
125 | if !self.no_builtin_ranlib { | |
064997fb FG |
126 | if symbol_table.contains_key(&entry_name) { |
127 | // The ar crate can't handle creating a symbol table in case of multiple archive | |
128 | // members with the same name. Work around this by prepending a number until we | |
129 | // get a unique name. | |
130 | for i in 1.. { | |
131 | let new_name = format!("{}_", i) | |
132 | .into_bytes() | |
133 | .into_iter() | |
134 | .chain(entry_name.iter().copied()) | |
135 | .collect::<Vec<_>>(); | |
136 | if !symbol_table.contains_key(&new_name) { | |
137 | entry_name = new_name; | |
138 | break; | |
139 | } | |
140 | } | |
141 | } | |
142 | ||
17df50a5 | 143 | match object::File::parse(&*data) { |
29967ef6 XL |
144 | Ok(object) => { |
145 | symbol_table.insert( | |
c295e0f8 | 146 | entry_name.to_vec(), |
29967ef6 XL |
147 | object |
148 | .symbols() | |
fc512014 | 149 | .filter_map(|symbol| { |
a2a8927a | 150 | if symbol.is_undefined() || symbol.is_local() { |
29967ef6 XL |
151 | None |
152 | } else { | |
fc512014 | 153 | symbol.name().map(|name| name.as_bytes().to_vec()).ok() |
29967ef6 XL |
154 | } |
155 | }) | |
156 | .collect::<Vec<_>>(), | |
157 | ); | |
158 | } | |
159 | Err(err) => { | |
160 | let err = err.to_string(); | |
161 | if err == "Unknown file magic" { | |
162 | // Not an object file; skip it. | |
163 | } else { | |
164 | sess.fatal(&format!( | |
165 | "error parsing `{}` during archive creation: {}", | |
c295e0f8 XL |
166 | String::from_utf8_lossy(&entry_name), |
167 | err | |
29967ef6 XL |
168 | )); |
169 | } | |
170 | } | |
171 | } | |
172 | } | |
173 | ||
174 | entries.push((entry_name, data)); | |
175 | } | |
176 | ||
177 | let mut builder = if self.use_gnu_style_archive { | |
178 | BuilderKind::Gnu( | |
179 | ar::GnuBuilder::new( | |
064997fb | 180 | File::create(output).unwrap_or_else(|err| { |
29967ef6 XL |
181 | sess.fatal(&format!( |
182 | "error opening destination during archive building: {}", | |
183 | err | |
184 | )); | |
185 | }), | |
c295e0f8 | 186 | entries.iter().map(|(name, _)| name.clone()).collect(), |
29967ef6 XL |
187 | ar::GnuSymbolTableFormat::Size32, |
188 | symbol_table, | |
189 | ) | |
190 | .unwrap(), | |
191 | ) | |
192 | } else { | |
193 | BuilderKind::Bsd( | |
194 | ar::Builder::new( | |
064997fb | 195 | File::create(output).unwrap_or_else(|err| { |
29967ef6 XL |
196 | sess.fatal(&format!( |
197 | "error opening destination during archive building: {}", | |
198 | err | |
199 | )); | |
200 | }), | |
201 | symbol_table, | |
202 | ) | |
203 | .unwrap(), | |
204 | ) | |
205 | }; | |
206 | ||
923072b8 FG |
207 | let any_members = !entries.is_empty(); |
208 | ||
29967ef6 XL |
209 | // Add all files |
210 | for (entry_name, data) in entries.into_iter() { | |
c295e0f8 | 211 | let header = ar::Header::new(entry_name, data.len() as u64); |
29967ef6 XL |
212 | match builder { |
213 | BuilderKind::Bsd(ref mut builder) => builder.append(&header, &mut &*data).unwrap(), | |
214 | BuilderKind::Gnu(ref mut builder) => builder.append(&header, &mut &*data).unwrap(), | |
215 | } | |
216 | } | |
217 | ||
218 | // Finalize archive | |
219 | std::mem::drop(builder); | |
220 | ||
221 | if self.no_builtin_ranlib { | |
222 | let ranlib = crate::toolchain::get_toolchain_binary(self.sess, "ranlib"); | |
223 | ||
224 | // Run ranlib to be able to link the archive | |
225 | let status = std::process::Command::new(ranlib) | |
064997fb | 226 | .arg(output) |
29967ef6 XL |
227 | .status() |
228 | .expect("Couldn't run ranlib"); | |
229 | ||
230 | if !status.success() { | |
6a06907d | 231 | self.sess.fatal(&format!("Ranlib exited with code {:?}", status.code())); |
29967ef6 XL |
232 | } |
233 | } | |
923072b8 FG |
234 | |
235 | any_members | |
29967ef6 XL |
236 | } |
237 | } |