authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2021-07-10 14:33:17+02:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2021-07-15 18:49:47+02:00
log3bdb3b574e36962528d203a69ee1de4b39e17830
treefda7b492a7f17d0f40b02fe2f181518ed445cb85
parentdd5c7588d105c544289b6344b652133538e7e898

zld: turn logging off

3 files changed, 45 insertions(+), 39 deletions(-)

src/link/MachO/Object.zig+4-4
......@@ -451,7 +451,7 @@ const TextBlockParser = struct {
451451pub fn parseTextBlocks(self: *Object, zld: *Zld) !void {
452452 const seg = self.load_commands.items[self.segment_cmd_index.?].Segment;
453453
454 log.warn("analysing {s}", .{self.name.?});
454 log.debug("analysing {s}", .{self.name.?});
455455
456456 const dysymtab = self.load_commands.items[self.dysymtab_cmd_index.?].Dysymtab;
457457 // We only care about defined symbols, so filter every other out.
......@@ -472,14 +472,14 @@ pub fn parseTextBlocks(self: *Object, zld: *Zld) !void {
472472
473473 for (seg.sections.items) |sect, id| {
474474 const sect_id = @intCast(u8, id);
475 log.warn("putting section '{s},{s}' as a TextBlock", .{
475 log.debug("putting section '{s},{s}' as a TextBlock", .{
476476 segmentName(sect),
477477 sectionName(sect),
478478 });
479479
480480 // Get matching segment/section in the final artifact.
481481 const match = (try zld.getMatchingSection(sect)) orelse {
482 log.warn("unhandled section", .{});
482 log.debug("unhandled section", .{});
483483 continue;
484484 };
485485
......@@ -523,7 +523,7 @@ pub fn parseTextBlocks(self: *Object, zld: *Zld) !void {
523523 const reg = &sym.payload.regular;
524524 if (reg.file) |file| {
525525 if (file != self) {
526 log.warn("deduping definition of {s} in {s}", .{ sym.name, self.name.? });
526 log.debug("deduping definition of {s} in {s}", .{ sym.name, self.name.? });
527527 block.deinit();
528528 self.allocator.destroy(block);
529529 continue;
src/link/MachO/Zld.zig+38-32
......@@ -171,46 +171,52 @@ pub const TextBlock = struct {
171171 }
172172 }
173173
174 pub fn print_this(self: *const TextBlock, zld: *Zld) void {
175 log.warn("TextBlock", .{});
176 log.warn(" | {}: {}", .{ self.local_sym_index, zld.locals.items[self.local_sym_index] });
174 pub fn format(self: *const TextBlock, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
175 _ = fmt;
176 _ = options;
177 try std.fmt.format(writer, "TextBlock {{\n", .{});
178 try std.fmt.format(writer, " {}: {}\n", .{ self.local_sym_index, zld.locals.items[self.local_sym_index] });
177179 if (self.aliases) |aliases| {
178 log.warn(" | aliases:", .{});
180 try std.fmt.format(writer, " aliases:\n", .{});
179181 for (aliases) |index| {
180 log.warn(" | {}: {}", .{ index, zld.locals.items[index] });
182 try std.fmt.format(writer, " {}: {}\n", .{ index, zld.locals.items[index] });
181183 }
182184 }
183185 if (self.references.count() > 0) {
184 log.warn(" | references:", .{});
186 try std.fmt.format(writer, " references:\n", .{});
185187 for (self.references.keys()) |index| {
186 log.warn(" | {}: {}", .{ index, zld.locals.items[index] });
188 try std.fmt.format(writer, " {}: {}\n", .{ index, zld.locals.items[index] });
187189 }
188190 }
189191 if (self.contained) |contained| {
190 log.warn(" | contained symbols:", .{});
192 try std.fmt.format(writer, " contained symbols:\n", .{});
191193 for (contained) |sym_at_off| {
192 log.warn(" | {}: {}", .{ sym_at_off.offset, zld.locals.items[sym_at_off.local_sym_index] });
194 try std.fmt.format(writer, " {}: {}\n", .{
195 sym_at_off.offset,
196 zld.locals.items[sym_at_off.local_sym_index],
197 });
193198 }
194199 }
195 log.warn(" | code.len = {}", .{self.code.len});
200 try std.fmt.format(writer, " code.len = {}\n", .{self.code.len});
196201 if (self.relocs.items.len > 0) {
197 log.warn(" | relocations:", .{});
202 try std.fmt.format(writer, " relocations:\n", .{});
198203 for (self.relocs.items) |rel| {
199 log.warn(" | {}", .{rel});
204 try std.fmt.format(writer, " {}\n", .{rel});
200205 }
201206 }
202207 if (self.rebases.items.len > 0) {
203 log.warn(" | rebases: {any}", .{self.rebases.items});
208 try std.fmt.format(writer, " rebases: {any}\n", .{self.rebases.items});
204209 }
205 log.warn(" | size = {}", .{self.size});
206 log.warn(" | align = {}", .{self.alignment});
210 try std.fmt.format(writer, " size = {}\n", .{self.size});
211 try std.fmt.format(writer, " align = {}\n", .{self.alignment});
212 try std.fmt.format(writer, "}}", .{});
207213 }
208214
209215 pub fn print(self: *const TextBlock, zld: *Zld) void {
210216 if (self.prev) |prev| {
211217 prev.print(zld);
212218 }
213 self.print_this(zld);
219 log.warn("{}\n", .{self});
214220 }
215221};
216222
......@@ -317,15 +323,15 @@ pub fn link(self: *Zld, files: []const []const u8, output: Output, args: LinkArg
317323 self.allocateLinkeditSegment();
318324 try self.allocateTextBlocks();
319325
320 var it = self.blocks.iterator();
321 while (it.next()) |entry| {
322 const seg = self.load_commands.items[entry.key_ptr.seg].Segment;
323 const sect = seg.sections.items[entry.key_ptr.sect];
326 // var it = self.blocks.iterator();
327 // while (it.next()) |entry| {
328 // const seg = self.load_commands.items[entry.key_ptr.seg].Segment;
329 // const sect = seg.sections.items[entry.key_ptr.sect];
324330
325 log.warn("\n\n{s},{s} contents:", .{ segmentName(sect), sectionName(sect) });
326 log.warn(" {}", .{sect});
327 entry.value_ptr.*.print(self);
328 }
331 // log.warn("\n\n{s},{s} contents:", .{ segmentName(sect), sectionName(sect) });
332 // log.warn(" {}", .{sect});
333 // entry.value_ptr.*.print(self);
334 // }
329335
330336 try self.flush();
331337}
......@@ -1036,7 +1042,7 @@ fn allocateSegment(self: *Zld, index: u16, offset: u64) !void {
10361042}
10371043
10381044fn allocateTextBlocks(self: *Zld) !void {
1039 log.warn("allocating text blocks", .{});
1045 log.debug("allocating text blocks", .{});
10401046
10411047 var it = self.blocks.iterator();
10421048 while (it.next()) |entry| {
......@@ -1047,8 +1053,8 @@ fn allocateTextBlocks(self: *Zld) !void {
10471053 const sect = seg.sections.items[match.sect];
10481054 var base_addr: u64 = sect.addr + sect.size;
10491055
1050 log.warn(" within section {s},{s}", .{ segmentName(sect), sectionName(sect) });
1051 log.warn(" {}", .{sect});
1056 log.debug(" within section {s},{s}", .{ segmentName(sect), sectionName(sect) });
1057 log.debug(" {}", .{sect});
10521058
10531059 while (true) {
10541060 const block_alignment = try math.powi(u32, 2, block.alignment);
......@@ -1058,7 +1064,7 @@ fn allocateTextBlocks(self: *Zld) !void {
10581064 assert(sym.payload == .regular);
10591065 sym.payload.regular.address = base_addr;
10601066
1061 log.warn(" {s}: start=0x{x}, end=0x{x}, size={}, align={}", .{
1067 log.debug(" {s}: start=0x{x}, end=0x{x}, size={}, align={}", .{
10621068 sym.name,
10631069 base_addr,
10641070 base_addr + block.size,
......@@ -1092,7 +1098,7 @@ fn allocateTextBlocks(self: *Zld) !void {
10921098}
10931099
10941100fn writeTextBlocks(self: *Zld) !void {
1095 log.warn("writing text blocks", .{});
1101 log.debug("writing text blocks", .{});
10961102
10971103 var it = self.blocks.iterator();
10981104 while (it.next()) |entry| {
......@@ -1103,8 +1109,8 @@ fn writeTextBlocks(self: *Zld) !void {
11031109 const sect = seg.sections.items[match.sect];
11041110 const sect_type = sectionType(sect);
11051111
1106 log.warn(" for section {s},{s}", .{ segmentName(sect), sectionName(sect) });
1107 log.warn(" {}", .{sect});
1112 log.debug(" for section {s},{s}", .{ segmentName(sect), sectionName(sect) });
1113 log.debug(" {}", .{sect});
11081114
11091115 var code = try self.allocator.alloc(u8, sect.size);
11101116 defer self.allocator.free(code);
......@@ -1120,7 +1126,7 @@ fn writeTextBlocks(self: *Zld) !void {
11201126 const aligned_base_off = mem.alignBackwardGeneric(u64, unaligned_base_off, block_alignment);
11211127
11221128 const sym = self.locals.items[block.local_sym_index];
1123 log.warn(" {s}: start=0x{x}, end=0x{x}, size={}, align={}", .{
1129 log.debug(" {s}: start=0x{x}, end=0x{x}, size={}, align={}", .{
11241130 sym.name,
11251131 aligned_base_off,
11261132 aligned_base_off + block.size,
src/link/MachO/reloc.zig+3-3
......@@ -491,9 +491,9 @@ pub const Relocation = struct {
491491 }
492492 };
493493
494 log.warn("relocating {}", .{self});
495 log.warn(" | source_addr = 0x{x}", .{source_addr});
496 log.warn(" | target_addr = 0x{x}", .{target_addr});
494 log.debug("relocating {}", .{self});
495 log.debug(" | source_addr = 0x{x}", .{source_addr});
496 log.debug(" | target_addr = 0x{x}", .{target_addr});
497497
498498 switch (self.payload) {
499499 .unsigned => |unsigned| try unsigned.resolve(self, source_addr, target_addr),