authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-11-05 12:08:15+01:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-11-05 12:08:15+01:00
log8d7ec05070ba5798adbeaf9a7153b6316fa6dcc3
treeec26ac5cd4ef5e9bdd13b0f426296ed7054f1035
parentf24ceec35a6fd1e5e6a671461b78919b5f588a32

elf: actually save correct object names in the archive

2 files changed, 60 insertions(+), 42 deletions(-)

src/link/Elf.zig+1-1
......@@ -1581,7 +1581,7 @@ pub fn flushStaticLib(
15811581
15821582 // Update file offsets of contributing objects.
15831583 const total_size: usize = blk: {
1584 var pos: usize = Archive.SARMAG;
1584 var pos: usize = Archive.ARMAG.len;
15851585 pos += @sizeOf(Archive.ar_hdr) + ar_symtab.size(.p64);
15861586
15871587 if (ar_strtab.size() > 0) {
src/link/Elf/Archive.zig+59-41
......@@ -8,7 +8,7 @@ pub fn isArchive(path: []const u8) !bool {
88 const file = try std.fs.cwd().openFile(path, .{});
99 defer file.close();
1010 const reader = file.reader();
11 const magic = reader.readBytesNoEof(SARMAG) catch return false;
11 const magic = reader.readBytesNoEof(ARMAG.len) catch return false;
1212 if (!mem.eql(u8, &magic, ARMAG)) return false;
1313 return true;
1414}
......@@ -24,14 +24,12 @@ pub fn parse(self: *Archive, elf_file: *Elf) !void {
2424
2525 var stream = std.io.fixedBufferStream(self.data);
2626 const reader = stream.reader();
27 _ = try reader.readBytesNoEof(SARMAG);
27 _ = try reader.readBytesNoEof(ARMAG.len);
2828
2929 while (true) {
3030 if (stream.pos >= self.data.len) break;
31 if (!mem.isAligned(stream.pos, 2)) stream.pos += 1;
3132
32 if (stream.pos % 2 != 0) {
33 stream.pos += 1;
34 }
3533 const hdr = try reader.readStruct(ar_hdr);
3634
3735 if (!mem.eql(u8, &hdr.ar_fmag, ARFMAG)) {
......@@ -48,28 +46,23 @@ pub fn parse(self: *Archive, elf_file: *Elf) !void {
4846 _ = stream.seekBy(size) catch {};
4947 }
5048
51 if (hdr.isSymtab()) continue;
49 if (hdr.isSymtab() or hdr.isSymtab64()) continue;
5250 if (hdr.isStrtab()) {
5351 self.strtab = self.data[stream.pos..][0..size];
5452 continue;
5553 }
54 if (hdr.isSymdef() or hdr.isSymdefSorted()) continue;
5655
57 const name = ar_hdr.getValue(&hdr.ar_name);
58
59 if (mem.eql(u8, name, "__.SYMDEF") or mem.eql(u8, name, "__.SYMDEF SORTED")) continue;
60
61 const object_name = blk: {
62 if (name[0] == '/') {
63 const off = try std.fmt.parseInt(u32, name[1..], 10);
64 const object_name = self.getString(off);
65 break :blk try gpa.dupe(u8, object_name[0 .. object_name.len - 1]); // To account for trailing '/'
66 }
67 break :blk try gpa.dupe(u8, name);
68 };
56 const name = if (hdr.name()) |name|
57 try gpa.dupe(u8, name)
58 else if (try hdr.nameOffset()) |off|
59 try gpa.dupe(u8, self.getString(off))
60 else
61 unreachable;
6962
7063 const object = Object{
7164 .archive = try gpa.dupe(u8, self.path),
72 .path = object_name,
65 .path = name,
7366 .data = try gpa.dupe(u8, self.data[stream.pos..][0..size]),
7467 .index = undefined,
7568 .alive = false,
......@@ -83,7 +76,8 @@ pub fn parse(self: *Archive, elf_file: *Elf) !void {
8376
8477fn getString(self: Archive, off: u32) []const u8 {
8578 assert(off < self.strtab.len);
86 return mem.sliceTo(@as([*:strtab_delimiter]const u8, @ptrCast(self.strtab.ptr + off)), 0);
79 const name = mem.sliceTo(@as([*:'\n']const u8, @ptrCast(self.strtab.ptr + off)), 0);
80 return name[0 .. name.len - 1];
8781}
8882
8983pub fn setArHdr(opts: struct {
......@@ -113,7 +107,7 @@ pub fn setArHdr(opts: struct {
113107 switch (opts.name) {
114108 .symtab => writer.print("{s}", .{Archive.SYM64NAME}) catch unreachable,
115109 .strtab => writer.print("//", .{}) catch unreachable,
116 .name => |x| writer.print("{s}", .{x}) catch unreachable,
110 .name => |x| writer.print("{s}/", .{x}) catch unreachable,
117111 .name_off => |x| writer.print("/{d}", .{x}) catch unreachable,
118112 }
119113 }
......@@ -125,25 +119,27 @@ pub fn setArHdr(opts: struct {
125119 return hdr;
126120}
127121
122fn genSpecialMemberName(comptime name: []const u8) *const [16]u8 {
123 assert(name.len <= 16);
124 const padding = 16 - name.len;
125 return name ++ &[_]u8{0x20} ** padding;
126}
127
128128// Archive files start with the ARMAG identifying string. Then follows a
129129// `struct ar_hdr', and as many bytes of member file data as its `ar_size'
130130// member indicates, for each member file.
131131/// String that begins an archive file.
132pub const ARMAG: *const [SARMAG:0]u8 = "!<arch>\n";
133/// Size of that string.
134pub const SARMAG = 8;
135
132pub const ARMAG = "!<arch>\n";
136133/// String in ar_fmag at the end of each header.
137const ARFMAG: *const [2:0]u8 = "`\n";
138
139/// Strtab identifier
140const STRNAME: *const [2:0]u8 = "//";
141
134const ARFMAG = "`\n";
142135/// 32-bit symtab identifier
143const SYMNAME: *const [1:0]u8 = "/";
144
136const SYMNAME = genSpecialMemberName("/");
137/// Strtab identifier
138const STRNAME = genSpecialMemberName("//");
145139/// 64-bit symtab identifier
146const SYM64NAME: *const [7:0]u8 = "/SYM64/";
140const SYM64NAME = genSpecialMemberName("/SYM64/");
141const SYMDEFNAME = genSpecialMemberName("__.SYMDEF");
142const SYMDEFSORTEDNAME = genSpecialMemberName("__.SYMDEF SORTED");
147143
148144const strtab_delimiter = '\n';
149145
......@@ -170,25 +166,47 @@ pub const ar_hdr = extern struct {
170166 ar_fmag: [2]u8,
171167
172168 fn date(self: ar_hdr) !u64 {
173 const value = getValue(&self.ar_date);
169 const value = mem.trimRight(u8, &self.ar_date, &[_]u8{0x20});
174170 return std.fmt.parseInt(u64, value, 10);
175171 }
176172
177173 fn size(self: ar_hdr) !u32 {
178 const value = getValue(&self.ar_size);
174 const value = mem.trimRight(u8, &self.ar_size, &[_]u8{0x20});
179175 return std.fmt.parseInt(u32, value, 10);
180176 }
181177
182 fn getValue(raw: []const u8) []const u8 {
183 return mem.trimRight(u8, raw, &[_]u8{@as(u8, 0x20)});
184 }
185
186178 fn isStrtab(self: ar_hdr) bool {
187 return mem.eql(u8, getValue(&self.ar_name), STRNAME);
179 return mem.eql(u8, &self.ar_name, STRNAME);
188180 }
189181
190182 fn isSymtab(self: ar_hdr) bool {
191 return mem.eql(u8, getValue(&self.ar_name), SYMNAME) or mem.eql(u8, getValue(&self.ar_name), SYM64NAME);
183 return mem.eql(u8, &self.ar_name, SYMNAME);
184 }
185
186 fn isSymtab64(self: ar_hdr) bool {
187 return mem.eql(u8, &self.ar_name, SYM64NAME);
188 }
189
190 fn isSymdef(self: ar_hdr) bool {
191 return mem.eql(u8, &self.ar_name, SYMDEFNAME);
192 }
193
194 fn isSymdefSorted(self: ar_hdr) bool {
195 return mem.eql(u8, &self.ar_name, SYMDEFSORTEDNAME);
196 }
197
198 fn name(self: *const ar_hdr) ?[]const u8 {
199 const value = &self.ar_name;
200 if (value[0] == '/') return null;
201 const sentinel = mem.indexOfScalar(u8, value, '/') orelse value.len;
202 return value[0..sentinel];
203 }
204
205 fn nameOffset(self: ar_hdr) !?u32 {
206 const value = &self.ar_name;
207 if (value[0] != '/') return null;
208 const trimmed = mem.trimRight(u8, value, &[_]u8{0x20});
209 return try std.fmt.parseInt(u32, trimmed[1..], 10);
192210 }
193211};
194212