Change:
// is never exactly 16 bytes long by adding a 16 byte extension to // it. This is to work around a bug in LLDB that would cause it to // crash if the name of a file in an archive was exactly 16 bytes. <del> let bc = obj_filename.with_extension("bc"); let bc_deflated = obj_filename.with_extension("bytecode.deflate"); match fs::File::open(&bc).read_to_end().and_then(|data| { fs::File::create(&bc_deflated) .write(match flate::deflate_bytes(data.as_slice()) { Some(compressed) => compressed, None => sess.fatal("failed to compress bytecode") }.as_slice()) }) { </del> <ins> let bc_filename = obj_filename.with_extension("bc"); let bc_deflated_filename = obj_filename.with_extension("bytecode.deflate"); let bc_data = match fs::File::open(&bc_filename).read_to_end() { Ok(buffer) => buffer, Err(e) => sess.fatal(format!("failed to read bytecode: {}", e).as_slice()) }; let bc_data_deflated = match flate::deflate_bytes(bc_data.as_slice()) { Some(compressed) => compressed, None => sess.fatal(format!("failed to compress bytecode from {}", bc_filename.display()).as_slice()) }; let mut bc_file_deflated = match fs::File::create(&bc_deflated_filename) { Ok(file) => file, Err(e) => { sess.fatal(format!("failed to create compressed bytecode  file: {}", e).as_slice()) } }; match write_rlib_bytecode_object_v1(&mut bc_file_deflated, bc_data_deflated.as_slice()) { </ins> Ok(()) => {} Err(e) => { sess.err(format!("failed to write compressed bytecode:  <del> {}", e).as_slice()); </del> <ins> {}", e).as_slice()); </ins> sess.abort_if_errors() } <del> } ab.add_file(&bc_deflated).unwrap(); remove(sess, &bc_deflated); </del> <ins> }; ab.add_file(&bc_deflated_filename).unwrap(); remove(sess, &bc_deflated_filename); </ins> if !sess.opts.cg.save_temps && !sess.opts.output_types.contains(&OutputTypeBitcode) { <del> remove(sess, &bc); </del> <ins> remove(sess, &bc_filename); </ins> } }

Discussion:
There's another bug in LLDB that causes it to segfault when reading archive files. This one has already been fixed in May () but it still exists in a lot of LLDB binaries out there. As far as I can tell, the bug occurs when a number of object files are stored in an archive and the last one ends at an uneven byte offset. This often seems to be the case for compressed byte-code archives in rlibs (maybe regular object files are always padded to an even size?). I'm currently compiling a possible workaround (pad the bytecode objects to an even size). It would be good if we could allow for rust code to be debugged with older LLDB versions too.
Update: Padding all archives entries to an even size seems to prevent the crash in LLDB and I have not seen any detrimental side effects to this approach so far. Any idea if the additional padding byte at the end of the compressed LLVM IR object in an archive could potentially lead to a problem?
I'm not familiar enough with the format of object files or bytecode files to know whether an extra byte or two at the end would corrupt them, but if it's working ok currently then I'd just ship it!
I doubt that the containing archive will care about the padding byte, but either the decompression algorithm or the LLVM bitcode reader could trip over it. The safe way to do this would probably be to prepend the actual size of the compressed data, so we always know how much data to pass to . I guess, I'll implement this and make a pull request.
Thinking about it, changing the format here is not as so trivial since the compiler must handle libs with the old format differently from libs with the new format. I see two options: (1) Just add the padding byte and hope for the best (2) Introduce some kind of header (including a version byte) before the compressed bitcode, in order to future-proof this against other changes to the encoding. I think I'd favor option (2).
Is this only a problem for the bytecode in archives, or is it also a problem for object files?
So far it has only occurred for bytecode. All object files I came across had a size dividable by 2. I don't know if that's a coincidence...
Interesting!

I'm all for putting the bytecode in whatever format we want (it's already just a huge deflated stream)
I'll come up with something and then we can discuss the matter further when we have some code to look at in a PR, OK?
Sounds good to me!