rustc_codegen_llvm: use safe references for RustArchiveMember.

Author: irinagpopa

src/librustc_codegen_llvm/back/archive.rs

@@ -226,10 +226,13 @@ impl<'a> ArchiveBuilder<'a> {
     }
 
     fn build_with_llvm(&mut self, kind: ArchiveKind) -> io::Result<()> {
-        let mut archives = Vec::new();
+        let removals = mem::replace(&mut self.removals, Vec::new());
+        let mut additions = mem::replace(&mut self.additions, Vec::new());
         let mut strings = Vec::new();
         let mut members = Vec::new();
-        let removals = mem::replace(&mut self.removals, Vec::new());
+
+        let dst = CString::new(self.config.dst.to_str().unwrap())?;
+        let should_update_symbols = self.should_update_symbols;
 
         unsafe {
             if let Some(archive) = self.src_archive() {
@@ -250,18 +253,18 @@ impl<'a> ArchiveBuilder<'a> {
                     strings.push(name);
                 }
             }
-            for addition in mem::replace(&mut self.additions, Vec::new()) {
+            for addition in &mut additions {
                 match addition {
                     Addition::File { path, name_in_archive } => {
                         let path = CString::new(path.to_str().unwrap())?;
-                        let name = CString::new(name_in_archive)?;
+                        let name = CString::new(name_in_archive.clone())?;
                         members.push(llvm::LLVMRustArchiveMemberNew(path.as_ptr(),
                                                                     name.as_ptr(),
                                                                     None));
                         strings.push(path);
                         strings.push(name);
                     }
-                    Addition::Archive { archive, mut skip } => {
+                    Addition::Archive { archive, skip } => {
                         for child in archive.iter() {
                             let child = child.map_err(string_to_io_error)?;
                             if !is_relevant_child(&child) {
@@ -288,17 +291,14 @@ impl<'a> ArchiveBuilder<'a> {
                             members.push(m);
                             strings.push(name);
                         }
-                        archives.push(archive);
                     }
                 }
             }
 
-            let dst = self.config.dst.to_str().unwrap().as_bytes();
-            let dst = CString::new(dst)?;
             let r = llvm::LLVMRustWriteArchive(dst.as_ptr(),
                                                members.len() as libc::size_t,
-                                               members.as_ptr(),
-                                               self.should_update_symbols,
+                                               members.as_ptr() as *const &_,
+                                               should_update_symbols,
                                                kind);
             let ret = if r.into_result().is_err() {
                 let err = llvm::LLVMRustGetLastError();

src/librustc_codegen_llvm/llvm/ffi.rs

@@ -413,8 +413,8 @@ pub struct ArchiveChild<'a>(InvariantOpaque<'a>);
 extern { pub type Twine; }
 extern { pub type DiagnosticInfo; }
 extern { pub type SMDiagnostic; }
-extern { pub type RustArchiveMember; }
-pub type RustArchiveMemberRef = *mut RustArchiveMember;
+#[repr(C)]
+pub struct RustArchiveMember<'a>(InvariantOpaque<'a>);
 #[repr(C)]
 pub struct OperandBundleDef<'a>(InvariantOpaque<'a>);
 #[repr(C)]
@@ -1540,15 +1540,15 @@ extern "C" {
 extern "C" {
     pub fn LLVMRustWriteArchive(Dst: *const c_char,
                                 NumMembers: size_t,
-                                Members: *const RustArchiveMemberRef,
+                                Members: *const &RustArchiveMember,
                                 WriteSymbtab: bool,
                                 Kind: ArchiveKind)
                                 -> LLVMRustResult;
     pub fn LLVMRustArchiveMemberNew(Filename: *const c_char,
                                     Name: *const c_char,
-                                    Child: Option<&ArchiveChild>)
-                                    -> RustArchiveMemberRef;
-    pub fn LLVMRustArchiveMemberFree(Member: RustArchiveMemberRef);
+                                    Child: Option<&'a ArchiveChild>)
+                                    -> &'a mut RustArchiveMember<'a>;
+    pub fn LLVMRustArchiveMemberFree(Member: &'a mut RustArchiveMember<'a>);
 
     pub fn LLVMRustSetDataLayoutFromTargetMachine(M: &'a Module, TM: &'a TargetMachine);