Fix loading large rlibs

Bumps object crate to permit parsing archives with 64-bit table entries. These
are primarily encountered when there's more than 4GB of archive data.

Author: Mark-Simulacrum

Cargo.lock

@@ -2141,9 +2141,9 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.4.0"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b16bd47d9e329435e309c58469fe0791c2d0d1ba96ec0954152a5ae2b04387dc"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
 
 [[package]]
 name = "memmap2"
@@ -2304,9 +2304,9 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.25.2"
+version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8bc1d42047cf336f0f939c99e97183cf31551bf0f2865a2ec9c8d91fd4ffb5e"
+checksum = "39f37e50073ccad23b6d09bcb5b263f4e76d3bb6038e4a3c08e52162ffa8abc2"
 dependencies = [
  "crc32fast",
  "indexmap",
@@ -3647,7 +3647,7 @@ dependencies = [
  "itertools 0.9.0",
  "jobserver",
  "libc",
- "object 0.25.2",
+ "object 0.26.2",
  "pathdiff",
  "rustc_apfloat",
  "rustc_ast",

compiler/rustc_codegen_ssa/Cargo.toml

@@ -36,6 +36,6 @@ rustc_target = { path = "../rustc_target" }
 rustc_session = { path = "../rustc_session" }
 
 [dependencies.object]
-version = "0.25.2"
+version = "0.26.2"
 default-features = false
 features = ["read_core", "elf", "macho", "pe", "unaligned", "archive", "write"]

src/test/run-make/issue-88351-large-rlib/Makefile

@@ -0,0 +1,7 @@
+-include ../../run-make-fulldeps/tools.mk
+
+all:
+	$(RUSTC) main.rs
+	$(TMPDIR)/main $(TMPDIR)
+	$(RUSTC) $(TMPDIR)/foo.rs --crate-type=rlib -l static=foo -L$(TMPDIR)
+	RUSTC_LOG=rustc_metadata=debug $(RUSTC) bar.rs --extern foo=$(TMPDIR)/libfoo.rlib --edition=2018

src/test/run-make/issue-88351-large-rlib/bar.rs

@@ -0,0 +1,5 @@
+fn main() {
+    unsafe {
+        println!("{}", foo::FOO_11_49[0]);
+    }
+}

src/test/run-make/issue-88351-large-rlib/main.rs

@@ -0,0 +1,64 @@
+//! Large archive example.
+//!
+//! This creates several C files with a bunch of global arrays. The goal is to
+//! create an rlib that is over 4GB in size so that the LLVM archiver creates
+//! a /SYM64/ entry instead of /.
+//!
+//! It compiles the C files to .o files, and then uses `ar` to collect them
+//! into a static library. It creates `foo.rs` with references to all the C
+//! arrays, and then uses `rustc` to build an rlib with that static
+//! information. It then creates `bar.rs` which links the giant libfoo.rlib,
+//! which should fail since it can't read the large libfoo.rlib file.
+
+use std::env;
+use std::fs::File;
+use std::io::{BufWriter, Write};
+use std::process::Command;
+
+// Number of object files to create.
+const NOBJ: u32 = 12;
+// Make the filename longer than 16 characters to force names to be placed in //
+const PREFIX: &str = "abcdefghijklmnopqrstuvwxyz";
+
+fn main() {
+    let tmpdir = std::path::PathBuf::from(env::args_os().nth(1).unwrap());
+    let mut foo_rs = File::create(tmpdir.join("foo.rs")).unwrap();
+    write!(foo_rs, "extern \"C\" {{\n").unwrap();
+    for obj in 0..NOBJ {
+        let filename = tmpdir.join(&format!("{}{}.c", PREFIX, obj));
+        let f = File::create(&filename).unwrap();
+        let mut buf = BufWriter::new(f);
+        write!(buf, "#include<stdint.h>\n").unwrap();
+        for n in 0..50 {
+            write!(buf, "int64_t FOO_{}_{}[] = {{\n", obj, n).unwrap();
+            for x in 0..1024 {
+                for y in 0..1024 {
+                    write!(buf, "{},", (obj + n + x + y) % 10).unwrap();
+                }
+                write!(buf, "\n").unwrap();
+            }
+            write!(buf, "}};\n").unwrap();
+            write!(foo_rs, "    pub static FOO_{}_{}: [i64; 1024*1024];\n", obj, n).unwrap();
+        }
+        drop(buf);
+        println!("compile {:?}", filename);
+        let status =
+            Command::new("cc").current_dir(&tmpdir).arg("-c").arg(&filename).status().unwrap();
+        if !status.success() {
+            panic!("failed: {:?}", status);
+        }
+    }
+    write!(foo_rs, "}}\n").unwrap();
+    drop(foo_rs);
+    let mut cmd = Command::new("ar");
+    cmd.arg("-crs");
+    cmd.arg(tmpdir.join("libfoo.a"));
+    for obj in 0..NOBJ {
+        cmd.arg(tmpdir.join(&format!("{}{}.o", PREFIX, obj)));
+    }
+    println!("archiving: {:?}", cmd);
+    let status = cmd.status().unwrap();
+    if !status.success() {
+        panic!("failed: {:?}", status);
+    }
+}