diff --git a/lib/std/debug/Pdb.zig b/lib/std/debug/Pdb.zig index a85a6df61c..3b1adb3c56 100644 --- a/lib/std/debug/Pdb.zig +++ b/lib/std/debug/Pdb.zig @@ -63,18 +63,18 @@ pub fn deinit(self: *Pdb) void { } pub fn parseDbiStream(self: *Pdb) !void { - var stream = self.getStream(pdb.StreamType.Dbi) orelse + var stream = self.getStream(pdb.StreamType.dbi) orelse return error.InvalidDebugInfo; const reader = stream.reader(); const header = try reader.readStruct(std.pdb.DbiStreamHeader); - if (header.VersionHeader != 19990903) // V70, only value observed by LLVM team + if (header.version_header != 19990903) // V70, only value observed by LLVM team return error.UnknownPDBVersion; // if (header.Age != age) // return error.UnmatchingPDB; - const mod_info_size = header.ModInfoSize; - const section_contrib_size = header.SectionContributionSize; + const mod_info_size = header.mod_info_size; + const section_contrib_size = header.section_contribution_size; var modules = std.ArrayList(Module).init(self.allocator); errdefer modules.deinit(); @@ -143,7 +143,7 @@ pub fn parseDbiStream(self: *Pdb) !void { } pub fn parseInfoStream(self: *Pdb) !void { - var stream = self.getStream(pdb.StreamType.Pdb) orelse + var stream = self.getStream(pdb.StreamType.pdb) orelse return error.InvalidDebugInfo; const reader = stream.reader(); @@ -168,23 +168,23 @@ pub fn parseInfoStream(self: *Pdb) !void { try reader.readNoEof(name_bytes); const HashTableHeader = extern struct { - Size: u32, - Capacity: u32, + size: u32, + capacity: u32, fn maxLoad(cap: u32) u32 { return cap * 2 / 3 + 1; } }; const hash_tbl_hdr = try reader.readStruct(HashTableHeader); - if (hash_tbl_hdr.Capacity == 0) + if (hash_tbl_hdr.capacity == 0) return error.InvalidDebugInfo; - if (hash_tbl_hdr.Size > HashTableHeader.maxLoad(hash_tbl_hdr.Capacity)) + if (hash_tbl_hdr.size > HashTableHeader.maxLoad(hash_tbl_hdr.capacity)) return error.InvalidDebugInfo; const present = try readSparseBitVector(&reader, self.allocator); defer self.allocator.free(present); - if (present.len != hash_tbl_hdr.Size) + if (present.len != hash_tbl_hdr.size) return error.InvalidDebugInfo; const deleted = try readSparseBitVector(&reader, self.allocator); defer self.allocator.free(deleted); @@ -212,19 +212,19 @@ pub fn getSymbolName(self: *Pdb, module: *Module, address: u64) ?[]const u8 { var symbol_i: usize = 0; while (symbol_i != module.symbols.len) { - const prefix = @as(*align(1) pdb.RecordPrefix, @ptrCast(&module.symbols[symbol_i])); - if (prefix.RecordLen < 2) + const prefix: *align(1) pdb.RecordPrefix = @ptrCast(&module.symbols[symbol_i]); + if (prefix.record_len < 2) return null; - switch (prefix.RecordKind) { - .S_LPROC32, .S_GPROC32 => { - const proc_sym = @as(*align(1) pdb.ProcSym, @ptrCast(&module.symbols[symbol_i + @sizeOf(pdb.RecordPrefix)])); - if (address >= proc_sym.CodeOffset and address < proc_sym.CodeOffset + proc_sym.CodeSize) { - return std.mem.sliceTo(@as([*:0]u8, @ptrCast(&proc_sym.Name[0])), 0); + switch (prefix.record_kind) { + .lproc32, .gproc32 => { + const proc_sym: *align(1) pdb.ProcSym = @ptrCast(&module.symbols[symbol_i + @sizeOf(pdb.RecordPrefix)]); + if (address >= proc_sym.code_offset and address < proc_sym.code_offset + proc_sym.code_size) { + return std.mem.sliceTo(@as([*:0]u8, @ptrCast(&proc_sym.name[0])), 0); } }, else => {}, } - symbol_i += prefix.RecordLen + @sizeOf(u16); + symbol_i += prefix.record_len + @sizeOf(u16); } return null; @@ -238,44 +238,44 @@ pub fn getLineNumberInfo(self: *Pdb, module: *Module, address: u64) !std.debug.S var skip_len: usize = undefined; const checksum_offset = module.checksum_offset orelse return error.MissingDebugInfo; while (sect_offset != subsect_info.len) : (sect_offset += skip_len) { - const subsect_hdr = @as(*align(1) pdb.DebugSubsectionHeader, @ptrCast(&subsect_info[sect_offset])); - skip_len = subsect_hdr.Length; + const subsect_hdr: *align(1) pdb.DebugSubsectionHeader = @ptrCast(&subsect_info[sect_offset]); + skip_len = subsect_hdr.length; sect_offset += @sizeOf(pdb.DebugSubsectionHeader); - switch (subsect_hdr.Kind) { - .Lines => { + switch (subsect_hdr.kind) { + .lines => { var line_index = sect_offset; - const line_hdr = @as(*align(1) pdb.LineFragmentHeader, @ptrCast(&subsect_info[line_index])); - if (line_hdr.RelocSegment == 0) + const line_hdr: *align(1) pdb.LineFragmentHeader = @ptrCast(&subsect_info[line_index]); + if (line_hdr.reloc_segment == 0) return error.MissingDebugInfo; line_index += @sizeOf(pdb.LineFragmentHeader); - const frag_vaddr_start = line_hdr.RelocOffset; - const frag_vaddr_end = frag_vaddr_start + line_hdr.CodeSize; + const frag_vaddr_start = line_hdr.reloc_offset; + const frag_vaddr_end = frag_vaddr_start + line_hdr.code_size; if (address >= frag_vaddr_start and address < frag_vaddr_end) { // There is an unknown number of LineBlockFragmentHeaders (and their accompanying line and column records) // from now on. We will iterate through them, and eventually find a SourceLocation that we're interested in, // breaking out to :subsections. If not, we will make sure to not read anything outside of this subsection. - const subsection_end_index = sect_offset + subsect_hdr.Length; + const subsection_end_index = sect_offset + subsect_hdr.length; while (line_index < subsection_end_index) { - const block_hdr = @as(*align(1) pdb.LineBlockFragmentHeader, @ptrCast(&subsect_info[line_index])); + const block_hdr: *align(1) pdb.LineBlockFragmentHeader = @ptrCast(&subsect_info[line_index]); line_index += @sizeOf(pdb.LineBlockFragmentHeader); const start_line_index = line_index; - const has_column = line_hdr.Flags.LF_HaveColumns; + const has_column = line_hdr.flags.have_columns; // All line entries are stored inside their line block by ascending start address. // Heuristic: we want to find the last line entry // that has a vaddr_start <= address. // This is done with a simple linear search. var line_i: u32 = 0; - while (line_i < block_hdr.NumLines) : (line_i += 1) { - const line_num_entry = @as(*align(1) pdb.LineNumberEntry, @ptrCast(&subsect_info[line_index])); + while (line_i < block_hdr.num_lines) : (line_i += 1) { + const line_num_entry: *align(1) pdb.LineNumberEntry = @ptrCast(&subsect_info[line_index]); line_index += @sizeOf(pdb.LineNumberEntry); - const vaddr_start = frag_vaddr_start + line_num_entry.Offset; + const vaddr_start = frag_vaddr_start + line_num_entry.offset; if (address < vaddr_start) { break; } @@ -283,19 +283,19 @@ pub fn getLineNumberInfo(self: *Pdb, module: *Module, address: u64) !std.debug.S // line_i == 0 would mean that no matching pdb.LineNumberEntry was found. if (line_i > 0) { - const subsect_index = checksum_offset + block_hdr.NameIndex; - const chksum_hdr = @as(*align(1) pdb.FileChecksumEntryHeader, @ptrCast(&module.subsect_info[subsect_index])); - const strtab_offset = @sizeOf(pdb.StringTableHeader) + chksum_hdr.FileNameOffset; + const subsect_index = checksum_offset + block_hdr.name_index; + const chksum_hdr: *align(1) pdb.FileChecksumEntryHeader = @ptrCast(&module.subsect_info[subsect_index]); + const strtab_offset = @sizeOf(pdb.StringTableHeader) + chksum_hdr.file_name_offset; try self.string_table.?.seekTo(strtab_offset); const source_file_name = try self.string_table.?.reader().readUntilDelimiterAlloc(self.allocator, 0, 1024); const line_entry_idx = line_i - 1; const column = if (has_column) blk: { - const start_col_index = start_line_index + @sizeOf(pdb.LineNumberEntry) * block_hdr.NumLines; + const start_col_index = start_line_index + @sizeOf(pdb.LineNumberEntry) * block_hdr.num_lines; const col_index = start_col_index + @sizeOf(pdb.ColumnNumberEntry) * line_entry_idx; - const col_num_entry = @as(*align(1) pdb.ColumnNumberEntry, @ptrCast(&subsect_info[col_index])); - break :blk col_num_entry.StartColumn; + const col_num_entry: *align(1) pdb.ColumnNumberEntry = @ptrCast(&subsect_info[col_index]); + break :blk col_num_entry.start_column; } else 0; const found_line_index = start_line_index + line_entry_idx * @sizeOf(pdb.LineNumberEntry); @@ -303,7 +303,7 @@ pub fn getLineNumberInfo(self: *Pdb, module: *Module, address: u64) !std.debug.S return .{ .file_name = source_file_name, - .line = line_num_entry.Flags.Start, + .line = line_num_entry.flags.start, .column = column, }; } @@ -334,12 +334,12 @@ pub fn getModule(self: *Pdb, index: usize) !?*Module { return mod; // At most one can be non-zero. - if (mod.mod_info.C11ByteSize != 0 and mod.mod_info.C13ByteSize != 0) + if (mod.mod_info.c11_byte_size != 0 and mod.mod_info.c13_byte_size != 0) return error.InvalidDebugInfo; - if (mod.mod_info.C13ByteSize == 0) + if (mod.mod_info.c13_byte_size == 0) return error.InvalidDebugInfo; - const stream = self.getStreamById(mod.mod_info.ModuleSymStream) orelse + const stream = self.getStreamById(mod.mod_info.module_sym_stream) orelse return error.MissingDebugInfo; const reader = stream.reader(); @@ -347,23 +347,23 @@ pub fn getModule(self: *Pdb, index: usize) !?*Module { if (signature != 4) return error.InvalidDebugInfo; - mod.symbols = try self.allocator.alloc(u8, mod.mod_info.SymByteSize - 4); + mod.symbols = try self.allocator.alloc(u8, mod.mod_info.sym_byte_size - 4); errdefer self.allocator.free(mod.symbols); try reader.readNoEof(mod.symbols); - mod.subsect_info = try self.allocator.alloc(u8, mod.mod_info.C13ByteSize); + mod.subsect_info = try self.allocator.alloc(u8, mod.mod_info.c13_byte_size); errdefer self.allocator.free(mod.subsect_info); try reader.readNoEof(mod.subsect_info); var sect_offset: usize = 0; var skip_len: usize = undefined; while (sect_offset != mod.subsect_info.len) : (sect_offset += skip_len) { - const subsect_hdr = @as(*align(1) pdb.DebugSubsectionHeader, @ptrCast(&mod.subsect_info[sect_offset])); - skip_len = subsect_hdr.Length; + const subsect_hdr: *align(1) pdb.DebugSubsectionHeader = @ptrCast(&mod.subsect_info[sect_offset]); + skip_len = subsect_hdr.length; sect_offset += @sizeOf(pdb.DebugSubsectionHeader); - switch (subsect_hdr.Kind) { - .FileChecksums => { + switch (subsect_hdr.kind) { + .file_checksums => { mod.checksum_offset = sect_offset; break; }, @@ -400,30 +400,30 @@ const Msf = struct { const superblock = try in.readStruct(pdb.SuperBlock); // Sanity checks - if (!std.mem.eql(u8, &superblock.FileMagic, pdb.SuperBlock.file_magic)) + if (!std.mem.eql(u8, &superblock.file_magic, pdb.SuperBlock.expect_magic)) return error.InvalidDebugInfo; - if (superblock.FreeBlockMapBlock != 1 and superblock.FreeBlockMapBlock != 2) + if (superblock.free_block_map_block != 1 and superblock.free_block_map_block != 2) return error.InvalidDebugInfo; const file_len = try file.getEndPos(); - if (superblock.NumBlocks * superblock.BlockSize != file_len) + if (superblock.num_blocks * superblock.block_size != file_len) return error.InvalidDebugInfo; - switch (superblock.BlockSize) { + switch (superblock.block_size) { // llvm only supports 4096 but we can handle any of these values 512, 1024, 2048, 4096 => {}, else => return error.InvalidDebugInfo, } - const dir_block_count = blockCountFromSize(superblock.NumDirectoryBytes, superblock.BlockSize); - if (dir_block_count > superblock.BlockSize / @sizeOf(u32)) + const dir_block_count = blockCountFromSize(superblock.num_directory_bytes, superblock.block_size); + if (dir_block_count > superblock.block_size / @sizeOf(u32)) return error.UnhandledBigDirectoryStream; // cf. BlockMapAddr comment. - try file.seekTo(superblock.BlockSize * superblock.BlockMapAddr); + try file.seekTo(superblock.block_size * superblock.block_map_addr); const dir_blocks = try allocator.alloc(u32, dir_block_count); for (dir_blocks) |*b| { b.* = try in.readInt(u32, .little); } var directory = MsfStream.init( - superblock.BlockSize, + superblock.block_size, file, dir_blocks, ); @@ -439,7 +439,7 @@ const Msf = struct { const Nil = 0xFFFFFFFF; for (stream_sizes) |*s| { const size = try directory.reader().readInt(u32, .little); - s.* = if (size == Nil) 0 else blockCountFromSize(size, superblock.BlockSize); + s.* = if (size == Nil) 0 else blockCountFromSize(size, superblock.block_size); } const streams = try allocator.alloc(MsfStream, stream_count); @@ -454,15 +454,15 @@ const Msf = struct { var j: u32 = 0; while (j < size) : (j += 1) { const block_id = try directory.reader().readInt(u32, .little); - const n = (block_id % superblock.BlockSize); + const n = (block_id % superblock.block_size); // 0 is for pdb.SuperBlock, 1 and 2 for FPMs. - if (block_id == 0 or n == 1 or n == 2 or block_id * superblock.BlockSize > file_len) + if (block_id == 0 or n == 1 or n == 2 or block_id * superblock.block_size > file_len) return error.InvalidBlockIndex; blocks[j] = block_id; } stream.* = MsfStream.init( - superblock.BlockSize, + superblock.block_size, file, blocks, ); @@ -470,7 +470,7 @@ const Msf = struct { } const end = directory.pos; - if (end - begin != superblock.NumDirectoryBytes) + if (end - begin != superblock.num_directory_bytes) return error.InvalidStreamDirectory; return Msf{ diff --git a/lib/std/debug/SelfInfo.zig b/lib/std/debug/SelfInfo.zig index 19adebf711..5e7aefef38 100644 --- a/lib/std/debug/SelfInfo.zig +++ b/lib/std/debug/SelfInfo.zig @@ -732,14 +732,14 @@ pub const Module = switch (native_os) { fn getSymbolFromPdb(self: *@This(), relocated_address: usize) !?std.debug.Symbol { var coff_section: *align(1) const coff.SectionHeader = undefined; const mod_index = for (self.pdb.?.sect_contribs) |sect_contrib| { - if (sect_contrib.Section > self.coff_section_headers.len) continue; + if (sect_contrib.section > self.coff_section_headers.len) continue; // Remember that SectionContribEntry.Section is 1-based. - coff_section = &self.coff_section_headers[sect_contrib.Section - 1]; + coff_section = &self.coff_section_headers[sect_contrib.section - 1]; - const vaddr_start = coff_section.virtual_address + sect_contrib.Offset; - const vaddr_end = vaddr_start + sect_contrib.Size; + const vaddr_start = coff_section.virtual_address + sect_contrib.offset; + const vaddr_end = vaddr_start + sect_contrib.size; if (relocated_address >= vaddr_start and relocated_address < vaddr_end) { - break sect_contrib.ModuleIndex; + break sect_contrib.module_index; } } else { // we have no information to add to the address diff --git a/lib/std/pdb.zig b/lib/std/pdb.zig index c30a963a9a..b44f48974d 100644 --- a/lib/std/pdb.zig +++ b/lib/std/pdb.zig @@ -20,297 +20,297 @@ const ArrayList = std.ArrayList; /// https://llvm.org/docs/PDB/DbiStream.html#stream-header pub const DbiStreamHeader = extern struct { - VersionSignature: i32, - VersionHeader: u32, - Age: u32, - GlobalStreamIndex: u16, - BuildNumber: u16, - PublicStreamIndex: u16, - PdbDllVersion: u16, - SymRecordStream: u16, - PdbDllRbld: u16, - ModInfoSize: u32, - SectionContributionSize: u32, - SectionMapSize: u32, - SourceInfoSize: i32, - TypeServerSize: i32, - MFCTypeServerIndex: u32, - OptionalDbgHeaderSize: i32, - ECSubstreamSize: i32, - Flags: u16, - Machine: u16, - Padding: u32, + version_signature: i32, + version_header: u32, + age: u32, + global_stream_index: u16, + build_number: u16, + public_stream_index: u16, + pdb_dll_version: u16, + sym_record_stream: u16, + pdb_dll_rbld: u16, + mod_info_size: u32, + section_contribution_size: u32, + section_map_size: u32, + source_info_size: i32, + type_server_size: i32, + mfc_type_server_index: u32, + optional_dbg_header_size: i32, + ec_substream_size: i32, + flags: u16, + machine: u16, + padding: u32, }; pub const SectionContribEntry = extern struct { /// COFF Section index, 1-based - Section: u16, - Padding1: [2]u8, - Offset: u32, - Size: u32, - Characteristics: u32, - ModuleIndex: u16, - Padding2: [2]u8, - DataCrc: u32, - RelocCrc: u32, + section: u16, + padding1: [2]u8, + offset: u32, + size: u32, + characteristics: u32, + module_index: u16, + padding2: [2]u8, + data_crc: u32, + reloc_crc: u32, }; pub const ModInfo = extern struct { - Unused1: u32, - SectionContr: SectionContribEntry, - Flags: u16, - ModuleSymStream: u16, - SymByteSize: u32, - C11ByteSize: u32, - C13ByteSize: u32, - SourceFileCount: u16, - Padding: [2]u8, - Unused2: u32, - SourceFileNameIndex: u32, - PdbFilePathNameIndex: u32, + unused1: u32, + section_contr: SectionContribEntry, + flags: u16, + module_sym_stream: u16, + sym_byte_size: u32, + c11_byte_size: u32, + c13_byte_size: u32, + source_file_count: u16, + padding: [2]u8, + unused2: u32, + source_file_name_index: u32, + pdb_file_path_name_index: u32, // These fields are variable length - //ModuleName: char[], - //ObjFileName: char[], + //module_name: char[], + //obj_file_name: char[], }; pub const SectionMapHeader = extern struct { /// Number of segment descriptors - Count: u16, + count: u16, /// Number of logical segment descriptors - LogCount: u16, + log_count: u16, }; pub const SectionMapEntry = extern struct { /// See the SectionMapEntryFlags enum below. - Flags: u16, + flags: u16, /// Logical overlay number - Ovl: u16, + ovl: u16, /// Group index into descriptor array. - Group: u16, - Frame: u16, + group: u16, + frame: u16, /// Byte index of segment / group name in string table, or 0xFFFF. - SectionName: u16, + section_name: u16, /// Byte index of class in string table, or 0xFFFF. - ClassName: u16, + class_name: u16, /// Byte offset of the logical segment within physical segment. If group is set in flags, this is the offset of the group. - Offset: u32, + offset: u32, /// Byte count of the segment or group. - SectionLength: u32, + section_length: u32, }; pub const StreamType = enum(u16) { - Pdb = 1, - Tpi = 2, - Dbi = 3, - Ipi = 4, + pdb = 1, + tpi = 2, + dbi = 3, + ipi = 4, }; /// Duplicate copy of SymbolRecordKind, but using the official CV names. Useful /// for reference purposes and when dealing with unknown record types. pub const SymbolKind = enum(u16) { - S_COMPILE = 1, - S_REGISTER_16t = 2, - S_CONSTANT_16t = 3, - S_UDT_16t = 4, - S_SSEARCH = 5, - S_SKIP = 7, - S_CVRESERVE = 8, - S_OBJNAME_ST = 9, - S_ENDARG = 10, - S_COBOLUDT_16t = 11, - S_MANYREG_16t = 12, - S_RETURN = 13, - S_ENTRYTHIS = 14, - S_BPREL16 = 256, - S_LDATA16 = 257, - S_GDATA16 = 258, - S_PUB16 = 259, - S_LPROC16 = 260, - S_GPROC16 = 261, - S_THUNK16 = 262, - S_BLOCK16 = 263, - S_WITH16 = 264, - S_LABEL16 = 265, - S_CEXMODEL16 = 266, - S_VFTABLE16 = 267, - S_REGREL16 = 268, - S_BPREL32_16t = 512, - S_LDATA32_16t = 513, - S_GDATA32_16t = 514, - S_PUB32_16t = 515, - S_LPROC32_16t = 516, - S_GPROC32_16t = 517, - S_THUNK32_ST = 518, - S_BLOCK32_ST = 519, - S_WITH32_ST = 520, - S_LABEL32_ST = 521, - S_CEXMODEL32 = 522, - S_VFTABLE32_16t = 523, - S_REGREL32_16t = 524, - S_LTHREAD32_16t = 525, - S_GTHREAD32_16t = 526, - S_SLINK32 = 527, - S_LPROCMIPS_16t = 768, - S_GPROCMIPS_16t = 769, - S_PROCREF_ST = 1024, - S_DATAREF_ST = 1025, - S_ALIGN = 1026, - S_LPROCREF_ST = 1027, - S_OEM = 1028, - S_TI16_MAX = 4096, - S_REGISTER_ST = 4097, - S_CONSTANT_ST = 4098, - S_UDT_ST = 4099, - S_COBOLUDT_ST = 4100, - S_MANYREG_ST = 4101, - S_BPREL32_ST = 4102, - S_LDATA32_ST = 4103, - S_GDATA32_ST = 4104, - S_PUB32_ST = 4105, - S_LPROC32_ST = 4106, - S_GPROC32_ST = 4107, - S_VFTABLE32 = 4108, - S_REGREL32_ST = 4109, - S_LTHREAD32_ST = 4110, - S_GTHREAD32_ST = 4111, - S_LPROCMIPS_ST = 4112, - S_GPROCMIPS_ST = 4113, - S_COMPILE2_ST = 4115, - S_MANYREG2_ST = 4116, - S_LPROCIA64_ST = 4117, - S_GPROCIA64_ST = 4118, - S_LOCALSLOT_ST = 4119, - S_PARAMSLOT_ST = 4120, - S_ANNOTATION = 4121, - S_GMANPROC_ST = 4122, - S_LMANPROC_ST = 4123, - S_RESERVED1 = 4124, - S_RESERVED2 = 4125, - S_RESERVED3 = 4126, - S_RESERVED4 = 4127, - S_LMANDATA_ST = 4128, - S_GMANDATA_ST = 4129, - S_MANFRAMEREL_ST = 4130, - S_MANREGISTER_ST = 4131, - S_MANSLOT_ST = 4132, - S_MANMANYREG_ST = 4133, - S_MANREGREL_ST = 4134, - S_MANMANYREG2_ST = 4135, - S_MANTYPREF = 4136, - S_UNAMESPACE_ST = 4137, - S_ST_MAX = 4352, - S_WITH32 = 4356, - S_MANYREG = 4362, - S_LPROCMIPS = 4372, - S_GPROCMIPS = 4373, - S_MANYREG2 = 4375, - S_LPROCIA64 = 4376, - S_GPROCIA64 = 4377, - S_LOCALSLOT = 4378, - S_PARAMSLOT = 4379, - S_MANFRAMEREL = 4382, - S_MANREGISTER = 4383, - S_MANSLOT = 4384, - S_MANMANYREG = 4385, - S_MANREGREL = 4386, - S_MANMANYREG2 = 4387, - S_UNAMESPACE = 4388, - S_DATAREF = 4390, - S_ANNOTATIONREF = 4392, - S_TOKENREF = 4393, - S_GMANPROC = 4394, - S_LMANPROC = 4395, - S_ATTR_FRAMEREL = 4398, - S_ATTR_REGISTER = 4399, - S_ATTR_REGREL = 4400, - S_ATTR_MANYREG = 4401, - S_SEPCODE = 4402, - S_LOCAL_2005 = 4403, - S_DEFRANGE_2005 = 4404, - S_DEFRANGE2_2005 = 4405, - S_DISCARDED = 4411, - S_LPROCMIPS_ID = 4424, - S_GPROCMIPS_ID = 4425, - S_LPROCIA64_ID = 4426, - S_GPROCIA64_ID = 4427, - S_DEFRANGE_HLSL = 4432, - S_GDATA_HLSL = 4433, - S_LDATA_HLSL = 4434, - S_LOCAL_DPC_GROUPSHARED = 4436, - S_DEFRANGE_DPC_PTR_TAG = 4439, - S_DPC_SYM_TAG_MAP = 4440, - S_ARMSWITCHTABLE = 4441, - S_POGODATA = 4444, - S_INLINESITE2 = 4445, - S_MOD_TYPEREF = 4447, - S_REF_MINIPDB = 4448, - S_PDBMAP = 4449, - S_GDATA_HLSL32 = 4450, - S_LDATA_HLSL32 = 4451, - S_GDATA_HLSL32_EX = 4452, - S_LDATA_HLSL32_EX = 4453, - S_FASTLINK = 4455, - S_INLINEES = 4456, - S_END = 6, - S_INLINESITE_END = 4430, - S_PROC_ID_END = 4431, - S_THUNK32 = 4354, - S_TRAMPOLINE = 4396, - S_SECTION = 4406, - S_COFFGROUP = 4407, - S_EXPORT = 4408, - S_LPROC32 = 4367, - S_GPROC32 = 4368, - S_LPROC32_ID = 4422, - S_GPROC32_ID = 4423, - S_LPROC32_DPC = 4437, - S_LPROC32_DPC_ID = 4438, - S_REGISTER = 4358, - S_PUB32 = 4366, - S_PROCREF = 4389, - S_LPROCREF = 4391, - S_ENVBLOCK = 4413, - S_INLINESITE = 4429, - S_LOCAL = 4414, - S_DEFRANGE = 4415, - S_DEFRANGE_SUBFIELD = 4416, - S_DEFRANGE_REGISTER = 4417, - S_DEFRANGE_FRAMEPOINTER_REL = 4418, - S_DEFRANGE_SUBFIELD_REGISTER = 4419, - S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE = 4420, - S_DEFRANGE_REGISTER_REL = 4421, - S_BLOCK32 = 4355, - S_LABEL32 = 4357, - S_OBJNAME = 4353, - S_COMPILE2 = 4374, - S_COMPILE3 = 4412, - S_FRAMEPROC = 4114, - S_CALLSITEINFO = 4409, - S_FILESTATIC = 4435, - S_HEAPALLOCSITE = 4446, - S_FRAMECOOKIE = 4410, - S_CALLEES = 4442, - S_CALLERS = 4443, - S_UDT = 4360, - S_COBOLUDT = 4361, - S_BUILDINFO = 4428, - S_BPREL32 = 4363, - S_REGREL32 = 4369, - S_CONSTANT = 4359, - S_MANCONSTANT = 4397, - S_LDATA32 = 4364, - S_GDATA32 = 4365, - S_LMANDATA = 4380, - S_GMANDATA = 4381, - S_LTHREAD32 = 4370, - S_GTHREAD32 = 4371, + compile = 1, + register_16t = 2, + constant_16t = 3, + udt_16t = 4, + ssearch = 5, + skip = 7, + cvreserve = 8, + objname_st = 9, + endarg = 10, + coboludt_16t = 11, + manyreg_16t = 12, + @"return" = 13, + entrythis = 14, + bprel16 = 256, + ldata16 = 257, + gdata16 = 258, + pub16 = 259, + lproc16 = 260, + gproc16 = 261, + thunk16 = 262, + block16 = 263, + with16 = 264, + label16 = 265, + cexmodel16 = 266, + vftable16 = 267, + regrel16 = 268, + bprel32_16t = 512, + ldata32_16t = 513, + gdata32_16t = 514, + pub32_16t = 515, + lproc32_16t = 516, + gproc32_16t = 517, + thunk32_st = 518, + block32_st = 519, + with32_st = 520, + label32_st = 521, + cexmodel32 = 522, + vftable32_16t = 523, + regrel32_16t = 524, + lthread32_16t = 525, + gthread32_16t = 526, + slink32 = 527, + lprocmips_16t = 768, + gprocmips_16t = 769, + procref_st = 1024, + dataref_st = 1025, + @"align" = 1026, + lprocref_st = 1027, + oem = 1028, + ti16_max = 4096, + register_st = 4097, + constant_st = 4098, + udt_st = 4099, + coboludt_st = 4100, + manyreg_st = 4101, + bprel32_st = 4102, + ldata32_st = 4103, + gdata32_st = 4104, + pub32_st = 4105, + lproc32_st = 4106, + gproc32_st = 4107, + vftable32 = 4108, + regrel32_st = 4109, + lthread32_st = 4110, + gthread32_st = 4111, + lprocmips_st = 4112, + gprocmips_st = 4113, + compile2_st = 4115, + manyreg2_st = 4116, + lprocia64_st = 4117, + gprocia64_st = 4118, + localslot_st = 4119, + paramslot_st = 4120, + annotation = 4121, + gmanproc_st = 4122, + lmanproc_st = 4123, + reserved1 = 4124, + reserved2 = 4125, + reserved3 = 4126, + reserved4 = 4127, + lmandata_st = 4128, + gmandata_st = 4129, + manframerel_st = 4130, + manregister_st = 4131, + manslot_st = 4132, + manmanyreg_st = 4133, + manregrel_st = 4134, + manmanyreg2_st = 4135, + mantypref = 4136, + unamespace_st = 4137, + st_max = 4352, + with32 = 4356, + manyreg = 4362, + lprocmips = 4372, + gprocmips = 4373, + manyreg2 = 4375, + lprocia64 = 4376, + gprocia64 = 4377, + localslot = 4378, + paramslot = 4379, + manframerel = 4382, + manregister = 4383, + manslot = 4384, + manmanyreg = 4385, + manregrel = 4386, + manmanyreg2 = 4387, + unamespace = 4388, + dataref = 4390, + annotationref = 4392, + tokenref = 4393, + gmanproc = 4394, + lmanproc = 4395, + attr_framerel = 4398, + attr_register = 4399, + attr_regrel = 4400, + attr_manyreg = 4401, + sepcode = 4402, + local_2005 = 4403, + defrange_2005 = 4404, + defrange2_2005 = 4405, + discarded = 4411, + lprocmips_id = 4424, + gprocmips_id = 4425, + lprocia64_id = 4426, + gprocia64_id = 4427, + defrange_hlsl = 4432, + gdata_hlsl = 4433, + ldata_hlsl = 4434, + local_dpc_groupshared = 4436, + defrange_dpc_ptr_tag = 4439, + dpc_sym_tag_map = 4440, + armswitchtable = 4441, + pogodata = 4444, + inlinesite2 = 4445, + mod_typeref = 4447, + ref_minipdb = 4448, + pdbmap = 4449, + gdata_hlsl32 = 4450, + ldata_hlsl32 = 4451, + gdata_hlsl32_ex = 4452, + ldata_hlsl32_ex = 4453, + fastlink = 4455, + inlinees = 4456, + end = 6, + inlinesite_end = 4430, + proc_id_end = 4431, + thunk32 = 4354, + trampoline = 4396, + section = 4406, + coffgroup = 4407, + @"export" = 4408, + lproc32 = 4367, + gproc32 = 4368, + lproc32_id = 4422, + gproc32_id = 4423, + lproc32_dpc = 4437, + lproc32_dpc_id = 4438, + register = 4358, + pub32 = 4366, + procref = 4389, + lprocref = 4391, + envblock = 4413, + inlinesite = 4429, + local = 4414, + defrange = 4415, + defrange_subfield = 4416, + defrange_register = 4417, + defrange_framepointer_rel = 4418, + defrange_subfield_register = 4419, + defrange_framepointer_rel_full_scope = 4420, + defrange_register_rel = 4421, + block32 = 4355, + label32 = 4357, + objname = 4353, + compile2 = 4374, + compile3 = 4412, + frameproc = 4114, + callsiteinfo = 4409, + filestatic = 4435, + heapallocsite = 4446, + framecookie = 4410, + callees = 4442, + callers = 4443, + udt = 4360, + coboludt = 4361, + buildinfo = 4428, + bprel32 = 4363, + regrel32 = 4369, + constant = 4359, + manconstant = 4397, + ldata32 = 4364, + gdata32 = 4365, + lmandata = 4380, + gmandata = 4381, + lthread32 = 4370, + gthread32 = 4371, }; pub const TypeIndex = u32; @@ -320,28 +320,28 @@ pub const TypeIndex = u32; // we should define RecordPrefix as part of the ProcSym structure. // This might be important when we start generating PDB in self-hosted with our own PE linker. pub const ProcSym = extern struct { - Parent: u32, - End: u32, - Next: u32, - CodeSize: u32, - DbgStart: u32, - DbgEnd: u32, - FunctionType: TypeIndex, - CodeOffset: u32, - Segment: u16, - Flags: ProcSymFlags, - Name: [1]u8, // null-terminated + parent: u32, + end: u32, + next: u32, + code_size: u32, + dbg_start: u32, + dbg_end: u32, + function_type: TypeIndex, + code_offset: u32, + segment: u16, + flags: ProcSymFlags, + name: [1]u8, // null-terminated }; pub const ProcSymFlags = packed struct { - HasFP: bool, - HasIRET: bool, - HasFRET: bool, - IsNoReturn: bool, - IsUnreachable: bool, - HasCustomCallingConv: bool, - IsNoInline: bool, - HasOptimizedDebugInfo: bool, + has_fp: bool, + has_iret: bool, + has_fret: bool, + is_no_return: bool, + is_unreachable: bool, + has_custom_calling_conv: bool, + is_no_inline: bool, + has_optimized_debug_info: bool, }; pub const SectionContrSubstreamVersion = enum(u32) { @@ -351,11 +351,11 @@ pub const SectionContrSubstreamVersion = enum(u32) { }; pub const RecordPrefix = extern struct { - /// Record length, starting from &RecordKind. - RecordLen: u16, + /// Record length, starting from &record_kind. + record_len: u16, /// Record kind enum (SymRecordKind or TypeRecordKind) - RecordKind: SymbolKind, + record_kind: SymbolKind, }; /// The following variable length array appears immediately after the header. @@ -364,19 +364,19 @@ pub const RecordPrefix = extern struct { /// Each `LineBlockFragmentHeader` as specified below. pub const LineFragmentHeader = extern struct { /// Code offset of line contribution. - RelocOffset: u32, + reloc_offset: u32, /// Code segment of line contribution. - RelocSegment: u16, - Flags: LineFlags, + reloc_segment: u16, + flags: LineFlags, /// Code size of this line contribution. - CodeSize: u32, + code_size: u32, }; pub const LineFlags = packed struct { /// CV_LINES_HAVE_COLUMNS - LF_HaveColumns: bool, + have_columns: bool, unused: u15, }; @@ -389,107 +389,109 @@ pub const LineBlockFragmentHeader = extern struct { /// checksums buffer. The checksum entry then /// contains another offset into the string /// table of the actual name. - NameIndex: u32, - NumLines: u32, + name_index: u32, + num_lines: u32, /// code size of block, in bytes - BlockSize: u32, + block_size: u32, }; pub const LineNumberEntry = extern struct { /// Offset to start of code bytes for line number - Offset: u32, - Flags: packed struct(u32) { + offset: u32, + flags: Flags, + + pub const Flags = packed struct(u32) { /// Start line number - Start: u24, + start: u24, /// Delta of lines to the end of the expression. Still unclear. // TODO figure out the point of this field. - End: u7, - IsStatement: bool, - }, + end: u7, + is_statement: bool, + }; }; pub const ColumnNumberEntry = extern struct { - StartColumn: u16, - EndColumn: u16, + start_column: u16, + end_column: u16, }; /// Checksum bytes follow. pub const FileChecksumEntryHeader = extern struct { /// Byte offset of filename in global string table. - FileNameOffset: u32, + file_name_offset: u32, /// Number of bytes of checksum. - ChecksumSize: u8, + checksum_size: u8, /// FileChecksumKind - ChecksumKind: u8, + checksum_kind: u8, }; pub const DebugSubsectionKind = enum(u32) { - None = 0, - Symbols = 0xf1, - Lines = 0xf2, - StringTable = 0xf3, - FileChecksums = 0xf4, - FrameData = 0xf5, - InlineeLines = 0xf6, - CrossScopeImports = 0xf7, - CrossScopeExports = 0xf8, + none = 0, + symbols = 0xf1, + lines = 0xf2, + string_table = 0xf3, + file_checksums = 0xf4, + frame_data = 0xf5, + inlinee_lines = 0xf6, + cross_scope_imports = 0xf7, + cross_scope_exports = 0xf8, // These appear to relate to .Net assembly info. - ILLines = 0xf9, - FuncMDTokenMap = 0xfa, - TypeMDTokenMap = 0xfb, - MergedAssemblyInput = 0xfc, + il_lines = 0xf9, + func_md_token_map = 0xfa, + type_md_token_map = 0xfb, + merged_assembly_input = 0xfc, - CoffSymbolRVA = 0xfd, + coff_symbol_rva = 0xfd, }; pub const DebugSubsectionHeader = extern struct { /// codeview::DebugSubsectionKind enum - Kind: DebugSubsectionKind, + kind: DebugSubsectionKind, /// number of bytes occupied by this record. - Length: u32, + length: u32, }; pub const StringTableHeader = extern struct { /// PDBStringTableSignature - Signature: u32, + signature: u32, /// 1 or 2 - HashVersion: u32, + hash_version: u32, /// Number of bytes of names buffer. - ByteSize: u32, + byte_size: u32, }; // https://llvm.org/docs/PDB/MsfFile.html#the-superblock pub const SuperBlock = extern struct { /// The LLVM docs list a space between C / C++ but empirically this is not the case. - pub const file_magic = "Microsoft C/C++ MSF 7.00\r\n\x1a\x44\x53\x00\x00\x00"; + pub const expect_magic = "Microsoft C/C++ MSF 7.00\r\n\x1a\x44\x53\x00\x00\x00"; - FileMagic: [file_magic.len]u8, + file_magic: [expect_magic.len]u8, /// The block size of the internal file system. Valid values are 512, 1024, /// 2048, and 4096 bytes. Certain aspects of the MSF file layout vary depending /// on the block sizes. For the purposes of LLVM, we handle only block sizes of /// 4KiB, and all further discussion assumes a block size of 4KiB. - BlockSize: u32, + block_size: u32, /// The index of a block within the file, at which begins a bitfield representing /// the set of all blocks within the file which are “free” (i.e. the data within /// that block is not used). See The Free Block Map for more information. Important: /// FreeBlockMapBlock can only be 1 or 2! - FreeBlockMapBlock: u32, + free_block_map_block: u32, /// The total number of blocks in the file. NumBlocks * BlockSize should equal the /// size of the file on disk. - NumBlocks: u32, + num_blocks: u32, /// The size of the stream directory, in bytes. The stream directory contains /// information about each stream’s size and the set of blocks that it occupies. /// It will be described in more detail later. - NumDirectoryBytes: u32, + num_directory_bytes: u32, - Unknown: u32, + unknown: u32, /// The index of a block within the MSF file. At this block is an array of /// ulittle32_t’s listing the blocks that the stream directory resides on. /// For large MSF files, the stream directory (which describes the block @@ -505,5 +507,5 @@ pub const SuperBlock = extern struct { // This would mean the Stream Directory is bigger than BlockSize / sizeof(u32) // blocks. We're not even close to this with a 1GB pdb file, and LLVM didn't // implement it so we're kind of safe making this assumption for now. - BlockMapAddr: u32, + block_map_addr: u32, };